Control.Monad.Freer

Effect Monad

data Eff effs a

The Eff monad provides a way to use effects in Haskell, in such a way that different types of effects can be interleaved, and so that the produced code is efficient.

Instances

Monad (Eff effs)

Methods

(>>=) :: Eff effs a -> (a -> Eff effs b) -> Eff effs b

(>>) :: Eff effs a -> Eff effs b -> Eff effs b

return :: a -> Eff effs a

fail :: String -> Eff effs a

Functor (Eff effs)

Methods

fmap :: (a -> b) -> Eff effs a -> Eff effs b

(<$) :: a -> Eff effs b -> Eff effs a

Applicative (Eff effs)

Methods

pure :: a -> Eff effs a

(<*>) :: Eff effs (a -> b) -> Eff effs a -> Eff effs b

(*>) :: Eff effs a -> Eff effs b -> Eff effs b

(<*) :: Eff effs a -> Eff effs b -> Eff effs a

Member NonDet effs => Alternative (Eff effs)

Methods

empty :: Eff effs a

(<|>) :: Eff effs a -> Eff effs a -> Eff effs a

some :: Eff effs a -> Eff effs [a]

many :: Eff effs a -> Eff effs [a]

Member NonDet effs => MonadPlus (Eff effs)

Methods

mzero :: Eff effs a

mplus :: Eff effs a -> Eff effs a -> Eff effs a

Effect Constraints

class FindElem t r => Member t r

This type class is used for two following purposes:

• As a Constraint it guarantees that t :: * -> * is a member of a type-list r :: [* -> *].
• Provides a way how to inject/project t :: * -> * into/from a Union, respectively.

Following law has to hold:

prj . inj === Just

Minimal complete definition

inj, prj

Instances

FindElem t r => Member t r

Methods

inj :: t a -> Union * r a

prj :: Union * r a -> Maybe (t a)

type family Members m r :: Constraint where ...

Equations

Members (t ': c) r = (Member t r, Members c r)

Members '[] r = ()

Sending Arbitrary Effect

send :: Member eff effs => eff a -> Eff effs a

Send a request and wait for a reply.

Handling Effects

type Arr effs a b = a -> Eff effs b

Effectful arrow type: a function from a :: * to b :: * that also does effects denoted by effs :: [* -> *].

run :: Eff '[] a -> a

Runs a set of Effects. Requires that all effects are consumed. Typically composed as follows:

run . runEff1 eff1Arg . runEff2 eff2Arg1 eff2Arg2 $ someProgram

runM :: Monad m => Eff '[m] a -> m a

Runs a set of Effects. Requires that all effects are consumed, except for a single effect known to be a monad. The value returned is a computation in that monad. This is useful for plugging in traditional transformer stacks.

Building Effect Handlers

runNat :: Member m effs => (forall a. eff a -> m a) -> Eff (eff ': effs) b -> Eff effs b

Variant of handleRelay simplified for the common case.

runNatS :: Member m effs => s -> (forall a. s -> eff a -> m (s, a)) -> Eff (eff ': effs) b -> Eff effs b

Variant of handleRelayS simplified for the common case.

handleRelay

Arguments

:: (a -> Eff effs b)

Handle a pure value.

-> (forall v. eff v -> Arr effs v b -> Eff effs b)

Handle a request for effect of type eff :: * -> *.

-> Eff (eff ': effs) a

-> Eff effs b

Result with effects of type eff :: * -> * handled.

Given a request, either handle it or relay it.

handleRelayS

Arguments

:: s

-> (s -> a -> Eff effs b)

Handle a pure value.

-> (forall v. s -> eff v -> (s -> Arr effs v b) -> Eff effs b)

Handle a request for effect of type eff :: * -> *.

-> Eff (eff ': effs) a

-> Eff effs b

Result with effects of type eff :: * -> * handled.

Parameterized handleRelay. Allows sending along some state of type s :: * to be handled for the target effect, or relayed to a handler that can- handle the target effect.