effect-handlers-0.1.0.0

Safe HaskellNone
LanguageHaskell2010

Control.Effects.Cont.Eff

Description

This implementation of the efffect monad uses hand rolled Free with hand rolled "inlined" codensity transformation (CPS-ish). It is supposed to be the fastest since it has no extra abstractions.

Synopsis

Documentation

data Eff r a

Instances

type Handler e r a b = Comp e r a b -> Res r b

Handler is a function that takes a result or an effect and a continuation |and handles it.

e is the effect functor you are handling

r represents the type of the type list of the remaining effects. Usually you want to be polymorphic in this.

a is the result type of the program you will handle

b is the result of handled computation.

data Comp e r a b

Comp represents a computation. It is either a pure value or a computation that needs further evaluation and effect handling.

Constructors

Value a 
Comp (e (Res r b)) 

data Res r a

Result structure of the program is isomorphic to `Free (Union r) a`

Instances

effect :: (forall b. (a -> Res r b) -> Union r (Res r b)) -> Eff r a

effect is meant to be used as a helper function for defining new effects. See predefined effects for examples. Good way to use it is to pass in a lambda expression with explicit k for continuation. You will need to manually inj into the Union because of some GHC limitations.

runPure :: Eff [] a -> a

A program without effects is guaranteed to be pure so you can safely convert it into a value.

runPureRes :: Res [] a -> a

Like runPure but for program results. You only need this for implementing some handlers.

handle :: (Functor e, Typeable e) => Handler e r a b -> Eff (e : r) a -> Eff r b

Use a Handler on an Eff program to stripe away the first layer of effects. There are some issues if you are using a handler that is somewhat polymorphic in e As the compiler cannot figure out which effect are you handling. Currently the best solution seems to be to manually specify type of the handler such that it is monomorphic in e. Sorry.

finish :: Eff r a -> Res r a

Finish a program and convert it into a result structure.

continue :: Res r a -> Eff r a

Convert a result back into a program in order to compose it. This function might not be needed and might introduce some performance issues (it is used in handle) but we didn't find a way to drop it.

inj :: (Typeable f, Functor f, Member f r) => f a -> Union r a

Smart constructor for Union. Injects the functor into any union of which the said functor is a member. Please note that only the type constructor need be a Typeable.

class Member f r

The Member type clas denotes that f is a member of type list r

Instances

Member x t => Member x ((:) (* -> *) h t) 
Member h ((:) (* -> *) h t) 

class Typeable a

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

Instances

Typeable * Bool 
Typeable * Char 
Typeable * Double 
Typeable * Float 
Typeable * Int 
Typeable * Integer 
Typeable * Ordering 
Typeable * RealWorld 
Typeable * Word 
Typeable * Word8 
Typeable * Word16 
Typeable * Word32 
Typeable * Word64 
Typeable * () 
Typeable * TypeRep 
Typeable * TyCon 
(Typeable (k1 -> k) s, Typeable k1 a) => Typeable k (s a)

Kind-polymorphic Typeable instance for type application

Typeable ((* -> *) -> * -> *) Free 
Typeable ((* -> *) -> Constraint) Alternative 
Typeable ((* -> *) -> Constraint) Applicative 
Typeable (* -> * -> * -> * -> * -> * -> * -> *) (,,,,,,) 
Typeable (* -> * -> * -> * -> * -> * -> *) (,,,,,) 
Typeable (* -> * -> * -> * -> * -> *) (,,,,) 
Typeable (* -> * -> * -> * -> *) (,,,) 
Typeable (* -> * -> * -> *) (,,) 
Typeable (* -> * -> * -> *) STArray 
Typeable (* -> * -> *) (->) 
Typeable (* -> * -> *) Either 
Typeable (* -> * -> *) (,) 
Typeable (* -> * -> *) ST 
Typeable (* -> * -> *) Array 
Typeable (* -> * -> *) STRef 
Typeable (* -> * -> *) Reader 
Typeable (* -> * -> *) Writer 
Typeable (* -> * -> *) State 
Typeable (* -> * -> *) Exception 
Typeable (* -> * -> *) Search 
Typeable (* -> * -> *) Reader 
Typeable (* -> * -> *) Writer 
Typeable (* -> * -> *) State 
Typeable (* -> * -> *) Exception 
Typeable (* -> * -> *) Search 
Typeable (* -> * -> *) Reader 
Typeable (* -> * -> *) Writer 
Typeable (* -> * -> *) State 
Typeable (* -> * -> *) Exception 
Typeable (* -> * -> *) Search 
Typeable (* -> *) [] 
Typeable (* -> *) Ratio 
Typeable (* -> *) IO 
Typeable (* -> *) Ptr 
Typeable (* -> *) FunPtr 
Typeable (* -> *) Maybe 
Typeable (* -> *) LiftIO 
Typeable (* -> *) LiftIO 
Typeable (* -> *) LiftIO 
Typeable (* -> Constraint) Monoid 
Typeable (k -> *) (Proxy k) 
Typeable (k -> k -> *) (Coercion k) 
Typeable (k -> k -> *) ((:~:) k)