Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2023 Kowainik |
---|---|
License | MIT |
Maintainer | Kowainik <xrom.xkov@gmail.com> |
Stability | Stable |
Portability | Portable |
Safe Haskell | Safe |
Language | Haskell2010 |
Relude.Monad.Reexport
Description
Reexports functions to work with monads.
Synopsis
- newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
- runExceptT :: ExceptT e m a -> m (Either e a)
- type Reader r = ReaderT r Identity
- class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
- asks :: MonadReader r m => (r -> a) -> m a
- runReader :: Reader r a -> r -> a
- withReader :: (r' -> r) -> Reader r a -> Reader r' a
- withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- class Monad m => MonadState s (m :: Type -> Type) | m -> s where
- type State s = StateT s Identity
- newtype StateT s (m :: Type -> Type) a = StateT {
- runStateT :: s -> m (a, s)
- evalState :: State s a -> s -> a
- evalStateT :: Monad m => StateT s m a -> s -> m a
- execState :: State s a -> s -> s
- execStateT :: Monad m => StateT s m a -> s -> m s
- gets :: MonadState s m => (s -> a) -> m a
- modify :: MonadState s m => (s -> s) -> m ()
- modify' :: MonadState s m => (s -> s) -> m ()
- runState :: State s a -> s -> (a, s)
- withState :: (s -> s) -> State s a -> State s a
- class Monad m => MonadIO (m :: Type -> Type) where
- class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- data IdentityT (f :: k -> Type) (a :: k)
- newtype MaybeT (m :: Type -> Type) a = MaybeT {}
- exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- class Applicative m => Monad (m :: Type -> Type) where
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- forever :: Applicative f => f a -> f b
- join :: Monad m => m (m a) -> m a
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- replicateM :: Applicative m => Int -> m a -> m [a]
- replicateM_ :: Applicative m => Int -> m a -> m ()
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- class Monad m => MonadFail (m :: Type -> Type) where
- data Maybe a
- maybe :: b -> (a -> b) -> Maybe a -> b
- catMaybes :: [Maybe a] -> [a]
- fromMaybe :: a -> Maybe a -> a
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- listToMaybe :: [a] -> Maybe a
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- maybeToList :: Maybe a -> [a]
- data Either a b
- partitionEithers :: [Either a b] -> ([a], [b])
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- isLeft :: Either a b -> Bool
- isRight :: Either a b -> Bool
- lefts :: [Either a b] -> [a]
- rights :: [Either a b] -> [b]
Reexport transformers
newtype ExceptT e (m :: Type -> Type) a #
Instances
MonadRWS r w s m => MonadRWS r w s (ExceptT e m) | |||||
Defined in Control.Monad.RWS.Class | |||||
Functor m => Generic1 (ExceptT e m :: Type -> Type) | |||||
Defined in Control.Monad.Trans.Except Associated Types
| |||||
MonadAccum w m => MonadAccum w (ExceptT e m) | |||||
Monad m => MonadError e (ExceptT e m) | |||||
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) | |||||
MonadSelect r m => MonadSelect r (ExceptT e m) | |||||
Defined in Control.Monad.Select | |||||
MonadState s m => MonadState s (ExceptT e m) | |||||
MonadWriter w m => MonadWriter w (ExceptT e m) | |||||
MonadTrans (ExceptT e) | |||||
Defined in Control.Monad.Trans.Except | |||||
MonadFail m => MonadFail (ExceptT e m) | |||||
Defined in Control.Monad.Trans.Except | |||||
MonadFix m => MonadFix (ExceptT e m) | |||||
Defined in Control.Monad.Trans.Except | |||||
MonadIO m => MonadIO (ExceptT e m) | |||||
Defined in Control.Monad.Trans.Except | |||||
MonadZip m => MonadZip (ExceptT e m) | |||||
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 | |||||
(Eq e, Eq1 m) => Eq1 (ExceptT e m) | |||||
(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) | |||||
Traversable f => Traversable (ExceptT e f) | |||||
Defined in Control.Monad.Trans.Except | |||||
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) | |||||
(Functor m, Monad m) => Applicative (ExceptT e m) | |||||
Defined in Control.Monad.Trans.Except | |||||
Functor m => Functor (ExceptT e m) | |||||
Monad m => Monad (ExceptT e m) | |||||
(Monad m, Monoid e) => MonadPlus (ExceptT e m) | |||||
MonadCont m => MonadCont (ExceptT e m) | |||||
Defined in Control.Monad.Cont.Class | |||||
Generic (ExceptT e m a) | |||||
Defined in Control.Monad.Trans.Except Associated Types
| |||||
(Read e, Read1 m, Read a) => Read (ExceptT e m a) | |||||
Defined in Control.Monad.Trans.Except | |||||
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |||||
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |||||
(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 # | |||||
type Rep1 (ExceptT e m :: Type -> Type) | |||||
Defined in Control.Monad.Trans.Except | |||||
type Rep (ExceptT e m a) | |||||
Defined in Control.Monad.Trans.Except |
runExceptT :: ExceptT e m a -> m (Either e a) #
class Monad m => MonadReader r (m :: Type -> Type) | m -> r where #
Instances
MonadReader r m => MonadReader r (MaybeT m) | |
(Monoid w, MonadReader r m) => MonadReader r (AccumT w m) | |
MonadReader r m => MonadReader r (ExceptT e m) | |
MonadReader r m => MonadReader r (IdentityT m) | |
Monad m => MonadReader r (ReaderT r m) | |
MonadReader r m => MonadReader r (StateT s m) | |
MonadReader r m => MonadReader r (StateT s m) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m) | |
MonadReader r' m => MonadReader r' (SelectT r m) | |
MonadReader r ((->) r) | |
MonadReader r' m => MonadReader r' (ContT r m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | |
(Monad m, Monoid w) => MonadReader r (RWST r w s m) | |
newtype ReaderT r (m :: Type -> Type) a #
Constructors
ReaderT | |
Fields
|
Instances
Generic1 (ReaderT r m :: Type -> Type) | |||||
Defined in Control.Monad.Trans.Reader Associated Types
| |||||
MonadAccum w m => MonadAccum w (ReaderT r m) | |||||
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) | |||||
MonadSelect r' m => MonadSelect r' (ReaderT r m) | |||||
Defined in Control.Monad.Select | |||||
MonadState s m => MonadState s (ReaderT r m) | |||||
MonadWriter w m => MonadWriter w (ReaderT r m) | |||||
MonadTrans (ReaderT r) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadFail m => MonadFail (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadFix m => MonadFix (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadIO m => MonadIO (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
MonadZip m => MonadZip (ReaderT r m) | |||||
Contravariant m => Contravariant (ReaderT r m) | |||||
Alternative m => Alternative (ReaderT r m) | |||||
Applicative m => Applicative (ReaderT r m) | |||||
Defined in Control.Monad.Trans.Reader | |||||
Functor m => Functor (ReaderT r m) | |||||
Monad m => Monad (ReaderT r m) | |||||
MonadPlus m => MonadPlus (ReaderT r m) | |||||
MonadCont m => MonadCont (ReaderT r m) | |||||
Defined in Control.Monad.Cont.Class | |||||
Generic (ReaderT r m a) | |||||
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.0-a97a" '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 |
asks :: MonadReader r m => (r -> a) -> m a #
withReader :: (r' -> r) -> Reader r a -> Reader r' a #
class Monad m => MonadState s (m :: Type -> Type) | m -> s where #
Instances
MonadState s m => MonadState s (MaybeT m) | |
(Monoid w, MonadState s m) => MonadState s (AccumT w m) | |
MonadState s m => MonadState s (ExceptT e m) | |
MonadState s m => MonadState s (IdentityT m) | |
MonadState s m => MonadState s (ReaderT r m) | |
MonadState s m => MonadState s (SelectT r m) | |
Monad m => MonadState s (StateT s m) | |
Monad m => MonadState s (StateT s m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
MonadState s m => MonadState s (ContT r m) | |
(Monad m, Monoid w) => MonadState s (RWST r w s m) | |
(Monad m, Monoid w) => MonadState s (RWST r w s m) | |
(Monad m, Monoid w) => MonadState s (RWST r w s m) | |
newtype StateT s (m :: Type -> Type) a #
Instances
evalStateT :: Monad m => StateT s m a -> s -> m a #
execStateT :: Monad m => StateT s m a -> s -> m s #
gets :: MonadState s m => (s -> a) -> m a #
modify :: MonadState s m => (s -> s) -> m () #
modify' :: MonadState s m => (s -> s) -> m () #
class Monad m => MonadIO (m :: Type -> Type) where #
Instances
MonadIO IO | |
Defined in Control.Monad.IO.Class | |
MonadIO Q | |
Defined in Language.Haskell.TH.Syntax | |
MonadIO m => MonadIO (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
MonadIO m => MonadIO (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadIO m => MonadIO (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
MonadIO m => MonadIO (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadIO m => MonadIO (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadIO m => MonadIO (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, MonadIO m) => MonadIO (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, MonadIO m) => MonadIO (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
MonadIO m => MonadIO (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
MonadIO m => MonadIO (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, MonadIO m) => MonadIO (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, MonadIO m) => MonadIO (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where #
Instances
MonadTrans MaybeT | |
Defined in Control.Monad.Trans.Maybe | |
Monoid w => MonadTrans (AccumT w) | |
Defined in Control.Monad.Trans.Accum | |
MonadTrans (ExceptT e) | |
Defined in Control.Monad.Trans.Except | |
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type) | |
Defined in Control.Monad.Trans.Identity | |
MonadTrans (ReaderT r) | |
Defined in Control.Monad.Trans.Reader | |
MonadTrans (SelectT r) | |
Defined in Control.Monad.Trans.Select | |
MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadTrans (WriterT w) | |
Defined in Control.Monad.Trans.Writer.CPS | |
Monoid w => MonadTrans (WriterT w) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
Monoid w => MonadTrans (WriterT w) | |
Defined in Control.Monad.Trans.Writer.Strict | |
MonadTrans (ContT r) | |
Defined in Control.Monad.Trans.Cont | |
MonadTrans (RWST r w s) | |
Defined in Control.Monad.Trans.RWS.CPS | |
Monoid w => MonadTrans (RWST r w s) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
Monoid w => MonadTrans (RWST r w s) | |
Defined in Control.Monad.Trans.RWS.Strict |
data IdentityT (f :: k -> Type) (a :: k) #
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
| |||||
MonadAccum w m => MonadAccum w (IdentityT m) | |||||
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) | |||||
MonadSelect r m => MonadSelect r (IdentityT m) | |||||
Defined in Control.Monad.Select | |||||
MonadState s m => MonadState s (IdentityT m) | |||||
MonadWriter w m => MonadWriter w (IdentityT m) | |||||
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type) | |||||
Defined in Control.Monad.Trans.Identity | |||||
MonadFail m => MonadFail (IdentityT m) | |||||
Defined in Control.Monad.Trans.Identity | |||||
MonadFix m => MonadFix (IdentityT m) | |||||
Defined in Control.Monad.Trans.Identity | |||||
MonadIO m => MonadIO (IdentityT m) | |||||
Defined in Control.Monad.Trans.Identity | |||||
MonadZip m => MonadZip (IdentityT m) | |||||
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 | |||||
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 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) | |||||
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) | |||||
Traversable f => Traversable (IdentityT f) | |||||
Defined in Control.Monad.Trans.Identity | |||||
Alternative m => Alternative (IdentityT m) | |||||
Applicative m => Applicative (IdentityT m) | |||||
Defined in Control.Monad.Trans.Identity | |||||
Functor m => Functor (IdentityT m) | |||||
Monad m => Monad (IdentityT m) | |||||
MonadPlus m => MonadPlus (IdentityT m) | |||||
MonadCont m => MonadCont (IdentityT m) | |||||
Defined in Control.Monad.Cont.Class | |||||
Generic (IdentityT f a) | |||||
Defined in Control.Monad.Trans.Identity Associated Types
| |||||
(Read1 f, Read a) => Read (IdentityT f a) | |||||
Defined in Control.Monad.Trans.Identity | |||||
(Show1 f, Show a) => Show (IdentityT f a) | |||||
(Eq1 f, Eq a) => Eq (IdentityT f a) | |||||
(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 # | |||||
type Rep1 (IdentityT f :: k -> Type) | |||||
Defined in Control.Monad.Trans.Identity | |||||
type Rep (IdentityT f a) | |||||
Defined in Control.Monad.Trans.Identity |
newtype MaybeT (m :: Type -> Type) a #
Instances
MonadTrans MaybeT | |||||
Defined in Control.Monad.Trans.Maybe | |||||
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
| |||||
MonadAccum w m => MonadAccum w (MaybeT m) | |||||
MonadError e m => MonadError e (MaybeT m) | |||||
Defined in Control.Monad.Error.Class | |||||
MonadReader r m => MonadReader r (MaybeT m) | |||||
MonadSelect r m => MonadSelect r (MaybeT m) | |||||
Defined in Control.Monad.Select | |||||
MonadState s m => MonadState s (MaybeT m) | |||||
MonadWriter w m => MonadWriter w (MaybeT m) | |||||
Monad m => MonadFail (MaybeT m) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
MonadFix m => MonadFix (MaybeT m) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
MonadIO m => MonadIO (MaybeT m) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
MonadZip m => MonadZip (MaybeT m) | |||||
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 elem :: Eq a => a -> MaybeT f a -> Bool maximum :: Ord a => MaybeT f a -> a minimum :: Ord a => MaybeT f a -> a | |||||
Eq1 m => Eq1 (MaybeT m) | |||||
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) | |||||
Traversable f => Traversable (MaybeT f) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
(Functor m, Monad m) => Alternative (MaybeT m) | |||||
(Functor m, Monad m) => Applicative (MaybeT m) | |||||
Functor m => Functor (MaybeT m) | |||||
Monad m => Monad (MaybeT m) | |||||
Monad m => MonadPlus (MaybeT m) | |||||
MonadCont m => MonadCont (MaybeT m) | |||||
Defined in Control.Monad.Cont.Class | |||||
Generic (MaybeT m a) | |||||
Defined in Control.Monad.Trans.Maybe Associated Types
| |||||
(Read1 m, Read a) => Read (MaybeT m a) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
(Show1 m, Show a) => Show (MaybeT m a) | |||||
(Eq1 m, Eq a) => Eq (MaybeT m a) | |||||
(Ord1 m, Ord a) => Ord (MaybeT m a) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
type Rep1 (MaybeT m :: Type -> Type) | |||||
Defined in Control.Monad.Trans.Maybe | |||||
type Rep (MaybeT m a) | |||||
Reexport monadic functions
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Complex | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Down | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad NonEmpty | |
Monad STM | |
Monad NoIO | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad Put | |
Monad Seq | |
Monad Tree | |
Monad IO | |
Monad Q | |
Monad Maybe | |
Monad Solo | |
Monad [] | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
Monad (ST s) | |
Monad (SetM s) | |
Monad (IParser t) | |
Monad m => Monad (MaybeT m) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (Kleisli m a) | |
Monad f => Monad (Ap f) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Rec1 f) | |
(Applicative f, Monad f) => Monad (WhenMissing f x) | |
Monad (t m) => Monad (LiftingAccum t m) | |
Monad (t m) => Monad (LiftingSelect t m) | |
(Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (IdentityT m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (SelectT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
Monad m => Monad (Reverse m) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monad f, Applicative f) => Monad (WhenMatched f x y) | |
(Applicative f, Monad f) => Monad (WhenMissing f k x) | |
Monad (ContT r m) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
(Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
Monad m => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Minimal complete definition
Nothing
Instances
MonadPlus STM | |
MonadPlus P | |
Defined in Text.ParserCombinators.ReadP | |
MonadPlus ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadPlus ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
MonadPlus Seq | |
MonadPlus IO | |
MonadPlus Maybe | |
MonadPlus [] | |
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) | |
Defined in Control.Arrow | |
MonadPlus (Proxy :: Type -> Type) | |
MonadPlus (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Monad m => MonadPlus (MaybeT m) | |
MonadPlus m => MonadPlus (Kleisli m a) | |
Defined in Control.Arrow | |
MonadPlus f => MonadPlus (Ap f) | |
MonadPlus f => MonadPlus (Alt f) | |
MonadPlus f => MonadPlus (Rec1 f) | |
Defined in GHC.Generics | |
(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
(Monad m, Monoid e) => MonadPlus (ExceptT e m) | |
MonadPlus m => MonadPlus (IdentityT m) | |
MonadPlus m => MonadPlus (ReaderT r m) | |
MonadPlus m => MonadPlus (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
MonadPlus m => MonadPlus (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadPlus m => MonadPlus (StateT s m) | |
(Functor m, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
MonadPlus m => MonadPlus (Reverse m) | |
Defined in Data.Functor.Reverse | |
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g) | |
Defined in Data.Functor.Product | |
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) | |
Defined in GHC.Generics | |
MonadPlus f => MonadPlus (M1 i c f) | |
Defined in GHC.Generics | |
(Functor m, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
forever :: Applicative f => f a -> f b #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM_ :: Applicative m => Int -> m a -> m () #
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
MonadFail Q | |
Defined in Language.Haskell.TH.Syntax | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
MonadFail [] | |
Defined in Control.Monad.Fail | |
IsString str => MonadFail (Either str) Source # | For convenient work with Since: 0.1.0 |
Defined in Relude.Monad.Either | |
Monad m => MonadFail (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid | |
(Monoid w, MonadFail m) => MonadFail (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFail m => MonadFail (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFail m => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, MonadFail m) => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, MonadFail m) => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
MonadFail m => MonadFail (Reverse m) | |
Defined in Data.Functor.Reverse | |
MonadFail m => MonadFail (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
MonadFail m => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, MonadFail m) => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, MonadFail m) => MonadFail (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
Reexport Maybe
Instances
MonadFail Maybe | |||||
Defined in Control.Monad.Fail | |||||
MonadFix Maybe | |||||
Defined in Control.Monad.Fix | |||||
MonadZip Maybe | |||||
Foldable Maybe | |||||
Defined in 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 elem :: Eq a => a -> Maybe a -> Bool maximum :: Ord a => Maybe a -> a | |||||
Eq1 Maybe | |||||
Ord1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |||||
Read1 Maybe | |||||
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 | |||||
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 | |||||
Traversable Maybe | |||||
Alternative Maybe | |||||
Applicative Maybe | |||||
Functor Maybe | |||||
Monad Maybe | |||||
MonadPlus Maybe | |||||
NFData1 Maybe | |||||
Defined in Control.DeepSeq | |||||
Hashable1 Maybe | |||||
Defined in Data.Hashable.Class | |||||
Generic1 Maybe | |||||
Defined in GHC.Generics Associated Types
| |||||
MonadError () Maybe | |||||
Defined in Control.Monad.Error.Class | |||||
Lift a => Lift (Maybe a :: Type) | |||||
Data a => Data (Maybe a) | |||||
Defined in 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) 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) | |||||
Semigroup a => Monoid (Maybe a) | |||||
Semigroup a => Semigroup (Maybe a) | |||||
Generic (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
SingKind a => SingKind (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
Read a => Read (Maybe a) | |||||
Show a => Show (Maybe a) | |||||
NFData a => NFData (Maybe a) | |||||
Defined in Control.DeepSeq | |||||
Eq a => Eq (Maybe a) | |||||
Ord a => Ord (Maybe a) | |||||
Hashable a => Hashable (Maybe a) | |||||
Defined in Data.Hashable.Class | |||||
SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Generics | |||||
SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Generics | |||||
type Rep1 Maybe | |||||
type DemoteRep (Maybe a) | |||||
Defined in GHC.Generics | |||||
type Rep (Maybe a) | |||||
Defined in GHC.Generics | |||||
data Sing (b :: Maybe a) | |||||
listToMaybe :: [a] -> Maybe a #
maybeToList :: Maybe a -> [a] #
Reexport Either
Instances
Bifoldable Either | |||||
Bifoldable1 Either | |||||
Defined in Data.Bifoldable1 | |||||
Bifunctor Either | |||||
Bitraversable Either | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) # | |||||
Eq2 Either | |||||
Ord2 Either | |||||
Defined in Data.Functor.Classes | |||||
Read2 Either | |||||
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 | |||||
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 | |||||
Defined in Control.DeepSeq | |||||
Hashable2 Either | |||||
Defined in Data.Hashable.Class | |||||
Generic1 (Either a :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
MonadError e (Either e) | |||||
Defined in Control.Monad.Error.Class | |||||
(Lift a, Lift b) => Lift (Either a b :: Type) | |||||
IsString str => MonadFail (Either str) Source # | For convenient work with Since: 0.1.0 | ||||
Defined in Relude.Monad.Either | |||||
MonadFix (Either e) | |||||
Defined in Control.Monad.Fix | |||||
Foldable (Either a) | |||||
Defined in 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] # 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 | |||||
Eq a => Eq1 (Either a) | |||||
Ord a => Ord1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |||||
Read a => Read1 (Either a) | |||||
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) | |||||
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 | |||||
Traversable (Either a) | |||||
Defined in Data.Traversable | |||||
Applicative (Either e) | |||||
Functor (Either a) | |||||
Monad (Either e) | |||||
NFData a => NFData1 (Either a) | |||||
Defined in Control.DeepSeq | |||||
Hashable a => Hashable1 (Either a) | |||||
Defined in Data.Hashable.Class | |||||
(Data a, Data b) => Data (Either a b) | |||||
Defined in 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) | |||||
Semigroup (Either a b) | |||||
Generic (Either a b) | |||||
Defined in GHC.Generics Associated Types
| |||||
(Read a, Read b) => Read (Either a b) | |||||
Defined in Data.Either | |||||
(Show a, Show b) => Show (Either a b) | |||||
(NFData a, NFData b) => NFData (Either a b) | |||||
Defined in Control.DeepSeq | |||||
(Eq a, Eq b) => Eq (Either a b) | |||||
(Ord a, Ord b) => Ord (Either a b) | |||||
(Hashable a, Hashable b) => Hashable (Either a b) | |||||
Defined in Data.Hashable.Class | |||||
type Rep1 (Either a :: Type -> Type) | |||||
Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" '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) | |||||
Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" '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))) |
partitionEithers :: [Either a b] -> ([a], [b]) #