Copyright	(c) Justin Le 2025
License	BSD3
Maintainer	[email protected]
Stability	experimental
Portability	non-portable
Safe Haskell	None
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 :: Type -> Type) a = Free {
- runFree :: forall r. (a -> r) -> (forall s. f s -> (s -> r) -> r) -> r
}
reFree :: forall (f :: Type -> Type) m a. (MonadFree f m, Functor f) => Free f a -> m a
liftFree :: f x -> Free f x
interpretFree :: forall (g :: Type -> Type) (f :: Type -> Type). Monad g => (f ~> g) -> Free f ~> g
retractFree :: forall (f :: Type -> Type). Monad f => Free f ~> f
hoistFree :: forall (f :: Type -> Type) (g :: Type -> Type). (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 :: forall a r (f :: Type -> Type). (a -> r) -> (Coyoneda f r -> r) -> Free f a -> r
newtype Free1 (f :: Type -> Type) 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 :: forall (f :: Type -> Type) m a. (MonadFree f m, Functor f) => Free1 f a -> m a
toFree :: forall (f :: Type -> Type) x. Free1 f x -> Free f x
liftFree1 :: f x -> Free1 f x
interpretFree1 :: forall (g :: Type -> Type) (f :: Type -> Type). Bind g => (f ~> g) -> Free1 f ~> g
retractFree1 :: forall (f :: Type -> Type). Bind f => Free1 f ~> f
hoistFree1 :: forall (f :: Type -> Type) (g :: Type -> Type). (f ~> g) -> Free1 f ~> Free1 g
free1Comp :: forall (f :: Type -> Type) x. Free1 f x -> Comp f (Free f) x
matchFree1 :: forall (f :: Type -> Type). 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 :: forall (f :: Type -> Type) a r. (Coyoneda f a -> r) -> (Coyoneda f r -> r) -> Free1 f a -> r
data Comp (f :: Type -> Type) (g :: k -> Type) (a :: k) where
- (f x) :>>= (x -> g a)
- pattern Comp :: forall {k} f g a. Functor f => f (g a) -> Comp f g a
comp :: forall {k} f g (a :: k). f (g a) -> Comp f g a

`Free`

newtype Free (f :: Type -> Type) 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 :: Type -> Type) (g :: Type -> Type). (f ~> Free g) -> Free f ~> Free g Source #

hjoin :: forall (f :: Type -> Type). Free (Free f) ~> Free f Source #

Inject Free Source #

Instance details

Defined in Data.HFunctor

Methods

inject :: forall (f :: Type -> Type). f ~> Free f Source #

FreeOf Monad Free Source #

Instance details

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Free
Instance details Defined in Data.HFunctor.Final type FreeFunctorBy Free = Unconstrained :: (Type -> Type) -> Constraint

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 :: Type -> Type) (g :: Type -> 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 :: Type -> Type). (g ~> f) -> Free g ~> f Source #

MonadFree f (Free f) Source #

Instance details

:: Functor f
=> (a -> r)	handle `pure`
-> (f r -> r)	handle `wrap`
-> Free f a
-> r

:: forall a r (f :: Type -> Type). (a -> r)	handle `pure`
-> (Coyoneda f r -> r)	handle `wrap`
-> Free f a
-> r

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

:: Functor f
=> (f a -> r)	handle `DoneF1`.
-> (f r -> r)	handle `MoreF1`.
-> Free1 f a
-> r

Free

Instances

Interpretation

Folding

Free1

Instances

Interpretation

Conversion

Folding

Comp

Instances

`Free`

`Free1`

`Comp`