Copyright	(c) Justin Le 2019
License	BSD3
Maintainer	justin@jle.im
Stability	experimental
Portability	non-portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Control.Monad.Freer.Church

Contents

Free
- Interpretation
- Folding
Free1
Comp

Description

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.

Synopsis

newtype Free f a = Free {
- runFree :: forall r. (a -> r) -> (forall s. f s -> (s -> r) -> r) -> r
}
reFree :: (MonadFree f m, Functor f) => Free f a -> m a
liftFree :: f ~> Free f
interpretFree :: Monad g => (f ~> g) -> Free f ~> g
retractFree :: Monad f => Free f ~> f
hoistFree :: (f ~> g) -> Free f ~> Free g
foldFree :: Functor f => (a -> r) -> (f r -> r) -> Free f a -> r
foldFree' :: (a -> r) -> (forall s. f s -> (s -> r) -> r) -> Free f a -> r
foldFreeC :: (a -> r) -> (Coyoneda f r -> r) -> Free f a -> r
newtype Free1 f a where
- Free1 {
  - runFree1 :: forall r. (forall s. f s -> (s -> a) -> r) -> (forall s. f s -> (s -> r) -> r) -> r
  }
- pattern DoneF1 :: Functor f => f a -> Free1 f a
- pattern MoreF1 :: Functor f => f (Free1 f a) -> Free1 f a
reFree1 :: (MonadFree f m, Functor f) => Free1 f a -> m a
toFree :: Free1 f ~> Free f
liftFree1 :: f ~> Free1 f
interpretFree1 :: Bind g => (f ~> g) -> Free1 f ~> g
retractFree1 :: Bind f => Free1 f ~> f
hoistFree1 :: (f ~> g) -> Free1 f ~> Free1 g
free1Comp :: Free1 f ~> Comp f (Free f)
matchFree1 :: forall f. Functor f => Free1 f ~> (f :+: Comp f (Free1 f))
foldFree1 :: Functor f => (f a -> r) -> (f r -> r) -> Free1 f a -> r
foldFree1' :: (forall s. f s -> (s -> a) -> r) -> (forall s. f s -> (s -> r) -> r) -> Free1 f a -> r
foldFree1C :: (Coyoneda f a -> r) -> (Coyoneda f r -> r) -> Free1 f a -> r
data Comp f g a where
- forall x. (f x) :>>= (x -> g a)
- pattern Comp :: Functor f => f (g a) -> Comp f g a
comp :: f (g a) -> Comp f g a

`Free`

newtype Free f a Source #

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

Instances details

HBind Free Source #
Instance details Defined in Data.HFunctor Methods hbind :: forall (f :: k -> Type) (g :: k -> Type). (f ~> Free g) -> Free f ~> Free g Source # hjoin :: forall (f :: k -> Type). Free (Free f) ~> Free f Source #
Inject Free Source #
Instance details Defined in Data.HFunctor Methods inject :: forall (f :: k -> Type). f ~> Free f Source #
FreeOf Monad Free Source #
Instance details Defined in Data.HFunctor.Final Associated Types type FreeFunctorBy Free :: (Type -> Type) -> Constraint Source # Methods fromFree :: forall (f :: Type -> Type). Free f ~> Final Monad f Source # toFree :: forall (f :: Type -> Type). FreeFunctorBy Free f => Final Monad f ~> Free f Source #
HFunctor Free Source #
Instance details Defined in Data.HFunctor.Internal Methods hmap :: forall (f :: k -> Type) (g :: k -> Type). (f ~> g) -> Free f ~> Free g Source #
Monad f => Interpret Free (f :: Type -> Type) Source #	A free `Monad`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Free f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Free g ~> f Source #
MonadFree f (Free f) Source #
Instance details Defined in Control.Monad.Freer.Church Methods wrap :: f (Free f a) -> Free f a #
Foldable f => Foldable (Free f) Source #
Instance details Defined in Control.Monad.Freer.Church Methods fold :: Monoid m => Free f m -> m # foldMap :: Monoid m => (a -> m) -> Free f a -> 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 #
(Functor f, Eq1 f) => Eq1 (Free f) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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 #
Traversable f => Traversable (Free f) Source #
Instance details 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) #
Applicative (Free f) Source #
Instance details 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 #
Functor (Free f) Source #
Instance details Defined in Control.Monad.Freer.Church Methods fmap :: (a -> b) -> Free f a -> Free f b # (<$) :: a -> Free f b -> Free f a #
Monad (Free f) Source #
Instance details 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 #
Pointed (Free f) Source #
Instance details Defined in Control.Monad.Freer.Church Methods point :: a -> Free f a #
Apply (Free f) Source #
Instance details 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 #
Bind (Free f) Source #
Instance details 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 #
(Functor f, Read1 f, Read a) => Read (Free f a) Source #	Read in terms of `pure` and `wrap`.
Instance details 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) Source #	Show in terms of `pure` and `wrap`.
Instance details Defined in Control.Monad.Freer.Church Methods showsPrec :: Int -> Free f a -> ShowS # show :: Free f a -> String # showList :: [Free f a] -> ShowS #
(Functor f, Eq1 f, Eq a) => Eq (Free f a) Source #
Instance details 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) Source #
Instance details 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 #
type FreeFunctorBy Free Source #
Instance details Defined in Data.HFunctor.Final type FreeFunctorBy Free = Unconstrained :: (Type -> Type) -> Constraint

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

Convert a Free f into any instance of MonadFree f.

Interpretation

liftFree :: f ~> Free f Source #

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 Source #

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

This is interpret.

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

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

This is retract.

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

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

Folding

foldFree Source #

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 Source #

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

foldFreeC Source #

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 Source #

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

Instances details

HBind Free1 Source #
Instance details Defined in Data.HFunctor Methods hbind :: forall (f :: k -> Type) (g :: k -> Type). (f ~> Free1 g) -> Free1 f ~> Free1 g Source # hjoin :: forall (f :: k -> Type). Free1 (Free1 f) ~> Free1 f Source #
Inject Free1 Source #
Instance details Defined in Data.HFunctor Methods inject :: forall (f :: k -> Type). f ~> Free1 f Source #
FreeOf Bind Free1 Source #
Instance details Defined in Data.HFunctor.Final Associated Types type FreeFunctorBy Free1 :: (Type -> Type) -> Constraint Source # Methods fromFree :: forall (f :: Type -> Type). Free1 f ~> Final Bind f Source # toFree :: forall (f :: Type -> Type). FreeFunctorBy Free1 f => Final Bind f ~> Free1 f Source #
HFunctor Free1 Source #
Instance details Defined in Data.HFunctor.Internal Methods hmap :: forall (f :: k -> Type) (g :: k -> Type). (f ~> g) -> Free1 f ~> Free1 g Source #
Bind f => Interpret Free1 (f :: Type -> Type) Source #	A free `Bind`
Instance details Defined in Data.HFunctor.Interpret Methods retract :: Free1 f ~> f Source # interpret :: forall (g :: k -> Type). (g ~> f) -> Free1 g ~> f Source #
Foldable f => Foldable (Free1 f) Source #
Instance details Defined in Control.Monad.Freer.Church Methods fold :: Monoid m => Free1 f m -> m # foldMap :: Monoid m => (a -> m) -> Free1 f a -> 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 #
(Functor f, Eq1 f) => Eq1 (Free1 f) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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 #
Traversable f => Traversable (Free1 f) Source #
Instance details 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 (Free1 f) Source #
Instance details Defined in Control.Monad.Freer.Church Methods fmap :: (a -> b) -> Free1 f a -> Free1 f b # (<$) :: a -> Free1 f b -> Free1 f a #
Apply (Free1 f) Source #
Instance details 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 #
Bind (Free1 f) Source #
Instance details 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 #
Foldable1 f => Foldable1 (Free1 f) Source #
Instance details 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 #
Traversable1 f => Traversable1 (Free1 f) Source #
Instance details 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) #
(Functor f, Read1 f, Read a) => Read (Free1 f a) Source #	Read in terms of `DoneF1` and `MoreF1`.
Instance details 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) Source #	Show in terms of `DoneF1` and `MoreF1`.
Instance details Defined in Control.Monad.Freer.Church Methods showsPrec :: Int -> Free1 f a -> ShowS # show :: Free1 f a -> String # showList :: [Free1 f a] -> ShowS #
(Functor f, Eq1 f, Eq a) => Eq (Free1 f a) Source #
Instance details 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) Source #
Instance details 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 #
type FreeFunctorBy Free1 Source #
Instance details Defined in Data.HFunctor.Final type FreeFunctorBy Free1 = Unconstrained :: (Type -> Type) -> Constraint

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

Convert a Free1 f into any instance of MonadFree f.

toFree :: Free1 f ~> Free f Source #

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 Source #

Inject an f into a Free1 f

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

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 Source #

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 Source #

Map the underlying functor under a Free1.

Conversion

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

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)) Source #

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 Source #

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 Source #

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 Source #

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

`Comp`

data Comp f g a Source #

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

forall x. (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

Instances details

HFunctor (Comp f :: (k -> Type) -> k -> Type) Source #
Instance details Defined in Data.HFunctor.Internal Methods hmap :: forall (f0 :: k0 -> Type) (g :: k0 -> Type). (f0 ~> g) -> Comp f f0 ~> Comp f g Source #
HBifunctor (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Data.HFunctor.Internal Methods hleft :: forall (f :: k -> Type) (j :: k -> Type) (g :: k -> Type). (f ~> j) -> Comp f g ~> Comp j g Source # hright :: forall (g :: k -> Type) (l :: k -> Type) (f :: k -> Type). (g ~> l) -> Comp f g ~> Comp f l Source # hbimap :: forall (f :: k -> Type) (j :: k -> Type) (g :: k -> Type) (l :: k -> Type). (f ~> j) -> (g ~> l) -> Comp f g ~> Comp j l Source #
Applicative f => Inject (Comp f :: (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Data.HFunctor Methods inject :: forall (f0 :: k -> Type). f0 ~> Comp f f0 Source #
Associative (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Data.HBifunctor.Associative Associated Types type NonEmptyBy Comp :: (Type -> Type) -> Type -> Type Source # type FunctorBy Comp :: (Type -> Type) -> Constraint Source # Methods associating :: forall (f :: Type -> Type) (g :: Type -> Type) (h :: Type -> Type). (FunctorBy Comp f, FunctorBy Comp g, FunctorBy Comp h) => Comp f (Comp g h) <~> Comp (Comp f g) h Source # appendNE :: forall (f :: Type -> Type). Comp (NonEmptyBy Comp f) (NonEmptyBy Comp f) ~> NonEmptyBy Comp f Source # matchNE :: forall (f :: Type -> Type). FunctorBy Comp f => NonEmptyBy Comp f ~> (f :+: Comp f (NonEmptyBy Comp f)) Source # consNE :: forall (f :: Type -> Type). Comp f (NonEmptyBy Comp f) ~> NonEmptyBy Comp f Source # toNonEmptyBy :: forall (f :: Type -> Type). Comp f f ~> NonEmptyBy Comp f Source #
Bind f => SemigroupIn (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f Source #	Instances of `Bind` are semigroups in the semigroupoidal category on `Comp`.
Instance details Defined in Data.HBifunctor.Associative Methods biretract :: Comp f f ~> f Source # binterpret :: forall (g :: Type -> Type) (h :: Type -> Type). (g ~> f) -> (h ~> f) -> Comp g h ~> f Source #
Tensor (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity Source #
Instance details Defined in Data.HBifunctor.Tensor Associated Types type ListBy Comp :: (Type -> Type) -> Type -> Type Source # Methods intro1 :: forall (f :: Type -> Type). f ~> Comp f Identity Source # intro2 :: forall (g :: Type -> Type). g ~> Comp Identity g Source # elim1 :: forall (f :: Type -> Type). FunctorBy Comp f => Comp f Identity ~> f Source # elim2 :: forall (g :: Type -> Type). FunctorBy Comp g => Comp Identity g ~> g Source # appendLB :: forall (f :: Type -> Type). Comp (ListBy Comp f) (ListBy Comp f) ~> ListBy Comp f Source # splitNE :: forall (f :: Type -> Type). NonEmptyBy Comp f ~> Comp f (ListBy Comp f) Source # splittingLB :: forall (f :: Type -> Type). ListBy Comp f <~> (Identity :+: Comp f (ListBy Comp f)) Source # toListBy :: forall (f :: Type -> Type). Comp f f ~> ListBy Comp f Source # fromNE :: forall (f :: Type -> Type). NonEmptyBy Comp f ~> ListBy Comp f Source #
(Bind f, Monad f) => MonoidIn (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f Source #	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`.
Instance details Defined in Data.HBifunctor.Tensor Methods pureT :: Identity ~> f Source #
(Foldable f, Foldable g) => Foldable (Comp f g) Source #
Instance details 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 # 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 #
(Functor f, Eq1 f, Eq1 g) => Eq1 (Comp f g) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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) Source #
Instance details 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 #
(Traversable f, Traversable g) => Traversable (Comp f g) Source #
Instance details 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) Source #
Instance details 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] #
(Applicative f, Applicative g) => Applicative (Comp f g) Source #
Instance details 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 #
Functor g => Functor (Comp f g) Source #
Instance details 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 #
(Alt f, Alt g) => Alt (Comp f g) Source #	Since: 0.3.6.0
Instance details Defined in Control.Monad.Freer.Church Methods (<!>) :: Comp f g a -> Comp f g a -> Comp f g a # some :: Applicative (Comp f g) => Comp f g a -> Comp f g [a] # many :: Applicative (Comp f g) => Comp f g a -> Comp f g [a] #
(Apply f, Apply g) => Apply (Comp f g) Source #	Since: 0.3.6.0
Instance details Defined in Control.Monad.Freer.Church Methods (<.>) :: Comp f g (a -> b) -> Comp f g a -> Comp f g b # (.>) :: Comp f g a -> Comp f g b -> Comp f g b # (<.) :: Comp f g a -> Comp f g b -> Comp f g a # liftF2 :: (a -> b -> c) -> Comp f g a -> Comp f g b -> Comp f g c #
Functor f => Apply (Chain1 (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) f) Source #
Instance details 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) Source #	`Chain1 Comp` is the free "semigroup in the semigroupoidal category of endofunctors enriched by `Comp`" --- aka, the free `Bind`.
Instance details 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 #
(Plus f, Plus g) => Plus (Comp f g) Source #	Since: 0.3.6.0
Instance details Defined in Control.Monad.Freer.Church Methods zero :: Comp f g a #
(Functor f, Read1 f, Read1 g, Read a) => Read (Comp f g a) Source #
Instance details 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) Source #
Instance details 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 #
(Functor f, Eq1 f, Eq1 g, Eq a) => Eq (Comp f g a) Source #
Instance details 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) Source #
Instance details 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 #
Applicative (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source #
Instance details 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 #
Monad (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source #	`Chain Comp Identity` is the free "monoid in the monoidal category of endofunctors enriched by `Comp`" --- aka, the free `Monad`.
Instance details 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 #
Apply (Chain (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Identity f) Source #
Instance details 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) Source #
Instance details 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 FunctorBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Data.HBifunctor.Associative type FunctorBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Functor
type NonEmptyBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Data.HBifunctor.Associative type NonEmptyBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Free1
type ListBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) Source #
Instance details Defined in Data.HBifunctor.Tensor type ListBy (Comp :: (Type -> Type) -> (Type -> Type) -> Type -> Type) = Free

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

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