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
Functor m => Generic1 (ExceptT e m :: Type -> Type) | |
MonadReader r m => MonadReader r (ExceptT e m) | |
MonadState s m => MonadState s (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) | |
Generic (ExceptT e m a) | |
(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) | |
Monad m => MonadReader r (ReaderT r m) | |
MonadState s m => MonadState s (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) | |
Generic (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.0" '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
MonadReader r m => MonadReader r (StateT s m) | |
Monad m => MonadState s (StateT s m) | |
MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFix m => MonadFix (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
Contravariant m => Contravariant (StateT s m) | |
(Functor m, MonadPlus m) => Alternative (StateT s m) | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
Functor m => Functor (StateT s m) | |
Monad m => Monad (StateT s m) | |
MonadPlus m => MonadPlus (StateT s m) | |
Generic (StateT s m a) | |
type Rep (StateT s m a) | |
Defined in Control.Monad.Trans.State.Strict |
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
class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where #
Instances
data IdentityT (f :: k -> Type) (a :: k) #
Instances
Generic1 (IdentityT f :: k -> Type) | |
MonadReader r m => MonadReader r (IdentityT m) | |
MonadState s m => MonadState s (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) | |
Generic (IdentityT f a) | |
(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 | |
Functor m => Generic1 (MaybeT m :: Type -> Type) | |
MonadReader r m => MonadReader r (MaybeT m) | |
MonadState s m => MonadState s (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) | |
Generic (MaybeT m a) | |
(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 Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad Put | |
Monad Seq | |
Monad Tree | |
Monad IO | |
Monad Q | |
Monad Maybe | |
Monad Solo | |
Monad List | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
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) | |
(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) | |
(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
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
Reexport Maybe
Instances
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
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 | |
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 | |
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) | |
SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) | |
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 | |
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) # | |
NFData2 Either | |
Defined in Control.DeepSeq | |
Hashable2 Either | |
Defined in Data.Hashable.Class | |
Generic1 (Either a :: Type -> Type) | |
(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 | |
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 | |
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) | |
(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]) #