Control.Monad.Freer.Church

The church-encoded Freer Monad. Basically provides the free monad in a way that is compatible with HFunctor and Interpret. We also have the "semigroup" version Free1, which is the free Bind.

The module also provides a version of :.: (or Compose), Comp, in a way that is compatible with HBifunctor and the related typeclasses.

Free

newtype Free f a

A Free f is f enhanced with "sequential binding" capabilities. It allows you to sequence multiple fs one after the other, and also to determine "what f to sequence" based on the result of the computation so far.

Essentially, you can think of this as "giving f a Monad instance", with all that that entails (return, >>=, etc.).

Lift f into it with inject :: f a -> Free f a. When you finally want to "use" it, you can interpret it into any monadic context:

interpret
    :: Monad g
    => (forall x. f x -> g x)
    -> Free f a
    -> g a

Structurally, this is equivalent to many "nested" f's. A value of type Free f a is either:

• a

• f a

• f (f a)

• f (f (f a))

• .. etc.

Under the hood, this is the Church-encoded Freer monad. It's Free, or F, but in a way that is compatible with HFunctor and Interpret.

Constructors

Free

Fields

• runFree :: forall r. (a -> r) -> (forall s. f s -> (s -> r) -> r) -> r

Instances

FreeOf Monad Free

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Free :: (Type -> Type) -> Constraint

Methods

fromFree :: Free f ~> Final Monad f

toFree :: FreeFunctorBy Free f => Final Monad f ~> Free f

MonadFree f (Free f)

Defined in Control.Monad.Freer.Church

Methods

wrap :: f (Free f a) -> Free f a

Monad (Free f)

Defined in Control.Monad.Freer.Church

Methods

(>>=) :: Free f a -> (a -> Free f b) -> Free f b

(>>) :: Free f a -> Free f b -> Free f b

return :: a -> Free f a

fail :: String -> Free f a

Functor (Free f)

Defined in Control.Monad.Freer.Church

Methods

fmap :: (a -> b) -> Free f a -> Free f b

(<$) :: a -> Free f b -> Free f a

Applicative (Free f)

Defined in Control.Monad.Freer.Church

Methods

pure :: a -> Free f a

(<*>) :: Free f (a -> b) -> Free f a -> Free f b

liftA2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

(*>) :: Free f a -> Free f b -> Free f b

(<*) :: Free f a -> Free f b -> Free f a

Foldable f => Foldable (Free f)

Defined in Control.Monad.Freer.Church

Methods

fold :: Monoid m => Free f m -> 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

toList :: Free f a -> [a]

null :: Free f a -> Bool

length :: Free f a -> Int

elem :: Eq a => a -> Free f a -> Bool

maximum :: Ord a => Free f a -> a

minimum :: Ord a => Free f a -> a

sum :: Num a => Free f a -> a

product :: Num a => Free f a -> a

Traversable f => Traversable (Free f)

Defined in Control.Monad.Freer.Church

Methods

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

sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a)

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

sequence :: Monad m => Free f (m a) -> m (Free f a)

(Functor f, Eq1 f) => Eq1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

liftEq :: (a -> b -> Bool) -> Free f a -> Free f b -> Bool

(Functor f, Ord1 f) => Ord1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

liftCompare :: (a -> b -> Ordering) -> Free f a -> Free f b -> Ordering

(Functor f, Read1 f) => Read1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

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

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

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Free f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Free f a]

(Functor f, Show1 f) => Show1 (Free f)

Defined in Control.Monad.Freer.Church

Methods

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

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

Apply (Free f)

Defined in Control.Monad.Freer.Church

Methods

(<.>) :: Free f (a -> b) -> Free f a -> Free f b

(.>) :: Free f a -> Free f b -> Free f b

(<.) :: Free f a -> Free f b -> Free f a

liftF2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

Pointed (Free f)

Defined in Control.Monad.Freer.Church

Methods

point :: a -> Free f a

Bind (Free f)

Defined in Control.Monad.Freer.Church

Methods

(>>-) :: Free f a -> (a -> Free f b) -> Free f b

join :: Free f (Free f a) -> Free f a

HBind Free

Defined in Data.HFunctor

Methods

hbind :: (f ~> Free g) -> Free f ~> Free g

hjoin :: Free (Free f) ~> Free f

Inject Free

Defined in Data.HFunctor

Methods

inject :: f ~> Free f

Monad f => Interpret Free (f :: Type -> Type)

A free Monad

Defined in Data.HFunctor.Interpret

Methods

retract :: Free f ~> f

interpret :: (g ~> f) -> Free g ~> f

HFunctor Free

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Free f ~> Free g

(Functor f, Eq1 f, Eq a) => Eq (Free f a)

Defined in Control.Monad.Freer.Church

Methods

(==) :: Free f a -> Free f a -> Bool

(/=) :: Free f a -> Free f a -> Bool

(Functor f, Ord1 f, Ord a) => Ord (Free f a)

Defined in Control.Monad.Freer.Church

Methods

compare :: Free f a -> Free f a -> Ordering

(<) :: Free f a -> Free f a -> Bool

(<=) :: Free f a -> Free f a -> Bool

(>) :: Free f a -> Free f a -> Bool

(>=) :: Free f a -> Free f a -> Bool

max :: Free f a -> Free f a -> Free f a

min :: Free f a -> Free f a -> Free f a

(Functor f, Read1 f, Read a) => Read (Free f a)

Read in terms of pure and wrap.

Defined in Control.Monad.Freer.Church

Methods

readsPrec :: Int -> ReadS (Free f a)

readList :: ReadS [Free f a]

readPrec :: ReadPrec (Free f a)

readListPrec :: ReadPrec [Free f a]

(Functor f, Show1 f, Show a) => Show (Free f a)

Show in terms of pure and wrap.

Defined in Control.Monad.Freer.Church

Methods

showsPrec :: Int -> Free f a -> ShowS

show :: Free f a -> String

showList :: [Free f a] -> ShowS

type FreeFunctorBy Free

Defined in Data.HFunctor.Final

type FreeFunctorBy Free = (Unconstrained :: (Type -> Type) -> Constraint)

reFree :: (MonadFree f m, Functor f) => Free f a -> m a

Convert a Free f into any instance of MonadFree f.

Interpretation

liftFree :: f ~> Free f

Lift an f into Free f, so you can use it as a Monad.

This is inject.

interpretFree :: Monad g => (f ~> g) -> Free f ~> g

Interpret a Free f into a context g, provided that g has a Monad instance.

This is interpret.

retractFree :: Monad f => Free f ~> f

Extract the fs back "out" of a Free f, utilizing its Monad instance.

This is retract.

hoistFree :: (f ~> g) -> Free f ~> Free g

Swap out the underlying functor over a Free. This preserves all of the structure of the Free.

Folding

foldFree

Arguments

:: Functor f

=> (a -> r)

handle pure

-> (f r -> r)

handle wrap

-> Free f a

-> r

Recursively fold down a Free by handling the pure case and the nested/wrapped case.

This is a catamorphism.

This requires Functor f; see foldFree' and foldFreeC for a version that doesn't require Functor f.

foldFree' :: (a -> r) -> (forall s. f s -> (s -> r) -> r) -> Free f a -> r

A version of foldFree that doesn't require Functor f, by taking a RankN folding function. This is essentially a flipped runFree.

foldFreeC

Arguments

:: (a -> r)

handle pure

-> (Coyoneda f r -> r)

handle wrap

-> Free f a

-> r

A version of foldFree that doesn't require Functor f, by folding over a Coyoneda instead.

Free1

newtype Free1 f a

The Free Bind. Imbues any functor f with a Bind instance.

Conceptually, this is "Free without pure". That is, while normally Free f a is an a, a f a, a f (f a), etc., a Free1 f a is an f a, f (f a), f (f (f a)), etc. It's a Free with "at least one layer of f", excluding the a case.

It can be useful as the semigroup formed by :.: (functor composition): Sometimes we want an f :.: f, or an f :.: f :.: f, or an f :.: f :.: f :.: f...just as long as we have at least one f.

Constructors

Free1

Fields

• runFree1 :: forall r. (forall s. f s -> (s -> a) -> r) -> (forall s. f s -> (s -> r) -> r) -> r

Bundled Patterns

pattern DoneF1 :: Functor f => f a -> Free1 f a

Constructor matching on the case that a Free1 f consists of just a single un-nested f. Used as a part of the Show and Read instances.

pattern MoreF1 :: Functor f => f (Free1 f a) -> Free1 f a

Constructor matching on the case that a Free1 f is a nested f (Free1 f a). Used as a part of the Show and Read instances.

As a constructor, this is equivalent to wrap.

Instances

FreeOf Bind Free1

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Free1 :: (Type -> Type) -> Constraint

Methods

fromFree :: Free1 f ~> Final Bind f

toFree :: FreeFunctorBy Free1 f => Final Bind f ~> Free1 f

Functor (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

fmap :: (a -> b) -> Free1 f a -> Free1 f b

(<$) :: a -> Free1 f b -> Free1 f a

Foldable f => Foldable (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

fold :: Monoid m => Free1 f m -> m

foldMap :: Monoid m => (a -> m) -> Free1 f a -> m

foldr :: (a -> b -> b) -> b -> Free1 f a -> b

foldr' :: (a -> b -> b) -> b -> Free1 f a -> b

foldl :: (b -> a -> b) -> b -> Free1 f a -> b

foldl' :: (b -> a -> b) -> b -> Free1 f a -> b

foldr1 :: (a -> a -> a) -> Free1 f a -> a

foldl1 :: (a -> a -> a) -> Free1 f a -> a

toList :: Free1 f a -> [a]

null :: Free1 f a -> Bool

length :: Free1 f a -> Int

elem :: Eq a => a -> Free1 f a -> Bool

maximum :: Ord a => Free1 f a -> a

minimum :: Ord a => Free1 f a -> a

sum :: Num a => Free1 f a -> a

product :: Num a => Free1 f a -> a

Traversable f => Traversable (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

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

sequenceA :: Applicative f0 => Free1 f (f0 a) -> f0 (Free1 f a)

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

sequence :: Monad m => Free1 f (m a) -> m (Free1 f a)

(Functor f, Eq1 f) => Eq1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

liftEq :: (a -> b -> Bool) -> Free1 f a -> Free1 f b -> Bool

(Functor f, Ord1 f) => Ord1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

liftCompare :: (a -> b -> Ordering) -> Free1 f a -> Free1 f b -> Ordering

(Functor f, Read1 f) => Read1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

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

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

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Free1 f a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Free1 f a]

(Functor f, Show1 f) => Show1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

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

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

Foldable1 f => Foldable1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

fold1 :: Semigroup m => Free1 f m -> m

foldMap1 :: Semigroup m => (a -> m) -> Free1 f a -> m

toNonEmpty :: Free1 f a -> NonEmpty a

Apply (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

(<.>) :: Free1 f (a -> b) -> Free1 f a -> Free1 f b

(.>) :: Free1 f a -> Free1 f b -> Free1 f b

(<.) :: Free1 f a -> Free1 f b -> Free1 f a

liftF2 :: (a -> b -> c) -> Free1 f a -> Free1 f b -> Free1 f c

Traversable1 f => Traversable1 (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Free1 f a -> f0 (Free1 f b)

sequence1 :: Apply f0 => Free1 f (f0 b) -> f0 (Free1 f b)

Bind (Free1 f)

Defined in Control.Monad.Freer.Church

Methods

(>>-) :: Free1 f a -> (a -> Free1 f b) -> Free1 f b

join :: Free1 f (Free1 f a) -> Free1 f a

HBind Free1

Defined in Data.HFunctor

Methods

hbind :: (f ~> Free1 g) -> Free1 f ~> Free1 g

hjoin :: Free1 (Free1 f) ~> Free1 f

Inject Free1

Defined in Data.HFunctor

Methods

inject :: f ~> Free1 f

Bind f => Interpret Free1 (f :: Type -> Type)

A free Bind

Defined in Data.HFunctor.Interpret

Methods

retract :: Free1 f ~> f

interpret :: (g ~> f) -> Free1 g ~> f

HFunctor Free1

Defined in Data.HFunctor.Internal

Methods

hmap :: (f ~> g) -> Free1 f ~> Free1 g

(Functor f, Eq1 f, Eq a) => Eq (Free1 f a)

Defined in Control.Monad.Freer.Church

Methods

(==) :: Free1 f a -> Free1 f a -> Bool

(/=) :: Free1 f a -> Free1 f a -> Bool

(Functor f, Ord1 f, Ord a) => Ord (Free1 f a)

Defined in Control.Monad.Freer.Church

Methods

compare :: Free1 f a -> Free1 f a -> Ordering

(<) :: Free1 f a -> Free1 f a -> Bool

(<=) :: Free1 f a -> Free1 f a -> Bool

(>) :: Free1 f a -> Free1 f a -> Bool

(>=) :: Free1 f a -> Free1 f a -> Bool

max :: Free1 f a -> Free1 f a -> Free1 f a

min :: Free1 f a -> Free1 f a -> Free1 f a

(Functor f, Read1 f, Read a) => Read (Free1 f a)

Read in terms of DoneF1 and MoreF1.

Defined in Control.Monad.Freer.Church

Methods

readsPrec :: Int -> ReadS (Free1 f a)

readList :: ReadS [Free1 f a]

readPrec :: ReadPrec (Free1 f a)

readListPrec :: ReadPrec [Free1 f a]

(Functor f, Show1 f, Show a) => Show (Free1 f a)

Show in terms of DoneF1 and MoreF1.

Defined in Control.Monad.Freer.Church

Methods

showsPrec :: Int -> Free1 f a -> ShowS

show :: Free1 f a -> String

showList :: [Free1 f a] -> ShowS

type FreeFunctorBy Free1

Defined in Data.HFunctor.Final

type FreeFunctorBy Free1 = (Unconstrained :: (Type -> Type) -> Constraint)

reFree1 :: (MonadFree f m, Functor f) => Free1 f a -> m a

Convert a Free1 f into any instance of MonadFree f.

toFree :: Free1 f ~> Free f

Free1 f is a special subset of Free f that consists of at least one nested f. This converts it back into the "bigger" type.

See free1Comp for a version that preserves the "one nested layer" property.

Interpretation

liftFree1 :: f ~> Free1 f

Inject an f into a Free1 f

interpretFree1 :: Bind g => (f ~> g) -> Free1 f ~> g

Interpret the Free1 f in some context g, provided that g has a Bind instance. Since we always have at least one f, we will always have at least one g, so we do not need a full Monad constraint.

retractFree1 :: Bind f => Free1 f ~> f

Retract the f out of a Free1 f, as long as the f implements Bind. Since we always have at least one f, we do not need a full Monad constraint.

hoistFree1 :: (f ~> g) -> Free1 f ~> Free1 g

Map the underlying functor under a Free1.

Conversion

free1Comp :: Free1 f ~> Comp f (Free f)

Because a Free1 f is just a Free f with at least one nested layer of f, this function converts it back into the one-nested-f format.

matchFree1 :: forall f. Functor f => Free1 f ~> (f :+: Comp f (Free1 f))

A Free1 f is either a single un-nested f, or a f nested with another Free1 f. This decides which is the case.

Folding

foldFree1

Arguments

:: Functor f

=> (f a -> r)

handle DoneF1.

-> (f r -> r)

handle MoreF1.

-> Free1 f a

-> r

Recursively fold down a Free1 by handling the single f case and the nested/wrapped case.

This is a catamorphism.

This requires Functor f; see foldFree' and foldFreeC for a version that doesn't require Functor f.

foldFree1' :: (forall s. f s -> (s -> a) -> r) -> (forall s. f s -> (s -> r) -> r) -> Free1 f a -> r

A version of foldFree1 that doesn't require Functor f, by taking a RankN folding function. This is essentially a flipped runFree.

foldFree1C :: (Coyoneda f a -> r) -> (Coyoneda f r -> r) -> Free1 f a -> r

A version of foldFree1 that doesn't require Functor f, by folding over a Coyoneda instead.

Comp

data Comp f g a

Functor composition. Comp f g a is equivalent to f (g a), and the Comp pattern synonym is a way of getting the f (g a) in a Comp f g a.

For example, Maybe (IO Bool) is Comp Maybe IO Bool.

This is mostly useful for its typeclass instances: in particular, Functor, Applicative, HBifunctor, and Monoidal.

This is essentially a version of :.: and Compose that allows for an HBifunctor instance.

It is slightly less performant. Using comp . unComp every once in a while will concretize a Comp value (if you have Functor f) and remove some indirection if you have a lot of chained operations.

The "free monoid" over Comp is Free, and the "free semigroup" over Comp is Free1.

Constructors

(f x) :>>= (x -> g a)

Bundled Patterns

pattern Comp :: Functor f => f (g a) -> Comp f g a

Pattern match on and construct a Comp f g a as if it were f (g a).

Instances

Applicative f => Inject (Comp f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor

Methods

inject :: f0 ~> Comp f f0

Associative (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

Associated Types

type NonEmptyBy Comp :: (Type -> Type) -> Type -> Type

type FunctorBy Comp :: (Type -> Type) -> Constraint

Methods

associating :: (FunctorBy Comp f, FunctorBy Comp g, FunctorBy Comp h) => Comp f (Comp g h) <~> Comp (Comp f g) h

appendNE :: Comp (NonEmptyBy Comp f) (NonEmptyBy Comp f) ~> NonEmptyBy Comp f

matchNE :: FunctorBy Comp f => NonEmptyBy Comp f ~> (f :+: Comp f (NonEmptyBy Comp f))

consNE :: Comp f (NonEmptyBy Comp f) ~> NonEmptyBy Comp f

toNonEmptyBy :: Comp f f ~> NonEmptyBy Comp f

Bind f => SemigroupIn (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f

Instances of Bind are semigroups in the semigroupoidal category on Comp.

Defined in Data.HBifunctor.Associative

Methods

biretract :: Comp f f ~> f

binterpret :: (g ~> f) -> (h ~> f) -> Comp g h ~> f

Tensor (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity

Defined in Data.HBifunctor.Tensor

Associated Types

type ListBy Comp :: (Type -> Type) -> Type -> Type

Methods

intro1 :: f ~> Comp f Identity

intro2 :: g ~> Comp Identity g

elim1 :: FunctorBy Comp f => Comp f Identity ~> f

elim2 :: FunctorBy Comp g => Comp Identity g ~> g

appendLB :: Comp (ListBy Comp f) (ListBy Comp f) ~> ListBy Comp f

splitNE :: NonEmptyBy Comp f ~> Comp f (ListBy Comp f)

splittingLB :: ListBy Comp f <~> (Identity :+: Comp f (ListBy Comp f))

toListBy :: Comp f f ~> ListBy Comp f

fromNE :: NonEmptyBy Comp f ~> ListBy Comp f

(Bind f, Monad f) => MonoidIn (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f

Instances of Monad are monoids in the monoidal category on Comp.

This instance is the "proof" that "monads are the monoids in the category of endofunctors (enriched with Comp)"

Note that because of typeclass constraints, this requires Bind as well as Monad. But, you can get a "local" instance of Apply for any Monad using unsafeBind.

Defined in Data.HBifunctor.Tensor

Methods

pureT :: Identity ~> f

HBifunctor (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hleft :: (f ~> j) -> Comp f g ~> Comp j g

hright :: (g ~> l) -> Comp f g ~> Comp f l

hbimap :: (f ~> j) -> (g ~> l) -> Comp f g ~> Comp j l

HFunctor (Comp f :: (Type -> Type) -> Type -> Type)

Defined in Data.HFunctor.Internal

Methods

hmap :: (f0 ~> g) -> Comp f f0 ~> Comp f g

Functor g => Functor (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

fmap :: (a -> b) -> Comp f g a -> Comp f g b

(<$) :: a -> Comp f g b -> Comp f g a

(Applicative f, Applicative g) => Applicative (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

pure :: a -> Comp f g a

(<*>) :: Comp f g (a -> b) -> Comp f g a -> Comp f g b

liftA2 :: (a -> b -> c) -> Comp f g a -> Comp f g b -> Comp f g c

(*>) :: Comp f g a -> Comp f g b -> Comp f g b

(<*) :: Comp f g a -> Comp f g b -> Comp f g a

(Foldable f, Foldable g) => Foldable (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

fold :: Monoid m => Comp f g m -> m

foldMap :: Monoid m => (a -> m) -> Comp f g a -> m

foldr :: (a -> b -> b) -> b -> Comp f g a -> b

foldr' :: (a -> b -> b) -> b -> Comp f g a -> b

foldl :: (b -> a -> b) -> b -> Comp f g a -> b

foldl' :: (b -> a -> b) -> b -> Comp f g a -> b

foldr1 :: (a -> a -> a) -> Comp f g a -> a

foldl1 :: (a -> a -> a) -> Comp f g a -> a

toList :: Comp f g a -> [a]

null :: Comp f g a -> Bool

length :: Comp f g a -> Int

elem :: Eq a => a -> Comp f g a -> Bool

maximum :: Ord a => Comp f g a -> a

minimum :: Ord a => Comp f g a -> a

sum :: Num a => Comp f g a -> a

product :: Num a => Comp f g a -> a

(Traversable f, Traversable g) => Traversable (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Comp f g a -> f0 (Comp f g b)

sequenceA :: Applicative f0 => Comp f g (f0 a) -> f0 (Comp f g a)

mapM :: Monad m => (a -> m b) -> Comp f g a -> m (Comp f g b)

sequence :: Monad m => Comp f g (m a) -> m (Comp f g a)

(Alternative f, Alternative g) => Alternative (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

empty :: Comp f g a

(<|>) :: Comp f g a -> Comp f g a -> Comp f g a

some :: Comp f g a -> Comp f g [a]

many :: Comp f g a -> Comp f g [a]

(Functor f, Eq1 f, Eq1 g) => Eq1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftEq :: (a -> b -> Bool) -> Comp f g a -> Comp f g b -> Bool

(Functor f, Ord1 f, Ord1 g) => Ord1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftCompare :: (a -> b -> Ordering) -> Comp f g a -> Comp f g b -> Ordering

(Functor f, Read1 f, Read1 g) => Read1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Comp f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Comp f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Comp f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Comp f g a]

(Functor f, Show1 f, Show1 g) => Show1 (Comp f g)

Defined in Control.Monad.Freer.Church

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Comp f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Comp f g a] -> ShowS

Functor f => Apply (Chain1 (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f)

Defined in Data.HFunctor.Chain

Methods

(<.>) :: Chain1 Comp f (a -> b) -> Chain1 Comp f a -> Chain1 Comp f b

(.>) :: Chain1 Comp f a -> Chain1 Comp f b -> Chain1 Comp f b

(<.) :: Chain1 Comp f a -> Chain1 Comp f b -> Chain1 Comp f a

liftF2 :: (a -> b -> c) -> Chain1 Comp f a -> Chain1 Comp f b -> Chain1 Comp f c

Functor f => Bind (Chain1 (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f)

Chain1 Comp is the free "semigroup in the semigroupoidal category of endofunctors enriched by Comp" --- aka, the free Bind.

Defined in Data.HFunctor.Chain

Methods

(>>-) :: Chain1 Comp f a -> (a -> Chain1 Comp f b) -> Chain1 Comp f b

join :: Chain1 Comp f (Chain1 Comp f a) -> Chain1 Comp f a

(Functor f, Eq1 f, Eq1 g, Eq a) => Eq (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

(==) :: Comp f g a -> Comp f g a -> Bool

(/=) :: Comp f g a -> Comp f g a -> Bool

(Functor f, Ord1 f, Ord1 g, Ord a) => Ord (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

compare :: Comp f g a -> Comp f g a -> Ordering

(<) :: Comp f g a -> Comp f g a -> Bool

(<=) :: Comp f g a -> Comp f g a -> Bool

(>) :: Comp f g a -> Comp f g a -> Bool

(>=) :: Comp f g a -> Comp f g a -> Bool

max :: Comp f g a -> Comp f g a -> Comp f g a

min :: Comp f g a -> Comp f g a -> Comp f g a

(Functor f, Read1 f, Read1 g, Read a) => Read (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

readsPrec :: Int -> ReadS (Comp f g a)

readList :: ReadS [Comp f g a]

readPrec :: ReadPrec (Comp f g a)

readListPrec :: ReadPrec [Comp f g a]

(Functor f, Show1 f, Show1 g, Show a) => Show (Comp f g a)

Defined in Control.Monad.Freer.Church

Methods

showsPrec :: Int -> Comp f g a -> ShowS

show :: Comp f g a -> String

showList :: [Comp f g a] -> ShowS

Monad (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f)

Chain Comp Identity is the free "monoid in the monoidal category of endofunctors enriched by Comp" --- aka, the free Monad.

Defined in Data.HFunctor.Chain

Methods

(>>=) :: Chain Comp Identity f a -> (a -> Chain Comp Identity f b) -> Chain Comp Identity f b

(>>) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f b

return :: a -> Chain Comp Identity f a

fail :: String -> Chain Comp Identity f a

Applicative (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f)

Defined in Data.HFunctor.Chain

Methods

pure :: a -> Chain Comp Identity f a

(<*>) :: Chain Comp Identity f (a -> b) -> Chain Comp Identity f a -> Chain Comp Identity f b

liftA2 :: (a -> b -> c) -> Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f c

(*>) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f b

(<*) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f a

Apply (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f)

Defined in Data.HFunctor.Chain

Methods

(<.>) :: Chain Comp Identity f (a -> b) -> Chain Comp Identity f a -> Chain Comp Identity f b

(.>) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f b

(<.) :: Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f a

liftF2 :: (a -> b -> c) -> Chain Comp Identity f a -> Chain Comp Identity f b -> Chain Comp Identity f c

Bind (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f)

Defined in Data.HFunctor.Chain

Methods

(>>-) :: Chain Comp Identity f a -> (a -> Chain Comp Identity f b) -> Chain Comp Identity f b

join :: Chain Comp Identity f (Chain Comp Identity f a) -> Chain Comp Identity f a

type NonEmptyBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

type NonEmptyBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Free1

type FunctorBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Associative

type FunctorBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Functor

type ListBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type)

Defined in Data.HBifunctor.Tensor

type ListBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Free

comp :: f (g a) -> Comp f g a

"Smart constructor" for Comp that doesn't require Functor f.