Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2019 Kowainik |
---|---|
License | MIT |
Maintainer | Kowainik <xrom.xkov@gmail.com> |
Safe Haskell | Safe |
Language | Haskell2010 |
Relude.Monad.Reexport
Description
Reexports functions to work with monads.
Synopsis
- runExceptT :: ExceptT e m a -> m (Either e a)
- newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e 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 :: (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
- type Reader r = ReaderT r Identity
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
- gets :: MonadState s m => (s -> a) -> m a
- modify :: MonadState s m => (s -> s) -> m ()
- modify' :: MonadState s m => (s -> s) -> m ()
- 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
- runState :: State s a -> s -> (a, s)
- withState :: (s -> s) -> State s a -> State s 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)
- class Monad m => MonadIO (m :: Type -> Type) where
- class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- data IdentityT (f :: k -> Type) (a :: k) :: forall k. (k -> Type) -> k -> Type
- exceptToMaybeT :: Functor m => ExceptT e m a -> MaybeT m a
- maybeToExceptT :: Functor m => e -> MaybeT m a -> ExceptT e m a
- newtype MaybeT (m :: Type -> Type) a = MaybeT {}
- join :: Monad m => m (m a) -> m a
- class Applicative m => Monad (m :: Type -> Type) where
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- 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])
- 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 ()
- class Monad m => MonadFail (m :: Type -> Type) where
- data Maybe a
- 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]
- maybe :: b -> (a -> b) -> Maybe a -> b
- maybeToList :: Maybe a -> [a]
- data Either 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]
- partitionEithers :: [Either a b] -> ([a], [b])
- rights :: [Either a b] -> [b]
Reexport transformers
runExceptT :: ExceptT e m a -> m (Either e a) #
newtype ExceptT e (m :: Type -> Type) a #
Instances
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 | |
Monad m => Monad (ExceptT e m) | |
Functor m => Functor (ExceptT e m) | |
MonadFix m => MonadFix (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
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 # 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 | |
Traversable f => Traversable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except | |
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) | |
(Monad m, Monoid e) => MonadPlus (ExceptT e m) | |
(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 | |
MonadZip m => MonadZip (ExceptT e m) | |
Contravariant m => Contravariant (ExceptT e m) | |
MonadIO m => MonadIO (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
(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 # | |
(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) | |
asks :: MonadReader r m => (r -> a) -> m a #
withReader :: (r' -> r) -> Reader r a -> Reader r' a #
withReaderT :: (r' -> r) -> ReaderT r m a -> ReaderT r' m a #
class Monad m => MonadReader r (m :: Type -> Type) | m -> r where #
Instances
MonadReader r m => MonadReader r (MaybeT m) | |
MonadReader r m => MonadReader r (ListT 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 (StateT s m) | |
MonadReader r m => MonadReader r (StateT s m) | |
Monad m => MonadReader r (ReaderT r m) | |
MonadReader r m => MonadReader r (IdentityT m) | |
MonadReader r m => MonadReader r (ExceptT e m) | |
(Error e, MonadReader r m) => MonadReader r (ErrorT e m) | |
MonadReader r ((->) r :: Type -> Type) | |
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) | |
newtype ReaderT r (m :: Type -> Type) a #
Constructors
ReaderT | |
Fields
|
Instances
Monad m => MonadReader r (ReaderT r m) | |
MonadState s m => MonadState s (ReaderT r m) | |
MonadTrans (ReaderT r) | |
Defined in Control.Monad.Trans.Reader | |
Monad m => Monad (ReaderT r m) | |
Functor m => Functor (ReaderT r m) | |
MonadFix m => MonadFix (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
Alternative m => Alternative (ReaderT r m) | |
MonadPlus m => MonadPlus (ReaderT r m) | |
MonadZip m => MonadZip (ReaderT r m) | |
Contravariant m => Contravariant (ReaderT r m) | |
MonadIO m => MonadIO (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader |
gets :: MonadState s m => (s -> a) -> m a #
modify :: MonadState s m => (s -> s) -> m () #
modify' :: MonadState s m => (s -> s) -> m () #
evalStateT :: Monad m => StateT s m a -> s -> m a #
execStateT :: Monad m => StateT s m a -> s -> m s #
class Monad m => MonadState s (m :: Type -> Type) | m -> s where #
Instances
MonadState s m => MonadState s (MaybeT m) | |
MonadState s m => MonadState s (ListT m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
(Monoid w, MonadState s m) => MonadState s (WriterT w m) | |
Monad m => MonadState s (StateT s m) | |
Monad m => MonadState s (StateT s m) | |
MonadState s m => MonadState s (ReaderT r m) | |
MonadState s m => MonadState s (IdentityT m) | |
MonadState s m => MonadState s (ExceptT e m) | |
(Error e, MonadState s m) => MonadState s (ErrorT e 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) | |
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 | |
Monad m => Monad (StateT s m) | |
Functor m => Functor (StateT s m) | |
MonadFix m => MonadFix (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, MonadPlus m) => Alternative (StateT s m) | |
MonadPlus m => MonadPlus (StateT s m) | |
Contravariant m => Contravariant (StateT s m) | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict |
class Monad m => MonadIO (m :: Type -> Type) where #
Instances
MonadIO IO | |
Defined in Control.Monad.IO.Class | |
MonadIO m => MonadIO (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadIO m => MonadIO (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadIO m => MonadIO (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadIO m => MonadIO (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadIO m => MonadIO (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
(Error e, MonadIO m) => MonadIO (ErrorT e m) | |
Defined in Control.Monad.Trans.Error |
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where #
Instances
MonadTrans MaybeT | |
Defined in Control.Monad.Trans.Maybe | |
MonadTrans (ExceptT e) | |
Defined in Control.Monad.Trans.Except | |
MonadTrans (ReaderT r) | |
Defined in Control.Monad.Trans.Reader | |
MonadTrans (StateT s) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type) | |
Defined in Control.Monad.Trans.Identity | |
MonadTrans (ErrorT e) | |
Defined in Control.Monad.Trans.Error |
data IdentityT (f :: k -> Type) (a :: k) :: forall k. (k -> Type) -> k -> Type #
Instances
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 | |
Monad m => Monad (IdentityT m) | |
Functor m => Functor (IdentityT m) | |
MonadFix m => MonadFix (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
MonadFail m => MonadFail (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
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 # 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 | |
Traversable f => Traversable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity | |
Alternative m => Alternative (IdentityT m) | |
MonadPlus m => MonadPlus (IdentityT m) | |
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 | |
MonadZip m => MonadZip (IdentityT m) | |
Contravariant f => Contravariant (IdentityT f) | |
MonadIO m => MonadIO (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
(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 # | |
(Read1 f, Read a) => Read (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity | |
(Show1 f, Show a) => Show (IdentityT f a) | |
exceptToMaybeT :: Functor m => ExceptT e m a -> MaybeT m a #
maybeToExceptT :: Functor m => e -> MaybeT m a -> ExceptT e m a #
newtype MaybeT (m :: Type -> Type) a #
Instances
MonadTrans MaybeT | |
Defined in Control.Monad.Trans.Maybe | |
MonadReader r m => MonadReader r (MaybeT m) | |
MonadState s m => MonadState s (MaybeT m) | |
Monad m => Monad (MaybeT m) | |
Functor m => Functor (MaybeT m) | |
MonadFix m => MonadFix (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
Monad m => MonadFail (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
(Functor m, Monad m) => Applicative (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 # 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 | |
Traversable f => Traversable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe | |
(Functor m, Monad m) => Alternative (MaybeT m) | |
Monad m => MonadPlus (MaybeT m) | |
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 | |
MonadZip m => MonadZip (MaybeT m) | |
Contravariant m => Contravariant (MaybeT m) | |
MonadIO m => MonadIO (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
(Eq1 m, Eq a) => Eq (MaybeT m a) | |
(Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
(Read1 m, Read a) => Read (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
(Show1 m, Show a) => Show (MaybeT m a) | |
Reexport monadic functions
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad [] | |
Monad Maybe | |
Monad IO | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad NonEmpty | |
Monad Down | |
Monad Identity | |
Monad Seq | |
Monad Product | |
Monad Sum | |
Monad Complex | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad Option | |
Monad Dual | |
Monad First | |
Monad Last | |
Monad STM | |
Monad Put | |
Monad Tree | |
Monad (Either e) | |
Monad (U1 :: Type -> Type) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Proxy :: Type -> Type) | |
Monad m => Monad (MaybeT m) | |
Monad f => Monad (Rec1 f) | |
(Applicative f, Monad f) => Monad (WhenMissing f x) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Ap f) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (IdentityT m) | |
(Monad m, Error e) => Monad (ErrorT e m) | |
Monad ((->) r :: Type -> Type) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Applicative f, Monad f) => Monad (WhenMissing f k x) | |
(Monad f, Applicative f) => Monad (WhenMatched f x y) | |
(Monad f, Monad g) => Monad (Product f g) | |
Monad f => Monad (M1 i c f) | |
(Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
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
MonadFail [] | |
Defined in Control.Monad.Fail | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
IsString str => MonadFail (Either str) # | |
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 | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
MonadFail m => MonadFail (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
(Monad m, Error e) => MonadFail (ErrorT e m) | |
Defined in Control.Monad.Trans.Error |
Reexport Maybe
Instances
Monad Maybe | |
Functor Maybe | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
Applicative Maybe | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> 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 | |
Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
Alternative Maybe | |
MonadPlus Maybe | |
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 | |
NFData1 Maybe | |
Defined in Control.DeepSeq | |
Eq a => Eq (Maybe a) | |
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 :: (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) | |
Ord a => Ord (Maybe a) | |
Read a => Read (Maybe a) | |
Show a => Show (Maybe a) | |
Generic (Maybe a) | |
Semigroup a => Semigroup (Maybe a) | |
Semigroup a => Monoid (Maybe a) | |
Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics | |
NFData a => NFData (Maybe a) | |
Defined in Control.DeepSeq | |
Generic1 Maybe | |
SingI (Nothing :: Maybe a) | |
Defined in GHC.Generics | |
SingI a2 => SingI (Just a2 :: Maybe a1) | |
Defined in GHC.Generics | |
type Rep (Maybe a) | |
type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
data Sing (b :: Maybe a) | |
type Rep1 Maybe | |
listToMaybe :: [a] -> Maybe a #
maybeToList :: Maybe a -> [a] #
Reexport Either
Instances
Hashable2 Either | |
Defined in Data.Hashable.Class | |
Eq2 Either | |
Ord2 Either | |
Defined in Data.Functor.Classes | |
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 | |
Bifoldable Either | |
Bitraversable Either | |
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) # | |
Bifunctor Either | |
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] | |
NFData2 Either | |
Defined in Control.DeepSeq | |
Monad (Either e) | |
Functor (Either a) | |
IsString str => MonadFail (Either str) # | |
Defined in Relude.Monad.Either | |
Applicative (Either e) | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> 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 | |
Hashable a => Hashable1 (Either a) | |
Defined in Data.Hashable.Class | |
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 | |
NFData a => NFData1 (Either a) | |
Defined in Control.DeepSeq | |
Generic1 (Either a :: Type -> Type) | |
(Eq a, Eq b) => Eq (Either a b) | |
(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 :: (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) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Read a, Read b) => Read (Either a b) | |
Defined in Data.Either | |
(Show a, Show b) => Show (Either a b) | |
Generic (Either a b) | |
Semigroup (Either a b) | |
(Hashable a, Hashable b) => Hashable (Either a b) | |
Defined in Data.Hashable.Class | |
(NFData a, NFData b) => NFData (Either a b) | |
Defined in Control.DeepSeq | |
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]) #