    {-# LANGUAGE CPP                #-}
    -- | The 'These' type and associated operations. Now enhanced with "Control.Lens" magic!
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric      #-}
    {-# LANGUAGE OverloadedStrings  #-}
    {-# LANGUAGE Safe               #-}

    #if MIN_VERSION_base(4,9,0)
    #define LIFTED_FUNCTOR_CLASSES 1
    #else
    #if MIN_VERSION_transformers(0,5,0)
    #define LIFTED_FUNCTOR_CLASSES 1
    #else
    #if MIN_VERSION_transformers_compat(0,5,0) && !MIN_VERSION_transformers(0,4,0)
    #define LIFTED_FUNCTOR_CLASSES 1
    #endif
    #endif
    #endif

    module Data.These (
          These(..)

        -- * Functions to get rid of 'These'
        , these
        , fromThese
        , mergeThese
        , mergeTheseWith

        -- * Partition
        , partitionThese
        , partitionHereThere
        , partitionEithersNE

        -- * Distributivity
        --
        -- | These distributivity combinators aren't isomorphisms!
        , distrThesePair
        , undistrThesePair
        , distrPairThese
        , undistrPairThese
        ) where

    import Control.Applicative  (Applicative (..), (<$>))
    import Control.DeepSeq      (NFData (..))
    import Data.Bifoldable      (Bifoldable (..))
    import Data.Bifoldable1     (Bifoldable1 (..))
    import Data.Bifunctor       (Bifunctor (..))
    import Data.Binary          (Binary (..))
    import Data.Bitraversable   (Bitraversable (..))
    import Data.Data            (Data, Typeable)
    import Data.Either          (partitionEithers)
    import Data.Foldable        (Foldable (..))
    import Data.Hashable        (Hashable (..))
    import Data.Hashable.Lifted (Hashable1 (..), Hashable2 (..))
    import Data.List.NonEmpty   (NonEmpty (..))
    import Data.Monoid          (Monoid (..))
    import Data.Semigroup       (Semigroup (..))
    import Data.Traversable     (Traversable (..))
    import GHC.Generics         (Generic)
    import Prelude
           (Bool (..), Either (..), Eq (..), Functor (..), Int, Monad (..),
           Ord (..), Ordering (..), Read (..), Show (..), fail, id, lex, readParen,
           seq, showParen, showString, ($), (&&), (.))

    #if MIN_VERSION_deepseq(1,4,3)
    import Control.DeepSeq (NFData1 (..), NFData2 (..))
    #endif

    #if __GLASGOW_HASKELL__ >= 706
    import GHC.Generics (Generic1)
    #endif

    #ifdef MIN_VERSION_assoc
    import Data.Bifunctor.Assoc (Assoc (..))
    import Data.Bifunctor.Swap  (Swap (..))
    #endif

    #ifdef LIFTED_FUNCTOR_CLASSES
    import Data.Functor.Classes
           (Eq1 (..), Eq2 (..), Ord1 (..), Ord2 (..), Read1 (..), Read2 (..),
           Show1 (..), Show2 (..))
    #else
    import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))
    #endif

    -- $setup
    -- >>> import Control.Lens
    -- >>> import Data.List.NonEmpty (NonEmpty (..))
    -- >>> import Prelude (Either (..), map, ($))

    -- --------------------------------------------------------------------------
    -- | The 'These' type represents values with two non-exclusive possibilities.
    --
    --   This can be useful to represent combinations of two values, where the
    --   combination is defined if either input is. Algebraically, the type
    --   @'These' A B@ represents @(A + B + AB)@, which doesn't factor easily into
    --   sums and products--a type like @'Either' A (B, 'Maybe' A)@ is unclear and
    --   awkward to use.
    --
    --   'These' has straightforward instances of 'Functor', 'Monad', &c., and
    --   behaves like a hybrid error/writer monad, as would be expected.
    --
    --   For zipping and unzipping of structures with 'These' values, see
    --   "Data.Align".
    data These a b = This a | That b | These a b
      deriving (These a b -> These a b -> Bool
    (These a b -> These a b -> Bool)
    -> (These a b -> These a b -> Bool) -> Eq (These a b)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall a b. (Eq a, Eq b) => These a b -> These a b -> Bool
    $c== :: forall a b. (Eq a, Eq b) => These a b -> These a b -> Bool
    == :: These a b -> These a b -> Bool
    $c/= :: forall a b. (Eq a, Eq b) => These a b -> These a b -> Bool
    /= :: These a b -> These a b -> Bool
    Eq, Eq (These a b)
    Eq (These a b)
    -> (These a b -> These a b -> Ordering)
    -> (These a b -> These a b -> Bool)
    -> (These a b -> These a b -> Bool)
    -> (These a b -> These a b -> Bool)
    -> (These a b -> These a b -> Bool)
    -> (These a b -> These a b -> These a b)
    -> (These a b -> These a b -> These a b)
    -> Ord (These a b)
    These a b -> These a b -> Bool
    These a b -> These a b -> Ordering
    These a b -> These a b -> These a b
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall {a} {b}. (Ord a, Ord b) => Eq (These a b)
    forall a b. (Ord a, Ord b) => These a b -> These a b -> Bool
    forall a b. (Ord a, Ord b) => These a b -> These a b -> Ordering
    forall a b. (Ord a, Ord b) => These a b -> These a b -> These a b
    $ccompare :: forall a b. (Ord a, Ord b) => These a b -> These a b -> Ordering
    compare :: These a b -> These a b -> Ordering
    $c< :: forall a b. (Ord a, Ord b) => These a b -> These a b -> Bool
    < :: These a b -> These a b -> Bool
    $c<= :: forall a b. (Ord a, Ord b) => These a b -> These a b -> Bool
    <= :: These a b -> These a b -> Bool
    $c> :: forall a b. (Ord a, Ord b) => These a b -> These a b -> Bool
    > :: These a b -> These a b -> Bool
    $c>= :: forall a b. (Ord a, Ord b) => These a b -> These a b -> Bool
    >= :: These a b -> These a b -> Bool
    $cmax :: forall a b. (Ord a, Ord b) => These a b -> These a b -> These a b
    max :: These a b -> These a b -> These a b
    $cmin :: forall a b. (Ord a, Ord b) => These a b -> These a b -> These a b
    min :: These a b -> These a b -> These a b
    Ord, ReadPrec [These a b]
    ReadPrec (These a b)
    Int -> ReadS (These a b)
    ReadS [These a b]
    (Int -> ReadS (These a b))
    -> ReadS [These a b]
    -> ReadPrec (These a b)
    -> ReadPrec [These a b]
    -> Read (These a b)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall a b. (Read a, Read b) => ReadPrec [These a b]
    forall a b. (Read a, Read b) => ReadPrec (These a b)
    forall a b. (Read a, Read b) => Int -> ReadS (These a b)
    forall a b. (Read a, Read b) => ReadS [These a b]
    $creadsPrec :: forall a b. (Read a, Read b) => Int -> ReadS (These a b)
    readsPrec :: Int -> ReadS (These a b)
    $creadList :: forall a b. (Read a, Read b) => ReadS [These a b]
    readList :: ReadS [These a b]
    $creadPrec :: forall a b. (Read a, Read b) => ReadPrec (These a b)
    readPrec :: ReadPrec (These a b)
    $creadListPrec :: forall a b. (Read a, Read b) => ReadPrec [These a b]
    readListPrec :: ReadPrec [These a b]
    Read, Int -> These a b -> ShowS
    [These a b] -> ShowS
    These a b -> String
    (Int -> These a b -> ShowS)
    -> (These a b -> String)
    -> ([These a b] -> ShowS)
    -> Show (These a b)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall a b. (Show a, Show b) => Int -> These a b -> ShowS
    forall a b. (Show a, Show b) => [These a b] -> ShowS
    forall a b. (Show a, Show b) => These a b -> String
    $cshowsPrec :: forall a b. (Show a, Show b) => Int -> These a b -> ShowS
    showsPrec :: Int -> These a b -> ShowS
    $cshow :: forall a b. (Show a, Show b) => These a b -> String
    show :: These a b -> String
    $cshowList :: forall a b. (Show a, Show b) => [These a b] -> ShowS
    showList :: [These a b] -> ShowS
    Show, Typeable, Typeable (These a b)
    Typeable (These a b)
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> These a b -> c (These a b))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (These a b))
    -> (These a b -> Constr)
    -> (These a b -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (These a b)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (These a b)))
    -> ((forall b. Data b => b -> b) -> These a b -> These a b)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> These a b -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> These a b -> r)
    -> (forall u. (forall d. Data d => d -> u) -> These a b -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> These a b -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> These a b -> m (These a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> These a b -> m (These a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> These a b -> m (These a b))
    -> Data (These a b)
    These a b -> Constr
    These a b -> DataType
    (forall b. Data b => b -> b) -> These a b -> These a b
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> These a b -> u
    forall u. (forall d. Data d => d -> u) -> These a b -> [u]
    forall {a} {b}. (Data a, Data b) => Typeable (These a b)
    forall a b. (Data a, Data b) => These a b -> Constr
    forall a b. (Data a, Data b) => These a b -> DataType
    forall a b.
    (Data a, Data b) =>
    (forall b. Data b => b -> b) -> These a b -> These a b
    forall a b u.
    (Data a, Data b) =>
    Int -> (forall d. Data d => d -> u) -> These a b -> u
    forall a b u.
    (Data a, Data b) =>
    (forall d. Data d => d -> u) -> These a b -> [u]
    forall a b r r'.
    (Data a, Data b) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    forall a b r r'.
    (Data a, Data b) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    forall a b (m :: * -> *).
    (Data a, Data b, Monad m) =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    forall a b (m :: * -> *).
    (Data a, Data b, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (These a b)
    forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> These a b -> c (These a b)
    forall a b (t :: * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (These a b))
    forall a b (t :: * -> * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (These a b))
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (These a b)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> These a b -> c (These a b)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (These a b))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (These a b))
    $cgfoldl :: forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> These a b -> c (These a b)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> These a b -> c (These a b)
    $cgunfold :: forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (These a b)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (These a b)
    $ctoConstr :: forall a b. (Data a, Data b) => These a b -> Constr
    toConstr :: These a b -> Constr
    $cdataTypeOf :: forall a b. (Data a, Data b) => These a b -> DataType
    dataTypeOf :: These a b -> DataType
    $cdataCast1 :: forall a b (t :: * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (These a b))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (These a b))
    $cdataCast2 :: forall a b (t :: * -> * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (These a b))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (These a b))
    $cgmapT :: forall a b.
    (Data a, Data b) =>
    (forall b. Data b => b -> b) -> These a b -> These a b
    gmapT :: (forall b. Data b => b -> b) -> These a b -> These a b
    $cgmapQl :: forall a b r r'.
    (Data a, Data b) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    $cgmapQr :: forall a b r r'.
    (Data a, Data b) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> These a b -> r
    $cgmapQ :: forall a b u.
    (Data a, Data b) =>
    (forall d. Data d => d -> u) -> These a b -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> These a b -> [u]
    $cgmapQi :: forall a b u.
    (Data a, Data b) =>
    Int -> (forall d. Data d => d -> u) -> These a b -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> These a b -> u
    $cgmapM :: forall a b (m :: * -> *).
    (Data a, Data b, Monad m) =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    $cgmapMp :: forall a b (m :: * -> *).
    (Data a, Data b, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    $cgmapMo :: forall a b (m :: * -> *).
    (Data a, Data b, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> These a b -> m (These a b)
    Data, (forall x. These a b -> Rep (These a b) x)
    -> (forall x. Rep (These a b) x -> These a b)
    -> Generic (These a b)
    forall x. Rep (These a b) x -> These a b
    forall x. These a b -> Rep (These a b) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a b x. Rep (These a b) x -> These a b
    forall a b x. These a b -> Rep (These a b) x
    $cfrom :: forall a b x. These a b -> Rep (These a b) x
    from :: forall x. These a b -> Rep (These a b) x
    $cto :: forall a b x. Rep (These a b) x -> These a b
    to :: forall x. Rep (These a b) x -> These a b
    Generic
    #if __GLASGOW_HASKELL__ >= 706
        , (forall a. These a a -> Rep1 (These a) a)
    -> (forall a. Rep1 (These a) a -> These a a) -> Generic1 (These a)
    forall a. Rep1 (These a) a -> These a a
    forall a. These a a -> Rep1 (These a) a
    forall a a. Rep1 (These a) a -> These a a
    forall a a. These a a -> Rep1 (These a) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a a. These a a -> Rep1 (These a) a
    from1 :: forall a. These a a -> Rep1 (These a) a
    $cto1 :: forall a a. Rep1 (These a) a -> These a a
    to1 :: forall a. Rep1 (These a) a -> These a a
    Generic1
    #endif
        )

    -------------------------------------------------------------------------------
    -- Eliminators
    -------------------------------------------------------------------------------

    -- | Case analysis for the 'These' type.
    these :: (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these :: forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these a -> c
    l b -> c
    _ a -> b -> c
    _ (This a
    a) = a -> c
    l a
    a
    these a -> c
    _ b -> c
    r a -> b -> c
    _ (That b
    x) = b -> c
    r b
    x
    these a -> c
    _ b -> c
    _ a -> b -> c
    lr (These a
    a b
    x) = a -> b -> c
    lr a
    a b
    x

    -- | Takes two default values and produces a tuple.
    fromThese :: a -> b -> These a b -> (a, b)
    fromThese :: forall a b. a -> b -> These a b -> (a, b)
    fromThese a
    x b
    y = (a -> (a, b))
    -> (b -> (a, b)) -> (a -> b -> (a, b)) -> These a b -> (a, b)
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these (a -> b -> (a, b)
    forall {a} {b}. a -> b -> (a, b)
    `pair` b
    y) (a
    x a -> b -> (a, b)
    forall {a} {b}. a -> b -> (a, b)
    `pair`) a -> b -> (a, b)
    forall {a} {b}. a -> b -> (a, b)
    pair where
        pair :: a -> b -> (a, b)
    pair = (,)

    -- | Coalesce with the provided operation.
    mergeThese :: (a -> a -> a) -> These a a -> a
    mergeThese :: forall a. (a -> a -> a) -> These a a -> a
    mergeThese = (a -> a) -> (a -> a) -> (a -> a -> a) -> These a a -> a
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these a -> a
    forall a. a -> a
    id a -> a
    forall a. a -> a
    id

    -- | 'bimap' and coalesce results with the provided operation.
    mergeTheseWith :: (a -> c) -> (b -> c) -> (c -> c -> c) -> These a b -> c
    mergeTheseWith :: forall a c b.
    (a -> c) -> (b -> c) -> (c -> c -> c) -> These a b -> c
    mergeTheseWith a -> c
    f b -> c
    g c -> c -> c
    op These a b
    t = (c -> c -> c) -> These c c -> c
    forall a. (a -> a -> a) -> These a a -> a
    mergeThese c -> c -> c
    op (These c c -> c) -> These c c -> c
    forall a b. (a -> b) -> a -> b
    $ (a -> c) -> (b -> c) -> These a b -> These c c
    forall a b c d. (a -> b) -> (c -> d) -> These a c -> These b d
    forall (p :: * -> * -> *) a b c d.
    Bifunctor p =>
    (a -> b) -> (c -> d) -> p a c -> p b d
    bimap a -> c
    f b -> c
    g These a b
    t

    -------------------------------------------------------------------------------
    -- Partitioning
    -------------------------------------------------------------------------------

    -- | Select each constructor and partition them into separate lists.
    partitionThese :: [These a b] -> ([a], [b], [(a, b)])
    partitionThese :: forall a b. [These a b] -> ([a], [b], [(a, b)])
    partitionThese []     = ([], [], [])
    partitionThese (These a b
    t:[These a b]
    ts) = case These a b
    t of
        This a
    x    -> (a
    x a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    : [a]
    xs,     [b]
    ys,         [(a, b)]
    xys)
        That b
    y    -> (    [a]
    xs, b
    y b -> [b] -> [b]
    forall a. a -> [a] -> [a]
    : [b]
    ys,         [(a, b)]
    xys)
        These a
    x b
    y -> (    [a]
    xs,     [b]
    ys, (a
    x,b
    y) (a, b) -> [(a, b)] -> [(a, b)]
    forall a. a -> [a] -> [a]
    : [(a, b)]
    xys)
      where
        ~([a]
    xs,[b]
    ys,[(a, b)]
    xys) = [These a b] -> ([a], [b], [(a, b)])
    forall a b. [These a b] -> ([a], [b], [(a, b)])
    partitionThese [These a b]
    ts

    -- | Select 'here' and 'there' elements and partition them into separate lists.
    --
    -- @since 0.8
    partitionHereThere :: [These a b] -> ([a], [b])
    partitionHereThere :: forall a b. [These a b] -> ([a], [b])
    partitionHereThere []     = ([], [])
    partitionHereThere (These a b
    t:[These a b]
    ts) = case These a b
    t of
        This a
    x     -> (a
    x a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    : [a]
    xs,     [b]
    ys)
        That b
    y     -> (    [a]
    xs, b
    y b -> [b] -> [b]
    forall a. a -> [a] -> [a]
    : [b]
    ys)
        These a
    x  b
    y -> (a
    x a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    : [a]
    xs, b
    y b -> [b] -> [b]
    forall a. a -> [a] -> [a]
    : [b]
    ys)
      where
        ~([a]
    xs,[b]
    ys) = [These a b] -> ([a], [b])
    forall a b. [These a b] -> ([a], [b])
    partitionHereThere [These a b]
    ts

    -- | Like 'partitionEithers' but for 'NonEmpty' types.
    --
    -- * either all are 'Left'
    -- * either all are 'Right'
    -- * or there is both 'Left' and 'Right' stuff
    --
    -- /Note:/ this is not online algorithm. In the worst case it will traverse
    -- the whole list before deciding the result constructor.
    --
    -- >>> partitionEithersNE $ Left 'x' :| [Right 'y']
    -- These ('x' :| "") ('y' :| "")
    --
    -- >>> partitionEithersNE $ Left 'x' :| map Left "yz"
    -- This ('x' :| "yz")
    --
    -- @since 1.0.1
    partitionEithersNE :: NonEmpty (Either a b) -> These (NonEmpty a) (NonEmpty b)
    partitionEithersNE :: forall a b.
    NonEmpty (Either a b) -> These (NonEmpty a) (NonEmpty b)
    partitionEithersNE (Either a b
    x :| [Either a b]
    xs) = case (Either a b
    x, [a]
    ls, [b]
    rs) of
        (Left a
    y,  [a]
    ys,   [])   -> NonEmpty a -> These (NonEmpty a) (NonEmpty b)
    forall a b. a -> These a b
    This (a
    y a -> [a] -> NonEmpty a
    forall a. a -> [a] -> NonEmpty a
    :| [a]
    ys)
        (Left a
    y,  [a]
    ys,   b
    z:[b]
    zs) -> NonEmpty a -> NonEmpty b -> These (NonEmpty a) (NonEmpty b)
    forall a b. a -> b -> These a b
    These (a
    y a -> [a] -> NonEmpty a
    forall a. a -> [a] -> NonEmpty a
    :| [a]
    ys) (b
    z b -> [b] -> NonEmpty b
    forall a. a -> [a] -> NonEmpty a
    :| [b]
    zs)
        (Right b
    z, [],   [b]
    zs)   -> NonEmpty b -> These (NonEmpty a) (NonEmpty b)
    forall a b. b -> These a b
    That (b
    z b -> [b] -> NonEmpty b
    forall a. a -> [a] -> NonEmpty a
    :| [b]
    zs)
        (Right b
    z, a
    y:[a]
    ys, [b]
    zs)   -> NonEmpty a -> NonEmpty b -> These (NonEmpty a) (NonEmpty b)
    forall a b. a -> b -> These a b
    These (a
    y a -> [a] -> NonEmpty a
    forall a. a -> [a] -> NonEmpty a
    :| [a]
    ys) (b
    z b -> [b] -> NonEmpty b
    forall a. a -> [a] -> NonEmpty a
    :| [b]
    zs)
      where
        ([a]
    ls, [b]
    rs) = [Either a b] -> ([a], [b])
    forall a b. [Either a b] -> ([a], [b])
    partitionEithers [Either a b]
    xs

    -------------------------------------------------------------------------------
    -- Distributivity
    -------------------------------------------------------------------------------

    distrThesePair :: These (a, b) c -> (These a c, These b c)
    distrThesePair :: forall a b c. These (a, b) c -> (These a c, These b c)
    distrThesePair (This (a
    a, b
    b))    = (a -> These a c
    forall a b. a -> These a b
    This a
    a, b -> These b c
    forall a b. a -> These a b
    This b
    b)
    distrThesePair (That c
    c)         = (c -> These a c
    forall a b. b -> These a b
    That c
    c, c -> These b c
    forall a b. b -> These a b
    That c
    c)
    distrThesePair (These (a
    a, b
    b) c
    c) = (a -> c -> These a c
    forall a b. a -> b -> These a b
    These a
    a c
    c, b -> c -> These b c
    forall a b. a -> b -> These a b
    These b
    b c
    c)

    undistrThesePair :: (These a c, These b c) -> These (a, b) c
    undistrThesePair :: forall a c b. (These a c, These b c) -> These (a, b) c
    undistrThesePair (This a
    a,    This b
    b)    = (a, b) -> These (a, b) c
    forall a b. a -> These a b
    This (a
    a, b
    b)
    undistrThesePair (That c
    c,    That c
    _)    = c -> These (a, b) c
    forall a b. b -> These a b
    That c
    c
    undistrThesePair (These a
    a c
    c, These b
    b c
    _) = (a, b) -> c -> These (a, b) c
    forall a b. a -> b -> These a b
    These (a
    a, b
    b) c
    c
    undistrThesePair (This a
    _,    That c
    c)    = c -> These (a, b) c
    forall a b. b -> These a b
    That c
    c
    undistrThesePair (This a
    a,    These b
    b c
    c) = (a, b) -> c -> These (a, b) c
    forall a b. a -> b -> These a b
    These (a
    a, b
    b) c
    c
    undistrThesePair (That c
    c,    This b
    _)    = c -> These (a, b) c
    forall a b. b -> These a b
    That c
    c
    undistrThesePair (That c
    c,    These b
    _ c
    _) = c -> These (a, b) c
    forall a b. b -> These a b
    That c
    c
    undistrThesePair (These a
    a c
    c, This b
    b)    = (a, b) -> c -> These (a, b) c
    forall a b. a -> b -> These a b
    These (a
    a, b
    b) c
    c
    undistrThesePair (These a
    _ c
    c, That c
    _)    = c -> These (a, b) c
    forall a b. b -> These a b
    That c
    c

    distrPairThese :: (These a b, c) -> These (a, c) (b, c)
    distrPairThese :: forall a b c. (These a b, c) -> These (a, c) (b, c)
    distrPairThese (This a
    a,    c
    c) = (a, c) -> These (a, c) (b, c)
    forall a b. a -> These a b
    This (a
    a, c
    c)
    distrPairThese (That b
    b,    c
    c) = (b, c) -> These (a, c) (b, c)
    forall a b. b -> These a b
    That (b
    b, c
    c)
    distrPairThese (These a
    a b
    b, c
    c) = (a, c) -> (b, c) -> These (a, c) (b, c)
    forall a b. a -> b -> These a b
    These (a
    a, c
    c) (b
    b, c
    c)

    undistrPairThese :: These (a, c) (b, c) -> (These a b, c)
    undistrPairThese :: forall a c b. These (a, c) (b, c) -> (These a b, c)
    undistrPairThese (This (a
    a, c
    c))         = (a -> These a b
    forall a b. a -> These a b
    This a
    a, c
    c)
    undistrPairThese (That (b
    b, c
    c))         = (b -> These a b
    forall a b. b -> These a b
    That b
    b, c
    c)
    undistrPairThese (These (a
    a, c
    c) (b
    b, c
    _)) = (a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a b
    b, c
    c)

    -------------------------------------------------------------------------------
    -- Instances
    -------------------------------------------------------------------------------

    instance (Semigroup a, Semigroup b) => Semigroup (These a b) where
        This  a
    a   <> :: These a b -> These a b -> These a b
    <> This  a
    b   = a -> These a b
    forall a b. a -> These a b
    This  (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b)
        This  a
    a   <> That    b
    y = a -> b -> These a b
    forall a b. a -> b -> These a b
    These  a
    a             b
    y
        This  a
    a   <> These a
    b b
    y = a -> b -> These a b
    forall a b. a -> b -> These a b
    These (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b)       b
    y
        That    b
    x <> This  a
    b   = a -> b -> These a b
    forall a b. a -> b -> These a b
    These       a
    b   b
    x
        That    b
    x <> That    b
    y = b -> These a b
    forall a b. b -> These a b
    That           (b
    x b -> b -> b
    forall a. Semigroup a => a -> a -> a
    <> b
    y)
        That    b
    x <> These a
    b b
    y = a -> b -> These a b
    forall a b. a -> b -> These a b
    These       a
    b  (b
    x b -> b -> b
    forall a. Semigroup a => a -> a -> a
    <> b
    y)
        These a
    a b
    x <> This  a
    b   = a -> b -> These a b
    forall a b. a -> b -> These a b
    These (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b)  b
    x
        These a
    a b
    x <> That    b
    y = a -> b -> These a b
    forall a b. a -> b -> These a b
    These  a
    a       (b
    x b -> b -> b
    forall a. Semigroup a => a -> a -> a
    <> b
    y)
        These a
    a b
    x <> These a
    b b
    y = a -> b -> These a b
    forall a b. a -> b -> These a b
    These (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b) (b
    x b -> b -> b
    forall a. Semigroup a => a -> a -> a
    <> b
    y)

    instance Functor (These a) where
        fmap :: forall a b. (a -> b) -> These a a -> These a b
    fmap a -> b
    _ (This a
    x) = a -> These a b
    forall a b. a -> These a b
    This a
    x
        fmap a -> b
    f (That a
    y) = b -> These a b
    forall a b. b -> These a b
    That (a -> b
    f a
    y)
        fmap a -> b
    f (These a
    x a
    y) = a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    x (a -> b
    f a
    y)

    instance Foldable (These a) where
        foldr :: forall a b. (a -> b -> b) -> b -> These a a -> b
    foldr a -> b -> b
    _ b
    z (This a
    _) = b
    z
        foldr a -> b -> b
    f b
    z (That a
    x) = a -> b -> b
    f a
    x b
    z
        foldr a -> b -> b
    f b
    z (These a
    _ a
    x) = a -> b -> b
    f a
    x b
    z

    instance Traversable (These a) where
        traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> These a a -> f (These a b)
    traverse a -> f b
    _ (This a
    a) = These a b -> f (These a b)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (These a b -> f (These a b)) -> These a b -> f (These a b)
    forall a b. (a -> b) -> a -> b
    $ a -> These a b
    forall a b. a -> These a b
    This a
    a
        traverse a -> f b
    f (That a
    x) = b -> These a b
    forall a b. b -> These a b
    That (b -> These a b) -> f b -> f (These a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    f a
    x
        traverse a -> f b
    f (These a
    a a
    x) = a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a (b -> These a b) -> f b -> f (These a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    f a
    x
        sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    These a (f a) -> f (These a a)
    sequenceA (This a
    a) = These a a -> f (These a a)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (These a a -> f (These a a)) -> These a a -> f (These a a)
    forall a b. (a -> b) -> a -> b
    $ a -> These a a
    forall a b. a -> These a b
    This a
    a
        sequenceA (That f a
    x) = a -> These a a
    forall a b. b -> These a b
    That (a -> These a a) -> f a -> f (These a a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f a
    x
        sequenceA (These a
    a f a
    x) = a -> a -> These a a
    forall a b. a -> b -> These a b
    These a
    a (a -> These a a) -> f a -> f (These a a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f a
    x

    instance Bifunctor These where
        bimap :: forall a b c d. (a -> b) -> (c -> d) -> These a c -> These b d
    bimap a -> b
    f c -> d
    _ (This  a
    a  ) = b -> These b d
    forall a b. a -> These a b
    This (a -> b
    f a
    a)
        bimap a -> b
    _ c -> d
    g (That    c
    x) = d -> These b d
    forall a b. b -> These a b
    That (c -> d
    g c
    x)
        bimap a -> b
    f c -> d
    g (These a
    a c
    x) = b -> d -> These b d
    forall a b. a -> b -> These a b
    These (a -> b
    f a
    a) (c -> d
    g c
    x)

    instance Bifoldable These where
        bifold :: forall m. Monoid m => These m m -> m
    bifold = (m -> m) -> (m -> m) -> (m -> m -> m) -> These m m -> m
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these m -> m
    forall a. a -> a
    id m -> m
    forall a. a -> a
    id m -> m -> m
    forall a. Monoid a => a -> a -> a
    mappend
        bifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> These a b -> m
    bifoldMap a -> m
    f b -> m
    g = (a -> m) -> (b -> m) -> (a -> b -> m) -> These a b -> m
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these a -> m
    f b -> m
    g (\a
    x b
    y -> m -> m -> m
    forall a. Monoid a => a -> a -> a
    mappend (a -> m
    f a
    x) (b -> m
    g b
    y))
        bifoldr :: forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> These a b -> c
    bifoldr a -> c -> c
    f b -> c -> c
    g c
    z = (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these (a -> c -> c
    `f` c
    z) (b -> c -> c
    `g` c
    z) (\a
    x b
    y -> a
    x a -> c -> c
    `f` (b
    y b -> c -> c
    `g` c
    z))
        bifoldl :: forall c a b. (c -> a -> c) -> (c -> b -> c) -> c -> These a b -> c
    bifoldl c -> a -> c
    f c -> b -> c
    g c
    z = (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these (c
    z c -> a -> c
    `f`) (c
    z c -> b -> c
    `g`) (\a
    x b
    y -> (c
    z c -> a -> c
    `f` a
    x) c -> b -> c
    `g` b
    y)

    -- | @since 1.2
    instance Bifoldable1 These where
        bifold1 :: forall m. Semigroup m => These m m -> m
    bifold1 = (m -> m) -> (m -> m) -> (m -> m -> m) -> These m m -> m
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these m -> m
    forall a. a -> a
    id m -> m
    forall a. a -> a
    id m -> m -> m
    forall a. Semigroup a => a -> a -> a
    (<>)
        bifoldMap1 :: forall m a b. Semigroup m => (a -> m) -> (b -> m) -> These a b -> m
    bifoldMap1 a -> m
    f b -> m
    g = (a -> m) -> (b -> m) -> (a -> b -> m) -> These a b -> m
    forall a c b.
    (a -> c) -> (b -> c) -> (a -> b -> c) -> These a b -> c
    these a -> m
    f b -> m
    g (\a
    x b
    y -> a -> m
    f a
    x m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> b -> m
    g b
    y)

    instance Bitraversable These where
        bitraverse :: forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> These a b -> f (These c d)
    bitraverse a -> f c
    f b -> f d
    _ (This a
    x) = c -> These c d
    forall a b. a -> These a b
    This (c -> These c d) -> f c -> f (These c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f c
    f a
    x
        bitraverse a -> f c
    _ b -> f d
    g (That b
    x) = d -> These c d
    forall a b. b -> These a b
    That (d -> These c d) -> f d -> f (These c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> b -> f d
    g b
    x
        bitraverse a -> f c
    f b -> f d
    g (These a
    x b
    y) = c -> d -> These c d
    forall a b. a -> b -> These a b
    These (c -> d -> These c d) -> f c -> f (d -> These c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f c
    f a
    x f (d -> These c d) -> f d -> f (These c d)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> b -> f d
    g b
    y

    instance (Semigroup a) => Applicative (These a) where
        pure :: forall a. a -> These a a
    pure = a -> These a a
    forall a b. b -> These a b
    That
        This  a
    a   <*> :: forall a b. These a (a -> b) -> These a a -> These a b
    <*> These a a
    _         = a -> These a b
    forall a b. a -> These a b
    This a
    a
        That    a -> b
    _ <*> This  a
    b   = a -> These a b
    forall a b. a -> These a b
    This a
    b
        That    a -> b
    f <*> That    a
    x = b -> These a b
    forall a b. b -> These a b
    That (a -> b
    f a
    x)
        That    a -> b
    f <*> These a
    b a
    x = a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    b (a -> b
    f a
    x)
        These a
    a a -> b
    _ <*> This  a
    b   = a -> These a b
    forall a b. a -> These a b
    This (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b)
        These a
    a a -> b
    f <*> That    a
    x = a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a (a -> b
    f a
    x)
        These a
    a a -> b
    f <*> These a
    b a
    x = a -> b -> These a b
    forall a b. a -> b -> These a b
    These (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b) (a -> b
    f a
    x)

    instance (Semigroup a) => Monad (These a) where
        return :: forall a. a -> These a a
    return = a -> These a a
    forall a. a -> These a a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
        This  a
    a   >>= :: forall a b. These a a -> (a -> These a b) -> These a b
    >>= a -> These a b
    _ = a -> These a b
    forall a b. a -> These a b
    This a
    a
        That    a
    x >>= a -> These a b
    k = a -> These a b
    k a
    x
        These a
    a a
    x >>= a -> These a b
    k = case a -> These a b
    k a
    x of
                              This  a
    b   -> a -> These a b
    forall a b. a -> These a b
    This  (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b)
                              That    b
    y -> a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a b
    y
                              These a
    b b
    y -> a -> b -> These a b
    forall a b. a -> b -> These a b
    These (a
    a a -> a -> a
    forall a. Semigroup a => a -> a -> a
    <> a
    b) b
    y

    -------------------------------------------------------------------------------
    -- Data.Functor.Classes
    -------------------------------------------------------------------------------

    #ifdef LIFTED_FUNCTOR_CLASSES
    -- | @since 1.1.1
    instance Eq2 These where
      liftEq2 :: forall a b c d.
    (a -> b -> Bool)
    -> (c -> d -> Bool) -> These a c -> These b d -> Bool
    liftEq2 a -> b -> Bool
    f c -> d -> Bool
    _ (This a
    a)    (This b
    a')     = a -> b -> Bool
    f a
    a b
    a'
      liftEq2 a -> b -> Bool
    _ c -> d -> Bool
    g (That c
    b)    (That d
    b')     = c -> d -> Bool
    g c
    b d
    b'
      liftEq2 a -> b -> Bool
    f c -> d -> Bool
    g (These a
    a c
    b) (These b
    a' d
    b') = a -> b -> Bool
    f a
    a b
    a' Bool -> Bool -> Bool
    && c -> d -> Bool
    g c
    b d
    b'
      liftEq2 a -> b -> Bool
    _ c -> d -> Bool
    _ These a c
    _           These b d
    _             = Bool
    False

    -- | @since 1.1.1
    instance Eq a => Eq1 (These a) where
      liftEq :: forall a b. (a -> b -> Bool) -> These a a -> These a b -> Bool
    liftEq = (a -> a -> Bool)
    -> (a -> b -> Bool) -> These a a -> These a b -> Bool
    forall a b c d.
    (a -> b -> Bool)
    -> (c -> d -> Bool) -> These a c -> These b d -> Bool
    forall (f :: * -> * -> *) a b c d.
    Eq2 f =>
    (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool
    liftEq2 a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    (==)

    -- | @since 1.1.1
    instance Ord2 These where
      liftCompare2 :: forall a b c d.
    (a -> b -> Ordering)
    -> (c -> d -> Ordering) -> These a c -> These b d -> Ordering
    liftCompare2 a -> b -> Ordering
    f c -> d -> Ordering
    _ (This a
    a)    (This b
    a')     = a -> b -> Ordering
    f a
    a b
    a'
      liftCompare2 a -> b -> Ordering
    _ c -> d -> Ordering
    _ (This a
    _)    These b d
    _             = Ordering
    LT
      liftCompare2 a -> b -> Ordering
    _ c -> d -> Ordering
    _ These a c
    _           (This b
    _)      = Ordering
    GT
      liftCompare2 a -> b -> Ordering
    _ c -> d -> Ordering
    g (That c
    b)    (That d
    b')     = c -> d -> Ordering
    g c
    b d
    b'
      liftCompare2 a -> b -> Ordering
    _ c -> d -> Ordering
    _ (That c
    _)    These b d
    _             = Ordering
    LT
      liftCompare2 a -> b -> Ordering
    _ c -> d -> Ordering
    _ These a c
    _           (That d
    _)      = Ordering
    GT
      liftCompare2 a -> b -> Ordering
    f c -> d -> Ordering
    g (These a
    a c
    b) (These b
    a' d
    b') = a -> b -> Ordering
    f a
    a b
    a' Ordering -> Ordering -> Ordering
    forall a. Monoid a => a -> a -> a
    `mappend` c -> d -> Ordering
    g c
    b d
    b'

    -- | @since 1.1.1
    instance Ord a => Ord1 (These a) where
      liftCompare :: forall a b.
    (a -> b -> Ordering) -> These a a -> These a b -> Ordering
    liftCompare = (a -> a -> Ordering)
    -> (a -> b -> Ordering) -> These a a -> These a b -> Ordering
    forall a b c d.
    (a -> b -> Ordering)
    -> (c -> d -> Ordering) -> These a c -> These b d -> Ordering
    forall (f :: * -> * -> *) a b c d.
    Ord2 f =>
    (a -> b -> Ordering)
    -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
    liftCompare2 a -> a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare

    -- | @since 1.1.1
    instance Show a => Show1 (These a) where
      liftShowsPrec :: forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> These a a -> ShowS
    liftShowsPrec = (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> Int
    -> These a a
    -> ShowS
    forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> These a b
    -> ShowS
    forall (f :: * -> * -> *) a b.
    Show2 f =>
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> f a b
    -> ShowS
    liftShowsPrec2 Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec [a] -> ShowS
    forall a. Show a => [a] -> ShowS
    showList

    -- | @since 1.1.1
    instance Show2 These where
      liftShowsPrec2 :: forall a b.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS)
    -> (Int -> b -> ShowS)
    -> ([b] -> ShowS)
    -> Int
    -> These a b
    -> ShowS
    liftShowsPrec2 Int -> a -> ShowS
    sa [a] -> ShowS
    _ Int -> b -> ShowS
    _sb [b] -> ShowS
    _ Int
    d (This a
    a) = Bool -> ShowS -> ShowS
    showParen (Int
    d Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10)
        (ShowS -> ShowS) -> ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $ String -> ShowS
    showString String
    "This "
        ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    sa Int
    11 a
    a
      liftShowsPrec2 Int -> a -> ShowS
    _sa [a] -> ShowS
    _ Int -> b -> ShowS
    sb [b] -> ShowS
    _ Int
    d (That b
    b) = Bool -> ShowS -> ShowS
    showParen (Int
    d Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10)
        (ShowS -> ShowS) -> ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $ String -> ShowS
    showString String
    "That "
        ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> b -> ShowS
    sb Int
    11 b
    b
      liftShowsPrec2 Int -> a -> ShowS
    sa [a] -> ShowS
    _ Int -> b -> ShowS
    sb [b] -> ShowS
    _ Int
    d (These a
    a b
    b) = Bool -> ShowS -> ShowS
    showParen (Int
    d Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10)
        (ShowS -> ShowS) -> ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $ String -> ShowS
    showString String
    "These "
        ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a -> ShowS
    sa Int
    11 a
    a
        ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ShowS
    showString String
    " "
        ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> b -> ShowS
    sb Int
    11 b
    b

    -- | @since 1.1.1
    instance Read2 These where
      liftReadsPrec2 :: forall a b.
    (Int -> ReadS a)
    -> ReadS [a]
    -> (Int -> ReadS b)
    -> ReadS [b]
    -> Int
    -> ReadS (These a b)
    liftReadsPrec2 Int -> ReadS a
    ra ReadS [a]
    _ Int -> ReadS b
    rb ReadS [b]
    _ Int
    d = Bool -> ReadS (These a b) -> ReadS (These a b)
    forall a. Bool -> ReadS a -> ReadS a
    readParen (Int
    d Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    10) (ReadS (These a b) -> ReadS (These a b))
    -> ReadS (These a b) -> ReadS (These a b)
    forall a b. (a -> b) -> a -> b
    $ \String
    s -> ReadS (These a b)
    cons String
    s
        where
          cons :: ReadS (These a b)
    cons String
    s0 = do
            (String
    ident, String
    s1) <- ReadS String
    lex String
    s0
            case String
    ident of
                String
    "This" ->  do
                    (a
    a, String
    s2) <- Int -> ReadS a
    ra Int
    11 String
    s1
                    (These a b, String) -> [(These a b, String)]
    forall a. a -> [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> These a b
    forall a b. a -> These a b
    This a
    a, String
    s2)
                String
    "That" ->  do
                    (b
    b, String
    s2) <- Int -> ReadS b
    rb Int
    11 String
    s1
                    (These a b, String) -> [(These a b, String)]
    forall a. a -> [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (b -> These a b
    forall a b. b -> These a b
    That b
    b, String
    s2)
                String
    "These" -> do
                    (a
    a, String
    s2) <- Int -> ReadS a
    ra Int
    11 String
    s1
                    (b
    b, String
    s3) <- Int -> ReadS b
    rb Int
    11 String
    s2
                    (These a b, String) -> [(These a b, String)]
    forall a. a -> [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a b
    b, String
    s3)
                String
    _ -> []

    -- | @since 1.1.1
    instance Read a => Read1 (These a) where
      liftReadsPrec :: forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (These a a)
    liftReadsPrec = (Int -> ReadS a)
    -> ReadS [a]
    -> (Int -> ReadS a)
    -> ReadS [a]
    -> Int
    -> ReadS (These a a)
    forall a b.
    (Int -> ReadS a)
    -> ReadS [a]
    -> (Int -> ReadS b)
    -> ReadS [b]
    -> Int
    -> ReadS (These a b)
    forall (f :: * -> * -> *) a b.
    Read2 f =>
    (Int -> ReadS a)
    -> ReadS [a]
    -> (Int -> ReadS b)
    -> ReadS [b]
    -> Int
    -> ReadS (f a b)
    liftReadsPrec2 Int -> ReadS a
    forall a. Read a => Int -> ReadS a
    readsPrec ReadS [a]
    forall a. Read a => ReadS [a]
    readList

    #else
    -- | @since 1.1.1
    instance Eq a   => Eq1   (These a) where eq1        = (==)
    -- | @since 1.1.1
    instance Ord a  => Ord1  (These a) where compare1   = compare
    -- | @since 1.1.1
    instance Show a => Show1 (These a) where showsPrec1 = showsPrec
    -- | @since 1.1.1
    instance Read a => Read1 (These a) where readsPrec1 = readsPrec
    #endif

    -------------------------------------------------------------------------------
    -- assoc
    -------------------------------------------------------------------------------

    -- | @since 0.8
    instance Swap These where
        swap :: forall a b. These a b -> These b a
    swap (This a
    a)    = a -> These b a
    forall a b. b -> These a b
    That a
    a
        swap (That b
    b)    = b -> These b a
    forall a b. a -> These a b
    This b
    b
        swap (These a
    a b
    b) = b -> a -> These b a
    forall a b. a -> b -> These a b
    These b
    b a
    a

    -- | @since 0.8
    instance Assoc These where
        assoc :: forall a b c. These (These a b) c -> These a (These b c)
    assoc (This (This a
    a))       = a -> These a (These b c)
    forall a b. a -> These a b
    This a
    a
        assoc (This (That b
    b))       = These b c -> These a (These b c)
    forall a b. b -> These a b
    That (b -> These b c
    forall a b. a -> These a b
    This b
    b)
        assoc (That c
    c)              = These b c -> These a (These b c)
    forall a b. b -> These a b
    That (c -> These b c
    forall a b. b -> These a b
    That c
    c)
        assoc (These (That b
    b) c
    c)    = These b c -> These a (These b c)
    forall a b. b -> These a b
    That (b -> c -> These b c
    forall a b. a -> b -> These a b
    These b
    b c
    c)
        assoc (This (These a
    a b
    b))    = a -> These b c -> These a (These b c)
    forall a b. a -> b -> These a b
    These a
    a (b -> These b c
    forall a b. a -> These a b
    This b
    b)
        assoc (These (This a
    a) c
    c)    = a -> These b c -> These a (These b c)
    forall a b. a -> b -> These a b
    These a
    a (c -> These b c
    forall a b. b -> These a b
    That c
    c)
        assoc (These (These a
    a b
    b) c
    c) = a -> These b c -> These a (These b c)
    forall a b. a -> b -> These a b
    These a
    a (b -> c -> These b c
    forall a b. a -> b -> These a b
    These b
    b c
    c)

        unassoc :: forall a b c. These a (These b c) -> These (These a b) c
    unassoc (This a
    a)              = These a b -> These (These a b) c
    forall a b. a -> These a b
    This (a -> These a b
    forall a b. a -> These a b
    This a
    a)
        unassoc (That (This b
    b))       = These a b -> These (These a b) c
    forall a b. a -> These a b
    This (b -> These a b
    forall a b. b -> These a b
    That b
    b)
        unassoc (That (That c
    c))       = c -> These (These a b) c
    forall a b. b -> These a b
    That c
    c
        unassoc (That (These b
    b c
    c))    = These a b -> c -> These (These a b) c
    forall a b. a -> b -> These a b
    These (b -> These a b
    forall a b. b -> These a b
    That b
    b) c
    c
        unassoc (These a
    a (This b
    b))    = These a b -> These (These a b) c
    forall a b. a -> These a b
    This (a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a b
    b)
        unassoc (These a
    a (That c
    c))    = These a b -> c -> These (These a b) c
    forall a b. a -> b -> These a b
    These (a -> These a b
    forall a b. a -> These a b
    This a
    a) c
    c
        unassoc (These a
    a (These b
    b c
    c)) = These a b -> c -> These (These a b) c
    forall a b. a -> b -> These a b
    These (a -> b -> These a b
    forall a b. a -> b -> These a b
    These a
    a b
    b) c
    c

    -------------------------------------------------------------------------------
    -- deepseq
    -------------------------------------------------------------------------------

    -- | @since 0.7.1
    instance (NFData a, NFData b) => NFData (These a b) where
        rnf :: These a b -> ()
    rnf (This a
    a)    = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a
        rnf (That b
    b)    = b -> ()
    forall a. NFData a => a -> ()
    rnf b
    b
        rnf (These a
    a b
    b) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` b -> ()
    forall a. NFData a => a -> ()
    rnf b
    b

    #if MIN_VERSION_deepseq(1,4,3)
    -- | @since 1.1.1
    instance NFData a => NFData1 (These a) where
        liftRnf :: forall a. (a -> ()) -> These a a -> ()
    liftRnf a -> ()
    _rnfB (This a
    a)    = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a
        liftRnf  a -> ()
    rnfB (That a
    b)    = a -> ()
    rnfB a
    b
        liftRnf  a -> ()
    rnfB (These a
    a a
    b) = a -> ()
    forall a. NFData a => a -> ()
    rnf a
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` a -> ()
    rnfB a
    b

    -- | @since 1.1.1
    instance NFData2 These where
        liftRnf2 :: forall a b. (a -> ()) -> (b -> ()) -> These a b -> ()
    liftRnf2  a -> ()
    rnfA b -> ()
    _rnfB (This a
    a)    = a -> ()
    rnfA a
    a
        liftRnf2 a -> ()
    _rnfA  b -> ()
    rnfB (That b
    b)    = b -> ()
    rnfB b
    b
        liftRnf2  a -> ()
    rnfA  b -> ()
    rnfB (These a
    a b
    b) = a -> ()
    rnfA a
    a () -> () -> ()
    forall a b. a -> b -> b
    `seq` b -> ()
    rnfB b
    b
    #endif

    -------------------------------------------------------------------------------
    -- binary
    -------------------------------------------------------------------------------

    -- | @since 0.7.1
    instance (Binary a, Binary b) => Binary (These a b) where
        put :: These a b -> Put
    put (This a
    a)    = Int -> Put
    forall t. Binary t => t -> Put
    put (Int
    0 :: Int) Put -> Put -> Put
    forall a b. PutM a -> PutM b -> PutM b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> a -> Put
    forall t. Binary t => t -> Put
    put a
    a
        put (That b
    b)    = Int -> Put
    forall t. Binary t => t -> Put
    put (Int
    1 :: Int) Put -> Put -> Put
    forall a b. PutM a -> PutM b -> PutM b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> b -> Put
    forall t. Binary t => t -> Put
    put b
    b
        put (These a
    a b
    b) = Int -> Put
    forall t. Binary t => t -> Put
    put (Int
    2 :: Int) Put -> Put -> Put
    forall a b. PutM a -> PutM b -> PutM b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> a -> Put
    forall t. Binary t => t -> Put
    put a
    a Put -> Put -> Put
    forall a b. PutM a -> PutM b -> PutM b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> b -> Put
    forall t. Binary t => t -> Put
    put b
    b

        get :: Get (These a b)
    get = do
            Int
    i <- Get Int
    forall t. Binary t => Get t
    get
            case (Int
    i :: Int) of
                Int
    0 -> a -> These a b
    forall a b. a -> These a b
    This (a -> These a b) -> Get a -> Get (These a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Get a
    forall t. Binary t => Get t
    get
                Int
    1 -> b -> These a b
    forall a b. b -> These a b
    That (b -> These a b) -> Get b -> Get (These a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Get b
    forall t. Binary t => Get t
    get
                Int
    2 -> a -> b -> These a b
    forall a b. a -> b -> These a b
    These (a -> b -> These a b) -> Get a -> Get (b -> These a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Get a
    forall t. Binary t => Get t
    get Get (b -> These a b) -> Get b -> Get (These a b)
    forall a b. Get (a -> b) -> Get a -> Get b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Get b
    forall t. Binary t => Get t
    get
                Int
    _ -> String -> Get (These a b)
    forall a. String -> Get a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Invalid These index"

    -------------------------------------------------------------------------------
    -- hashable
    -------------------------------------------------------------------------------

    instance (Hashable a, Hashable b) => Hashable (These a b) where
        hashWithSalt :: Int -> These a b -> Int
    hashWithSalt Int
    salt (This a
    a) =
            Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    0 :: Int) Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    a
        hashWithSalt Int
    salt (That b
    b) =
            Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    1 :: Int) Int -> b -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` b
    b
        hashWithSalt Int
    salt (These a
    a b
    b) =
            Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    2 :: Int) Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    a Int -> b -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` b
    b

    -- | @since 1.1.1
    instance Hashable a => Hashable1 (These a) where
        liftHashWithSalt :: forall a. (Int -> a -> Int) -> Int -> These a a -> Int
    liftHashWithSalt Int -> a -> Int
    _hashB Int
    salt (This a
    a) =
            Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    0 :: Int) Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    a
        liftHashWithSalt  Int -> a -> Int
    hashB Int
    salt (That a
    b) =
            (Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    1 :: Int)) Int -> a -> Int
    `hashB` a
    b
        liftHashWithSalt  Int -> a -> Int
    hashB Int
    salt (These a
    a a
    b) =
            (Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    2 :: Int) Int -> a -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` a
    a) Int -> a -> Int
    `hashB` a
    b

    -- | @since 1.1.1
    instance Hashable2 These where
        liftHashWithSalt2 :: forall a b.
    (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> These a b -> Int
    liftHashWithSalt2  Int -> a -> Int
    hashA Int -> b -> Int
    _hashB Int
    salt (This a
    a) =
            (Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    0 :: Int)) Int -> a -> Int
    `hashA` a
    a
        liftHashWithSalt2 Int -> a -> Int
    _hashA  Int -> b -> Int
    hashB Int
    salt (That b
    b) =
            (Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    1 :: Int)) Int -> b -> Int
    `hashB` b
    b
        liftHashWithSalt2  Int -> a -> Int
    hashA  Int -> b -> Int
    hashB Int
    salt (These a
    a b
    b) =
            (Int
    salt Int -> Int -> Int
    forall a. Hashable a => Int -> a -> Int
    `hashWithSalt` (Int
    2 :: Int)) Int -> a -> Int
    `hashA` a
    a Int -> b -> Int
    `hashB` b
    b