-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | This package provides datatypes to construct Free monads, Free monad
--   transformers, and useful instances. In addition it provides the
--   constructs to avoid quadratic complexity of left associative bind, as
--   explained in:
--   
--   <ul>
--   <li>Janis Voigtlander, <i>Asymptotic Improvement of Computations over
--   Free Monads, MPC'08</i></li>
--   </ul>
@package control-monad-free
@version 0.6.2

module Control.Monad.Free
(=<<) :: Monad m => (a -> m b) -> m a -> m b
ap :: Monad m => m (a -> b) -> m a -> m b
join :: Monad m => m (m a) -> m a
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
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
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
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 ()
forever :: Applicative f => f a -> f b
guard :: Alternative f => Bool -> f ()
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 ()
unless :: Applicative f => Bool -> f () -> f ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
void :: Functor f => f a -> f ()
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b
return :: Monad m => a -> m a
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
class Monad m => MonadFail (m :: Type -> Type)
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a

-- | This type class generalizes over encodings of Free Monads.
class (Functor f, Monad m) => MonadFree (f :: Type -> Type) (m :: Type -> Type)
free :: MonadFree f m => m a -> m (Either a (f (m a)))
wrap :: MonadFree f m => f (m a) -> m a
data Free (f :: Type -> Type) a
Impure :: f (Free f a) -> Free (f :: Type -> Type) a
Pure :: a -> Free (f :: Type -> Type) a
isPure :: forall (f :: Type -> Type) a. Free f a -> Bool
isImpure :: forall (f :: Type -> Type) a. 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 a1. () => f a1 -> m (g a1)) -> 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 a1. () => f a1 -> m a1) -> Free f a -> m a
newtype FreeT (f :: Type -> Type) (m :: Type -> Type) a
FreeT :: m (Either a (f (FreeT f m a))) -> FreeT (f :: Type -> Type) (m :: Type -> Type) a
[unFreeT] :: FreeT (f :: Type -> Type) (m :: Type -> Type) a -> m (Either a (f (FreeT f m a)))
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 :: forall (f :: Type -> Type) m m' a. (Functor f, Functor m) => (forall a1. () => m a1 -> m' a1) -> 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 :: forall (f :: Type -> Type) m a. MonadFree f m => Free f a -> m a
trans' :: forall (f :: Type -> Type) m a. (Functor f, Monad m) => m (Free f a) -> FreeT f m a
untrans :: forall (f :: Type -> Type) m a. (Traversable f, Monad m) => FreeT f m a -> m (Free f a)
liftFree :: forall (f :: Type -> Type) (m :: Type -> Type) a b. (Functor f, Monad m) => (a -> Free f b) -> a -> FreeT f m b
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Functor m, GHC.Internal.Base.Monad m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.Alternative (Control.Monad.Free.FreeT f m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Applicative (Control.Monad.Free.Free f)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Functor a, GHC.Internal.Base.Monad a) => GHC.Internal.Base.Applicative (Control.Monad.Free.FreeT f a)
instance Data.Functor.Classes.Eq1 f => Data.Functor.Classes.Eq1 (Control.Monad.Free.Free f)
instance (GHC.Classes.Eq a, Data.Functor.Classes.Eq1 f) => GHC.Classes.Eq (Control.Monad.Free.Free f a)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Data.Foldable.Foldable f) => GHC.Internal.Data.Foldable.Foldable (Control.Monad.Free.Free f)
instance (GHC.Internal.Data.Traversable.Traversable m, GHC.Internal.Data.Traversable.Traversable f) => GHC.Internal.Data.Foldable.Foldable (Control.Monad.Free.FreeT f m)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Control.Monad.Free.Free f)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Functor m) => GHC.Internal.Base.Functor (Control.Monad.Free.FreeT f m)
instance GHC.Internal.Generics.Generic (Control.Monad.Free.Free f a)
instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Monad (Control.Monad.Free.Free f)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Monad m) => GHC.Internal.Base.Monad (Control.Monad.Free.FreeT f m)
instance GHC.Internal.Base.Functor f => Control.Monad.Free.MonadFree f (Control.Monad.Free.Free f)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Monad m) => Control.Monad.Free.MonadFree f (Control.Monad.Free.FreeT f m)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Monad m, GHC.Internal.Control.Monad.IO.Class.MonadIO m) => GHC.Internal.Control.Monad.IO.Class.MonadIO (Control.Monad.Free.FreeT f m)
instance (GHC.Internal.Base.Functor f, GHC.Internal.Base.Monad m, GHC.Internal.Base.MonadPlus m) => GHC.Internal.Base.MonadPlus (Control.Monad.Free.FreeT f m)
instance GHC.Internal.Base.Functor f => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Free.FreeT f)
instance Data.Functor.Classes.Ord1 f => Data.Functor.Classes.Ord1 (Control.Monad.Free.Free f)
instance (GHC.Classes.Ord a, Data.Functor.Classes.Ord1 f) => GHC.Classes.Ord (Control.Monad.Free.Free f a)
instance (GHC.Internal.Show.Show a, Data.Functor.Classes.Show1 f) => GHC.Internal.Show.Show (Control.Monad.Free.Free f a)
instance GHC.Internal.Data.Traversable.Traversable f => GHC.Internal.Data.Traversable.Traversable (Control.Monad.Free.Free f)
instance (GHC.Internal.Data.Traversable.Traversable m, GHC.Internal.Data.Traversable.Traversable f) => GHC.Internal.Data.Traversable.Traversable (Control.Monad.Free.FreeT f m)


-- | Naive Free monads suffer from a quadratic complexity, as explained in
--   
--   <ul>
--   <li>Janis Voigtlander, <i>Asymptotic Improvement of Computations over
--   Free Monads, MPC'08</i></li>
--   </ul>
--   
--   The solution is to redefine the Free datatype in CPS, similar to what
--   is done in difference lists to solve the problem on quadratic append
--   for lists.
module Control.Monad.Free.Improve
newtype C (mu :: Type -> Type) a
C :: (forall b. () => (a -> mu b) -> mu b) -> C (mu :: Type -> Type) a
rep :: Monad mu => mu a -> C mu a
improve :: Monad mu => C mu a -> mu a
instance GHC.Internal.Base.MonadPlus mu => GHC.Internal.Base.Alternative (Control.Monad.Free.Improve.C mu)
instance GHC.Internal.Base.Applicative (Control.Monad.Free.Improve.C mu)
instance GHC.Internal.Base.Functor (Control.Monad.Free.Improve.C mu)
instance GHC.Internal.Base.Monad (Control.Monad.Free.Improve.C mu)
instance GHC.Internal.Base.Functor f => Control.Monad.Free.MonadFree f (Control.Monad.Free.Improve.C (Control.Monad.Free.Free f))
instance (GHC.Internal.Base.Monad m, GHC.Internal.Base.Functor f) => Control.Monad.Free.MonadFree f (Control.Monad.Free.Improve.C (Control.Monad.Free.FreeT f m))
instance GHC.Internal.Base.MonadPlus mu => GHC.Internal.Base.MonadPlus (Control.Monad.Free.Improve.C mu)
instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Free.Improve.C

module Control.Monad.Free.Zip
zipFree :: forall (f :: Type -> Type) m a b c. (Traversable f, Eq (f ()), MonadFail m) => (Free f a -> Free f b -> m (Free f c)) -> Free f a -> Free f b -> m (Free f c)
zipFree_ :: forall (f :: Type -> Type) m a b. (Traversable f, Eq (f ()), MonadFail m) => (Free f a -> Free f b -> m ()) -> Free f a -> Free f b -> m ()
