module Data.Either.Semigroup
  ( EitherS (LeftS, RightS)
  , toEither
  , unLeftS
  , unRightS
  , eitherS
  , leftsS
  , rightsS
  ) where

import Control.Monad.Fix (MonadFix (mfix))
import Data.Bifoldable (Bifoldable (bifoldMap))
import Data.Bifoldable1
import Data.Bifunctor (Bifunctor (bimap))
import Data.Bitraversable (Bitraversable (bitraverse))
import Data.Data (Data, Typeable)
import Data.Functor.Classes
import GHC.Generics (Generic, Generic1)

-- | The 'EitherS' type represents values with two possibilities:
-- a value of type 'EitherS' @a b@ is either 'LeftS' @a@ or 'RightS' @b@.
--
-- The 'EitherS' type is sometimes used to represent a value which is either correct or an error;
-- by convention, the 'LeftS' constructor is used to hold an error value and the 'RightS' constructor
-- is used to hold a correct value (mnemonic: "right" also means "correct").
--
-- This type differs from 'Data.Either.Either' in the 'Semigroup' instance, requiring
-- the 'LeftS' type to be a 'Semigroup' in the first place.
data EitherS l r = LeftS l | RightS r
  deriving (EitherS l r -> EitherS l r -> Bool
(EitherS l r -> EitherS l r -> Bool)
-> (EitherS l r -> EitherS l r -> Bool) -> Eq (EitherS l r)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall l r. (Eq l, Eq r) => EitherS l r -> EitherS l r -> Bool
$c== :: forall l r. (Eq l, Eq r) => EitherS l r -> EitherS l r -> Bool
== :: EitherS l r -> EitherS l r -> Bool
$c/= :: forall l r. (Eq l, Eq r) => EitherS l r -> EitherS l r -> Bool
/= :: EitherS l r -> EitherS l r -> Bool
Eq, Eq (EitherS l r)
Eq (EitherS l r) =>
(EitherS l r -> EitherS l r -> Ordering)
-> (EitherS l r -> EitherS l r -> Bool)
-> (EitherS l r -> EitherS l r -> Bool)
-> (EitherS l r -> EitherS l r -> Bool)
-> (EitherS l r -> EitherS l r -> Bool)
-> (EitherS l r -> EitherS l r -> EitherS l r)
-> (EitherS l r -> EitherS l r -> EitherS l r)
-> Ord (EitherS l r)
EitherS l r -> EitherS l r -> Bool
EitherS l r -> EitherS l r -> Ordering
EitherS l r -> EitherS l r -> EitherS l r
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 l r. (Ord l, Ord r) => Eq (EitherS l r)
forall l r. (Ord l, Ord r) => EitherS l r -> EitherS l r -> Bool
forall l r.
(Ord l, Ord r) =>
EitherS l r -> EitherS l r -> Ordering
forall l r.
(Ord l, Ord r) =>
EitherS l r -> EitherS l r -> EitherS l r
$ccompare :: forall l r.
(Ord l, Ord r) =>
EitherS l r -> EitherS l r -> Ordering
compare :: EitherS l r -> EitherS l r -> Ordering
$c< :: forall l r. (Ord l, Ord r) => EitherS l r -> EitherS l r -> Bool
< :: EitherS l r -> EitherS l r -> Bool
$c<= :: forall l r. (Ord l, Ord r) => EitherS l r -> EitherS l r -> Bool
<= :: EitherS l r -> EitherS l r -> Bool
$c> :: forall l r. (Ord l, Ord r) => EitherS l r -> EitherS l r -> Bool
> :: EitherS l r -> EitherS l r -> Bool
$c>= :: forall l r. (Ord l, Ord r) => EitherS l r -> EitherS l r -> Bool
>= :: EitherS l r -> EitherS l r -> Bool
$cmax :: forall l r.
(Ord l, Ord r) =>
EitherS l r -> EitherS l r -> EitherS l r
max :: EitherS l r -> EitherS l r -> EitherS l r
$cmin :: forall l r.
(Ord l, Ord r) =>
EitherS l r -> EitherS l r -> EitherS l r
min :: EitherS l r -> EitherS l r -> EitherS l r
Ord, Int -> EitherS l r -> ShowS
[EitherS l r] -> ShowS
EitherS l r -> String
(Int -> EitherS l r -> ShowS)
-> (EitherS l r -> String)
-> ([EitherS l r] -> ShowS)
-> Show (EitherS l r)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall l r. (Show l, Show r) => Int -> EitherS l r -> ShowS
forall l r. (Show l, Show r) => [EitherS l r] -> ShowS
forall l r. (Show l, Show r) => EitherS l r -> String
$cshowsPrec :: forall l r. (Show l, Show r) => Int -> EitherS l r -> ShowS
showsPrec :: Int -> EitherS l r -> ShowS
$cshow :: forall l r. (Show l, Show r) => EitherS l r -> String
show :: EitherS l r -> String
$cshowList :: forall l r. (Show l, Show r) => [EitherS l r] -> ShowS
showList :: [EitherS l r] -> ShowS
Show, ReadPrec [EitherS l r]
ReadPrec (EitherS l r)
Int -> ReadS (EitherS l r)
ReadS [EitherS l r]
(Int -> ReadS (EitherS l r))
-> ReadS [EitherS l r]
-> ReadPrec (EitherS l r)
-> ReadPrec [EitherS l r]
-> Read (EitherS l r)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall l r. (Read l, Read r) => ReadPrec [EitherS l r]
forall l r. (Read l, Read r) => ReadPrec (EitherS l r)
forall l r. (Read l, Read r) => Int -> ReadS (EitherS l r)
forall l r. (Read l, Read r) => ReadS [EitherS l r]
$creadsPrec :: forall l r. (Read l, Read r) => Int -> ReadS (EitherS l r)
readsPrec :: Int -> ReadS (EitherS l r)
$creadList :: forall l r. (Read l, Read r) => ReadS [EitherS l r]
readList :: ReadS [EitherS l r]
$creadPrec :: forall l r. (Read l, Read r) => ReadPrec (EitherS l r)
readPrec :: ReadPrec (EitherS l r)
$creadListPrec :: forall l r. (Read l, Read r) => ReadPrec [EitherS l r]
readListPrec :: ReadPrec [EitherS l r]
Read, (forall a b. (a -> b) -> EitherS l a -> EitherS l b)
-> (forall a b. a -> EitherS l b -> EitherS l a)
-> Functor (EitherS l)
forall a b. a -> EitherS l b -> EitherS l a
forall a b. (a -> b) -> EitherS l a -> EitherS l b
forall l a b. a -> EitherS l b -> EitherS l a
forall l a b. (a -> b) -> EitherS l a -> EitherS l b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall l a b. (a -> b) -> EitherS l a -> EitherS l b
fmap :: forall a b. (a -> b) -> EitherS l a -> EitherS l b
$c<$ :: forall l a b. a -> EitherS l b -> EitherS l a
<$ :: forall a b. a -> EitherS l b -> EitherS l a
Functor, (forall x. EitherS l r -> Rep (EitherS l r) x)
-> (forall x. Rep (EitherS l r) x -> EitherS l r)
-> Generic (EitherS l r)
forall x. Rep (EitherS l r) x -> EitherS l r
forall x. EitherS l r -> Rep (EitherS l r) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l r x. Rep (EitherS l r) x -> EitherS l r
forall l r x. EitherS l r -> Rep (EitherS l r) x
$cfrom :: forall l r x. EitherS l r -> Rep (EitherS l r) x
from :: forall x. EitherS l r -> Rep (EitherS l r) x
$cto :: forall l r x. Rep (EitherS l r) x -> EitherS l r
to :: forall x. Rep (EitherS l r) x -> EitherS l r
Generic, (forall a. EitherS l a -> Rep1 (EitherS l) a)
-> (forall a. Rep1 (EitherS l) a -> EitherS l a)
-> Generic1 (EitherS l)
forall a. Rep1 (EitherS l) a -> EitherS l a
forall a. EitherS l a -> Rep1 (EitherS l) a
forall l a. Rep1 (EitherS l) a -> EitherS l a
forall l a. EitherS l a -> Rep1 (EitherS l) 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 l a. EitherS l a -> Rep1 (EitherS l) a
from1 :: forall a. EitherS l a -> Rep1 (EitherS l) a
$cto1 :: forall l a. Rep1 (EitherS l) a -> EitherS l a
to1 :: forall a. Rep1 (EitherS l) a -> EitherS l a
Generic1, Typeable (EitherS l r)
Typeable (EitherS l r) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EitherS l r -> c (EitherS l r))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EitherS l r))
-> (EitherS l r -> Constr)
-> (EitherS l r -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EitherS l r)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EitherS l r)))
-> ((forall b. Data b => b -> b) -> EitherS l r -> EitherS l r)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EitherS l r -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EitherS l r -> r)
-> (forall u. (forall d. Data d => d -> u) -> EitherS l r -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EitherS l r -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r))
-> Data (EitherS l r)
EitherS l r -> Constr
EitherS l r -> DataType
(forall b. Data b => b -> b) -> EitherS l r -> EitherS l r
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) -> EitherS l r -> u
forall u. (forall d. Data d => d -> u) -> EitherS l r -> [u]
forall l r. (Data l, Data r) => Typeable (EitherS l r)
forall l r. (Data l, Data r) => EitherS l r -> Constr
forall l r. (Data l, Data r) => EitherS l r -> DataType
forall l r.
(Data l, Data r) =>
(forall b. Data b => b -> b) -> EitherS l r -> EitherS l r
forall l r u.
(Data l, Data r) =>
Int -> (forall d. Data d => d -> u) -> EitherS l r -> u
forall l r u.
(Data l, Data r) =>
(forall d. Data d => d -> u) -> EitherS l r -> [u]
forall l r r r'.
(Data l, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
forall l r r r'.
(Data l, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
forall l r (m :: * -> *).
(Data l, Data r, Monad m) =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
forall l r (m :: * -> *).
(Data l, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
forall l r (c :: * -> *).
(Data l, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EitherS l r)
forall l r (c :: * -> *).
(Data l, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EitherS l r -> c (EitherS l r)
forall l r (t :: * -> *) (c :: * -> *).
(Data l, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EitherS l r))
forall l r (t :: * -> * -> *) (c :: * -> *).
(Data l, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EitherS l r))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EitherS l r)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EitherS l r -> c (EitherS l r)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EitherS l r))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EitherS l r))
$cgfoldl :: forall l r (c :: * -> *).
(Data l, Data r) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EitherS l r -> c (EitherS l r)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EitherS l r -> c (EitherS l r)
$cgunfold :: forall l r (c :: * -> *).
(Data l, Data r) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EitherS l r)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EitherS l r)
$ctoConstr :: forall l r. (Data l, Data r) => EitherS l r -> Constr
toConstr :: EitherS l r -> Constr
$cdataTypeOf :: forall l r. (Data l, Data r) => EitherS l r -> DataType
dataTypeOf :: EitherS l r -> DataType
$cdataCast1 :: forall l r (t :: * -> *) (c :: * -> *).
(Data l, Data r, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EitherS l r))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EitherS l r))
$cdataCast2 :: forall l r (t :: * -> * -> *) (c :: * -> *).
(Data l, Data r, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EitherS l r))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EitherS l r))
$cgmapT :: forall l r.
(Data l, Data r) =>
(forall b. Data b => b -> b) -> EitherS l r -> EitherS l r
gmapT :: (forall b. Data b => b -> b) -> EitherS l r -> EitherS l r
$cgmapQl :: forall l r r r'.
(Data l, Data r) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
$cgmapQr :: forall l r r r'.
(Data l, Data r) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EitherS l r -> r
$cgmapQ :: forall l r u.
(Data l, Data r) =>
(forall d. Data d => d -> u) -> EitherS l r -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EitherS l r -> [u]
$cgmapQi :: forall l r u.
(Data l, Data r) =>
Int -> (forall d. Data d => d -> u) -> EitherS l r -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EitherS l r -> u
$cgmapM :: forall l r (m :: * -> *).
(Data l, Data r, Monad m) =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
$cgmapMp :: forall l r (m :: * -> *).
(Data l, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
$cgmapMo :: forall l r (m :: * -> *).
(Data l, Data r, MonadPlus m) =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EitherS l r -> m (EitherS l r)
Data, Typeable)

instance (Semigroup l) => Semigroup (EitherS l r) where
  (<>) :: (Semigroup l) => EitherS l r -> EitherS l r -> EitherS l r
  LeftS l
l0 <> :: Semigroup l => EitherS l r -> EitherS l r -> EitherS l r
<> LeftS l
l1 = l -> EitherS l r
forall l r. l -> EitherS l r
LeftS (l
l0 l -> l -> l
forall a. Semigroup a => a -> a -> a
<> l
l1)
  RightS r
r <> EitherS l r
_ = r -> EitherS l r
forall l r. r -> EitherS l r
RightS r
r
  EitherS l r
_ <> RightS r
r = r -> EitherS l r
forall l r. r -> EitherS l r
RightS r
r

instance (Monoid l) => Monoid (EitherS l r) where
  mempty :: (Monoid l) => EitherS l r
  mempty :: Monoid l => EitherS l r
mempty = l -> EitherS l r
forall l r. l -> EitherS l r
LeftS l
forall a. Monoid a => a
mempty

instance (Monoid l) => Applicative (EitherS l) where
  pure :: (Monoid l) => r -> EitherS l r
  pure :: forall r. Monoid l => r -> EitherS l r
pure = r -> EitherS l r
forall l r. r -> EitherS l r
RightS

  (<*>) :: (Monoid l) => EitherS l (r0 -> r1) -> EitherS l r0 -> EitherS l r1
  RightS r0 -> r1
f <*> :: forall r0 r1.
Monoid l =>
EitherS l (r0 -> r1) -> EitherS l r0 -> EitherS l r1
<*> RightS r0
x = r1 -> EitherS l r1
forall l r. r -> EitherS l r
RightS (r0 -> r1
f r0
x)
  LeftS l
l <*> EitherS l r0
_ = l -> EitherS l r1
forall l r. l -> EitherS l r
LeftS l
l
  EitherS l (r0 -> r1)
_ <*> LeftS l
l = l -> EitherS l r1
forall l r. l -> EitherS l r
LeftS l
l

instance (Monoid l) => Monad (EitherS l) where
  (>>=) :: (Monoid l) => EitherS l r0 -> (r0 -> EitherS l r1) -> EitherS l r1
  RightS r0
m >>= :: forall r0 r1.
Monoid l =>
EitherS l r0 -> (r0 -> EitherS l r1) -> EitherS l r1
>>= r0 -> EitherS l r1
f = r0 -> EitherS l r1
f r0
m
  LeftS l
l >>= r0 -> EitherS l r1
_ = l -> EitherS l r1
forall l r. l -> EitherS l r
LeftS l
l

instance (Monoid l) => MonadFix (EitherS l) where
  mfix :: (Monoid l) => (r -> EitherS l r) -> EitherS l r
  mfix :: forall r. Monoid l => (r -> EitherS l r) -> EitherS l r
mfix r -> EitherS l r
f = let x :: EitherS l r
x = r -> EitherS l r
f (EitherS l r -> r
forall {l} {a}. EitherS l a -> a
un EitherS l r
x) in EitherS l r
x
   where
    un :: EitherS l a -> a
un = \case
      LeftS l
_ -> String -> a
forall a. HasCallStack => String -> a
error String
"mfix EitherS: LeftS"
      RightS a
r -> a
r

instance Bifunctor EitherS where
  bimap :: (l0 -> l1) -> (r0 -> r1) -> EitherS l0 r0 -> EitherS l1 r1
  bimap :: forall a b c d. (a -> b) -> (c -> d) -> EitherS a c -> EitherS b d
bimap l0 -> l1
f r0 -> r1
g = \case
    LeftS l0
l -> l1 -> EitherS l1 r1
forall l r. l -> EitherS l r
LeftS (l0 -> l1
f l0
l)
    RightS r0
r -> r1 -> EitherS l1 r1
forall l r. r -> EitherS l r
RightS (r0 -> r1
g r0
r)

instance Foldable (EitherS l) where
  foldMap :: (Monoid m) => (r -> m) -> EitherS l r -> m
  foldMap :: forall m a. Monoid m => (a -> m) -> EitherS l a -> m
foldMap r -> m
f = \case
    LeftS l
_ -> m
forall a. Monoid a => a
mempty
    RightS r
r -> r -> m
f r
r

instance Bifoldable EitherS where
  bifoldMap :: (Monoid m) => (l -> m) -> (r -> m) -> EitherS l r -> m
  bifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> EitherS a b -> m
bifoldMap = (l -> m) -> (r -> m) -> EitherS l r -> m
forall l x r. (l -> x) -> (r -> x) -> EitherS l r -> x
eitherS

instance Bifoldable1 EitherS where
  bifoldMap1 :: (Semigroup s) => (l -> s) -> (r -> s) -> EitherS l r -> s
  bifoldMap1 :: forall m a b.
Semigroup m =>
(a -> m) -> (b -> m) -> EitherS a b -> m
bifoldMap1 = (l -> s) -> (r -> s) -> EitherS l r -> s
forall l x r. (l -> x) -> (r -> x) -> EitherS l r -> x
eitherS

instance Traversable (EitherS l) where
  traverse ::
    (Applicative f) =>
    (r0 -> f r1) ->
    EitherS l r0 ->
    f (EitherS l r1)
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EitherS l a -> f (EitherS l b)
traverse r0 -> f r1
f = \case
    LeftS l
l -> EitherS l r1 -> f (EitherS l r1)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (l -> EitherS l r1
forall l r. l -> EitherS l r
LeftS l
l)
    RightS r0
r -> r1 -> EitherS l r1
forall l r. r -> EitherS l r
RightS (r1 -> EitherS l r1) -> f r1 -> f (EitherS l r1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> r0 -> f r1
f r0
r

instance Bitraversable EitherS where
  bitraverse ::
    (Applicative f) =>
    (l0 -> f l1) ->
    (r0 -> f r1) ->
    EitherS l0 r0 ->
    f (EitherS l1 r1)
  bitraverse :: forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> EitherS a b -> f (EitherS c d)
bitraverse l0 -> f l1
f r0 -> f r1
g = \case
    LeftS l0
l -> l1 -> EitherS l1 r1
forall l r. l -> EitherS l r
LeftS (l1 -> EitherS l1 r1) -> f l1 -> f (EitherS l1 r1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> l0 -> f l1
f l0
l
    RightS r0
r -> r1 -> EitherS l1 r1
forall l r. r -> EitherS l r
RightS (r1 -> EitherS l1 r1) -> f r1 -> f (EitherS l1 r1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> r0 -> f r1
g r0
r

instance (Eq l) => Eq1 (EitherS l) where
  liftEq ::
    (Eq l) =>
    (r0 -> r1 -> Bool) ->
    EitherS l r0 ->
    EitherS l r1 ->
    Bool
  liftEq :: forall r0 r1.
Eq l =>
(r0 -> r1 -> Bool) -> EitherS l r0 -> EitherS l r1 -> Bool
liftEq = (l -> l -> Bool)
-> (r0 -> r1 -> Bool) -> EitherS l r0 -> EitherS l r1 -> Bool
forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> EitherS a c -> EitherS 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 l -> l -> Bool
forall a. Eq a => a -> a -> Bool
(==)

instance Eq2 EitherS where
  liftEq2 ::
    (l0 -> l1 -> Bool) ->
    (r0 -> r1 -> Bool) ->
    EitherS l0 r0 ->
    EitherS l1 r1 ->
    Bool
  liftEq2 :: forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> EitherS a c -> EitherS b d -> Bool
liftEq2 l0 -> l1 -> Bool
f r0 -> r1 -> Bool
_ (LeftS l0
l0) = \case
    LeftS l1
l1 -> l0 -> l1 -> Bool
f l0
l0 l1
l1
    RightS r1
_ -> Bool
False
  liftEq2 l0 -> l1 -> Bool
_ r0 -> r1 -> Bool
g (RightS r0
r0) = \case
    LeftS l1
_ -> Bool
False
    RightS r1
r1 -> r0 -> r1 -> Bool
g r0
r0 r1
r1

instance (Ord l) => Ord1 (EitherS l) where
  liftCompare ::
    (Eq l) =>
    (r0 -> r1 -> Ordering) ->
    EitherS l r0 ->
    EitherS l r1 ->
    Ordering
  liftCompare :: forall r0 r1.
Eq l =>
(r0 -> r1 -> Ordering) -> EitherS l r0 -> EitherS l r1 -> Ordering
liftCompare = (l -> l -> Ordering)
-> (r0 -> r1 -> Ordering)
-> EitherS l r0
-> EitherS l r1
-> Ordering
forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> EitherS a c -> EitherS 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 l -> l -> Ordering
forall a. Ord a => a -> a -> Ordering
compare

instance Ord2 EitherS where
  liftCompare2 ::
    (l0 -> l1 -> Ordering) ->
    (r0 -> r1 -> Ordering) ->
    EitherS l0 r0 ->
    EitherS l1 r1 ->
    Ordering
  liftCompare2 :: forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> EitherS a c -> EitherS b d -> Ordering
liftCompare2 l0 -> l1 -> Ordering
f r0 -> r1 -> Ordering
_ (LeftS l0
l0) = \case
    LeftS l1
l1 -> l0 -> l1 -> Ordering
f l0
l0 l1
l1
    RightS r1
_ -> Ordering
LT
  liftCompare2 l0 -> l1 -> Ordering
_ r0 -> r1 -> Ordering
g (RightS r0
r0) = \case
    LeftS l1
_ -> Ordering
GT
    RightS r1
r1 -> r0 -> r1 -> Ordering
g r0
r0 r1
r1

-- | Turn an 'EitherS' value into a plain 'Either' value.
toEither :: EitherS l r -> Either l r
toEither :: forall l r. EitherS l r -> Either l r
toEither = \case
  LeftS l
l -> l -> Either l r
forall a b. a -> Either a b
Left l
l
  RightS r
r -> r -> Either l r
forall a b. b -> Either a b
Right r
r

unLeftS :: EitherS l r -> Maybe l
unLeftS :: forall l r. EitherS l r -> Maybe l
unLeftS = \case
  LeftS l
l -> l -> Maybe l
forall a. a -> Maybe a
Just l
l
  RightS r
_ -> Maybe l
forall a. Maybe a
Nothing

unRightS :: EitherS l r -> Maybe r
unRightS :: forall l r. EitherS l r -> Maybe r
unRightS = \case
  LeftS l
_ -> Maybe r
forall a. Maybe a
Nothing
  RightS r
r -> r -> Maybe r
forall a. a -> Maybe a
Just r
r

eitherS :: (l -> x) -> (r -> x) -> EitherS l r -> x
eitherS :: forall l x r. (l -> x) -> (r -> x) -> EitherS l r -> x
eitherS l -> x
f r -> x
g = \case
  LeftS l
l -> l -> x
f l
l
  RightS r
r -> r -> x
g r
r

leftsS :: [EitherS l r] -> [l]
leftsS :: forall l r. [EitherS l r] -> [l]
leftsS [EitherS l r]
es = [l
l | LeftS l
l <- [EitherS l r]
es]

rightsS :: [EitherS l r] -> [r]
rightsS :: forall l r. [EitherS l r] -> [r]
rightsS [EitherS l r]
es = [r
r | RightS r
r <- [EitherS l r]
es]