-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | An either monad transformer
--   
--   An either monad transformer
@package either
@version 4.4.1

-- | Monoidal Validation sibling to Either.
module Data.Either.Validation

-- | Validation is Either with a Left that is a Monoid
data Validation e a
Failure :: e -> Validation e a
Success :: a -> Validation e a
_Success :: Prism (Validation c a) (Validation c b) a b
_Failure :: Prism (Validation a c) (Validation b c) a b
eitherToValidation :: Either e a -> Validation e a
validationToEither :: Validation e a -> Either e a

-- | Validation is isomorphic to Either
_Validation :: Iso (Validation e a) (Validation g b) (Either e a) (Either g b)
instance (GHC.Show.Show e, GHC.Show.Show a) => GHC.Show.Show (Data.Either.Validation.Validation e a)
instance (GHC.Classes.Ord e, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.Either.Validation.Validation e a)
instance (GHC.Classes.Eq e, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Either.Validation.Validation e a)
instance GHC.Base.Functor (Data.Either.Validation.Validation e)
instance Data.Semigroup.Semigroup e => GHC.Base.Applicative (Data.Either.Validation.Validation e)
instance Data.Functor.Alt.Alt (Data.Either.Validation.Validation e)
instance (Data.Semigroup.Semigroup e, GHC.Base.Monoid e) => GHC.Base.Alternative (Data.Either.Validation.Validation e)
instance Data.Foldable.Foldable (Data.Either.Validation.Validation e)
instance Data.Traversable.Traversable (Data.Either.Validation.Validation e)
instance Data.Bifunctor.Bifunctor Data.Either.Validation.Validation
instance Data.Bifoldable.Bifoldable Data.Either.Validation.Validation
instance Data.Bitraversable.Bitraversable Data.Either.Validation.Validation
instance Data.Semigroup.Semigroup e => Data.Semigroup.Semigroup (Data.Either.Validation.Validation e a)
instance GHC.Base.Monoid e => GHC.Base.Monoid (Data.Either.Validation.Validation e a)

-- | Functions for probing and unwrapping values inside of Either.
--   
--   Most of these combinators are provided for pedagogical purposes and
--   exist in more general forms in other libraries. To that end
--   alternative definitions are supplied below.
module Data.Either.Combinators

-- | The isLeft function returns True iff its argument is of
--   the form Left _.
--   
--   Using Control.Lens:
--   
--   
--   isLeft ≡ has _Left
--   
--   
--   
--   >>> isLeft (Left 12)
--   True
--   
--   
--   
--   >>> isLeft (Right 12)
--   False
--   
isLeft :: Either a b -> Bool

-- | The isRight function returns True iff its argument is of
--   the form Right _.
--   
--   Using Control.Lens:
--   
--   
--   isRight ≡ has _Right
--   
--   
--   
--   >>> isRight (Left 12)
--   False
--   
--   
--   
--   >>> isRight (Right 12)
--   True
--   
isRight :: Either a b -> Bool

-- | Extract the left value or a default.
--   
--   
--   fromLeft ≡ either id
--   
--   
--   
--   >>> fromLeft "hello" (Right 42)
--   "hello"
--   
--   
--   
--   >>> fromLeft "hello" (Left "world")
--   "world"
--   
fromLeft :: a -> Either a b -> a

-- | Extract the right value or a default.
--   
--   
--   fromRight b ≡ either b id
--   
--   
--   
--   >>> fromRight "hello" (Right "world")
--   "world"
--   
--   
--   
--   >>> fromRight "hello" (Left 42)
--   "hello"
--   
fromRight :: b -> Either a b -> b

-- | Extracts the element out of a Left and throws an error if its
--   argument take the form Right _.
--   
--   Using Control.Lens:
--   
--   
--   fromLeft' x ≡ x^?!_Left
--   
--   
--   
--   >>> fromLeft' (Left 12)
--   12
--   
fromLeft' :: Either a b -> a

-- | Extracts the element out of a Right and throws an error if its
--   argument take the form Left _.
--   
--   Using Control.Lens:
--   
--   
--   fromRight' x ≡ x^?!_Right
--   
--   
--   
--   >>> fromRight' (Right 12)
--   12
--   
fromRight' :: Either a b -> b

-- | The mapBoth function takes two functions and applies the first
--   if iff the value takes the form Left _ and the second
--   if the value takes the form Right _.
--   
--   Using Data.Bifunctor:
--   
--   
--   mapBoth = bimap
--   
--   
--   Using Control.Arrow:
--   
--   
--   mapBoth = (+++)
--   
--   
--   
--   >>> mapBoth (*2) (*3) (Left 4)
--   Left 8
--   
--   
--   
--   >>> mapBoth (*2) (*3) (Right 4)
--   Right 12
--   
mapBoth :: (a -> c) -> (b -> d) -> Either a b -> Either c d

-- | The mapLeft function takes a function and applies it to an
--   Either value iff the value takes the form Left _.
--   
--   Using Data.Bifunctor:
--   
--   
--   mapLeft = first
--   
--   
--   Using Control.Arrow:
--   
--   
--   mapLeft = (left)
--   
--   
--   Using Control.Lens:
--   
--   
--   mapLeft = over _Left
--   
--   
--   
--   >>> mapLeft (*2) (Left 4)
--   Left 8
--   
--   
--   
--   >>> mapLeft (*2) (Right "hello")
--   Right "hello"
--   
mapLeft :: (a -> c) -> Either a b -> Either c b

-- | The mapRight function takes a function and applies it to an
--   Either value iff the value takes the form Right _.
--   
--   Using Data.Bifunctor:
--   
--   
--   mapRight = second
--   
--   
--   Using Control.Arrow:
--   
--   
--   mapRight = (right)
--   
--   
--   Using Control.Lens:
--   
--   
--   mapRight = over _Right
--   
--   
--   
--   >>> mapRight (*2) (Left "hello")
--   Left "hello"
--   
--   
--   
--   >>> mapRight (*2) (Right 4)
--   Right 8
--   
mapRight :: (b -> c) -> Either a b -> Either a c

-- | The whenLeft function takes an Either value and a
--   function which returns a monad. The monad is only executed when the
--   given argument takes the form Left _, otherwise it
--   does nothing.
--   
--   Using Control.Lens:
--   
--   
--   whenLeft ≡ forOf_ _Left
--   
--   
--   
--   >>> whenLeft (Left 12) print
--   12
--   
whenLeft :: Applicative m => Either a b -> (a -> m ()) -> m ()

-- | The whenRight function takes an Either value and a
--   function which returns a monad. The monad is only executed when the
--   given argument takes the form Right _, otherwise it
--   does nothing.
--   
--   Using Data.Foldable:
--   
--   
--   whenRight ≡ forM_
--   
--   
--   Using Control.Lens:
--   
--   
--   whenRight ≡ forOf_ _Right
--   
--   
--   
--   >>> whenRight (Right 12) print
--   12
--   
whenRight :: Applicative m => Either a b -> (b -> m ()) -> m ()

-- | A synonym of whenRight.
unlessLeft :: Applicative m => Either a b -> (b -> m ()) -> m ()

-- | A synonym of whenLeft.
unlessRight :: Applicative m => Either a b -> (a -> m ()) -> m ()

-- | Maybe get the Left side of an Either.
--   
--   
--   leftToMaybe ≡ either Just (const Nothing)
--   
--   
--   Using Control.Lens:
--   
--   
--   leftToMaybe ≡ preview _Left
--   leftToMaybe x ≡ x^?_Left
--   
--   
--   
--   >>> leftToMaybe (Left 12)
--   Just 12
--   
--   
--   
--   >>> leftToMaybe (Right 12)
--   Nothing
--   
leftToMaybe :: Either a b -> Maybe a

-- | Maybe get the Right side of an Either.
--   
--   
--   rightToMaybe ≡ either (const Nothing) Just
--   
--   
--   Using Control.Lens:
--   
--   
--   rightToMaybe ≡ preview _Right
--   rightToMaybe x ≡ x^?_Right
--   
--   
--   
--   >>> rightToMaybe (Left 12)
--   Nothing
--   
--   
--   
--   >>> rightToMaybe (Right 12)
--   Just 12
--   
rightToMaybe :: Either a b -> Maybe b

-- | Generalize Either e as MonadError e m.
--   
--   If the argument has form Left e, an error is produced in the
--   monad via throwError. Otherwise, the Right a part is
--   forwarded.
eitherToError :: (MonadError e m) => Either e a -> m a

-- | Swap the Left and Right sides of an Either.
--   
--   
--   >>> swapEither (Right 3)
--   Left 3
--   
--   >>> swapEither (Left "error")
--   Right "error"
--   
swapEither :: Either e a -> Either a e

-- | This module provides a minimalist Either monad transformer.
module Control.Monad.Trans.Either

-- | EitherT is a version of ErrorT that does not require a
--   spurious Error instance for the Left case.
--   
--   Either is a perfectly usable Monad without such a
--   constraint. ErrorT is not the generalization of the current
--   Either monad, it is something else.
--   
--   This is necessary for both theoretical and practical reasons. For
--   instance an apomorphism is the generalized anamorphism for this Monad,
--   but it cannot be written with ErrorT.
--   
--   In addition to the combinators here, the errors package
--   provides a large number of combinators for working with this type.
newtype EitherT e m a
EitherT :: m (Either e a) -> EitherT e m a
[runEitherT] :: EitherT e m a -> m (Either e a)

-- | Given a pair of actions, one to perform in case of failure, and one to
--   perform in case of success, run an EitherT and get back a
--   monadic result.
eitherT :: Monad m => (a -> m c) -> (b -> m c) -> EitherT a m b -> m c

-- | Map over both failure and success.
bimapEitherT :: Functor m => (e -> f) -> (a -> b) -> EitherT e m a -> EitherT f m b

-- | Map the unwrapped computation using the given function.
--   
--   
--   runEitherT (mapEitherT f m) = f (runEitherT m)
--   
mapEitherT :: (m (Either e a) -> n (Either e' b)) -> EitherT e m a -> EitherT e' n b

-- | Lift an Either into an EitherT
hoistEither :: Monad m => Either e a -> EitherT e m a

-- | Acquire a resource in EitherT and then perform an action with
--   it, cleaning up afterwards regardless of error. Like bracket,
--   but acting only in EitherT.
bracketEitherT :: Monad m => EitherT e m a -> (a -> EitherT e m b) -> (a -> EitherT e m c) -> EitherT e m c

-- | Version of bracketEitherT which discards the result from the
--   initial action.
bracketEitherT_ :: Monad m => EitherT e m a -> EitherT e m b -> EitherT e m c -> EitherT e m c

-- | Analogous to Left. Equivalent to throwError.
left :: Monad m => e -> EitherT e m a

-- | Analogous to Right. Equivalent to return.
right :: Monad m => a -> EitherT e m a

-- | Monad transformer version of swapEither.
swapEitherT :: (Functor m) => EitherT e m a -> EitherT a m e
instance GHC.Show.Show (m (Data.Either.Either e a)) => GHC.Show.Show (Control.Monad.Trans.Either.EitherT e m a)
instance GHC.Read.Read (m (Data.Either.Either e a)) => GHC.Read.Read (Control.Monad.Trans.Either.EitherT e m a)
instance GHC.Classes.Eq (m (Data.Either.Either e a)) => GHC.Classes.Eq (Control.Monad.Trans.Either.EitherT e m a)
instance GHC.Classes.Ord (m (Data.Either.Either e a)) => GHC.Classes.Ord (Control.Monad.Trans.Either.EitherT e m a)
instance Control.Monad.Morph.MFunctor (Control.Monad.Trans.Either.EitherT e)
instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Trans.Either.EitherT e m)
instance GHC.Base.Monad m => Data.Functor.Bind.Class.Apply (Control.Monad.Trans.Either.EitherT e m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Trans.Either.EitherT e m)
instance (GHC.Base.Monad m, GHC.Base.Monoid e) => GHC.Base.Alternative (Control.Monad.Trans.Either.EitherT e m)
instance (GHC.Base.Monad m, GHC.Base.Monoid e) => GHC.Base.MonadPlus (Control.Monad.Trans.Either.EitherT e m)
instance GHC.Base.Monad m => Data.Semigroup.Semigroup (Control.Monad.Trans.Either.EitherT e m a)
instance (GHC.Base.Monad m, Data.Semigroup.Semigroup e) => Data.Functor.Alt.Alt (Control.Monad.Trans.Either.EitherT e m)
instance GHC.Base.Monad m => Data.Functor.Bind.Class.Bind (Control.Monad.Trans.Either.EitherT e m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Either.EitherT e m)
instance GHC.Base.Monad m => Control.Monad.Error.Class.MonadError e (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Either.EitherT e)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Writer.Class.MonadWriter s m => Control.Monad.Writer.Class.MonadWriter s (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Random.Class.MonadRandom m => Control.Monad.Random.Class.MonadRandom (Control.Monad.Trans.Either.EitherT e m)
instance Data.Foldable.Foldable m => Data.Foldable.Foldable (Control.Monad.Trans.Either.EitherT e m)
instance (GHC.Base.Functor f, Control.Monad.Free.Class.MonadFree f m) => Control.Monad.Free.Class.MonadFree f (Control.Monad.Trans.Either.EitherT e m)
instance (GHC.Base.Monad f, Data.Traversable.Traversable f) => Data.Traversable.Traversable (Control.Monad.Trans.Either.EitherT e f)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.Either.EitherT e m)
instance Control.Monad.Trans.Control.MonadTransControl (Control.Monad.Trans.Either.EitherT e)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Control.Monad.Trans.Either.EitherT e m)
