Relude.Monad.Reexport

Reexports functions to work with monads.

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

MonadRWS r w s m => MonadRWS r w s (ExceptT e m)

Since: mtl-2.2

Defined in Control.Monad.RWS.Class

Functor m => Generic1 (ExceptT e m :: Type -> Type)

Defined in Control.Monad.Trans.Except

Associated Types

type Rep1 (ExceptT e m :: Type -> Type)

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-1df5" '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

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

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

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

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

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

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)

Defined in Control.Monad.Trans.Except

Methods

lift :: Monad m => m a -> ExceptT e m a

MonadIO m => MonadIO (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

liftIO :: IO a -> ExceptT e m a

MonadZip m => MonadZip (ExceptT e m)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.Except

Methods

fail :: String -> ExceptT e m a

MonadFix m => MonadFix (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

mfix :: (a -> ExceptT e m a) -> ExceptT e m a

Foldable f => Foldable (ExceptT e f)

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)

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

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)

Defined in Control.Monad.Trans.Except

Associated Types

type Rep (ExceptT e m a)

Defined in Control.Monad.Trans.Except

type Rep (ExceptT e m a) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-1df5" '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)

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)

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)

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)

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)

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-1df5" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 (Either e))))

type Rep (ExceptT e m a)

Defined in Control.Monad.Trans.Except

type Rep (ExceptT e m a) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-1df5" '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

Generic1 (ReaderT r m :: Type -> Type)

Defined in Control.Monad.Trans.Reader

Associated Types

type Rep1 (ReaderT r m :: Type -> Type)

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-1df5" '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

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)

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)

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

Defined in Control.Monad.Select

Methods

select :: ((a -> r') -> a) -> ReaderT r m a

MonadState s m => MonadState s (ReaderT r m)

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)

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)

Defined in Control.Monad.Trans.Reader

Methods

lift :: Monad m => m a -> ReaderT r m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

MonadZip m => MonadZip (ReaderT r m)

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)

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)

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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.Reader

Methods

fail :: String -> ReaderT r m a

MonadFix m => MonadFix (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mfix :: (a -> ReaderT r m a) -> ReaderT r m a

MonadCont m => MonadCont (ReaderT r m)

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)

Defined in Control.Monad.Trans.Reader

Associated Types

type Rep (ReaderT r m a)

Defined in Control.Monad.Trans.Reader

type Rep (ReaderT r m a) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.1-1df5" '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)

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-1df5" '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)

Defined in Control.Monad.Trans.Reader

type Rep (ReaderT r m a) = D1 ('MetaData "ReaderT" "Control.Monad.Trans.Reader" "transformers-0.6.1.1-1df5" '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

MonadReader r m => MonadReader r (MaybeT m)

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

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

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)

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)

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)

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)

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

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)

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)

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

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)

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)

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

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)

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)

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

MonadState s m => MonadState s (MaybeT m)

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

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

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)

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)

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

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)

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)

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

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)

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)

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)

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

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)

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)

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

MonadAccum w m => MonadAccum w (StateT s m)

Since: mtl-2.3

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)

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)

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

Defined in Control.Monad.Select

Methods

select :: ((a -> w) -> a) -> StateT s m a

Monad m => MonadState s (StateT s m)

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)

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)

Defined in Control.Monad.Trans.State.Strict

Methods

lift :: Monad m => m a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

Contravariant m => Contravariant (StateT s m)

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)

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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.State.Strict

Methods

fail :: String -> StateT s m a

MonadFix m => MonadFix (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

mfix :: (a -> StateT s m a) -> StateT s m a

MonadCont m => MonadCont (StateT s m)

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)

Defined in Control.Monad.Trans.State.Strict

Associated Types

type Rep (StateT s m a)

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-1df5" '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)

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-1df5" '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

MonadRWS r w s m => MonadRWS r w s (IdentityT m)

Defined in Control.Monad.RWS.Class

Generic1 (IdentityT f :: k -> Type)

Defined in Control.Monad.Trans.Identity

Associated Types

type Rep1 (IdentityT f :: k -> Type)

Defined in Control.Monad.Trans.Identity

type Rep1 (IdentityT f :: k -> Type) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-1df5" '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

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)

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)

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

Defined in Control.Monad.Select

Methods

select :: ((a -> r) -> a) -> IdentityT m a

MonadState s m => MonadState s (IdentityT m)

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)

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)

Defined in Control.Monad.Trans.Identity

Methods

lift :: Monad m => m a -> IdentityT m a

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

MonadZip m => MonadZip (IdentityT m)

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)

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)

Defined in Control.Monad.Trans.Identity

Methods

liftEq :: (a -> b -> Bool) -> IdentityT f a -> IdentityT f b -> Bool

Ord1 f => Ord1 (IdentityT f)

Defined in Control.Monad.Trans.Identity

Methods

liftCompare :: (a -> b -> Ordering) -> IdentityT f a -> IdentityT f b -> Ordering

Read1 f => Read1 (IdentityT f)

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)

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)

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)

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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.Identity

Methods

fail :: String -> IdentityT m a

MonadFix m => MonadFix (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

mfix :: (a -> IdentityT m a) -> IdentityT m a

Foldable f => Foldable (IdentityT f)

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)

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)

Defined in Control.Monad.Cont.Class

Methods

callCC :: ((a -> IdentityT m b) -> IdentityT m a) -> IdentityT m a

Generic (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Associated Types

type Rep (IdentityT f a)

Defined in Control.Monad.Trans.Identity

type Rep (IdentityT f a) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-1df5" '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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.Identity

type Rep1 (IdentityT f :: k -> Type) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-1df5" 'True) (C1 ('MetaCons "IdentityT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentityT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))

type Rep (IdentityT f a)

Defined in Control.Monad.Trans.Identity

type Rep (IdentityT f a) = D1 ('MetaData "IdentityT" "Control.Monad.Trans.Identity" "transformers-0.6.1.1-1df5" '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

MonadTrans MaybeT

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)

Defined in Control.Monad.RWS.Class

Functor m => Generic1 (MaybeT m :: Type -> Type)

Defined in Control.Monad.Trans.Maybe

Associated Types

type Rep1 (MaybeT m :: Type -> Type)

Defined in Control.Monad.Trans.Maybe

type Rep1 (MaybeT m :: Type -> Type) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-1df5" '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

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)

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)

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

Defined in Control.Monad.Select

Methods

select :: ((a -> r) -> a) -> MaybeT m a

MonadState s m => MonadState s (MaybeT m)

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)

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)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

MonadZip m => MonadZip (MaybeT m)

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)

Defined in Control.Monad.Trans.Maybe

Methods

liftEq :: (a -> b -> Bool) -> MaybeT m a -> MaybeT m b -> Bool

Ord1 m => Ord1 (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftCompare :: (a -> b -> Ordering) -> MaybeT m a -> MaybeT m b -> Ordering

Read1 m => Read1 (MaybeT m)

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)

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)

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)

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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.Maybe

Methods

fail :: String -> MaybeT m a

MonadFix m => MonadFix (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

mfix :: (a -> MaybeT m a) -> MaybeT m a

Foldable f => Foldable (MaybeT f)

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)

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)

Defined in Control.Monad.Cont.Class

Methods

callCC :: ((a -> MaybeT m b) -> MaybeT m a) -> MaybeT m a

Generic (MaybeT m a)

Defined in Control.Monad.Trans.Maybe

Associated Types

type Rep (MaybeT m a)

Defined in Control.Monad.Trans.Maybe

type Rep (MaybeT m a) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-1df5" '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)

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)

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)

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)

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)

Defined in Control.Monad.Trans.Maybe

type Rep1 (MaybeT m :: Type -> Type) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-1df5" 'True) (C1 ('MetaCons "MaybeT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runMaybeT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 Maybe)))

type Rep (MaybeT m a)

Defined in Control.Monad.Trans.Maybe

type Rep (MaybeT m a) = D1 ('MetaData "MaybeT" "Control.Monad.Trans.Maybe" "transformers-0.6.1.1-1df5" '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

Monad Complex

Since: base-4.9.0.0

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

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

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

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

Defined in Data.Semigroup

Methods

(>>=) :: Min a -> (a -> Min b) -> Min b

(>>) :: Min a -> Min b -> Min b

return :: a -> Min a

Monad Put

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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)

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)

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

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

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

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

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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.

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

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

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

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

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

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)

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

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

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

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

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)

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)

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)

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

>>> 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

MonadPlus Seq

Defined in Data.Sequence.Internal

Methods

mzero :: Seq a

mplus :: Seq a -> Seq a -> Seq a

MonadPlus STM

Takes the first non-retrying STM action.

@since base-4.3.0.0

Defined in GHC.Internal.Conc.Sync

Methods

mzero :: STM a

mplus :: STM a -> STM a -> STM a

MonadPlus P

@since base-2.01

Defined in GHC.Internal.Text.ParserCombinators.ReadP

Methods

mzero :: P a

mplus :: P a -> P a -> P a

MonadPlus ReadP

@since base-2.01

Defined in GHC.Internal.Text.ParserCombinators.ReadP

Methods

mzero :: ReadP a

mplus :: ReadP a -> ReadP a -> ReadP a

MonadPlus ReadPrec

@since base-2.01

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

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

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

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

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

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

Defined in GHC.Internal.Generics

Methods

mzero :: U1 a

mplus :: U1 a -> U1 a -> U1 a

Monad m => MonadPlus (MaybeT m)

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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.

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

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

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

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)

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)

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)

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

>>> 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

A common use of forever is to process input from network sockets, Handles, 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

>>> 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

>>> 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

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

MonadZip Maybe

Since: base-4.8.0.0

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

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool

Ord1 Maybe

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering

Read1 Maybe

Since: base-4.9.0.0

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

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

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Maybe a -> ()

Alternative Maybe

Picks the leftmost Just value, or, alternatively, Nothing.

@since base-2.01

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

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

Defined in GHC.Internal.Base

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b

(<$) :: a -> Maybe b -> Maybe a

Monad Maybe

@since base-2.01

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

Defined in GHC.Internal.Base

Methods

mzero :: Maybe a

mplus :: Maybe a -> Maybe a -> Maybe a

MonadFail Maybe

@since base-4.9.0.0

Defined in GHC.Internal.Control.Monad.Fail

Methods

fail :: String -> Maybe a

Foldable Maybe

@since base-2.01

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

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

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Maybe a -> Int

Generic1 Maybe

Defined in GHC.Internal.Generics

Associated Types

type Rep1 Maybe

@since base-4.6.0.0

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

Defined in Control.Monad.Error.Class

Methods

throwError :: () -> Maybe a

catchError :: Maybe a -> (() -> Maybe a) -> Maybe a

Lift a => Lift (Maybe a :: Type)

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)

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

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

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

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)

Defined in GHC.Internal.Generics

Associated Types

type Rep (Maybe a)

@since base-4.6.0.0

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

Defined in GHC.Internal.Generics

Associated Types

type DemoteRep (Maybe a)

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

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

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

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

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)

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

Defined in GHC.Internal.Generics

Methods

sing :: Sing ('Nothing :: Maybe a)

SingI a2 => SingI ('Just a2 :: Maybe a1)

@since base-4.9.0.0

Defined in GHC.Internal.Generics

Methods

sing :: Sing ('Just a2)

type Rep1 Maybe

@since base-4.6.0.0

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)

Defined in GHC.Internal.Generics

type DemoteRep (Maybe a) = Maybe (DemoteRep a)

type Rep (Maybe a)

@since base-4.6.0.0

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)

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

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

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

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

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

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

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 Maybes and returns a list of all the Just values.

Examples

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

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

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 Strings, and the Right constructor can be used only on Ints:

>>> 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 Ints.

>>> :{
    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

Bifoldable Either

Since: base-4.10.0.0

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

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

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

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

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

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

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

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

Defined in Control.DeepSeq

Methods

liftRnf2 :: (a -> ()) -> (b -> ()) -> Either a b -> ()

Hashable2 Either

Defined in Data.Hashable.Class

Methods

liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Either a b -> Int

Generic1 (Either a :: Type -> Type)

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (Either a :: Type -> Type)

@since base-4.6.0.0

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)

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)

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

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

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

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

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

Defined in Control.DeepSeq

Methods

liftRnf :: (a0 -> ()) -> Either a a0 -> ()

Applicative (Either e)

@since base-3.0

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

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

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

Defined in Relude.Monad.Either

Methods

fail :: String -> Either str a

Foldable (Either a)

@since base-4.7.0.0

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

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)

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Either a a0 -> Int

(NFData a, NFData b) => NFData (Either a b)

Defined in Control.DeepSeq

Methods

rnf :: Either a b -> ()

Semigroup (Either a b)

@since base-4.9.0.0

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

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)

Defined in GHC.Internal.Generics

Associated Types

type Rep (Either a b)

@since base-4.6.0.0

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

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

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

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

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)

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

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

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

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

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

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

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

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

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