Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Control.Monad.Free
Synopsis
- class Applicative m => Monad (m :: Type -> Type) where
- class Functor (f :: Type -> Type) where
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- class Monad m => MonadFail (m :: Type -> Type)
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- join :: Monad m => m (m a) -> m a
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- ap :: Monad m => m (a -> b) -> m a -> m b
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- void :: Functor f => f a -> f ()
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- when :: Applicative f => Bool -> f () -> f ()
- (<$!>) :: 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
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- replicateM_ :: Applicative m => Int -> m a -> m ()
- unless :: Applicative f => Bool -> f () -> f ()
- 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
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- guard :: Alternative f => Bool -> f ()
- class (Functor f, Monad m) => MonadFree f m where
- data Free f a
- isPure :: Free f a -> Bool
- isImpure :: Free f a -> Bool
- foldFree :: Functor f => (a -> b) -> (f b -> b) -> Free f a -> b
- evalFree :: (a -> b) -> (f (Free f a) -> b) -> Free f a -> b
- mapFree :: (Functor f, Functor g) => (f (Free g a) -> g (Free g a)) -> Free f a -> Free g a
- mapFreeM :: (Traversable f, Functor g, Monad m) => (f (Free g a) -> m (g (Free g a))) -> Free f a -> m (Free g a)
- mapFreeM' :: (Functor f, Traversable g, Monad m) => (forall a. f a -> m (g a)) -> Free f a -> m (Free g a)
- foldFreeM :: (Traversable f, Monad m) => (a -> m b) -> (f b -> m b) -> Free f a -> m b
- induce :: (Functor f, Monad m) => (forall a. f a -> m a) -> Free f a -> m a
- newtype FreeT f m a = FreeT {}
- foldFreeT :: (Traversable f, Monad m) => (a -> m b) -> (f b -> m b) -> FreeT f m a -> m b
- foldFreeT' :: (Traversable f, Monad m) => (a -> b) -> (f b -> b) -> FreeT f m a -> m b
- mapFreeT :: (Functor f, Functor m) => (forall a. m a -> m' a) -> FreeT f m a -> FreeT f m' a
- foldFreeA :: (Traversable f, Applicative m) => (a -> m b) -> m (f b -> b) -> Free f a -> m b
- mapFreeA :: (Traversable f, Functor g, Applicative m) => m (f (Free g a) -> g (Free g a)) -> Free f a -> m (Free g a)
- trans :: MonadFree f m => Free f a -> m a
- trans' :: (Functor f, Monad m) => m (Free f a) -> FreeT f m a
- untrans :: (Traversable f, Monad m) => FreeT f m a -> m (Free f a)
- liftFree :: (Functor f, Monad m) => (a -> Free f b) -> a -> FreeT f m b
Documentation
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Complex | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad NonEmpty | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad IO | |
Monad Maybe | |
Monad Solo | |
Monad List | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (U1 :: Type -> Type) | |
Functor f => Monad (Free f) Source # | |
Monad (C mu) Source # | |
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) | |
(Functor f, Monad m) => Monad (FreeT f m) Source # | |
Monad m => Monad (StateT s m) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Functor ZipList | |
Defined in Control.Applicative | |
Functor Complex | |
Defined in Data.Complex | |
Functor Identity | |
Defined in Data.Functor.Identity | |
Functor First | |
Defined in Data.Monoid | |
Functor Last | |
Defined in Data.Monoid | |
Functor Dual | |
Defined in Data.Semigroup.Internal | |
Functor Product | |
Defined in Data.Semigroup.Internal | |
Functor Sum | |
Defined in Data.Semigroup.Internal | |
Functor NonEmpty | |
Functor Par1 | |
Defined in GHC.Generics | |
Functor P | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
Functor IO | |
Functor Maybe | |
Functor Solo | |
Functor List | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
Arrow a => Functor (ArrowMonad a) | |
Defined in Control.Arrow | |
Functor (Either a) | |
Defined in Data.Either | |
Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (V1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor f => Functor (Free f) Source # | |
Functor (C mu) Source # | |
Functor ((,) a) | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
Functor m => Functor (Kleisli m a) | |
Defined in Control.Arrow | |
Functor (Const m :: Type -> Type) | |
Defined in Data.Functor.Const | |
Functor f => Functor (Ap f) | |
Defined in Data.Monoid | |
Functor f => Functor (Alt f) | |
Defined in Data.Semigroup.Internal | |
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | |
Defined in GHC.Generics | |
Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
Functor (URec (Ptr ()) :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Char :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Double :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Float :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Int :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Word :: Type -> Type) | |
Defined in GHC.Generics | |
(Functor f, Functor m) => Functor (FreeT f m) Source # | |
Functor m => Functor (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
Functor ((,,) a b) | |
(Functor f, Functor g) => Functor (Product f g) | |
Defined in Data.Functor.Product | |
(Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
(Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Generics | |
Functor ((,,,) a b c) | |
Functor ((->) r) | |
(Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
(Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
Functor ((,,,,) a b c d) | |
Functor ((,,,,,) a b c d e) | |
Functor ((,,,,,,) a b c d e f) | |
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Minimal complete definition
Nothing
Instances
MonadPlus P | |
Defined in Text.ParserCombinators.ReadP | |
MonadPlus ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadPlus IO | |
MonadPlus Maybe | |
MonadPlus List | |
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) | |
Defined in Control.Arrow | |
MonadPlus (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
MonadPlus mu => MonadPlus (C mu) Source # | |
MonadPlus m => MonadPlus (Kleisli m a) | |
Defined in Control.Arrow | |
MonadPlus f => MonadPlus (Ap f) | |
Defined in Data.Monoid | |
MonadPlus f => MonadPlus (Alt f) | |
Defined in Data.Semigroup.Internal | |
MonadPlus f => MonadPlus (Rec1 f) | |
Defined in GHC.Generics | |
(Functor f, Monad m, MonadPlus m) => MonadPlus (FreeT f m) Source # | |
MonadPlus m => MonadPlus (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(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 |
class Monad m => MonadFail (m :: Type -> Type) #
Minimal complete definition
fail
Instances
MonadFail P | |
Defined in Text.ParserCombinators.ReadP Methods fail :: String -> P a | |
MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP Methods fail :: String -> ReadP a | |
MonadFail IO | |
Defined in Control.Monad.Fail Methods fail :: String -> IO a | |
MonadFail Maybe | |
Defined in Control.Monad.Fail Methods fail :: String -> Maybe a | |
MonadFail List | |
Defined in Control.Monad.Fail Methods fail :: String -> [a] | |
MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid Methods fail :: String -> Ap f a | |
MonadFail m => MonadFail (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy Methods fail :: String -> StateT s m a |
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM_ :: Applicative m => Int -> m a -> m () #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
Free Monads
class (Functor f, Monad m) => MonadFree f m where Source #
This type class generalizes over encodings of Free Monads.
Methods
Arguments
:: m a | |
-> m (Either a (f (m a))) |
|
Arguments
:: f (m a) | |
-> m a | Wraps a side effect into a monadic computation |
Instances
Functor f => MonadFree f (Free f) Source # | |
Functor f => MonadFree f (C (Free f)) Source # | |
(Functor f, Foldable f) => Foldable (Free f) Source # | |
Defined in Control.Monad.Free Methods fold :: Monoid m => Free f m -> m foldMap :: Monoid m => (a -> m) -> Free f a -> m foldMap' :: Monoid m => (a -> m) -> Free f a -> m foldr :: (a -> b -> b) -> b -> Free f a -> b foldr' :: (a -> b -> b) -> b -> Free f a -> b foldl :: (b -> a -> b) -> b -> Free f a -> b foldl' :: (b -> a -> b) -> b -> Free f a -> b foldr1 :: (a -> a -> a) -> Free f a -> a foldl1 :: (a -> a -> a) -> Free f a -> a elem :: Eq a => a -> Free f a -> Bool maximum :: Ord a => Free f a -> a | |
Eq1 f => Eq1 (Free f) Source # | |
Defined in Control.Monad.Free | |
Ord1 f => Ord1 (Free f) Source # | |
Defined in Control.Monad.Free Methods liftCompare :: (a -> b -> Ordering) -> Free f a -> Free f b -> Ordering | |
Traversable f => Traversable (Free f) Source # | |
Functor f => Applicative (Free f) Source # | |
Functor f => Functor (Free f) Source # | |
Functor f => Monad (Free f) Source # | |
Generic (Free f a) Source # | |
(Show a, Show1 f) => Show (Free f a) Source # | |
(Eq a, Eq1 f) => Eq (Free f a) Source # | |
(Ord a, Ord1 f) => Ord (Free f a) Source # | |
Defined in Control.Monad.Free | |
type Rep (Free f a) Source # | |
Defined in Control.Monad.Free type Rep (Free f a) = D1 ('MetaData "Free" "Control.Monad.Free" "control-monad-free-0.6.2-HmwVFf4NY3DBSRV2qX5ck0" 'False) (C1 ('MetaCons "Impure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (Free f a)))) :+: C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))) |
mapFree :: (Functor f, Functor g) => (f (Free g a) -> g (Free g a)) -> Free f a -> Free g a Source #
mapFreeM :: (Traversable f, Functor g, Monad m) => (f (Free g a) -> m (g (Free g a))) -> Free f a -> m (Free g a) Source #
mapFreeM' :: (Functor f, Traversable g, Monad m) => (forall a. f a -> m (g a)) -> Free f a -> m (Free g a) Source #
Monad Morphisms
Free Monad Transformers
Instances
(Monad m, Functor f) => MonadFree f (C (FreeT f m)) Source # | |
(Functor f, Monad m) => MonadFree f (FreeT f m) Source # | |
Functor f => MonadTrans (FreeT f) Source # | |
Defined in Control.Monad.Free | |
(Functor f, Monad m, MonadIO m) => MonadIO (FreeT f m) Source # | |
Defined in Control.Monad.Free | |
(Traversable m, Traversable f) => Foldable (FreeT f m) Source # | |
Defined in Control.Monad.Free Methods fold :: Monoid m0 => FreeT f m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 foldMap' :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 foldr :: (a -> b -> b) -> b -> FreeT f m a -> b foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b foldl :: (b -> a -> b) -> b -> FreeT f m a -> b foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b foldr1 :: (a -> a -> a) -> FreeT f m a -> a foldl1 :: (a -> a -> a) -> FreeT f m a -> a elem :: Eq a => a -> FreeT f m a -> Bool maximum :: Ord a => FreeT f m a -> a minimum :: Ord a => FreeT f m a -> a | |
(Traversable m, Traversable f) => Traversable (FreeT f m) Source # | |
Defined in Control.Monad.Free | |
(Functor f, Functor m, Monad m, MonadPlus m) => Alternative (FreeT f m) Source # | |
(Functor f, Functor a, Monad a) => Applicative (FreeT f a) Source # | |
(Functor f, Functor m) => Functor (FreeT f m) Source # | |
(Functor f, Monad m) => Monad (FreeT f m) Source # | |
(Functor f, Monad m, MonadPlus m) => MonadPlus (FreeT f m) Source # | |
foldFreeT' :: (Traversable f, Monad m) => (a -> b) -> (f b -> b) -> FreeT f m a -> m b Source #
mapFreeT :: (Functor f, Functor m) => (forall a. m a -> m' a) -> FreeT f m a -> FreeT f m' a Source #
foldFreeA :: (Traversable f, Applicative m) => (a -> m b) -> m (f b -> b) -> Free f a -> m b Source #
mapFreeA :: (Traversable f, Functor g, Applicative m) => m (f (Free g a) -> g (Free g a)) -> Free f a -> m (Free g a) Source #