Relude.Monad.Reexport

relude-1.2.2.0: Safe, performant, user-friendly and lightweight Haskell Standard Library

Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2023 Kowainik
License | MIT
Maintainer | Kowainik <xrom.xkov@gmail.com>
Stability | Stable
Portability | Portable
Safe Haskell | Safe
Language | Haskell2010

Relude.Monad.Reexport

Contents

- Reexport transformers
- Reexport monadic functions
- Reexport `Maybe`
- Reexport `Either`

Description

Reexports functions to work with monads.

Synopsis

- newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
- runExceptT :: ExceptT e m a -> m (Either e a)
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
  - runReaderT :: r -> m a
  }
- type Reader r = ReaderT r Identity
- runReader :: Reader r a -> r -> a
- withReader :: (r' -> r) -> Reader r a -> Reader r' a
- withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
  - ask :: m r
  - local :: (r -> r) -> m a -> m a
  - reader :: (r -> a) -> m a
- asks :: MonadReader r m => (r -> a) -> m a
- class Monad m => MonadState s (m :: Type -> Type) | m -> s where
  - get :: m s
  - put :: s -> m ()
  - state :: (s -> (a, s)) -> m a
- type State s = StateT s Identity
- runState :: State s a -> s -> (a, s)
- execState :: State s a -> s -> s
- newtype StateT s (m :: Type -> Type) a = StateT {
  - runStateT :: s -> m (a, s)
  }
- evalState :: State s a -> s -> a
- withState :: (s -> s) -> State s a -> State s a
- evalStateT :: Monad m => StateT s m a -> s -> m a
- execStateT :: Monad m => StateT s m a -> s -> m s
- modify :: MonadState s m => (s -> s) -> m ()
- modify' :: MonadState s m => (s -> s) -> m ()
- gets :: MonadState s m => (s -> a) -> m a
- module Control.Monad.Trans
- data IdentityT (f :: k -> Type) (a :: k)
- newtype MaybeT (m :: Type -> Type) a = MaybeT {
  - runMaybeT :: m (Maybe a)
  }
- maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- class Applicative m => Monad (m :: Type -> Type) where
  - (>>=) :: m a -> (a -> m b) -> m b
  - (>>) :: m a -> m b -> m b
  - return :: a -> m a
- join :: Monad m => m (m a) -> m a
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
  - mzero :: m a
  - mplus :: m a -> m a -> m a
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- forever :: Applicative f => f a -> f b
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- replicateM_ :: Applicative m => Int -> m a -> m ()
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- module Control.Monad.Fail
- data Maybe a
  - = Nothing
  - | Just a
- maybe :: b -> (a -> b) -> Maybe a -> b
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- fromMaybe :: a -> Maybe a -> a
- maybeToList :: Maybe a -> [a]
- listToMaybe :: [a] -> Maybe a
- catMaybes :: [Maybe a] -> [a]
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- data Either a b
  - = Left a
  - | Right b
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lefts :: [Either a b] -> [a]
- rights :: [Either a b] -> [b]
- partitionEithers :: [Either a b] -> ([a], [b])
- isLeft :: Either a b -> Bool
- isRight :: Either a b -> Bool

# Reexport transformers

newtype ExceptT e (m :: Type -> Type) a #

A monad transformer that adds exceptions to other monads.

`ExceptT` constructs a monad parameterized over two things:

- e - The exception type.
- m - The inner monad.

The `return` function yields a computation that produces the given value, while `>>=` sequences two subcomputations, exiting on the first exception.

Constructors

ExceptT (m (Either e a)) |

#### Instances

Instances details

MonadRWS r w s m => MonadRWS r w s (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.RWS.Class
Functor m => Generic1 (ExceptT e m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Except Associated Types
type Rep1 (ExceptT e m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Except type Rep1 (ExceptT e m :: Type -> Type) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 (Either e))))
Methods from1 :: ExceptT e m a -> Rep1 (ExceptT e m) a # to1 :: Rep1 (ExceptT e m) a -> ExceptT e m a #
MonadAccum w m => MonadAccum w (ExceptT e m) | The accumulated value 'survives' an exception: even if the computation fails to deliver a result, we still have an accumulated value. Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods look :: ExceptT e m w # add :: w -> ExceptT e m () # accum :: (w -> (a, w)) -> ExceptT e m a #
Monad m => MonadError e (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
MonadReader r m => MonadReader r (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
MonadSelect r m => MonadSelect r (ExceptT e m) | 'Extends' the possibilities considered by `m` to include every value of `e`; this means that the potential result could be either a `Left` (making it a choice of type `e`) or a `Right` (making it a choice of type `a`). Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods select :: ((a -> r) -> a) -> ExceptT e m a #
MonadState s m => MonadState s (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.State.Class Methods get :: ExceptT e m s # put :: s -> ExceptT e m () # state :: (s -> (a, s)) -> ExceptT e m a #
MonadWriter w m => MonadWriter w (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.Writer.Class Methods writer :: (a, w) -> ExceptT e m a # tell :: w -> ExceptT e m () # listen :: ExceptT e m a -> ExceptT e m (a, w) # pass :: ExceptT e m (a, w -> w) -> ExceptT e m a #
MonadTrans (ExceptT e) |
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a #
MonadIO m => MonadIO (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadZip m => MonadZip (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods mzip :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b) # mzipWith :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # munzip :: ExceptT e m (a, b) -> (ExceptT e m a, ExceptT e m b) #
(Eq e, Eq1 m) => Eq1 (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods liftEq :: (a -> b -> Bool) -> ExceptT e m a -> ExceptT e m b -> Bool #
(Ord e, Ord1 m) => Ord1 (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering #
(Read e, Read1 m) => Read1 (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT e m a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ExceptT e m a] #
(Show e, Show1 m) => Show1 (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExceptT e m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExceptT e m a] -> ShowS #
Contravariant m => Contravariant (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods contramap :: (a' -> a) -> ExceptT e m a -> ExceptT e m a' # (>$) :: b -> ExceptT e m b -> ExceptT e m a #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a # (<|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
(Functor m, Monad m) => Applicative (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods pure :: a -> ExceptT e m a # (<*>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # (*>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Monad m => Monad (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
MonadFail m => MonadFail (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods fail :: String -> ExceptT e m a #
MonadFix m => MonadFix (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a #
Foldable f => Foldable (ExceptT e f) |
Instance details Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # sum :: Num a => ExceptT e f a -> a # product :: Num a => ExceptT e f a -> a #
Traversable f => Traversable (ExceptT e f) |
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 (ExceptT e f b) # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
MonadCont m => MonadCont (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.Cont.Class Methods callCC :: ((a -> ExceptT e m b) -> ExceptT e m a) -> ExceptT e m a #
Generic (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Associated Types
type Rep (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except type Rep (ExceptT e m a) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Either e a)))))
Methods from :: ExceptT e m a -> Rep (ExceptT e m a) x # to :: Rep (ExceptT e m a) x -> ExceptT e m a #
(Read e, Read1 m, Read a) => Read (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Methods readsPrec :: Int -> ReadS (ExceptT e m a) # readList :: ReadS [ExceptT e m a] # readPrec :: ReadPrec (ExceptT e m a) # readListPrec :: ReadPrec [ExceptT e m a] #
(Show e, Show1 m, Show a) => Show (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Methods showsPrec :: Int -> ExceptT e m a -> ShowS # show :: ExceptT e m a -> String # showList :: [ExceptT e m a] -> ShowS #
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
type Rep1 (ExceptT e m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Except type Rep1 (ExceptT e m :: Type -> Type) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 (Either e))))
type Rep (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except type Rep (ExceptT e m a) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Either e a)))))

runExceptT :: ExceptT e m a -> m (Either e a) #

The inverse of `ExceptT`.

newtype ReaderT r (m :: Type -> Type) a #

The reader monad transformer, which adds a read-only environment to the given monad.

The `return` function ignores the environment, while `m `>>=` k` passes the inherited environment to both subcomputations:

Constructors

ReaderT |
Fields runReaderT :: r -> m a

#### Instances

Instances details

Generic1 (ReaderT r m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Reader Associated Types
type Rep1 (ReaderT r m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Reader type Rep1 (ReaderT r m :: Type -> Type) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ReaderT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runReaderT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many r :: Type -> Type) :.: Rec1 m)))
Methods from1 :: ReaderT r m a -> Rep1 (ReaderT r m) a # to1 :: Rep1 (ReaderT r m) a -> ReaderT r m a #
MonadAccum w m => MonadAccum w (ReaderT r m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods look :: ReaderT r m w # add :: w -> ReaderT r m () # accum :: (w -> (a, w)) -> ReaderT r m a #
MonadError e m => MonadError e (ReaderT r m) |
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ReaderT r m a # catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
Monad m => MonadReader r (ReaderT r m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a # reader :: (r -> a) -> ReaderT r m a #
MonadSelect r' m => MonadSelect r' (ReaderT r m) | Provides a read-only environment of type `r` to the 'strategy' function. However, the 'ranking' function (or more accurately, representation) has no access to `r`. Put another way, you can influence what values get chosen by changing `r`, but not how solutions are ranked. Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods select :: ((a -> r') -> a) -> ReaderT r m a #
MonadState s m => MonadState s (ReaderT r m) |
Instance details Defined in Control.Monad.State.Class Methods get :: ReaderT r m s # put :: s -> ReaderT r m () # state :: (s -> (a, s)) -> ReaderT r m a #
MonadWriter w m => MonadWriter w (ReaderT r m) |
Instance details Defined in Control.Monad.Writer.Class Methods writer :: (a, w) -> ReaderT r m a # tell :: w -> ReaderT r m () # listen :: ReaderT r m a -> ReaderT r m (a, w) # pass :: ReaderT r m (a, w -> w) -> ReaderT r m a #
MonadTrans (ReaderT r) |
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a #
MonadIO m => MonadIO (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadZip m => MonadZip (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods mzip :: ReaderT r m a -> ReaderT r m b -> ReaderT r m (a, b) # mzipWith :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c # munzip :: ReaderT r m (a, b) -> (ReaderT r m a, ReaderT r m b) #
Contravariant m => Contravariant (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods contramap :: (a' -> a) -> ReaderT r m a -> ReaderT r m a' # (>$) :: b -> ReaderT r m b -> ReaderT r m a #
Alternative m => Alternative (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a # (<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a # some :: ReaderT r m a -> ReaderT r m [a] # many :: ReaderT r m a -> ReaderT r m [a] #
Applicative m => Applicative (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods pure :: a -> ReaderT r m a # (<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c # (*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a #
Functor m => Functor (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b # (<$) :: a -> ReaderT r m b -> ReaderT r m a #
Monad m => Monad (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # return :: a -> ReaderT r m a #
MonadPlus m => MonadPlus (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a #
MonadFail m => MonadFail (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods fail :: String -> ReaderT r m a #
MonadFix m => MonadFix (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods mfix :: (a -> ReaderT r m a) -> ReaderT r m a #
MonadCont m => MonadCont (ReaderT r m) |
Instance details Defined in Control.Monad.Cont.Class Methods callCC :: ((a -> ReaderT r m b) -> ReaderT r m a) -> ReaderT r m a #
Generic (ReaderT r m a) |
Instance details Defined in Control.Monad.Trans.Reader Associated Types
type Rep (ReaderT r m a) |
Instance details Defined in Control.Monad.Trans.Reader type Rep (ReaderT r m a) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ReaderT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runReaderT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (r -> m a))))
Methods from :: ReaderT r m a -> Rep (ReaderT r m a) x # to :: Rep (ReaderT r m a) x -> ReaderT r m a #
type Rep1 (ReaderT r m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Reader type Rep1 (ReaderT r m :: Type -> Type) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ReaderT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runReaderT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many r :: Type -> Type) :.: Rec1 m)))
type Rep (ReaderT r m a) |
Instance details Defined in Control.Monad.Trans.Reader type Rep (ReaderT r m a) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "ReaderT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runReaderT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (r -> m a))))

type Reader r = ReaderT r Identity #

The parameterizable reader monad.

Computations are functions of a shared environment.

The `return` function ignores the environment, while `m `>>=` k` passes the inherited environment to both subcomputations:

runReader #

Arguments

:: Reader r a | A `Reader` to run.
-> r | An initial environment.
-> a |

Runs a `Reader` and extracts the final value from it. (The inverse of `reader`.)

withReader #

Arguments

:: (r' -> r) | The function to modify the environment.
-> Reader r a | Computation to run in the modified environment.
-> Reader r' a |

Execute a computation in a modified environment (a specialization of `withReaderT`).

-     runReader (withReader f m) = runReader m . f

withReaderT #

Arguments

:: forall r' r (m :: Type -> Type) a. (r' -> r) | The function to modify the environment.
-> ReaderT r m a | Computation to run in the modified environment.
-> ReaderT r' m a |

Execute a computation in a modified environment (a more general version of `local`).

-     runReaderT (withReaderT f m) = runReaderT m . f

class Monad m => MonadReader r (m :: Type -> Type) | m -> r where #

See examples in Control.Monad.Reader. Note, the partially applied function type `(->) r` is a simple reader monad. See the `instance` declaration below.

Minimal complete definition

(ask | reader), local

Methods

ask :: m r #

Retrieves the monad environment.

local #

Arguments

:: (r -> r) | The function to modify the environment.
-> m a | `Reader` to run in the modified environment.
-> m a |

Executes a computation in a modified environment.

reader #

Arguments

:: (r -> a) | The selector function to apply to the environment.
-> m a |

Retrieves a function of the current environment.

#### Instances

Instances details

MonadReader r m => MonadReader r (MaybeT m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
(Monoid w, MonadReader r m) => MonadReader r (AccumT w m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Reader.Class Methods ask :: AccumT w m r # local :: (r -> r) -> AccumT w m a -> AccumT w m a # reader :: (r -> a) -> AccumT w m a #
MonadReader r m => MonadReader r (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
MonadReader r m => MonadReader r (IdentityT m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: IdentityT m r # local :: (r -> r) -> IdentityT m a -> IdentityT m a # reader :: (r -> a) -> IdentityT m a #
Monad m => MonadReader r (ReaderT r m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a # reader :: (r -> a) -> ReaderT r m a #
MonadReader r m => MonadReader r (StateT s m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
MonadReader r' m => MonadReader r' (SelectT r m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Reader.Class Methods ask :: SelectT r m r' # local :: (r' -> r') -> SelectT r m a -> SelectT r m a # reader :: (r' -> a) -> SelectT r m a #
MonadReader r ((->) r) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: r -> r # local :: (r -> r) -> (r -> a) -> r -> a # reader :: (r -> a) -> r -> a #
MonadReader r' m => MonadReader r' (ContT r m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ContT r m r' # local :: (r' -> r') -> ContT r m a -> ContT r m a # reader :: (r' -> a) -> ContT r m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #

asks #

Arguments

:: MonadReader r m |
=> (r -> a) | The selector function to apply to the environment.
-> m a |

Retrieves a function of the current environment.

class Monad m => MonadState s (m :: Type -> Type) | m -> s where #

Minimal definition is either both of `get` and `put` or just `state`

Minimal complete definition

state | get, put

Methods

get :: m s #

Return the state from the internals of the monad.

put :: s -> m () #

Replace the state inside the monad.

state :: (s -> (a, s)) -> m a #

Embed a simple state action into the monad.

#### Instances

Instances details

MonadState s m => MonadState s (MaybeT m) |
Instance details Defined in Control.Monad.State.Class Methods get :: MaybeT m s # put :: s -> MaybeT m () # state :: (s -> (a, s)) -> MaybeT m a #
(Monoid w, MonadState s m) => MonadState s (AccumT w m) | Since: mtl-2.3
Instance details Defined in Control.Monad.State.Class Methods get :: AccumT w m s # put :: s -> AccumT w m () # state :: (s -> (a, s)) -> AccumT w m a #
MonadState s m => MonadState s (ExceptT e m) | Since: mtl-2.2
Instance details Defined in Control.Monad.State.Class Methods get :: ExceptT e m s # put :: s -> ExceptT e m () # state :: (s -> (a, s)) -> ExceptT e m a #
MonadState s m => MonadState s (IdentityT m) |
Instance details Defined in Control.Monad.State.Class Methods get :: IdentityT m s # put :: s -> IdentityT m () # state :: (s -> (a, s)) -> IdentityT m a #
MonadState s m => MonadState s (ReaderT r m) |
Instance details Defined in Control.Monad.State.Class Methods get :: ReaderT r m s # put :: s -> ReaderT r m () # state :: (s -> (a, s)) -> ReaderT r m a #
MonadState s m => MonadState s (SelectT r m) | Since: mtl-2.3
Instance details Defined in Control.Monad.State.Class Methods get :: SelectT r m s # put :: s -> SelectT r m () # state :: (s -> (a, s)) -> SelectT r m a #
Monad m => MonadState s (StateT s m) |
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
Monad m => MonadState s (StateT s m) |
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | Since: mtl-2.3
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m) |
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m) |
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
MonadState s m => MonadState s (ContT r m) |
Instance details Defined in Control.Monad.State.Class Methods get :: ContT r m s # put :: s -> ContT r m () # state :: (s -> (a, s)) -> ContT r m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m) | Since: mtl-2.3
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m) |
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m) |
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #

type State s = StateT s Identity #

A state monad parameterized by the type `s` of the state to carry.

The `return` function leaves the state unchanged, while `>>=` uses the final state of the first computation as the initial state of the second.

runState #

Arguments

:: State s a | state-passing computation to execute
-> s | initial state
-> (a, s) | return value and final state

Unwrap a state monad computation as a function. (The inverse of `state`.)

execState #

Arguments

:: State s a | state-passing computation to execute
-> s | initial value
-> s | final state

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

-     execState m s = snd (runState m s)

newtype StateT s (m :: Type -> Type) a #

A state transformer monad parameterized by:

- `s` - The state.
- `m` - The inner monad.

The `return` function leaves the state unchanged, while `>>=` uses the final state of the first computation as the initial state of the second.

Constructors

StateT |
Fields runStateT :: s -> m (a, s)

#### Instances

Instances details

MonadAccum w m => MonadAccum w (StateT s m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods look :: StateT s m w # add :: w -> StateT s m () # accum :: (w -> (a, w)) -> StateT s m a #
MonadError e m => MonadError e (StateT s m) |
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadSelect w m => MonadSelect w (StateT s m) | 'Readerizes' the state: the 'ranking' function can see a value of type `s`, but not modify it. Effectively, can be thought of as 'extending' the 'ranking' by all values in `s`, but which `s` gets given to any rank calls is predetermined by the 'outer state' (and cannot change). Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods select :: ((a -> w) -> a) -> StateT s m a #
Monad m => MonadState s (StateT s m) |
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
MonadWriter w m => MonadWriter w (StateT s m) |
Instance details Defined in Control.Monad.Writer.Class Methods writer :: (a, w) -> StateT s m a # tell :: w -> StateT s m () # listen :: StateT s m a -> StateT s m (a, w) # pass :: StateT s m (a, w -> w) -> StateT s m a #
MonadTrans (StateT s) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a #
MonadIO m => MonadIO (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
Contravariant m => Contravariant (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods contramap :: (a' -> a) -> StateT s m a -> StateT s m a' # (>$) :: b -> StateT s m b -> StateT s m a #
(Functor m, MonadPlus m) => Alternative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a # (<|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, Monad m) => Applicative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods pure :: a -> StateT s m a # (<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (*>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
Functor m => Functor (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Monad m => Monad (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadFail m => MonadFail (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods fail :: String -> StateT s m a #
MonadFix m => MonadFix (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadCont m => MonadCont (StateT s m) |
Instance details Defined in Control.Monad.Cont.Class Methods callCC :: ((a -> StateT s m b) -> StateT s m a) -> StateT s m a #
Generic (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Strict Associated Types
type Rep (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Strict type Rep (StateT s m a) = D1 ('MetaData "StateT" "Control.Monad.Trans.State.Strict" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "StateT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runStateT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (s -> m (a, s)))))
Methods from :: StateT s m a -> Rep (StateT s m a) x # to :: Rep (StateT s m a) x -> StateT s m a #
type Rep (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Strict type Rep (StateT s m a) = D1 ('MetaData "StateT" "Control.Monad.Trans.State.Strict" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "StateT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runStateT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (s -> m (a, s)))))

evalState #

Arguments

:: State s a | state-passing computation to execute
-> s | initial value
-> a | return value of the state computation

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

-     evalState m s = fst (runState m s)

withState :: (s -> s) -> State s a -> State s a #

``withState` f m` executes action `m` on a state modified by applying `f`.

-     withState f m = modify f >> m

evalStateT :: Monad m => StateT s m a -> s -> m a #

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

-     evalStateT m s = liftM fst (runStateT m s)

execStateT :: Monad m => StateT s m a -> s -> m s #

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

-     execStateT m s = liftM snd (runStateT m s)

modify :: MonadState s m => (s -> s) -> m () #

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

         Main> :t modify ((+1) :: Int -> Int)
         modify (...) :: (MonadState Int a) => a ()

This says that `modify (+1)` acts over any Monad that is a member of the `MonadState` class, with an `Int` state.

modify' :: MonadState s m => (s -> s) -> m () #

A variant of `modify` in which the computation is strict in the new state.

Since: mtl-2.2

gets :: MonadState s m => (s -> a) -> m a #

Gets specific component of the state, using a projection function supplied.

module Control.Monad.Trans

data IdentityT (f :: k -> Type) (a :: k) #

The trivial monad transformer, which maps a monad to an equivalent monad.

#### Instances

Instances details

MonadRWS r w s m => MonadRWS r w s (IdentityT m) |
Instance details Defined in Control.Monad.RWS.Class
Generic1 (IdentityT f :: k -> Type) |
Instance details Defined in Control.Monad.Trans.Identity Associated Types
type Rep1 (IdentityT f :: k -> Type) |
Instance details Defined in Control.Monad.Trans.Identity type Rep1 (IdentityT f :: k -> Type) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "IdentityT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentityT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))
Methods from1 :: forall (a :: k). IdentityT f a -> Rep1 (IdentityT f) a # to1 :: forall (a :: k). Rep1 (IdentityT f) a -> IdentityT f a #
MonadAccum w m => MonadAccum w (IdentityT m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods look :: IdentityT m w # add :: w -> IdentityT m () # accum :: (w -> (a, w)) -> IdentityT m a #
MonadError e m => MonadError e (IdentityT m) |
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> IdentityT m a # catchError :: IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadReader r m => MonadReader r (IdentityT m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: IdentityT m r # local :: (r -> r) -> IdentityT m a -> IdentityT m a # reader :: (r -> a) -> IdentityT m a #
MonadSelect r m => MonadSelect r (IdentityT m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods select :: ((a -> r) -> a) -> IdentityT m a #
MonadState s m => MonadState s (IdentityT m) |
Instance details Defined in Control.Monad.State.Class Methods get :: IdentityT m s # put :: s -> IdentityT m () # state :: (s -> (a, s)) -> IdentityT m a #
MonadWriter w m => MonadWriter w (IdentityT m) |
Instance details Defined in Control.Monad.Writer.Class Methods writer :: (a, w) -> IdentityT m a # tell :: w -> IdentityT m () # listen :: IdentityT m a -> IdentityT m (a, w) # pass :: IdentityT m (a, w -> w) -> IdentityT m a #
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type) |
Instance details Defined in Control.Monad.Trans.Identity Methods lift :: Monad m => m a -> IdentityT m a #
MonadIO m => MonadIO (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadZip m => MonadZip (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods mzip :: IdentityT m a -> IdentityT m b -> IdentityT m (a, b) # mzipWith :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c # munzip :: IdentityT m (a, b) -> (IdentityT m a, IdentityT m b) #
Foldable1 m => Foldable1 (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods fold1 :: Semigroup m0 => IdentityT m m0 -> m0 # foldMap1 :: Semigroup m0 => (a -> m0) -> IdentityT m a -> m0 # foldMap1' :: Semigroup m0 => (a -> m0) -> IdentityT m a -> m0 # toNonEmpty :: IdentityT m a -> NonEmpty a # maximum :: Ord a => IdentityT m a -> a # minimum :: Ord a => IdentityT m a -> a # head :: IdentityT m a -> a # last :: IdentityT m a -> a # foldrMap1 :: (a -> b) -> (a -> b -> b) -> IdentityT m a -> b # foldlMap1' :: (a -> b) -> (b -> a -> b) -> IdentityT m a -> b # foldlMap1 :: (a -> b) -> (b -> a -> b) -> IdentityT m a -> b # foldrMap1' :: (a -> b) -> (a -> b -> b) -> IdentityT m a -> b #
Eq1 f => Eq1 (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods liftEq :: (a -> b -> Bool) -> IdentityT f a -> IdentityT f b -> Bool #
Ord1 f => Ord1 (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods liftCompare :: (a -> b -> Ordering) -> IdentityT f a -> IdentityT f b -> Ordering #
Read1 f => Read1 (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (IdentityT f a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [IdentityT f a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (IdentityT f a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [IdentityT f a] #
Show1 f => Show1 (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> IdentityT f a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [IdentityT f a] -> ShowS #
Contravariant f => Contravariant (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods contramap :: (a' -> a) -> IdentityT f a -> IdentityT f a' # (>$) :: b -> IdentityT f b -> IdentityT f a #
Alternative m => Alternative (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a # (<|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a # some :: IdentityT m a -> IdentityT m [a] # many :: IdentityT m a -> IdentityT m [a] #
Applicative m => Applicative (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods pure :: a -> IdentityT m a # (<*>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b # liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c # (*>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # (<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a #
Functor m => Functor (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods fmap :: (a -> b) -> IdentityT m a -> IdentityT m b # (<$) :: a -> IdentityT m b -> IdentityT m a #
Monad m => Monad (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods (>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b # (>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # return :: a -> IdentityT m a #
MonadPlus m => MonadPlus (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a #
MonadFail m => MonadFail (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods fail :: String -> IdentityT m a #
MonadFix m => MonadFix (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods mfix :: (a -> IdentityT m a) -> IdentityT m a #
Foldable f => Foldable (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b # foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] # null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # sum :: Num a => IdentityT f a -> a # product :: Num a => IdentityT f a -> a #
Traversable f => Traversable (IdentityT f) |
Instance details Defined in Control.Monad.Trans.Identity Methods traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) # sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a) # mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b) # sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a) #
MonadCont m => MonadCont (IdentityT m) |
Instance details Defined in Control.Monad.Cont.Class Methods callCC :: ((a -> IdentityT m b) -> IdentityT m a) -> IdentityT m a #
Generic (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Associated Types
type Rep (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity type Rep (IdentityT f a) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "IdentityT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentityT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f a))))
Methods from :: IdentityT f a -> Rep (IdentityT f a) x # to :: Rep (IdentityT f a) x -> IdentityT f a #
(Read1 f, Read a) => Read (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Methods readsPrec :: Int -> ReadS (IdentityT f a) # readList :: ReadS [IdentityT f a] # readPrec :: ReadPrec (IdentityT f a) # readListPrec :: ReadPrec [IdentityT f a] #
(Show1 f, Show a) => Show (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Methods showsPrec :: Int -> IdentityT f a -> ShowS # show :: IdentityT f a -> String # showList :: [IdentityT f a] -> ShowS #
(Eq1 f, Eq a) => Eq (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Methods (==) :: IdentityT f a -> IdentityT f a -> Bool # (/=) :: IdentityT f a -> IdentityT f a -> Bool #
(Ord1 f, Ord a) => Ord (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # max :: IdentityT f a -> IdentityT f a -> IdentityT f a # min :: IdentityT f a -> IdentityT f a -> IdentityT f a #
type Rep1 (IdentityT f :: k -> Type) |
Instance details Defined in Control.Monad.Trans.Identity type Rep1 (IdentityT f :: k -> Type) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "IdentityT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentityT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))
type Rep (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity type Rep (IdentityT f a) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "IdentityT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentityT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f a))))

newtype MaybeT (m :: Type -> Type) a #

The parameterizable maybe monad, obtained by composing an arbitrary monad with the `Maybe` monad.

Computations are actions that may produce a value or exit.

The `return` function yields a computation that produces that value, while `>>=` sequences two subcomputations, exiting if either computation does.

Constructors

MaybeT |
Fields runMaybeT :: m (Maybe a)

#### Instances

Instances details

MonadTrans MaybeT |
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a #
MonadRWS r w s m => MonadRWS r w s (MaybeT m) |
Instance details Defined in Control.Monad.RWS.Class
Functor m => Generic1 (MaybeT m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Maybe Associated Types
type Rep1 (MaybeT m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Maybe type Rep1 (MaybeT m :: Type -> Type) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 Maybe)))
Methods from1 :: MaybeT m a -> Rep1 (MaybeT m) a # to1 :: Rep1 (MaybeT m) a -> MaybeT m a #
MonadAccum w m => MonadAccum w (MaybeT m) | The accumulated value 'survives' an error: even if the computation fails to deliver a result, we still have an accumulated value. Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods look :: MaybeT m w # add :: w -> MaybeT m () # accum :: (w -> (a, w)) -> MaybeT m a #
MonadError e m => MonadError e (MaybeT m) |
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> MaybeT m a # catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadReader r m => MonadReader r (MaybeT m) |
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadSelect r m => MonadSelect r (MaybeT m) | 'Extends' the possibilities considered by `m` to include `Nothing`; this means that `Nothing` gains a 'rank' (namely, a value of `r`), and the potential result could also be `Nothing`. Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods select :: ((a -> r) -> a) -> MaybeT m a #
MonadState s m => MonadState s (MaybeT m) |
Instance details Defined in Control.Monad.State.Class Methods get :: MaybeT m s # put :: s -> MaybeT m () # state :: (s -> (a, s)) -> MaybeT m a #
MonadWriter w m => MonadWriter w (MaybeT m) |
Instance details Defined in Control.Monad.Writer.Class Methods writer :: (a, w) -> MaybeT m a # tell :: w -> MaybeT m () # listen :: MaybeT m a -> MaybeT m (a, w) # pass :: MaybeT m (a, w -> w) -> MaybeT m a #
MonadIO m => MonadIO (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadZip m => MonadZip (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods mzip :: MaybeT m a -> MaybeT m b -> MaybeT m (a, b) # mzipWith :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # munzip :: MaybeT m (a, b) -> (MaybeT m a, MaybeT m b) #
Eq1 m => Eq1 (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods liftEq :: (a -> b -> Bool) -> MaybeT m a -> MaybeT m b -> Bool #
Ord1 m => Ord1 (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods liftCompare :: (a -> b -> Ordering) -> MaybeT m a -> MaybeT m b -> Ordering #
Read1 m => Read1 (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MaybeT m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [MaybeT m a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (MaybeT m a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [MaybeT m a] #
Show1 m => Show1 (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MaybeT m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [MaybeT m a] -> ShowS #
Contravariant m => Contravariant (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods contramap :: (a' -> a) -> MaybeT m a -> MaybeT m a' # (>$) :: b -> MaybeT m b -> MaybeT m a #
(Functor m, Monad m) => Alternative (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a # (<|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a # some :: MaybeT m a -> MaybeT m [a] # many :: MaybeT m a -> MaybeT m [a] #
(Functor m, Monad m) => Applicative (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods pure :: a -> MaybeT m a # (<*>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # (*>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a #
Functor m => Functor (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
Monad m => Monad (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a #
Monad m => MonadPlus (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
Monad m => MonadFail (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> MaybeT m a #
MonadFix m => MonadFix (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods mfix :: (a -> MaybeT m a) -> MaybeT m a #
Foldable f => Foldable (MaybeT f) |
Instance details Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] # null :: MaybeT f a -> Bool # length :: MaybeT f a -> Int # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # sum :: Num a => MaybeT f a -> a # product :: Num a => MaybeT f a -> a #
Traversable f => Traversable (MaybeT f) |
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) #
MonadCont m => MonadCont (MaybeT m) |
Instance details Defined in Control.Monad.Cont.Class Methods callCC :: ((a -> MaybeT m b) -> MaybeT m a) -> MaybeT m a #
Generic (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Associated Types
type Rep (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe type Rep (MaybeT m a) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Maybe a)))))
Methods from :: MaybeT m a -> Rep (MaybeT m a) x # to :: Rep (MaybeT m a) x -> MaybeT m a #
(Read1 m, Read a) => Read (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Methods readsPrec :: Int -> ReadS (MaybeT m a) # readList :: ReadS [MaybeT m a] # readPrec :: ReadPrec (MaybeT m a) # readListPrec :: ReadPrec [MaybeT m a] #
(Show1 m, Show a) => Show (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Methods showsPrec :: Int -> MaybeT m a -> ShowS # show :: MaybeT m a -> String # showList :: [MaybeT m a] -> ShowS #
(Eq1 m, Eq a) => Eq (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Methods (==) :: MaybeT m a -> MaybeT m a -> Bool # (/=) :: MaybeT m a -> MaybeT m a -> Bool #
(Ord1 m, Ord a) => Ord (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Methods compare :: MaybeT m a -> MaybeT m a -> Ordering # (<) :: MaybeT m a -> MaybeT m a -> Bool # (<=) :: MaybeT m a -> MaybeT m a -> Bool # (>) :: MaybeT m a -> MaybeT m a -> Bool # (>=) :: MaybeT m a -> MaybeT m a -> Bool # max :: MaybeT m a -> MaybeT m a -> MaybeT m a # min :: MaybeT m a -> MaybeT m a -> MaybeT m a #
type Rep1 (MaybeT m :: Type -> Type) |
Instance details Defined in Control.Monad.Trans.Maybe type Rep1 (MaybeT m :: Type -> Type) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 Maybe)))
type Rep (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe type Rep (MaybeT m a) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-inplace" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Maybe a)))))

maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a #

Convert a `MaybeT` computation to `ExceptT`, with a default exception value.

exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a #

Convert a `ExceptT` computation to `MaybeT`, discarding the value of any exception.

# Reexport monadic functions

class Applicative m => Monad (m :: Type -> Type) where #

The `Monad` class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's `do` expressions provide a convenient syntax for writing monadic expressions.

Instances of `Monad` should satisfy the following:

Left identity
  ``return` a `>>=` k = k a`
Right identity
  `m `>>=` `return` = m`
Associativity
  `m `>>=` (\x -> k x `>>=` h) = (m `>>=` k) `>>=` h`

Furthermore, the `Monad` and `Applicative` operations should relate as follows:

-     pure = return

-     m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

The above laws imply:

-     fmap f xs  =  xs >>= return . f

-     (>>) = (*>)

and that `pure` and (`<*>`) satisfy the applicative functor laws.

The instances of `Monad` for `List`, `Maybe` and `IO` defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1 #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

'`as `>>=` bs`' can be understood as the `do` expression

    do a <- as
       bs a

An alternative name for this function is 'bind', but some people may refer to it as 'flatMap', which results from it being equivialent to

    \x f -> join (fmap f x) :: Monad m => m a -> (a -> m b) -> m b

which can be seen as mapping a value with `Monad m => m a -> m (m b)` and then 'flattening' `m (m b)` to `m b` using `join`.

(>>) :: m a -> m b -> m b infixl 1 #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

'`as `>>` bs`' can be understood as the `do` expression

    do as
       bs

or in terms of ``(>>=)`` as

    as >>= const bs

return :: a -> m a #

Inject a value into the monadic type. This function should not be different from its default implementation as `pure`. The justification for the existence of this function is merely historic.

#### Instances

Instances details

Monad Complex | Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b # (>>) :: Complex a -> Complex b -> Complex b # return :: a -> Complex a #
Monad First | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Max | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Max a -> (a -> Max b) -> Max b # (>>) :: Max a -> Max b -> Max b # return :: a -> Max a #
Monad Min | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Min a -> (a -> Min b) -> Min b # (>>) :: Min a -> Min b -> Min b # return :: a -> Min a #
Monad Put |
Instance details Defined in Data.ByteString.Builder.Internal Methods (>>=) :: Put a -> (a -> Put b) -> Put b # (>>) :: Put a -> Put b -> Put b # return :: a -> Put a #
Monad Seq |
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a #
Monad Tree |
Instance details Defined in Data.Tree Methods (>>=) :: Tree a -> (a -> Tree b) -> Tree b # (>>) :: Tree a -> Tree b -> Tree b # return :: a -> Tree a #
Monad NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
Monad STM | @since base-4.3.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a #
Monad Identity | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
Monad First | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Down | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b # (>>) :: Down a -> Down b -> Down b # return :: a -> Down a #
Monad Dual | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a #
Monad Product | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a #
Monad Sum | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a #
Monad Par1 | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a #
Monad P | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods (>>=) :: P a -> (a -> P b) -> P b # (>>) :: P a -> P b -> P b # return :: a -> P a #
Monad ReadP | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b # (>>) :: ReadP a -> ReadP b -> ReadP b # return :: a -> ReadP a #
Monad ReadPrec | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods (>>=) :: ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b # (>>) :: ReadPrec a -> ReadPrec b -> ReadPrec b # return :: a -> ReadPrec a #
Monad IO | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
Monad Q |
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
Monad Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
Monad Solo | @since base-4.15
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b # (>>) :: Solo a -> Solo b -> Solo b # return :: a -> Solo a #
Monad [] | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] #
Monad m => Monad (WrappedMonad m) | Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a #
Monad (SetM s) |
Instance details Defined in Data.Graph Methods (>>=) :: SetM s a -> (a -> SetM s b) -> SetM s b # (>>) :: SetM s a -> SetM s b -> SetM s b # return :: a -> SetM s a #
ArrowApply a => Monad (ArrowMonad a) | @since base-2.01
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # return :: a0 -> ArrowMonad a a0 #
Monad (Either e) | @since base-4.4.0.0
Instance details Defined in GHC.Internal.Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a #
Monad (Proxy :: Type -> Type) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b # (>>) :: Proxy a -> Proxy b -> Proxy b # return :: a -> Proxy a #
Monad (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a #
Monad (IParser t) |
Instance details Defined in Data.Text.Internal.Read Methods (>>=) :: IParser t a -> (a -> IParser t b) -> IParser t b # (>>) :: IParser t a -> IParser t b -> IParser t b # return :: a -> IParser t a #
Monad m => Monad (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a #
Monoid a => Monad ((,) a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) # (>>) :: (a, a0) -> (a, b) -> (a, b) # return :: a0 -> (a, a0) #
(Applicative f, Monad f) => Monad (WhenMissing f x) | Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods (>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # return :: a -> WhenMissing f x a #
Monad m => Monad (Kleisli m a) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b # (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # return :: a0 -> Kleisli m a a0 #
Monad f => Monad (Ap f) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b # (>>) :: Ap f a -> Ap f b -> Ap f b # return :: a -> Ap f a #
Monad f => Monad (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b # (>>) :: Alt f a -> Alt f b -> Alt f b # return :: a -> Alt f a #
Monad f => Monad (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # return :: a -> Rec1 f a #
Monad (t m) => Monad (LiftingAccum t m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods (>>=) :: LiftingAccum t m a -> (a -> LiftingAccum t m b) -> LiftingAccum t m b # (>>) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m b # return :: a -> LiftingAccum t m a #
Monad (t m) => Monad (LiftingSelect t m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods (>>=) :: LiftingSelect t m a -> (a -> LiftingSelect t m b) -> LiftingSelect t m b # (>>) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m b # return :: a -> LiftingSelect t m a #
(Monoid w, Functor m, Monad m) => Monad (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods (>>=) :: AccumT w m a -> (a -> AccumT w m b) -> AccumT w m b # (>>) :: AccumT w m a -> AccumT w m b -> AccumT w m b # return :: a -> AccumT w m a #
Monad m => Monad (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a #
Monad m => Monad (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods (>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b # (>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # return :: a -> IdentityT m a #
Monad m => Monad (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # return :: a -> ReaderT r m a #
Monad m => Monad (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods (>>=) :: SelectT r m a -> (a -> SelectT r m b) -> SelectT r m b # (>>) :: SelectT r m a -> SelectT r m b -> SelectT r m b # return :: a -> SelectT r m a #
Monad m => Monad (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
Monad m => Monad (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
Monad m => Monad (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a #
(Monoid w, Monad m) => Monad (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a #
(Monoid w, Monad m) => Monad (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a #
Monad m => Monad (Reverse m) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods (>>=) :: Reverse m a -> (a -> Reverse m b) -> Reverse m b # (>>) :: Reverse m a -> Reverse m b -> Reverse m b # return :: a -> Reverse m a #
(Monoid a, Monoid b) => Monad ((,,) a b) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # return :: a0 -> (a, b, a0) #
(Monad f, Monad g) => Monad (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods (>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b # (>>) :: Product f g a -> Product f g b -> Product f g b # return :: a -> Product f g a #
(Monad f, Applicative f) => Monad (WhenMatched f x y) | Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods (>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # return :: a -> WhenMatched f x y a #
(Applicative f, Monad f) => Monad (WhenMissing f k x) | Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods (>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # return :: a -> WhenMissing f k x a #
(Monad f, Monad g) => Monad (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b # (>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b # return :: a -> (f :*: g) a #
Monad (ContT r m) |
Instance details Defined in Control.Monad.Trans.Cont Methods (>>=) :: ContT r m a -> (a -> ContT r m b) -> ContT r m b # (>>) :: ContT r m a -> ContT r m b -> ContT r m b # return :: a -> ContT r m a #
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # return :: a0 -> (a, b, c, a0) #
Monad ((->) r) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a #
(Monad f, Applicative f) => Monad (WhenMatched f k x y) | Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods (>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # return :: a -> WhenMatched f k x y a #
Monad f => Monad (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # return :: a -> M1 i c f a #
Monad m => Monad (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a #
(Monoid w, Monad m) => Monad (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a #
(Monoid w, Monad m) => Monad (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a #

join :: Monad m => m (m a) -> m a #

The `join` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'``join` bss`' can be understood as the `do` expression

    do bs <- bss
       bs

#### Examples

Expand

    >>> join [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    [1,2,3,4,5,6,7,8,9]

    >>> join (Just (Just 3))
    Just 3

A common use of `join` is to run an `IO` computation returned from an `STM` transaction, since `STM` transactions can't perform `IO` directly. Recall that

    atomically :: STM a -> IO a

is used to run `STM` transactions atomically. So, by specializing the types of `atomically` and `join` to

    atomically :: STM (IO b) -> IO (IO b)
    join       :: IO (IO b)  -> IO b

we can compose them as

    join . atomically :: STM (IO b) -> IO b

to run an `STM` transaction and the `IO` action it returns.

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a #

The identity of `mplus`. It should also satisfy the equations

    mzero >>= f  =  mzero
    v >> mzero   =  mzero

The default definition is

    mzero = empty

mplus :: m a -> m a -> m a #

An associative operation. The default definition is

    mplus = (<|>)

#### Instances

Instances details

MonadPlus Seq |
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
MonadPlus STM | Takes the first non-`retry`ing `STM` action. @since base-4.3.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadPlus P | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods mzero :: P a # mplus :: P a -> P a -> P a #
MonadPlus ReadP | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods mzero :: ReadP a # mplus :: ReadP a -> ReadP a -> ReadP a #
MonadPlus ReadPrec | @since base-2.01
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods mzero :: ReadPrec a # mplus :: ReadPrec a -> ReadPrec a -> ReadPrec a #
MonadPlus IO | Takes the first non-throwing `IO` action's result. `mzero` throws an exception. @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus Maybe | Picks the leftmost `Just` value, or, alternatively, `Nothing`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus [] | Combines lists by concatenation, starting from the empty list. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 #
MonadPlus (Proxy :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods mzero :: Proxy a # mplus :: Proxy a -> Proxy a -> Proxy a #
MonadPlus (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
Monad m => MonadPlus (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
MonadPlus m => MonadPlus (Kleisli m a) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: Kleisli m a a0 # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 #
MonadPlus f => MonadPlus (Ap f) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods mzero :: Ap f a # mplus :: Ap f a -> Ap f a -> Ap f a #
MonadPlus f => MonadPlus (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mzero :: Alt f a # mplus :: Alt f a -> Alt f a -> Alt f a #
MonadPlus f => MonadPlus (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods mzero :: AccumT w m a # mplus :: AccumT w m a -> AccumT w m a -> AccumT w m a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
MonadPlus m => MonadPlus (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a #
MonadPlus m => MonadPlus (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a #
MonadPlus m => MonadPlus (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods mzero :: SelectT r m a # mplus :: SelectT r m a -> SelectT r m a -> SelectT r m a #
MonadPlus m => MonadPlus (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
(Functor m, MonadPlus m) => MonadPlus (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
MonadPlus m => MonadPlus (Reverse m) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods mzero :: Reverse m a # mplus :: Reverse m a -> Reverse m a -> Reverse m a #
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods mzero :: Product f g a # mplus :: Product f g a -> Product f g a -> Product f g a #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: (f :*: g) a # mplus :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a #
MonadPlus f => MonadPlus (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a #
(Functor m, MonadPlus m) => MonadPlus (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #

Same as `>>=`, but with the arguments interchanged.

    as >>= f == f =<< as

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #

This generalizes the list-based `filter` function.

    runIdentity (filterM (Identity . p) xs) == filter p xs

#### Examples

Expand

    >>> filterM (\x -> do
          putStrLn ("Keep: " ++ show x ++ "?")
          answer <- getLine
          pure (answer == "y"))
        [1, 2, 3]
    Keep: 1?
    y
    Keep: 2?
    n
    Keep: 3?
    y
    [1,3]

    >>> filterM (\x -> do
          putStr (show x)
          x' <- readLn
          pure (x == x'))
        [1, 2, 3]
    12
    22
    33
    [2,3]

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right composition of `Kleisli` arrows.

'`(bs `>=>` cs) a`' can be understood as the `do` expression

    do b <- bs a
       cs b

or in terms of ``(>>=)`` as

    bs a >>= cs

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

Right-to-left composition of Kleisli arrows. `(`>=>`)`, with the arguments flipped.

Note how this operator resembles function composition `(`.`)`:

    (.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
    (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

forever :: Applicative f => f a -> f b #

Repeat an action indefinitely.

#### Examples

Expand

A common use of `forever` is to process input from network sockets, `Handle`s, and channels (e.g. `MVar` and `Chan`).

For example, here is how we might implement an echo server, using `forever` both to listen for client connections on a network socket and to echo client input on client connection handles:

    echoServer :: Socket -> IO ()
    echoServer socket = forever $ do
      client <- accept socket
      forkFinally (echo client) (\_ -> hClose client)
      where
        echo :: Handle -> IO ()
        echo client = forever $
          hGetLine client >>= hPutStrLn client

Note that "forever" isn't necessarily non-terminating. If the action is in a ``MonadPlus`` and short-circuits after some number of iterations. then ``forever`` actually returns `mzero`, effectively short-circuiting its caller.

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #

The `mapAndUnzipM` function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state monad.

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #

The `zipWithM` function generalizes `zipWith` to arbitrary applicative functors.

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #

`zipWithM_` is the extension of `zipWithM` which ignores the final result.

replicateM :: Applicative m => Int -> m a -> m [a] #

``replicateM` n act` performs the action `act` `n` times, and then returns the list of results.

    replicateM n (pure x) == replicate n x

#### Examples

Expand

    >>> replicateM 3 getLine
    hi
    heya
    hiya
    ["hi","heya","hiya"]

    >>> import Control.Monad.State
    >>> runState (replicateM 3 $ state $ \s -> (s, s + 1)) 1
    ([1,2,3],4)

replicateM_ :: Applicative m => Int -> m a -> m () #

Like `replicateM`, but discards the result.

#### Examples

Expand

    >>> replicateM_ 3 (putStr "a")
    aaa

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 #

Strict version of `<$>`.

@since base-4.8.0.0

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

Direct `MonadPlus` equivalent of `filter`.

#### Examples

Expand

The `filter` function is just `mfilter` specialized to the list monad:

    filter = ( mfilter :: (a -> Bool) -> [a] -> [a] )

An example using `mfilter` with the `Maybe` monad:

    >>> mfilter odd (Just 1)
    Just 1
    >>> mfilter odd (Just 2)
    Nothing

module Control.Monad.Fail

# Reexport `Maybe`

data Maybe a #

The `Maybe` type encapsulates an optional value. A value of type ``Maybe` a` either contains a value of type `a` (represented as ``Just` a`), or it is empty (represented as `Nothing`). Using `Maybe` is a good way to deal with errors or exceptional cases without resorting to drastic measures such as `error`.

The `Maybe` type is also a monad. It is a simple kind of error monad, where all errors are represented by `Nothing`. A richer error monad can be built using the `Either` type.

Constructors

Nothing |
Just a |

#### Instances

Instances details

MonadZip Maybe | Since: base-4.8.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: Maybe a -> Maybe b -> Maybe (a, b) # mzipWith :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # munzip :: Maybe (a, b) -> (Maybe a, Maybe b) #
Eq1 Maybe | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool #
Ord1 Maybe | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering #
Read1 Maybe | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] #
Show1 Maybe | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS #
NFData1 Maybe | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Maybe a -> () #
Alternative Maybe | Picks the leftmost `Just` value, or, alternatively, `Nothing`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods empty :: Maybe a # (<|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Applicative Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> Maybe a # (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (*>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Functor Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Monad Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
MonadPlus Maybe | Picks the leftmost `Just` value, or, alternatively, `Nothing`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadFail Maybe | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Control.Monad.Fail Methods fail :: String -> Maybe a #
Foldable Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Traversable Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Hashable1 Maybe |
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Maybe a -> Int #
Generic1 Maybe |
Instance details Defined in GHC.Internal.Generics Associated Types
type Rep1 Maybe | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Internal.Maybe" "ghc-internal" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
Methods from1 :: Maybe a -> Rep1 Maybe a # to1 :: Rep1 Maybe a -> Maybe a #
MonadError () Maybe | Since: mtl-2.2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: () -> Maybe a # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a #
Lift a => Lift (Maybe a :: Type) |
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Maybe a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Maybe a -> Code m (Maybe a) #
NFData a => NFData (Maybe a) |
Instance details Defined in Control.DeepSeq Methods rnf :: Maybe a -> () #
Semigroup a => Monoid (Maybe a) | Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Semigroup a => Semigroup (Maybe a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Data a => Data (Maybe a) | @since base-4.0.0.0
Instance details Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #
Generic (Maybe a) |
Instance details Defined in GHC.Internal.Generics Associated Types
type Rep (Maybe a) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Internal.Maybe" "ghc-internal" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
SingKind a => SingKind (Maybe a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Associated Types
type DemoteRep (Maybe a) |
Instance details Defined in GHC.Internal.Generics type DemoteRep (Maybe a) = Maybe (DemoteRep a)
Methods fromSing :: forall (a0 :: Maybe a). Sing a0 -> DemoteRep (Maybe a)
Read a => Read (Maybe a) | @since base-2.01
Instance details Defined in GHC.Internal.Read Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a) | @since base-2.01
Instance details Defined in GHC.Internal.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Eq a => Eq (Maybe a) | @since base-2.01
Instance details Defined in GHC.Internal.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Ord a => Ord (Maybe a) | @since base-2.01
Instance details Defined in GHC.Internal.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Hashable a => Hashable (Maybe a) |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
SingI ('Nothing :: Maybe a) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods sing :: Sing ('Nothing :: Maybe a)
SingI a2 => SingI ('Just a2 :: Maybe a1) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods sing :: Sing ('Just a2)
type Rep1 Maybe | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Internal.Maybe" "ghc-internal" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type DemoteRep (Maybe a) |
Instance details Defined in GHC.Internal.Generics type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Rep (Maybe a) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Internal.Maybe" "ghc-internal" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
data Sing (b :: Maybe a) |
Instance details Defined in GHC.Internal.Generics data Sing (b :: Maybe a) where SNothing :: forall {a}. Sing ('Nothing :: Maybe a) SJust :: forall {a} (a1 :: a). Sing a1 -> Sing ('Just a1)

maybe :: b -> (a -> b) -> Maybe a -> b #

The `maybe` function takes a default value, a function, and a `Maybe` value. If the `Maybe` value is `Nothing`, the function returns the default value. Otherwise, it applies the function to the value inside the `Just` and returns the result.

#### Examples

Expand

Basic usage:

    >>> maybe False odd (Just 3)
    True

    >>> maybe False odd Nothing
    False

Read an integer from a string using `readMaybe`. If we succeed, return twice the integer; that is, apply `(*2)` to it. If instead we fail to parse an integer, return `0` by default:

    >>> import GHC.Internal.Text.Read ( readMaybe )
    >>> maybe 0 (*2) (readMaybe "5")
    10
    >>> maybe 0 (*2) (readMaybe "")
    0

Apply `show` to a `Maybe Int`. If we have `Just n`, we want to show the underlying `Int` `n`. But if we have `Nothing`, we return the empty string instead of (for example) "Nothing":

    >>> maybe "" show (Just 5)
    "5"
    >>> maybe "" show Nothing
    ""

isJust :: Maybe a -> Bool #

The `isJust` function returns `True` iff its argument is of the form `Just _`.

#### Examples

Expand

Basic usage:

    >>> isJust (Just 3)
    True

    >>> isJust (Just ())
    True

    >>> isJust Nothing
    False

Only the outer constructor is taken into consideration:

    >>> isJust (Just Nothing)
    True

isNothing :: Maybe a -> Bool #

The `isNothing` function returns `True` iff its argument is `Nothing`.

#### Examples

Expand

Basic usage:

    >>> isNothing (Just 3)
    False

    >>> isNothing (Just ())
    False

    >>> isNothing Nothing
    True

Only the outer constructor is taken into consideration:

    >>> isNothing (Just Nothing)
    False

fromMaybe :: a -> Maybe a -> a #

The `fromMaybe` function takes a default value and a `Maybe` value. If the `Maybe` is `Nothing`, it returns the default value; otherwise, it returns the value contained in the `Maybe`.

#### Examples

Expand

Basic usage:

    >>> fromMaybe "" (Just "Hello, World!")
    "Hello, World!"

    >>> fromMaybe "" Nothing
    ""

Read an integer from a string using `readMaybe`. If we fail to parse an integer, we want to return `0` by default:

    >>> import GHC.Internal.Text.Read ( readMaybe )
    >>> fromMaybe 0 (readMaybe "5")
    5
    >>> fromMaybe 0 (readMaybe "")
    0

maybeToList :: Maybe a -> [a] #

The `maybeToList` function returns an empty list when given `Nothing` or a singleton list when given `Just`.

#### Examples

Expand

Basic usage:

    >>> maybeToList (Just 7)
    [7]

    >>> maybeToList Nothing
    []

One can use `maybeToList` to avoid pattern matching when combined with a function that (safely) works on lists:

    >>> import GHC.Internal.Text.Read ( readMaybe )
    >>> sum $ maybeToList (readMaybe "3")
    3
    >>> sum $ maybeToList (readMaybe "")
    0

listToMaybe :: [a] -> Maybe a #

The `listToMaybe` function returns `Nothing` on an empty list or ``Just` a` where `a` is the first element of the list.

#### Examples

Expand

Basic usage:

    >>> listToMaybe []
    Nothing

    >>> listToMaybe [9]
    Just 9

    >>> listToMaybe [1,2,3]
    Just 1

Composing `maybeToList` with `listToMaybe` should be the identity on singleton/empty lists:

    >>> maybeToList $ listToMaybe [5]
    [5]
    >>> maybeToList $ listToMaybe []
    []

But not on lists with more than one element:

    >>> maybeToList $ listToMaybe [1,2,3]
    [1]

catMaybes :: [Maybe a] -> [a] #

The `catMaybes` function takes a list of `Maybe`s and returns a list of all the `Just` values.

#### Examples

Expand

Basic usage:

    >>> catMaybes [Just 1, Nothing, Just 3]
    [1,3]

When constructing a list of `Maybe` values, `catMaybes` can be used to return all of the "success" results (if the list is the result of a `map`, then `mapMaybe` would be more appropriate):

    >>> import GHC.Internal.Text.Read ( readMaybe )
    >>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
    [Just 1,Nothing,Just 3]
    >>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
    [1,3]

mapMaybe :: (a -> Maybe b) -> [a] -> [b] #

The `mapMaybe` function is a version of `map` which can throw out elements. In particular, the functional argument returns something of type ``Maybe` b`. If this is `Nothing`, no element is added on to the result list. If it is ``Just` b`, then `b` is included in the result list.

#### Examples

Expand

Using ``mapMaybe` f x` is a shortcut for ``catMaybes` $ `map` f x` in most cases:

    >>> import GHC.Internal.Text.Read ( readMaybe )
    >>> let readMaybeInt = readMaybe :: String -> Maybe Int
    >>> mapMaybe readMaybeInt ["1", "Foo", "3"]
    [1,3]
    >>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
    [1,3]

If we map the `Just` constructor, the entire list should be returned:

    >>> mapMaybe Just [1,2,3]
    [1,2,3]

# Reexport `Either`

data Either a b #

The `Either` type represents values with two possibilities: a value of type ``Either` a b` is either ``Left` a` or ``Right` b`.

The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").

#### Examples

Expand

The type ``Either` `String` `Int`` is the type of values which can be either a `String` or an `Int`. The `Left` constructor can be used only on `String`s, and the `Right` constructor can be used only on `Int`s:

    >>> let s = Left "foo" :: Either String Int
    >>> s
    Left "foo"
    >>> let n = Right 3 :: Either String Int
    >>> n
    Right 3
    >>> :type s
    s :: Either String Int
    >>> :type n
    n :: Either String Int

The `fmap` from our `Functor` instance will ignore `Left` values, but will apply the supplied function to values contained in a `Right`:

    >>> let s = Left "foo" :: Either String Int
    >>> let n = Right 3 :: Either String Int
    >>> fmap (*2) s
    Left "foo"
    >>> fmap (*2) n
    Right 6

The `Monad` instance for `Either` allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an `Int` from a `Char`, or fail.

    >>> import Data.Char ( digitToInt, isDigit )
    >>> :{
        let parseEither :: Char -> Either String Int
            parseEither c
              | isDigit c = Right (digitToInt c)
              | otherwise = Left "parse error"
    >>> :}

The following should work, since both `'1'` and `'2'` can be parsed as `Int`s.

    >>> :{
        let parseMultiple :: Either String Int
            parseMultiple = do
              x <- parseEither '1'
              y <- parseEither '2'
              return (x + y)
    >>> :}

    >>> parseMultiple
    Right 3

But the following should fail overall, since the first operation where we attempt to parse `'m'` as an `Int` will fail:

    >>> :{
        let parseMultiple :: Either String Int
            parseMultiple = do
              x <- parseEither 'm'
              y <- parseEither '2'
              return (x + y)
    >>> :}

    >>> parseMultiple
    Left "parse error"

Constructors

Left a |
Right b |

#### Instances

Instances details

Bifoldable Either | Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => Either m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Either a b -> m # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Either a b -> c # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Either a b -> c #
Bifoldable1 Either |
Instance details Defined in Data.Bifoldable1 Methods bifold1 :: Semigroup m => Either m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Either a b -> m #
Bifunctor Either | Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bitraversable Either | Since: base-4.10.0.0
Instance details Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) #
Eq2 Either | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Either a c -> Either b d -> Bool #
Ord2 Either | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Either a c -> Either b d -> Ordering #
Read2 Either | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] #
Show2 Either | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Either a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Either a b] -> ShowS #
NFData2 Either | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Either a b -> () #
Hashable2 Either |
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Either a b -> Int #
Generic1 (Either a :: Type -> Type) |
Instance details Defined in GHC.Internal.Generics Associated Types
type Rep1 (Either a :: Type -> Type) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
Methods from1 :: Either a a0 -> Rep1 (Either a) a0 # to1 :: Rep1 (Either a) a0 -> Either a a0 #
MonadError e (Either e) |
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> Either e a # catchError :: Either e a -> (e -> Either e a) -> Either e a #
(Lift a, Lift b) => Lift (Either a b :: Type) |
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Either a b -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Either a b -> Code m (Either a b) #
Eq a => Eq1 (Either a) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a0 -> b -> Bool) -> Either a a0 -> Either a b -> Bool #
Ord a => Ord1 (Either a) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering #
Read a => Read1 (Either a) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] #
Show a => Show1 (Either a) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Either a a0 -> ShowS # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Either a a0] -> ShowS #
NFData a => NFData1 (Either a) | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Either a a0 -> () #
Applicative (Either e) | @since base-3.0
Instance details Defined in GHC.Internal.Data.Either Methods pure :: a -> Either e a # (<*>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (*>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Functor (Either a) | @since base-3.0
Instance details Defined in GHC.Internal.Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Monad (Either e) | @since base-4.4.0.0
Instance details Defined in GHC.Internal.Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a #
IsString str => MonadFail (Either str) # | For convenient work with `MonadFail`. Since: 0.1.0
Instance details Defined in Relude.Monad.Either Methods fail :: String -> Either str a #
Foldable (Either a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # null :: Either a a0 -> Bool # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # sum :: Num a0 => Either a a0 -> a0 # product :: Num a0 => Either a a0 -> a0 #
Traversable (Either a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) # sequence :: Monad m => Either a (m a0) -> m (Either a a0) #
Hashable a => Hashable1 (Either a) |
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Either a a0 -> Int #
(NFData a, NFData b) => NFData (Either a b) |
Instance details Defined in Control.DeepSeq Methods rnf :: Either a b -> () #
Semigroup (Either a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
(Data a, Data b) => Data (Either a b) | @since base-4.0.0.0
Instance details Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) # toConstr :: Either a b -> Constr # dataTypeOf :: Either a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) #
Generic (Either a b) |
Instance details Defined in GHC.Internal.Generics Associated Types
type Rep (Either a b) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep (Either a b) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b)))
Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
(Read a, Read b) => Read (Either a b) | @since base-3.0
Instance details Defined in GHC.Internal.Data.Either Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] # readPrec :: ReadPrec (Either a b) # readListPrec :: ReadPrec [Either a b] #
(Show a, Show b) => Show (Either a b) | @since base-3.0
Instance details Defined in GHC.Internal.Data.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
(Eq a, Eq b) => Eq (Either a b) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Either Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
(Ord a, Ord b) => Ord (Either a b) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Either Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
(Hashable a, Hashable b) => Hashable (Either a b) |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
type Rep1 (Either a :: Type -> Type) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Rep (Either a b) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Generics type Rep (Either a b) = D1 ('MetaData "Either" "GHC.Internal.Data.Either" "ghc-internal" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b)))

either :: (a -> c) -> (b -> c) -> Either a b -> c #

Case analysis for the `Either` type. If the value is ``Left` a`, apply the first function to `a`; if it is ``Right` b`, apply the second function to `b`.

#### Examples

Expand

We create two values of type ``Either` `String` `Int``, one using the `Left` constructor and another using the `Right` constructor. Then we apply "either" the `length` function (if we have a `String`) or the "times-two" function (if we have an `Int`):

    >>> let s = Left "foo" :: Either String Int
    >>> let n = Right 3 :: Either String Int
    >>> either length (*2) s
    3
    >>> either length (*2) n
    6

lefts :: [Either a b] -> [a] #

Extracts from a list of `Either` all the `Left` elements. All the `Left` elements are extracted in order.

#### Examples

Expand

Basic usage:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> lefts list
    ["foo","bar","baz"]

rights :: [Either a b] -> [b] #

Extracts from a list of `Either` all the `Right` elements. All the `Right` elements are extracted in order.

#### Examples

Expand

Basic usage:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> rights list
    [3,7]

partitionEithers :: [Either a b] -> ([a], [b]) #

Partitions a list of `Either` into two lists. All the `Left` elements are extracted, in order, to the first component of the output. Similarly the `Right` elements are extracted to the second component of the output.

#### Examples

Expand

Basic usage:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> partitionEithers list
    (["foo","bar","baz"],[3,7])

The pair returned by ``partitionEithers` x` should be the same pair as `(`lefts` x, `rights` x)`:

    >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
    >>> partitionEithers list == (lefts list, rights list)
    True

isLeft :: Either a b -> Bool #

Return `True` if the given value is a `Left`-value, `False` otherwise.

@since base-4.7.0.0

#### Examples

Expand

Basic usage:

    >>> isLeft (Left "foo")
    True
    >>> isLeft (Right 3)
    False

Assuming a `Left` value signifies some sort of error, we can use `isLeft` to write a very simple error-reporting function that does absolutely nothing in the case of success, and outputs "ERROR" if any error occurred.

This example shows how `isLeft` might be used to avoid pattern matching when one does not care about the value contained in the constructor:

    >>> import Control.Monad ( when )
    >>> let report e = when (isLeft e) $ putStrLn "ERROR"
    >>> report (Right 1)
    >>> report (Left "parse error")
    ERROR

isRight :: Either a b -> Bool #

Return `True` if the given value is a `Right`-value, `False` otherwise.

@since base-4.7.0.0

#### Examples

Expand

Basic usage:

    >>> isRight (Left "foo")
    False
    >>> isRight (Right 3)
    True

Assuming a `Left` value signifies some sort of error, we can use `isRight` to write a very simple reporting function that only outputs "SUCCESS" when a computation has succeeded.

This example shows how `isRight` might be used to avoid pattern matching when one does not care about the value contained in the constructor:

    >>> import Control.Monad ( when )
    >>> let report e = when (isRight e) $ putStrLn "SUCCESS"
    >>> report (Left "parse error")
    >>> report (Right 1)
    SUCCESS