Safe Haskell	Safe
Language	Haskell2010

Control.Monad.Trans.Free.Ap

Contents

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

Description

Given an applicative, the free monad transformer.

Synopsis

The base functor

data FreeF f a b #

The base functor for a free monad.

Constructors

Pure a
Free (f b)

Instances

Eq1 f => Eq2 (FreeF f) #
Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> FreeF f a c -> FreeF f b d -> Bool #
Ord1 f => Ord2 (FreeF f) #
Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> FreeF f a c -> FreeF f b d -> Ordering #
Read1 f => Read2 (FreeF f) #
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] #
Show1 f => Show2 (FreeF f) #
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 #
Functor f => Bifunctor (FreeF f) #
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) #
Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> FreeF f a b -> f (FreeF f c d) #
Foldable f => Bifoldable (FreeF f) #
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 => Functor (FreeF f a) #
Methods fmap :: (a -> b) -> FreeF f a a -> FreeF f a b # (<$) :: a -> FreeF f a b -> FreeF f a a #
Foldable f => Foldable (FreeF f a) #
Methods fold :: Monoid m => FreeF f a m -> m # foldMap :: Monoid m => (a -> m) -> FreeF f a a -> m # foldr :: (a -> b -> b) -> b -> FreeF f a a -> b # foldr' :: (a -> b -> b) -> b -> FreeF f a a -> b # foldl :: (b -> a -> b) -> b -> FreeF f a a -> b # foldl' :: (b -> a -> b) -> b -> FreeF f a a -> b # foldr1 :: (a -> a -> a) -> FreeF f a a -> a # foldl1 :: (a -> a -> a) -> FreeF f a a -> a # toList :: FreeF f a a -> [a] # null :: FreeF f a a -> Bool # length :: FreeF f a a -> Int # elem :: Eq a => a -> FreeF f a a -> Bool # maximum :: Ord a => FreeF f a a -> a # minimum :: Ord a => FreeF f a a -> a # sum :: Num a => FreeF f a a -> a # product :: Num a => FreeF f a a -> a #
Traversable f => Traversable (FreeF f a) #
Methods traverse :: Applicative f => (a -> f b) -> FreeF f a a -> f (FreeF f a b) # sequenceA :: Applicative f => FreeF f a (f a) -> f (FreeF f a a) # mapM :: Monad m => (a -> m b) -> FreeF f a a -> m (FreeF f a b) # sequence :: Monad m => FreeF f a (m a) -> m (FreeF f a a) #
Generic1 (FreeF f a) #
Associated Types type Rep1 (FreeF f a :: * -> ) :: -> * # Methods from1 :: FreeF f a a -> Rep1 (FreeF f a) a # to1 :: Rep1 (FreeF f a) a -> FreeF f a a #
(Eq1 f, Eq a) => Eq1 (FreeF f a) #
Methods liftEq :: (a -> b -> Bool) -> FreeF f a a -> FreeF f a b -> Bool #
(Ord1 f, Ord a) => Ord1 (FreeF f a) #
Methods liftCompare :: (a -> b -> Ordering) -> FreeF f a a -> FreeF f a b -> Ordering #
(Read1 f, Read a) => Read1 (FreeF f a) #
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (FreeF f a a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [FreeF f a a] #
(Show1 f, Show a) => Show1 (FreeF f a) #
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> FreeF f a a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [FreeF f a a] -> ShowS #
(Eq (f b), Eq a) => Eq (FreeF f a b) #
Methods (==) :: FreeF f a b -> FreeF f a b -> Bool # (/=) :: FreeF f a b -> FreeF f a b -> Bool #
(Ord (f b), Ord a) => Ord (FreeF f a b) #
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 #
(Read (f b), Read a) => Read (FreeF f a b) #
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 (f b), Show a) => Show (FreeF f a b) #
Methods showsPrec :: Int -> FreeF f a b -> ShowS # show :: FreeF f a b -> String # showList :: [FreeF f a b] -> ShowS #
Generic (FreeF f a b) #
Associated Types type Rep (FreeF f a b) :: * -> * # Methods from :: FreeF f a b -> Rep (FreeF f a b) x # to :: Rep (FreeF f a b) x -> FreeF f a b #
type Rep1 (FreeF f a) #
type Rep1 (FreeF f a) = D1 (MetaData "FreeF" "Control.Monad.Trans.Free.Ap" "free-5.1-1jP8ElRitNU7ogrcsVAzbs" False) ((:+:) (C1 (MetaCons "Pure" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) (C1 (MetaCons "Free" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f))))
type Rep (FreeF f a b) #
type Rep (FreeF f a b) = D1 (MetaData "FreeF" "Control.Monad.Trans.Free.Ap" "free-5.1-1jP8ElRitNU7ogrcsVAzbs" False) ((:+:) (C1 (MetaCons "Pure" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) (C1 (MetaCons "Free" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f b)))))

The free monad transformer

newtype FreeT f m a #

The "free monad transformer" for an applicative f

Constructors

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

Instances

(Applicative f, Applicative m, MonadError e m) => MonadError e (FreeT f m) #
Methods throwError :: e -> FreeT f m a # catchError :: FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a #
(Applicative f, Applicative m, MonadReader r m) => MonadReader r (FreeT f m) #
Methods ask :: FreeT f m r # local :: (r -> r) -> FreeT f m a -> FreeT f m a # reader :: (r -> a) -> FreeT f m a #
(Applicative f, Applicative m, MonadState s m) => MonadState s (FreeT f m) #
Methods get :: FreeT f m s # put :: s -> FreeT f m () # state :: (s -> (a, s)) -> FreeT f m a #
(Applicative f, Applicative m, MonadWriter w m) => MonadWriter w (FreeT f m) #
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 #
(Applicative f, Applicative m, Monad m) => MonadFree f (FreeT f m) #
Methods wrap :: f (FreeT f m a) -> FreeT f m a #
MonadTrans (FreeT f) #
Methods lift :: Monad m => m a -> FreeT f m a #
(Applicative f, Applicative m, Monad m) => Monad (FreeT f m) #
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 # fail :: String -> FreeT f m a #
(Functor f, Monad m) => Functor (FreeT f m) #
Methods fmap :: (a -> b) -> FreeT f m a -> FreeT f m b # (<$) :: a -> FreeT f m b -> FreeT f m a #
(Applicative f, Applicative m, Monad m) => MonadFail (FreeT f m) #
Methods fail :: String -> FreeT f m a #
(Applicative f, Applicative m, Monad m) => Applicative (FreeT f m) #
Methods pure :: a -> FreeT f m a # (<>) :: 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 #
(Foldable m, Foldable f) => Foldable (FreeT f m) #
Methods fold :: Monoid m => FreeT f m m -> m # foldMap :: Monoid m => (a -> m) -> FreeT f m a -> m # 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) #
Methods traverse :: Applicative f => (a -> f b) -> FreeT f m a -> f (FreeT f m b) # sequenceA :: Applicative f => FreeT f m (f a) -> f (FreeT f m a) # mapM :: Monad m => (a -> m b) -> FreeT f m a -> m (FreeT f m b) # sequence :: Monad m => FreeT f m (m a) -> m (FreeT f m a) #
(Eq1 f, Eq1 m) => Eq1 (FreeT f m) #
Methods liftEq :: (a -> b -> Bool) -> FreeT f m a -> FreeT f m b -> Bool #
(Ord1 f, Ord1 m) => Ord1 (FreeT f m) #
Methods liftCompare :: (a -> b -> Ordering) -> FreeT f m a -> FreeT f m b -> Ordering #
(Read1 f, Read1 m) => Read1 (FreeT f m) #
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (FreeT f m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [FreeT f m a] #
(Show1 f, Show1 m) => Show1 (FreeT f m) #
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> FreeT f m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [FreeT f m a] -> ShowS #
(Applicative f, Applicative m, MonadIO m) => MonadIO (FreeT f m) #
Methods liftIO :: IO a -> FreeT f m a #
(Applicative f, Applicative m, MonadPlus m) => Alternative (FreeT f m) #
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] #
(Applicative f, Applicative m, MonadPlus m) => MonadPlus (FreeT f m) #
Methods mzero :: FreeT f m a # mplus :: FreeT f m a -> FreeT f m a -> FreeT f m a #
(Applicative f, Applicative m, MonadThrow m) => MonadThrow (FreeT f m) #
Methods throwM :: Exception e => e -> FreeT f m a #
(Applicative f, Applicative m, MonadCatch m) => MonadCatch (FreeT f m) #
Methods catch :: Exception e => FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a #
(Applicative f, Applicative m, MonadCont m) => MonadCont (FreeT f m) #
Methods callCC :: ((a -> FreeT f m b) -> FreeT f m a) -> FreeT f m a #
(Apply f, Apply m, Monad m) => Apply (FreeT f m) #
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 #
(Apply f, Apply m, Monad m) => Bind (FreeT f m) #
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 #
(Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a) #
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) #
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 #
(Read1 f, Read1 m, Read a) => Read (FreeT f m a) #
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) #
Methods showsPrec :: Int -> FreeT f m a -> ShowS # show :: FreeT f m a -> String # showList :: [FreeT f m a] -> ShowS #

The free monad

type Free f = FreeT f Identity #

The "free monad" for an applicative f.

free :: FreeF f a (Free f a) -> Free f a #

Pushes a layer into a free monad value.

runFree :: Free f a -> FreeF f a (Free f a) #

Evaluates the first layer out of a free monad value.

Operations

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

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

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

Given an applicative homomorphism from f (m a) to m a, tear down a free monad transformer using iteration.

iterTM :: (Applicative f, Monad m, MonadTrans t, Monad (t m)) => (f (t m a) -> t m a) -> FreeT f m a -> t m a #

Given an applicative homomorphism from f (t m a) to t m a, tear down a free monad transformer using iteration over a transformer.

hoistFreeT :: (Monad m, Applicative f) => (forall a. m a -> n a) -> FreeT f m b -> FreeT f n b #

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

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

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

Lift an applicative homomorphism from f to g into a monad homomorphism from FreeT f m to FreeT g m

joinFreeT :: (Monad m, Traversable f, Applicative f) => FreeT f m a -> m (Free f a) #

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

cutoff :: (Applicative f, Applicative m, Monad m) => Integer -> FreeT f m a -> FreeT f m (Maybe a) #

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 #

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 :: (Monad m, Applicative m, Applicative f) => f a -> FreeT f m b -> FreeT f m b #

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 :: (Monad m, MonadTrans t, Monad (t m)) => t m a -> FreeT (t m) m b -> t m b #

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

intercalateT f ≡ retractT . intersperseT f

retractT :: (MonadTrans t, Monad (t m), Monad m) => FreeT (t m) m a -> t m a #

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

Operations of free monad

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

retract is the left inverse of liftF

retract . liftF = id

iter :: Applicative f => (f a -> a) -> Free f a -> a #

Given an applicative homomorphism from f to Identity, tear down a Free Monad using iteration.

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

Like iter for monadic values.

Free Monads With Class

class Monad m => MonadFree f m | m -> f where #

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.

Methods

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

Add a layer.

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

wrap :: (m ~ t n, MonadTrans t, MonadFree f n, Functor f) => f (m a) -> m a #

Add a layer.

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

Instances

(Functor f, MonadFree f m) => MonadFree f (ListT m) #
Methods wrap :: f (ListT m a) -> ListT m a #
(Functor f, MonadFree f m) => MonadFree f (MaybeT m) #
Methods wrap :: f (MaybeT m a) -> MaybeT m a #
Applicative f => MonadFree f (Free f) #
Methods wrap :: f (Free f a) -> Free f a #
Functor f => MonadFree f (Free f) #
Methods wrap :: f (Free f a) -> Free f a #
Functor f => MonadFree f (F f) #
Methods wrap :: f (F f a) -> F f a #
Monad m => MonadFree Identity (IterT m) #
Methods wrap :: Identity (IterT m a) -> IterT m a #
(Functor f, MonadFree f m) => MonadFree f (ExceptT e m) #
Methods wrap :: f (ExceptT e m a) -> ExceptT e m a #
(Functor f, MonadFree f m, Error e) => MonadFree f (ErrorT e m) #
Methods wrap :: f (ErrorT e m a) -> ErrorT e m a #
(Functor f, MonadFree f m) => MonadFree f (IdentityT * m) #
Methods wrap :: f (IdentityT * m a) -> IdentityT * m a #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) #
Methods wrap :: f (WriterT w m a) -> WriterT w m a #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) #
Methods wrap :: f (WriterT w m a) -> WriterT w m a #
(Functor f, MonadFree f m) => MonadFree f (StateT s m) #
Methods wrap :: f (StateT s m a) -> StateT s m a #
(Functor f, MonadFree f m) => MonadFree f (StateT s m) #
Methods wrap :: f (StateT s m a) -> StateT s m a #
(Functor f, Monad m) => MonadFree f (FreeT f m) #
Methods wrap :: f (FreeT f m a) -> FreeT f m a #
(Applicative f, Applicative m, Monad m) => MonadFree f (FreeT f m) #
Methods wrap :: f (FreeT f m a) -> FreeT f m a #
MonadFree f (FT f m) #
Methods wrap :: f (FT f m a) -> FT f m a #
(Functor f, MonadFree f m) => MonadFree f (ContT * r m) #
Methods wrap :: f (ContT * r m a) -> ContT * r m a #
(Functor f, MonadFree f m) => MonadFree f (ReaderT * e m) #
Methods wrap :: f (ReaderT * e m a) -> ReaderT * e m a #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) #
Methods wrap :: f (RWST r w s m a) -> RWST r w s m a #
(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) #
Methods wrap :: f (RWST r w s m a) -> RWST r w s m a #