Safe Haskell  None 

Language  Haskell2010 
Synopsis
 class FreeAlgebra1 (m :: (k > Type) > k > Type) where
 liftFree :: AlgebraType0 m f => f a > m f a
 foldNatFree :: forall d f a. (AlgebraType m d, AlgebraType0 m f) => (forall x. f x > d x) > m f a > d a
 codom1 :: forall f. AlgebraType0 m f => Proof (AlgebraType m (m f)) (m f)
 forget1 :: forall f. AlgebraType m f => Proof (AlgebraType0 m f) (m f)
 data Proof (c :: Constraint) (a :: l) where
 type family AlgebraType0 (f :: k) (a :: l) :: Constraint
 type family AlgebraType (f :: k) (a :: l) :: Constraint
 wrapFree :: forall (m :: (Type > Type) > Type > Type) (f :: Type > Type) a. (FreeAlgebra1 m, AlgebraType0 m f, Monad (m f)) => f (m f a) > m f a
 foldFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType m f) => m f a > f a
 unFoldNatFree :: (FreeAlgebra1 m, AlgebraType0 m f) => (forall x. m f x > d x) > f a > d a
 hoistFree1 :: forall m f g a. (FreeAlgebra1 m, AlgebraType0 m g, AlgebraType0 m f) => (forall x. f x > g x) > m f a > m g a
 hoistFreeH :: forall m n f a. (FreeAlgebra1 m, FreeAlgebra1 n, AlgebraType0 m f, AlgebraType0 n f, AlgebraType m (n f)) => m f a > n f a
 joinFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType0 m f) => m (m f) a > m f a
 bindFree1 :: forall m f g a. (FreeAlgebra1 m, AlgebraType0 m g, AlgebraType0 m f) => m f a > (forall x. f x > m g x) > m g a
 assocFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType m f, Functor (m (m f))) => m f (m f a) > m (m f) (f a)
 iterFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType0 m f, AlgebraType m Identity) => (forall x. f x > x) > m f a > a
 cataFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType m f, Monad f, Traversable (m f)) => Fix (m f) > f a
 newtype DayF f a = DayF {}
 dayToAp :: Applicative f => Day f f a > Ap f a
 apToDay :: Applicative f => Ap f a > Day f f a
 newtype Free1 (c :: (Type > Type) > Constraint) (f :: Type > Type) a = Free1 {
 runFree1 :: forall g. c g => (forall x. f x > g x) > g a
 class Monad m => MonadList m where
 class MonadMaybe m where
 point :: forall a. m a
Documentation
class FreeAlgebra1 (m :: (k > Type) > k > Type) where Source #
Higher kinded version of
. Instances includes free functors,
free applicative functors, free monads, state monads etc.FreeAlgebra
A lawful instance should guarantee that
is an isomorphism
with inverses foldNatFree
.unFoldNatFree
This guaranties that m
is a left adjoint functor from the category of
types of kind Type > Type
which satisfy
constraint, to the
category of types of kind AlgebraType0
mType > Type
which satisfy the
constraint. This functor is left adjoin to the forgetful functor (which is
well defined if the laws on AlgebraType
m
family are satisfied. This in
turn guarantees that AlgebraType0
m
composed with this forgetful functor is a monad.
In result we get monadic operations:
For m
such that
subsumes AlgebraType0
this class implies:Monad
MFunctor
viahoist = hoistFree1
MMonad
viaembed = flip bindFree1
MonadTrans
vialift = liftFree
liftFree :: AlgebraType0 m f => f a > m f a Source #
Natural transformation that embeds generators into m
.
:: forall d f a. (AlgebraType m d, AlgebraType0 m f)  
=> (forall x. f x > d x)  a natural transformation which embeds generators of 
> m f a > d a  a morphism from 
The freeness property.
foldNatFree nat (liftFree m) = nat m
foldNatFree nat . foldNatFree nat' = foldNatFree (foldNatFree nat . nat')
codom1 :: forall f. AlgebraType0 m f => Proof (AlgebraType m (m f)) (m f) Source #
A proof that
holds for all AlgebraType
m (m f)AlgebraType0 f => f
.
Together with
this proves that hoistFree1
FreeAlgebra m => m
is
a functor from the full subcategory of types of kind Type > Type
which satisfy
to ones that satisfy AlgebraType0
m f
.AlgebraType
m f
default codom1 :: forall a. AlgebraType m (m a) => Proof (AlgebraType m (m a)) (m a) Source #
forget1 :: forall f. AlgebraType m f => Proof (AlgebraType0 m f) (m f) Source #
A proof that the forgetful functor from the full subcategory of types of
kind Type > Type
satisfying
constraint to types
satisfying AlgebraType
m f
is well defined.AlgebraType0
m f
default forget1 :: forall a. AlgebraType0 m a => Proof (AlgebraType0 m a) (m a) Source #
Instances
FreeAlgebra1 (ReaderT r :: (Type > Type) > Type > Type) Source # 

Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (ReaderT r) f => f a > ReaderT r f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (ReaderT r) d, AlgebraType0 (ReaderT r) f) => (forall (x :: k). f x > d x) > ReaderT r f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (ReaderT r) f => Proof (AlgebraType (ReaderT r) (ReaderT r f)) (ReaderT r f) Source # forget1 :: forall (f :: k > Type). AlgebraType (ReaderT r) f => Proof (AlgebraType0 (ReaderT r) f) (ReaderT r f) Source #  
(forall (f :: Type > Type). c (Free1 c f)) => FreeAlgebra1 (Free1 c :: (Type > Type) > Type > Type) Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (Free1 c) f => f a > Free1 c f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (Free1 c) d, AlgebraType0 (Free1 c) f) => (forall (x :: k). f x > d x) > Free1 c f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (Free1 c) f => Proof (AlgebraType (Free1 c) (Free1 c f)) (Free1 c f) Source # forget1 :: forall (f :: k > Type). AlgebraType (Free1 c) f => Proof (AlgebraType0 (Free1 c) f) (Free1 c f) Source #  
Monad m => FreeAlgebra1 (FreeMAction m :: (Type > Type) > Type > Type) Source #  
Defined in Control.Monad.Action liftFree :: forall f (a :: k). AlgebraType0 (FreeMAction m) f => f a > FreeMAction m f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (FreeMAction m) d, AlgebraType0 (FreeMAction m) f) => (forall (x :: k). f x > d x) > FreeMAction m f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (FreeMAction m) f => Proof (AlgebraType (FreeMAction m) (FreeMAction m f)) (FreeMAction m f) Source # forget1 :: forall (f :: k > Type). AlgebraType (FreeMAction m) f => Proof (AlgebraType0 (FreeMAction m) f) (FreeMAction m f) Source #  
FreeAlgebra1 MaybeT Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 MaybeT f => f a > MaybeT f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType MaybeT d, AlgebraType0 MaybeT f) => (forall (x :: k). f x > d x) > MaybeT f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 MaybeT f => Proof (AlgebraType MaybeT (MaybeT f)) (MaybeT f) Source # forget1 :: forall (f :: k > Type). AlgebraType MaybeT f => Proof (AlgebraType0 MaybeT f) (MaybeT f) Source #  
FreeAlgebra1 F Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 F f => f a > F f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType F d, AlgebraType0 F f) => (forall (x :: k). f x > d x) > F f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 F f => Proof (AlgebraType F (F f)) (F f) Source # forget1 :: forall (f :: k > Type). AlgebraType F f => Proof (AlgebraType0 F f) (F f) Source #  
FreeAlgebra1 Free Source # 

Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 Free f => f a > Free f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType Free d, AlgebraType0 Free f) => (forall (x :: k). f x > d x) > Free f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 Free f => Proof (AlgebraType Free (Free f)) (Free f) Source # forget1 :: forall (f :: k > Type). AlgebraType Free f => Proof (AlgebraType0 Free f) (Free f) Source #  
FreeAlgebra1 Ap Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 Ap f => f a > Ap f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType Ap d, AlgebraType0 Ap f) => (forall (x :: k). f x > d x) > Ap f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 Ap f => Proof (AlgebraType Ap (Ap f)) (Ap f) Source # forget1 :: forall (f :: k > Type). AlgebraType Ap f => Proof (AlgebraType0 Ap f) (Ap f) Source #  
FreeAlgebra1 Ap Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 Ap f => f a > Ap f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType Ap d, AlgebraType0 Ap f) => (forall (x :: k). f x > d x) > Ap f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 Ap f => Proof (AlgebraType Ap (Ap f)) (Ap f) Source # forget1 :: forall (f :: k > Type). AlgebraType Ap f => Proof (AlgebraType0 Ap f) (Ap f) Source #  
FreeAlgebra1 Ap Source # 

Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 Ap f => f a > Ap f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType Ap d, AlgebraType0 Ap f) => (forall (x :: k). f x > d x) > Ap f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 Ap f => Proof (AlgebraType Ap (Ap f)) (Ap f) Source # forget1 :: forall (f :: k > Type). AlgebraType Ap f => Proof (AlgebraType0 Ap f) (Ap f) Source #  
FreeAlgebra1 Alt Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 Alt f => f a > Alt f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType Alt d, AlgebraType0 Alt f) => (forall (x :: k). f x > d x) > Alt f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 Alt f => Proof (AlgebraType Alt (Alt f)) (Alt f) Source # forget1 :: forall (f :: k > Type). AlgebraType Alt f => Proof (AlgebraType0 Alt f) (Alt f) Source #  
FreeAlgebra1 Coyoneda Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 Coyoneda f => f a > Coyoneda f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType Coyoneda d, AlgebraType0 Coyoneda f) => (forall (x :: k). f x > d x) > Coyoneda f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 Coyoneda f => Proof (AlgebraType Coyoneda (Coyoneda f)) (Coyoneda f) Source # forget1 :: forall (f :: k > Type). AlgebraType Coyoneda f => Proof (AlgebraType0 Coyoneda f) (Coyoneda f) Source #  
FreeAlgebra1 ListT Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 ListT f => f a > ListT f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType ListT d, AlgebraType0 ListT f) => (forall (x :: k). f x > d x) > ListT f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 ListT f => Proof (AlgebraType ListT (ListT f)) (ListT f) Source # forget1 :: forall (f :: k > Type). AlgebraType ListT f => Proof (AlgebraType0 ListT f) (ListT f) Source #  
FreeAlgebra1 DayF Source # 

Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 DayF f => f a > DayF f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType DayF d, AlgebraType0 DayF f) => (forall (x :: k). f x > d x) > DayF f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 DayF f => Proof (AlgebraType DayF (DayF f)) (DayF f) Source # forget1 :: forall (f :: k > Type). AlgebraType DayF f => Proof (AlgebraType0 DayF f) (DayF f) Source #  
FreeAlgebra1 (ExceptT e :: (Type > Type) > Type > Type) Source # 

Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (ExceptT e) f => f a > ExceptT e f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (ExceptT e) d, AlgebraType0 (ExceptT e) f) => (forall (x :: k). f x > d x) > ExceptT e f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (ExceptT e) f => Proof (AlgebraType (ExceptT e) (ExceptT e f)) (ExceptT e f) Source # forget1 :: forall (f :: k > Type). AlgebraType (ExceptT e) f => Proof (AlgebraType0 (ExceptT e) f) (ExceptT e f) Source #  
FreeAlgebra1 (StateT s :: (Type > Type) > Type > Type) Source #  Lazy
This is also true for all the other monad transformers. 
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (StateT s) f => f a > StateT s f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (StateT s) d, AlgebraType0 (StateT s) f) => (forall (x :: k). f x > d x) > StateT s f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (StateT s) f => Proof (AlgebraType (StateT s) (StateT s f)) (StateT s f) Source # forget1 :: forall (f :: k > Type). AlgebraType (StateT s) f => Proof (AlgebraType0 (StateT s) f) (StateT s f) Source #  
FreeAlgebra1 (StateT s :: (Type > Type) > Type > Type) Source #  Strict 
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (StateT s) f => f a > StateT s f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (StateT s) d, AlgebraType0 (StateT s) f) => (forall (x :: k). f x > d x) > StateT s f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (StateT s) f => Proof (AlgebraType (StateT s) (StateT s f)) (StateT s f) Source # forget1 :: forall (f :: k > Type). AlgebraType (StateT s) f => Proof (AlgebraType0 (StateT s) f) (StateT s f) Source #  
FreeAlgebra1 (WriterT w :: (Type > Type) > Type > Type) Source #  Lazy 
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (WriterT w) f => f a > WriterT w f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (WriterT w) d, AlgebraType0 (WriterT w) f) => (forall (x :: k). f x > d x) > WriterT w f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (WriterT w) f => Proof (AlgebraType (WriterT w) (WriterT w f)) (WriterT w f) Source # forget1 :: forall (f :: k > Type). AlgebraType (WriterT w) f => Proof (AlgebraType0 (WriterT w) f) (WriterT w f) Source #  
FreeAlgebra1 (WriterT w :: (Type > Type) > Type > Type) Source #  Strict 
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (WriterT w) f => f a > WriterT w f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (WriterT w) d, AlgebraType0 (WriterT w) f) => (forall (x :: k). f x > d x) > WriterT w f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (WriterT w) f => Proof (AlgebraType (WriterT w) (WriterT w f)) (WriterT w f) Source # forget1 :: forall (f :: k > Type). AlgebraType (WriterT w) f => Proof (AlgebraType0 (WriterT w) f) (WriterT w f) Source #  
FreeAlgebra1 (RWST r w s :: (Type > Type) > Type > Type) Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (RWST r w s) f => f a > RWST r w s f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (RWST r w s) d, AlgebraType0 (RWST r w s) f) => (forall (x :: k). f x > d x) > RWST r w s f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (RWST r w s) f => Proof (AlgebraType (RWST r w s) (RWST r w s f)) (RWST r w s f) Source # forget1 :: forall (f :: k > Type). AlgebraType (RWST r w s) f => Proof (AlgebraType0 (RWST r w s) f) (RWST r w s f) Source #  
FreeAlgebra1 (RWST r w s :: (Type > Type) > Type > Type) Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (RWST r w s) f => f a > RWST r w s f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (RWST r w s) d, AlgebraType0 (RWST r w s) f) => (forall (x :: k). f x > d x) > RWST r w s f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (RWST r w s) f => Proof (AlgebraType (RWST r w s) (RWST r w s f)) (RWST r w s f) Source # forget1 :: forall (f :: k > Type). AlgebraType (RWST r w s) f => Proof (AlgebraType0 (RWST r w s) f) (RWST r w s f) Source # 
Type level witnesses
data Proof (c :: Constraint) (a :: l) where Source #
A proof that constraint c
holds for type a
.
Higher algebra type / constraints
type family AlgebraType0 (f :: k) (a :: l) :: Constraint Source #
Type family which limits Hask to its full subcategory which satisfies
a given constraints. Some free algebras, like free groups, or free abelian
semigroups have additional constraints on on generators, like Eq
or Ord
.
Instances
type AlgebraType0 Coyoneda (g :: l) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 DList (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 Maybe (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 [] (a :: l) Source #  
Defined in Data.Algebra.Free type AlgebraType0 [] (a :: l) = ()  
type AlgebraType0 NonEmpty (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 Identity (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 DNonEmpty (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 (Free1 c :: (Type > Type) > Type > Type) (f :: l) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 (Free Group) (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 (Free Monoid) (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 (Free Semigroup) (a :: l) Source #  
Defined in Data.Algebra.Free  
type AlgebraType0 FreeGroupL (a :: Type) Source #  
Defined in Data.Group.Free  
type AlgebraType0 FreeGroup (a :: Type) Source #  
Defined in Data.Group.Free  
type AlgebraType0 FreeAbelianSemigroup (a :: Type) Source #  
Defined in Data.Semigroup.Abelian  
type AlgebraType0 FreeAbelianMonoid (a :: Type) Source #  
Defined in Data.Monoid.Abelian  
type AlgebraType0 FreeSemilattice (a :: Type) Source #  
Defined in Data.Semigroup.Semilattice  
type AlgebraType0 MaybeT (m :: Type > Type) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 F (f :: Type > Type) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 Free (f :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 Ap (g :: Type > Type) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 Ap (g :: Type > Type) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 Ap (g :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 Alt (f :: Type > Type) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 ListT (f :: Type > Type) Source #  
Defined in Control.Algebra.Free  
type AlgebraType0 DayF (g :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 (FreeMAction m :: (Type > Type) > Type > Type) (f :: Type > Type) Source #  
Defined in Control.Monad.Action  
type AlgebraType0 (ExceptT e :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 (ReaderT r :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  Algebras of the same type as TODO: take advantage of polykinded 
Defined in Control.Algebra.Free  
type AlgebraType0 (StateT s :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 (StateT s :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType0 (WriterT w :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  Algebras of the same type as 
type AlgebraType0 (WriterT w :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  Algebras of the same type as 
type AlgebraType0 (RWST r w s :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  
type AlgebraType0 (RWST r w s :: (Type > Type) > Type > Type) (m :: Type > Type) Source #  
type family AlgebraType (f :: k) (a :: l) :: Constraint Source #
Type family which for each free algebra m
returns a type level lambda
from types to constraints. It is describe the class of algebras for which
this free algebra is free.
A lawful instance for this type family must guarantee
that the constraint
is implied by the AlgebraType0
m f
constraint. This guarantees that there exists a forgetful functor from
the category of types of kind AlgebraType
m f* > *
which satisfy
constrain to the category of types of kind AlgebraType
m* > *
which satisfy the
'AlgebraType0 m
constraint.
Instances
Combinators
wrapFree :: forall (m :: (Type > Type) > Type > Type) (f :: Type > Type) a. (FreeAlgebra1 m, AlgebraType0 m f, Monad (m f)) => f (m f a) > m f a Source #
Anything that carries
constraint is also an instance of
FreeAlgebra1
, but not vice versa. You can use
MonadFree
to define a wrap
instance.
MonadFree
is an example of a monad which does have an ContT
instance, but has an FreeAlgebra1
instance.MonadFree
The
constrain will be satisfied for many monads through the
Monad
'AlgebraType m'
constraint.
foldFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType m f) => m f a > f a Source #
implies that FreeAlgebra1
mm f
is a foldable.
foldFree1
.liftFree
==id
:: f a > f a
foldFree1
is the
unit of the
adjunction imposed by FreeAlgebra1
constraint.
It can be specialized to:
lowerCoyoneda
::Functor
f =>Coyoneda
f a > f aretractAp
::Applicative
f =>Ap
f a > f aretract
::Monad
f =>Free
f a > f a
unFoldNatFree :: (FreeAlgebra1 m, AlgebraType0 m f) => (forall x. m f x > d x) > f a > d a Source #
is an inverse of unFoldNatFree
foldNatFree
It is uniquelly determined by its universal property (by Yonneda lemma):
unFoldNatFree id = ruturnFree1
Note that
is the
unit of the
adjunction imposed by the unFoldNatFree
id
constraint.FreeAlgebra1
:: forall m f g a. (FreeAlgebra1 m, AlgebraType0 m g, AlgebraType0 m f)  
=> (forall x. f x > g x)  a natural transformation 
> m f a  
> m g a 
This is a functor instance for m
when considered as an endofuctor of some
subcategory of Type > Type
(e.g. endofunctors of Hask) and it satisfies
the functor laws:
hoistFree1 id = id
hoistFree1 f . hoistFree1 g = hoistFree1 (f . g)
It can be specialized to:
hoistFreeH :: forall m n f a. (FreeAlgebra1 m, FreeAlgebra1 n, AlgebraType0 m f, AlgebraType0 n f, AlgebraType m (n f)) => m f a > n f a Source #
joinFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType0 m f) => m (m f) a > m f a Source #
:: forall m f g a. (FreeAlgebra1 m, AlgebraType0 m g, AlgebraType0 m f)  
=> m f a  
> (forall x. f x > m g x)  natural transformation 
> m g a 
Bind operator for the
monad, this is just joinFree1
in
disguise.foldNatFree
For
,
StateT
or
WriterT
(or any ReaderT
such
that FreeAlgebra1
m => m
subsumes AlgebraType0
m
), this is the Monad
m>>=
version of
Control.Monad.Morph.embed
.
assocFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType m f, Functor (m (m f))) => m f (m f a) > m (m f) (f a) Source #
iterFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType0 m f, AlgebraType m Identity) => (forall x. f x > x) > m f a > a Source #
Specialization of
; it will further specialize to:foldNatFree
@_ @Identity
\_ >
runIdentity
.lowerCoyoneda
iterAp
::Functor
g => (g a > a) >Ap
g a > aiter
::Functor
f => (f a > a) >Free
f a > a
cataFree1 :: forall m f a. (FreeAlgebra1 m, AlgebraType m f, Monad f, Traversable (m f)) => Fix (m f) > f a Source #
is the initial algebra of type Fix
(m f)
and
AlgebraType
m
.AlgebraType0
f
Day convolution
newtype wrapper. It is isomorphic with Day
f f
for
applicative functors Ap
ff
via
(and dayToAp
).apToDay
Instances
Functor (DayF f) Source #  
Applicative f => Applicative (DayF f) Source #  
FreeAlgebra1 DayF Source # 

Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 DayF f => f a > DayF f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType DayF d, AlgebraType0 DayF f) => (forall (x :: k). f x > d x) > DayF f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 DayF f => Proof (AlgebraType DayF (DayF f)) (DayF f) Source # forget1 :: forall (f :: k > Type). AlgebraType DayF f => Proof (AlgebraType0 DayF f) (DayF f) Source #  
type AlgebraType0 DayF (g :: Type > Type) Source #  Algebras of the same type as 
Defined in Control.Algebra.Free  
type AlgebraType DayF (g :: Type > Type) Source #  
Defined in Control.Algebra.Free 
Free construction in continuation passing style
newtype Free1 (c :: (Type > Type) > Constraint) (f :: Type > Type) a Source #
Free construction for kinds
. Type
> Type
is
isomorhpic to Free1
Functor
via Coyoneda
, and hoistFreeH
is isomorphic to Free1
Applicative
(also via Ap
).hoistFreeH
Note: useful instance are only provided for ghc8.6 using quantified constraints.
Instances
(forall (f :: Type > Type). c (Free1 c f)) => FreeAlgebra1 (Free1 c :: (Type > Type) > Type > Type) Source #  
Defined in Control.Algebra.Free liftFree :: forall f (a :: k). AlgebraType0 (Free1 c) f => f a > Free1 c f a Source # foldNatFree :: forall d f (a :: k). (AlgebraType (Free1 c) d, AlgebraType0 (Free1 c) f) => (forall (x :: k). f x > d x) > Free1 c f a > d a Source # codom1 :: forall (f :: k > Type). AlgebraType0 (Free1 c) f => Proof (AlgebraType (Free1 c) (Free1 c f)) (Free1 c f) Source # forget1 :: forall (f :: k > Type). AlgebraType (Free1 c) f => Proof (AlgebraType0 (Free1 c) f) (Free1 c f) Source #  
(forall (h :: Type > Type). c h => Monad h, c (Free1 c f)) => Monad (Free1 c f) Source #  
(forall (h :: Type > Type). c h => Functor h) => Functor (Free1 c f) Source #  
(forall (h :: Type > Type). c h => Applicative h, c (Free1 c f)) => Applicative (Free1 c f) Source # 

(forall (h :: Type > Type). c h => MonadZip h, c (Free1 c f)) => MonadZip (Free1 c f) Source #  
(forall (h :: Type > Type). c h => Alternative h, c (Free1 c f)) => Alternative (Free1 c f) Source #  
(forall (h :: Type > Type). c h => MonadPlus h, c (Free1 c f)) => MonadPlus (Free1 c f) Source #  
type AlgebraType0 (Free1 c :: (Type > Type) > Type > Type) (f :: l) Source #  
Defined in Control.Algebra.Free  
type AlgebraType (Free1 c :: (Type > Type) > Type > Type) (f :: Type > Type) Source #  
Defined in Control.Algebra.Free 