Safe Haskell	Safe
Language	Haskell2010

Control.Eff

Contents

Effect type
Effect list

Description

A monadic library for implementing effectful computation in a modular way.

This module provides the Eff monad - the base type for all effectful computation. The Member typeclass is the main interface for describing which effects are necessary for a given function.

Consult the Control.Eff.QuickStart module and the readme for gentle introductions.

To use extensible effects effectively some language extensions are necessary/recommended.

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MonoLocalBinds #-}

Synopsis

run :: Eff '[] w -> w
data Eff r a
class FindElem t r => Member (t :: * -> *) r
class Member t r => SetMember (tag :: k -> * -> *) (t :: * -> *) r | tag r -> t
type family (ms :: [* -> *]) <:: r where ...

Effect type

run :: Eff '[] w -> w Source #

Get the result from a pure computation

A pure computation has type Eff '[] a. The empty effect-list indicates that no further effects need to be handled.

data Eff r a Source #

The monad that all effects in this library are based on.

An effectful computation is a value of type `Eff r a`. In this signature, r is a type-level list of effects that are being requested and need to be handled inside an effectful computation. a is the computation's result similar to other monads.

A computation's result can be retrieved via the run function. However, all effects used in the computation need to be handled by the use of the effects' run* functions before unwrapping the final result. For additional details, see the documentation of the effects you are using.

Instances

(MonadBase b m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r) => MonadBase b (Eff r) Source #
Instance details Defined in Control.Eff.Internal Methods liftBase :: b α -> Eff r α #
MonadBase m m => MonadBaseControl m (Eff (Lift m ': ([] :: [* -> *]))) Source #
Instance details Defined in Control.Eff.Internal Associated Types type StM (Eff (Lift m ': [])) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Lift m ': [])) m -> m a) -> Eff (Lift m ': []) a # restoreM :: StM (Eff (Lift m ': [])) a -> Eff (Lift m ': []) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Writer w ': r)) #
Instance details Defined in Control.Eff.Writer.Strict Associated Types type StM (Eff (Writer w ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Writer w ': r)) m -> m a) -> Eff (Writer w ': r) a # restoreM :: StM (Eff (Writer w ': r)) a -> Eff (Writer w ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Writer w ': r)) #
Instance details Defined in Control.Eff.Writer.Lazy Associated Types type StM (Eff (Writer w ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Writer w ': r)) m -> m a) -> Eff (Writer w ': r) a # restoreM :: StM (Eff (Writer w ': r)) a -> Eff (Writer w ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) s, MonadBaseControl m (Eff s)) => MonadBaseControl m (Eff (Reader e ': s)) #
Instance details Defined in Control.Eff.Reader.Strict Associated Types type StM (Eff (Reader e ': s)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Reader e ': s)) m -> m a) -> Eff (Reader e ': s) a # restoreM :: StM (Eff (Reader e ': s)) a -> Eff (Reader e ': s) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (State s ': r)) #
Instance details Defined in Control.Eff.State.Strict Associated Types type StM (Eff (State s ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (State s ': r)) m -> m a) -> Eff (State s ': r) a # restoreM :: StM (Eff (State s ': r)) a -> Eff (State s ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) s, MonadBaseControl m (Eff s)) => MonadBaseControl m (Eff (Reader e ': s)) #
Instance details Defined in Control.Eff.Reader.Lazy Associated Types type StM (Eff (Reader e ': s)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Reader e ': s)) m -> m a) -> Eff (Reader e ': s) a # restoreM :: StM (Eff (Reader e ': s)) a -> Eff (Reader e ': s) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (OnDemandState s ': r)) #
Instance details Defined in Control.Eff.State.OnDemand Associated Types type StM (Eff (OnDemandState s ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (OnDemandState s ': r)) m -> m a) -> Eff (OnDemandState s ': r) a # restoreM :: StM (Eff (OnDemandState s ': r)) a -> Eff (OnDemandState s ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (State s ': r)) #
Instance details Defined in Control.Eff.State.Lazy Associated Types type StM (Eff (State s ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (State s ': r)) m -> m a) -> Eff (State s ': r) a # restoreM :: StM (Eff (State s ': r)) a -> Eff (State s ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (NdetEff ': r)) #
Instance details Defined in Control.Eff.NdetEff Associated Types type StM (Eff (NdetEff ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (NdetEff ': r)) m -> m a) -> Eff (NdetEff ': r) a # restoreM :: StM (Eff (NdetEff ': r)) a -> Eff (NdetEff ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Fresh ': r)) #
Instance details Defined in Control.Eff.Fresh Associated Types type StM (Eff (Fresh ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Fresh ': r)) m -> m a) -> Eff (Fresh ': r) a # restoreM :: StM (Eff (Fresh ': r)) a -> Eff (Fresh ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> ) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff ((Exc e :: -> *) ': r)) #
Instance details Defined in Control.Eff.Exception Associated Types type StM (Eff (Exc e ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Exc e ': r)) m -> m a) -> Eff (Exc e ': r) a # restoreM :: StM (Eff (Exc e ': r)) a -> Eff (Exc e ': r) a #
(MonadBase m m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r, MonadBaseControl m (Eff r)) => MonadBaseControl m (Eff (Choose ': r)) #
Instance details Defined in Control.Eff.Choose Associated Types type StM (Eff (Choose ': r)) a :: * # Methods liftBaseWith :: (RunInBase (Eff (Choose ': r)) m -> m a) -> Eff (Choose ': r) a # restoreM :: StM (Eff (Choose ': r)) a -> Eff (Choose ': r) a #
Monad (Eff r) Source #
Instance details Defined in Control.Eff.Internal Methods (>>=) :: Eff r a -> (a -> Eff r b) -> Eff r b # (>>) :: Eff r a -> Eff r b -> Eff r b # return :: a -> Eff r a # fail :: String -> Eff r a #
Functor (Eff r) Source #
Instance details Defined in Control.Eff.Internal Methods fmap :: (a -> b) -> Eff r a -> Eff r b # (<$) :: a -> Eff r b -> Eff r a #
Applicative (Eff r) Source #
Instance details Defined in Control.Eff.Internal Methods pure :: a -> Eff r a # (<>) :: Eff r (a -> b) -> Eff r a -> Eff r b # liftA2 :: (a -> b -> c) -> Eff r a -> Eff r b -> Eff r c # (>) :: Eff r a -> Eff r b -> Eff r b # (<*) :: Eff r a -> Eff r b -> Eff r a #
(MonadIO m, SetMember (Lift :: (* -> ) -> -> *) (Lift m) r) => MonadIO (Eff r) Source #
Instance details Defined in Control.Eff.Internal Methods liftIO :: IO a -> Eff r a #
Member NdetEff r => Alternative (Eff r) #
Instance details Defined in Control.Eff.NdetEff Methods empty :: Eff r a # (<\|>) :: Eff r a -> Eff r a -> Eff r a # some :: Eff r a -> Eff r [a] # many :: Eff r a -> Eff r [a] #
Member Choose r => Alternative (Eff r) #	MonadPlus-like operators are expressible via choose
Instance details Defined in Control.Eff.Choose Methods empty :: Eff r a # (<\|>) :: Eff r a -> Eff r a -> Eff r a # some :: Eff r a -> Eff r [a] # many :: Eff r a -> Eff r [a] #
Member NdetEff r => MonadPlus (Eff r) #
Instance details Defined in Control.Eff.NdetEff Methods mzero :: Eff r a # mplus :: Eff r a -> Eff r a -> Eff r a #
Member Choose r => MonadPlus (Eff r) #
Instance details Defined in Control.Eff.Choose Methods mzero :: Eff r a # mplus :: Eff r a -> Eff r a -> Eff r a #
type StM (Eff (Lift m ': ([] :: [* -> *]))) a Source #
Instance details Defined in Control.Eff.Internal type StM (Eff (Lift m ': ([] :: [* -> *]))) a = a
type StM (Eff (Writer w ': r)) a #
Instance details Defined in Control.Eff.Writer.Strict type StM (Eff (Writer w ': r)) a = StM (Eff r) (a, [w])
type StM (Eff (Writer w ': r)) a #
Instance details Defined in Control.Eff.Writer.Lazy type StM (Eff (Writer w ': r)) a = StM (Eff r) (a, [w])
type StM (Eff (State s ': r)) a #
Instance details Defined in Control.Eff.State.Strict type StM (Eff (State s ': r)) a = StM (Eff r) (a, s)
type StM (Eff (OnDemandState s ': r)) a #
Instance details Defined in Control.Eff.State.OnDemand type StM (Eff (OnDemandState s ': r)) a = StM (Eff r) (a, s)
type StM (Eff (State s ': r)) a #
Instance details Defined in Control.Eff.State.Lazy type StM (Eff (State s ': r)) a = StM (Eff r) (a, s)
type StM (Eff (NdetEff ': r)) a #
Instance details Defined in Control.Eff.NdetEff type StM (Eff (NdetEff ': r)) a = StM (Eff r) [a]
type StM (Eff (Fresh ': r)) a #
Instance details Defined in Control.Eff.Fresh type StM (Eff (Fresh ': r)) a = StM (Eff r) (a, Int)
type StM (Eff (Choose ': r)) a #
Instance details Defined in Control.Eff.Choose type StM (Eff (Choose ': r)) a = StM (Eff r) [a]
type StM (Eff (Reader e ': s)) a #
Instance details Defined in Control.Eff.Reader.Strict type StM (Eff (Reader e ': s)) a = StM (Eff s) a
type StM (Eff (Reader e ': s)) a #
Instance details Defined in Control.Eff.Reader.Lazy type StM (Eff (Reader e ': s)) a = StM (Eff s) a
type StM (Eff ((Exc e :: * -> *) ': r)) a #
Instance details Defined in Control.Eff.Exception type StM (Eff ((Exc e :: * -> *) ': r)) a = StM (Eff r) (Either e a)

Effect list

class FindElem t r => Member (t :: * -> *) r Source #

Typeclass that asserts that effect t is contained inside the effect-list r.

The FindElem typeclass is an implementation detail and not required for using the effect list or implementing custom effects.

Minimal complete definition

inj, prj

Instances

FindElem t r => Member t r Source #
Instance details Defined in Data.OpenUnion Methods inj :: t v -> Union r v Source # prj :: Union r v -> Maybe (t v) Source #
t ~ s => Member t (s ': ([] :: [* -> *])) Source #	Explicit type-level equality condition is a dirty hack to eliminate the type annotation in the trivial case, such as `run (runReader () get)`. There is no ambiguity when finding instances for `Member t (a ': b ': r)`, which the second instance is selected. The only case we have to concerned about is `Member t '[s]`. But, in this case, values of definition is the same (if present), and the first one is chosen according to GHC User Manual, since the latter one is incoherent. This is the optimal choice.
Instance details Defined in Data.OpenUnion Methods inj :: t v -> Union (s ': []) v Source # prj :: Union (s ': []) v -> Maybe (t v) Source #

class Member t r => SetMember (tag :: k -> * -> *) (t :: * -> *) r | tag r -> t Source #

This class is used for emulating monad transformers

Instances

(EQU t1 t2 p, MemberU' p tag t1 (t2 ': r)) => SetMember (tag :: k -> * -> *) t1 (t2 ': r) Source #
Instance details Defined in Data.OpenUnion

type family (ms :: [* -> *]) <:: r where ... Source #

A useful operator for reducing boilerplate in signatures.

The following lines are equivalent.

(Member (Exc e) r, Member (State s) r) => ...
[ Exc e, State s ] r = ...

Equations

'[] <:: r = (() :: Constraint)
(m ': ms) <:: r = (Member m r, (<::) ms r)