Copyright	(C) 2008-2013 Edward Kmett
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	provisional
Portability	MPTCs, fundeps
Safe Haskell	Safe
Language	Haskell2010

Control.Monad.Trans.Free

Contents

The base functor
The free monad transformer
The free monad
Operations
Operations of free monad
Free Monads With Class

Description

The free monad transformer

Synopsis

data FreeF (f :: Type -> Type) a b
- = Pure a
- | Free (f b)
newtype FreeT (f :: Type -> Type) (m :: Type -> Type) a = FreeT {
- runFreeT :: m (FreeF f a (FreeT f m a))
}
type Free (f :: Type -> Type) = FreeT f Identity
free :: forall (f :: Type -> Type) a. FreeF f a (Free f a) -> Free f a
runFree :: forall (f :: Type -> Type) a. Free f a -> FreeF f a (Free f a)
liftF :: (Functor f, MonadFree f m) => f a -> m a
iterT :: (Functor f, Monad m) => (f (m a) -> m a) -> FreeT f m a -> m a
iterTM :: forall f (m :: Type -> Type) t a. (Functor f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> FreeT f m a -> t m a
hoistFreeT :: forall m (f :: Type -> Type) n b. (Functor m, Functor f) => (forall a. m a -> n a) -> FreeT f m b -> FreeT f n b
foldFreeT :: forall t (m :: Type -> Type) f a. (MonadTrans t, Monad (t m), Monad m) => (forall (n :: Type -> Type) x. Monad n => f x -> t n x) -> FreeT f m a -> t m a
transFreeT :: forall (m :: Type -> Type) g f b. (Monad m, Functor g) => (forall a. f a -> g a) -> FreeT f m b -> FreeT g m b
joinFreeT :: forall m (f :: Type -> Type) a. (Monad m, Traversable f) => FreeT f m a -> m (Free f a)
cutoff :: forall (f :: Type -> Type) (m :: Type -> Type) a. (Functor f, Monad m) => Integer -> FreeT f m a -> FreeT f m (Maybe a)
partialIterT :: Monad m => Integer -> (forall a. f a -> m a) -> FreeT f m b -> FreeT f m b
intersperseT :: forall (m :: Type -> Type) f a b. (Monad m, Functor f) => f a -> FreeT f m b -> FreeT f m b
intercalateT :: forall (m :: Type -> Type) t a b. (Monad m, MonadTrans t, Monad (t m)) => t m a -> FreeT (t m) m b -> t m b
retractT :: forall t (m :: Type -> Type) a. (MonadTrans t, Monad (t m), Monad m) => FreeT (t m) m a -> t m a
retract :: Monad f => Free f a -> f a
iter :: Functor f => (f a -> a) -> Free f a -> a
iterM :: (Functor f, Monad m) => (f (m a) -> m a) -> Free f a -> m a
class Monad m => MonadFree (f :: Type -> Type) (m :: Type -> Type) | m -> f where
- wrap :: f (m a) -> m a

The base functor

data FreeF (f :: Type -> Type) a b Source #

The base functor for a free monad.

Constructors

Pure a
Free (f b)

Instances

Instances details

Generic1 (FreeF f a :: Type -> Type) Source #

Instance details

Defined in Control.Monad.Trans.Free

Associated Types

type Rep1 (FreeF f a :: Type -> Type)

Instance details

Defined in Control.Monad.Trans.Free

type Rep1 (FreeF f a :: Type -> Type) = D1 ('MetaData "FreeF" "Control.Monad.Trans.Free" "free-5.2-5Eqzn0yMORp8HDZN4aiZIP" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))

Methods

from1 :: FreeF f a a0 -> Rep1 (FreeF f a) a0

to1 :: Rep1 (FreeF f a) a0 -> FreeF f a a0

Foldable f => Bifoldable (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

bifold :: Monoid m => FreeF f m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> FreeF f a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> FreeF f a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> FreeF f a b -> c

Functor f => Bifunctor (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

bimap :: (a -> b) -> (c -> d) -> FreeF f a c -> FreeF f b d

first :: (a -> b) -> FreeF f a c -> FreeF f b c

second :: (b -> c) -> FreeF f a b -> FreeF f a c

Traversable f => Bitraversable (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

bitraverse :: Applicative f0 => (a -> f0 c) -> (b -> f0 d) -> FreeF f a b -> f0 (FreeF f c d)

Eq1 f => Eq2 (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> FreeF f a c -> FreeF f b d -> Bool

Ord1 f => Ord2 (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> FreeF f a c -> FreeF f b d -> Ordering

Read1 f => Read2 (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (FreeF f a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [FreeF f a b]

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (FreeF f a b)

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [FreeF f a b]

Show1 f => Show2 (FreeF f) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> FreeF f a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [FreeF f a b] -> ShowS

(Eq1 f, Eq a) => Eq1 (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftEq :: (a0 -> b -> Bool) -> FreeF f a a0 -> FreeF f a b -> Bool

(Ord1 f, Ord a) => Ord1 (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftCompare :: (a0 -> b -> Ordering) -> FreeF f a a0 -> FreeF f a b -> Ordering

(Read1 f, Read a) => Read1 (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (FreeF f a a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [FreeF f a a0]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (FreeF f a a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [FreeF f a a0]

(Show1 f, Show a) => Show1 (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> FreeF f a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [FreeF f a a0] -> ShowS

Functor f => Functor (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a0 -> b) -> FreeF f a a0 -> FreeF f a b

(<$) :: a0 -> FreeF f a b -> FreeF f a a0

Foldable f => Foldable (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m => FreeF f a m -> m

foldMap :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m

foldMap' :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0

toList :: FreeF f a a0 -> [a0]

null :: FreeF f a a0 -> Bool

length :: FreeF f a a0 -> Int

elem :: Eq a0 => a0 -> FreeF f a a0 -> Bool

maximum :: Ord a0 => FreeF f a a0 -> a0

minimum :: Ord a0 => FreeF f a a0 -> a0

sum :: Num a0 => FreeF f a a0 -> a0

product :: Num a0 => FreeF f a a0 -> a0

Traversable f => Traversable (FreeF f a) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> FreeF f a a0 -> f0 (FreeF f a b)

sequenceA :: Applicative f0 => FreeF f a (f0 a0) -> f0 (FreeF f a a0)

mapM :: Monad m => (a0 -> m b) -> FreeF f a a0 -> m (FreeF f a b)

sequence :: Monad m => FreeF f a (m a0) -> m (FreeF f a a0)

(Typeable f, Typeable b, Data a, Data (f b)) => Data (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> FreeF f a b -> c (FreeF f a b)

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FreeF f a b)

toConstr :: FreeF f a b -> Constr

dataTypeOf :: FreeF f a b -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FreeF f a b))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FreeF f a b))

gmapT :: (forall b0. Data b0 => b0 -> b0) -> FreeF f a b -> FreeF f a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FreeF f a b -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FreeF f a b -> r

gmapQ :: (forall d. Data d => d -> u) -> FreeF f a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FreeF f a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FreeF f a b -> m (FreeF f a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FreeF f a b -> m (FreeF f a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FreeF f a b -> m (FreeF f a b)

Generic (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

Associated Types

type Rep (FreeF f a b)

Instance details

Defined in Control.Monad.Trans.Free

type Rep (FreeF f a b) = D1 ('MetaData "FreeF" "Control.Monad.Trans.Free" "free-5.2-5Eqzn0yMORp8HDZN4aiZIP" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f b))))

Methods

from :: FreeF f a b -> Rep (FreeF f a b) x

to :: Rep (FreeF f a b) x -> FreeF f a b

(Read a, Read (f b)) => Read (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

readsPrec :: Int -> ReadS (FreeF f a b)

readList :: ReadS [FreeF f a b]

readPrec :: ReadPrec (FreeF f a b)

readListPrec :: ReadPrec [FreeF f a b]

(Show a, Show (f b)) => Show (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeF f a b -> ShowS

show :: FreeF f a b -> String

showList :: [FreeF f a b] -> ShowS

(Eq a, Eq (f b)) => Eq (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

(==) :: FreeF f a b -> FreeF f a b -> Bool

(/=) :: FreeF f a b -> FreeF f a b -> Bool

(Ord a, Ord (f b)) => Ord (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

Methods

compare :: FreeF f a b -> FreeF f a b -> Ordering

(<) :: FreeF f a b -> FreeF f a b -> Bool

(<=) :: FreeF f a b -> FreeF f a b -> Bool

(>) :: FreeF f a b -> FreeF f a b -> Bool

(>=) :: FreeF f a b -> FreeF f a b -> Bool

max :: FreeF f a b -> FreeF f a b -> FreeF f a b

min :: FreeF f a b -> FreeF f a b -> FreeF f a b

type Rep1 (FreeF f a :: Type -> Type) Source #

Instance details

Defined in Control.Monad.Trans.Free

type Rep1 (FreeF f a :: Type -> Type) = D1 ('MetaData "FreeF" "Control.Monad.Trans.Free" "free-5.2-5Eqzn0yMORp8HDZN4aiZIP" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))

type Rep (FreeF f a b) Source #

Instance details

Defined in Control.Monad.Trans.Free

type Rep (FreeF f a b) = D1 ('MetaData "FreeF" "Control.Monad.Trans.Free" "free-5.2-5Eqzn0yMORp8HDZN4aiZIP" 'False) (C1 ('MetaCons "Pure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Free" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f b))))

The free monad transformer

newtype FreeT (f :: Type -> Type) (m :: Type -> Type) a Source #

The "free monad transformer" for a functor f

Constructors

FreeT
Fields runFreeT :: m (FreeF f a (FreeT f m a))

Instances

Instances details

(Functor f, Monad m) => MonadFree f (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods wrap :: f (FreeT f m a) -> FreeT f m a Source #
(Functor f, MonadError e m) => MonadError e (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods throwError :: e -> FreeT f m a catchError :: FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a
(Functor f, MonadReader r m) => MonadReader r (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods ask :: FreeT f m r local :: (r -> r) -> FreeT f m a -> FreeT f m a reader :: (r -> a) -> FreeT f m a
(Functor f, MonadState s m) => MonadState s (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods get :: FreeT f m s put :: s -> FreeT f m () state :: (s -> (a, s)) -> FreeT f m a
(Functor f, MonadWriter w m) => MonadWriter w (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods writer :: (a, w) -> FreeT f m a tell :: w -> FreeT f m () listen :: FreeT f m a -> FreeT f m (a, w) pass :: FreeT f m (a, w -> w) -> FreeT f m a
(Functor f, MonadBase b m) => MonadBase b (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods liftBase :: b α -> FreeT f m α
Functor f => MonadTrans (FreeT f) Source #
Instance details Defined in Control.Monad.Trans.Free Methods lift :: Monad m => m a -> FreeT f m a
(Eq1 f, Eq1 m) => Eq1 (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods liftEq :: (a -> b -> Bool) -> FreeT f m a -> FreeT f m b -> Bool
(Ord1 f, Ord1 m) => Ord1 (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods liftCompare :: (a -> b -> Ordering) -> FreeT f m a -> FreeT f m b -> Ordering
(Read1 f, Read1 m) => Read1 (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (FreeT f m a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [FreeT f m a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (FreeT f m a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [FreeT f m a]
(Show1 f, Show1 m) => Show1 (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> FreeT f m a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [FreeT f m a] -> ShowS
(Functor f, MonadCatch m) => MonadCatch (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods catch :: (HasCallStack, Exception e) => FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a
(Functor f, MonadThrow m) => MonadThrow (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods throwM :: (HasCallStack, Exception e) => e -> FreeT f m a
(Functor f, MonadPlus m) => Alternative (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods empty :: FreeT f m a (<\|>) :: FreeT f m a -> FreeT f m a -> FreeT f m a some :: FreeT f m a -> FreeT f m [a] many :: FreeT f m a -> FreeT f m [a]
(Functor f, Monad m) => Applicative (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods pure :: a -> FreeT f m a (<>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b liftA2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c (>) :: FreeT f m a -> FreeT f m b -> FreeT f m b (<*) :: FreeT f m a -> FreeT f m b -> FreeT f m a
(Functor f, Functor m) => Functor (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods fmap :: (a -> b) -> FreeT f m a -> FreeT f m b (<$) :: a -> FreeT f m b -> FreeT f m a
(Functor f, Monad m) => Monad (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods (>>=) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b (>>) :: FreeT f m a -> FreeT f m b -> FreeT f m b return :: a -> FreeT f m a
(Functor f, MonadPlus m) => MonadPlus (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods mzero :: FreeT f m a mplus :: FreeT f m a -> FreeT f m a -> FreeT f m a
(Functor f, MonadFail m) => MonadFail (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods fail :: String -> FreeT f m a
(Functor f, MonadIO m) => MonadIO (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods liftIO :: IO a -> FreeT f m a
(Foldable m, Foldable f) => Foldable (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.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 toList :: FreeT f m a -> [a] null :: FreeT f m a -> Bool length :: FreeT f m a -> Int 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 sum :: Num a => FreeT f m a -> a product :: Num a => FreeT f m a -> a
(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> FreeT f m a -> f0 (FreeT f m b) sequenceA :: Applicative f0 => FreeT f m (f0 a) -> f0 (FreeT f m a) mapM :: Monad m0 => (a -> m0 b) -> FreeT f m a -> m0 (FreeT f m b) sequence :: Monad m0 => FreeT f m (m0 a) -> m0 (FreeT f m a)
(Functor f, MonadCont m) => MonadCont (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods callCC :: ((a -> FreeT f m b) -> FreeT f m a) -> FreeT f m a
(Functor f, Monad m) => Apply (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods (<.>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b (.>) :: FreeT f m a -> FreeT f m b -> FreeT f m b (<.) :: FreeT f m a -> FreeT f m b -> FreeT f m a liftF2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c
(Functor f, Monad m) => Bind (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods (>>-) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b join :: FreeT f m (FreeT f m a) -> FreeT f m a
(Read1 f, Read1 m, Read a) => Read (FreeT f m a) Source #
Instance details Defined in Control.Monad.Trans.Free Methods readsPrec :: Int -> ReadS (FreeT f m a) readList :: ReadS [FreeT f m a] readPrec :: ReadPrec (FreeT f m a) readListPrec :: ReadPrec [FreeT f m a]
(Show1 f, Show1 m, Show a) => Show (FreeT f m a) Source #
Instance details Defined in Control.Monad.Trans.Free Methods showsPrec :: Int -> FreeT f m a -> ShowS show :: FreeT f m a -> String showList :: [FreeT f m a] -> ShowS
(Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a) Source #
Instance details Defined in Control.Monad.Trans.Free Methods (==) :: FreeT f m a -> FreeT f m a -> Bool (/=) :: FreeT f m a -> FreeT f m a -> Bool
(Ord1 f, Ord1 m, Ord a) => Ord (FreeT f m a) Source #
Instance details Defined in Control.Monad.Trans.Free Methods compare :: FreeT f m a -> FreeT f m a -> Ordering (<) :: FreeT f m a -> FreeT f m a -> Bool (<=) :: FreeT f m a -> FreeT f m a -> Bool (>) :: FreeT f m a -> FreeT f m a -> Bool (>=) :: FreeT f m a -> FreeT f m a -> Bool max :: FreeT f m a -> FreeT f m a -> FreeT f m a min :: FreeT f m a -> FreeT f m a -> FreeT f m a

The free monad

type Free (f :: Type -> Type) = FreeT f Identity Source #

The "free monad" for a functor f.

free :: forall (f :: Type -> Type) a. FreeF f a (Free f a) -> Free f a Source #

Pushes a layer into a free monad value.

runFree :: forall (f :: Type -> Type) a. Free f a -> FreeF f a (Free f a) Source #

Evaluates the first layer out of a free monad value.

Operations

liftF :: (Functor f, MonadFree f m) => f a -> m a Source #

A version of lift that can be used with just a Functor for f.

iterT :: (Functor f, Monad m) => (f (m a) -> m a) -> FreeT f m a -> m a Source #

Tear down a free monad transformer using iteration.

iterTM :: forall f (m :: Type -> Type) t a. (Functor f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> FreeT f m a -> t m a Source #

Tear down a free monad transformer using iteration over a transformer.

hoistFreeT :: forall m (f :: Type -> Type) n b. (Functor m, Functor f) => (forall a. m a -> n a) -> FreeT f m b -> FreeT f n b Source #

Lift a monad homomorphism from m to n into a monad homomorphism from FreeT f m to FreeT f n

hoistFreeT :: (Functor m, Functor f) => (m ~> n) -> FreeT f m ~> FreeT f n

foldFreeT :: forall t (m :: Type -> Type) f a. (MonadTrans t, Monad (t m), Monad m) => (forall (n :: Type -> Type) x. Monad n => f x -> t n x) -> FreeT f m a -> t m a Source #

The very definition of a free monad transformer is that given a natural transformation you get a monad transformer homomorphism.

transFreeT :: forall (m :: Type -> Type) g f b. (Monad m, Functor g) => (forall a. f a -> g a) -> FreeT f m b -> FreeT g m b Source #

Lift a natural transformation from f to g into a monad homomorphism from FreeT f m to FreeT g m

joinFreeT :: forall m (f :: Type -> Type) a. (Monad m, Traversable f) => FreeT f m a -> m (Free f a) Source #

Pull out and join m layers of FreeT f m a.

cutoff :: forall (f :: Type -> Type) (m :: Type -> Type) a. (Functor f, Monad m) => Integer -> FreeT f m a -> FreeT f m (Maybe a) Source #

Cuts off a tree of computations at a given depth. If the depth is 0 or less, no computation nor monadic effects will take place.

Some examples (n ≥ 0):

cutoff 0     _        ≡ return Nothing
cutoff (n+1) . return ≡ return . Just
cutoff (n+1) . lift   ≡ lift . liftM Just
cutoff (n+1) . wrap   ≡ wrap . fmap (cutoff n)

Calling retract . cutoff n is always terminating, provided each of the steps in the iteration is terminating.

partialIterT :: Monad m => Integer -> (forall a. f a -> m a) -> FreeT f m b -> FreeT f m b Source #

partialIterT n phi m interprets first n layers of m using phi. This is sort of the opposite for cutoff.

Some examples (n ≥ 0):

partialIterT 0 _ m              ≡ m
partialIterT (n+1) phi . return ≡ return
partialIterT (n+1) phi . lift   ≡ lift
partialIterT (n+1) phi . wrap   ≡ join . lift . phi

intersperseT :: forall (m :: Type -> Type) f a b. (Monad m, Functor f) => f a -> FreeT f m b -> FreeT f m b Source #

intersperseT f m inserts a layer f between every two layers in m.

intersperseT f . return ≡ return
intersperseT f . lift   ≡ lift
intersperseT f . wrap   ≡ wrap . fmap (iterTM (wrap . (<$ f) . wrap))

intercalateT :: forall (m :: Type -> Type) t a b. (Monad m, MonadTrans t, Monad (t m)) => t m a -> FreeT (t m) m b -> t m b Source #

intercalateT f m inserts a layer f between every two layers in m and then retracts the result.

intercalateT f ≡ retractT . intersperseT f

retractT :: forall t (m :: Type -> Type) a. (MonadTrans t, Monad (t m), Monad m) => FreeT (t m) m a -> t m a Source #

Tear down a free monad transformer using Monad instance for t m.

Operations of free monad

retract :: Monad f => Free f a -> f a Source #

retract is the left inverse of liftF

retract . liftF = id

iter :: Functor f => (f a -> a) -> Free f a -> a Source #

Tear down a Free Monad using iteration.

iterM :: (Functor f, Monad m) => (f (m a) -> m a) -> Free f a -> m a Source #

Like iter for monadic values.

Free Monads With Class

class Monad m => MonadFree (f :: Type -> Type) (m :: Type -> Type) | m -> f where Source #

Monads provide substitution (fmap) and renormalization (join):

m >>= f = join (fmap f m)

A free Monad is one that does no work during the normalization step beyond simply grafting the two monadic values together.

[] is not a free Monad (in this sense) because join [[a]] smashes the lists flat.

On the other hand, consider:

data Tree a = Bin (Tree a) (Tree a) | Tip a

instance Monad Tree where
  return = Tip
  Tip a >>= f = f a
  Bin l r >>= f = Bin (l >>= f) (r >>= f)

This Monad is the free Monad of Pair:

data Pair a = Pair a a

And we could make an instance of MonadFree for it directly:

instance MonadFree Pair Tree where
   wrap (Pair l r) = Bin l r

Or we could choose to program with Free Pair instead of Tree and thereby avoid having to define our own Monad instance.

Moreover, Control.Monad.Free.Church provides a MonadFree instance that can improve the asymptotic complexity of code that constructs free monads by effectively reassociating the use of (>>=). You may also want to take a look at the kan-extensions package (http://hackage.haskell.org/package/kan-extensions).

See Free for a more formal definition of the free Monad for a Functor.

Minimal complete definition

Nothing

Methods

wrap :: f (m a) -> m a Source #

Add a layer.

wrap (fmap f x) ≡ wrap (fmap return x) >>= f

default wrap :: forall (t :: (Type -> Type) -> Type -> Type) (n :: Type -> Type) a. (m ~ t n, MonadTrans t, MonadFree f n, Functor f) => f (m a) -> m a Source #

Instances

Instances details

Monad m => MonadFree Identity (IterT m) Source #
Instance details Defined in Control.Monad.Trans.Iter Methods wrap :: Identity (IterT m a) -> IterT m a Source #
Functor f => MonadFree f (Free f) Source #
Instance details Defined in Control.Monad.Free Methods wrap :: f (Free f a) -> Free f a Source #
Applicative f => MonadFree f (Free f) Source #
Instance details Defined in Control.Monad.Free.Ap Methods wrap :: f (Free f a) -> Free f a Source #
Functor f => MonadFree f (F f) Source #
Instance details Defined in Control.Monad.Free.Church Methods wrap :: f (F f a) -> F f a Source #
(Functor f, MonadFree f m) => MonadFree f (MaybeT m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (MaybeT m a) -> MaybeT m a Source #
(Functor f, Monad m) => MonadFree f (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free Methods wrap :: f (FreeT f m a) -> FreeT f m a Source #
(Applicative f, Monad m) => MonadFree f (FreeT f m) Source #
Instance details Defined in Control.Monad.Trans.Free.Ap Methods wrap :: f (FreeT f m a) -> FreeT f m a Source #
MonadFree f (FT f m) Source #
Instance details Defined in Control.Monad.Trans.Free.Church Methods wrap :: f (FT f m a) -> FT f m a Source #
(Functor f, MonadFree f m) => MonadFree f (ExceptT e m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (ExceptT e m a) -> ExceptT e m a Source #
(Functor f, MonadFree f m) => MonadFree f (IdentityT m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (IdentityT m a) -> IdentityT m a Source #
(Functor f, MonadFree f m) => MonadFree f (ReaderT e m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (ReaderT e m a) -> ReaderT e m a Source #
(Functor f, MonadFree f m) => MonadFree f (StateT s m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (StateT s m a) -> StateT s m a Source #
(Functor f, MonadFree f m) => MonadFree f (StateT s m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (StateT s m a) -> StateT s m a Source #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (WriterT w m a) -> WriterT w m a Source #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (WriterT w m a) -> WriterT w m a Source #
(Functor f, MonadFree f m) => MonadFree f (ContT r m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (ContT r m a) -> ContT r m a Source #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (RWST r w s m a) -> RWST r w s m a Source #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) Source #
Instance details Defined in Control.Monad.Free.Class Methods wrap :: f (RWST r w s m a) -> RWST r w s m a Source #