Control.Eff

Original work available at: http:okmij.orgftpHgetellextensibleEff.hs. This module implements extensible effects as an alternative to monad transformers, as described in http:okmij.orgftpHgetellextensibleexteff.pdf.

Extensible Effects are implemented as typeclass constraints on an Eff[ect] datatype. A contrived example is:

• - Print a list of numbers, then print their sum. printAndSum :: (Member (Lift IO) e, Member State e) => [Integer] -> Eff e Integer printAndSum (x:xs) = do lift $ putStrLn $ show x onState (+ x) printAndSum [] = getState >>= lift . putStrLn

Documentation

data Eff r a

Instances

Monad (Eff r)

Functor (Eff r)

Applicative (Eff r)

class Member t r

Instances

Member t r => Member t (:> t' r)

Member t (:> t r)

data a :> b

A sum data type, for composing effects In GHC 7.4, we should make it a list (:>) :: (* -> *) -> (* -> List) -> List

Instances

Member t r => Member t (:> t' r)

Member t (:> t r)

run :: Eff Void w -> w

send :: (forall w. (a -> VE w r) -> Union r (VE w r)) -> Eff r a

admin :: Eff r w -> VE w r

data Reader e v

The request for a value of type e from the current environment. This environment is analogous to a parameter of type e.

Instances

Typeable2 Reader

Functor (Reader e)

runReader :: Typeable e => Eff (Reader e :> r) w -> e -> Eff r w

The handler of Reader requests. The return type shows that all Reader requests are fully handled.

getReader :: Typeable e => Member (Reader e) r => Eff r e

local :: (Typeable e, Member (Reader e) r) => (e -> e) -> Eff r a -> Eff r a

Locally rebind the value in the dynamic environment. This function both requests and admins Reader requests.

data Trace v

Instances

Functor Trace

Typeable1 Trace

trace :: Member Trace r => String -> Eff r ()

runTrace :: Eff (Trace :> Void) w -> IO w

data Yield a v

The yield request: reporting the value of type e and suspending the coroutine (For simplicity, a co-routine reports a value but accepts unit)

Instances

Typeable2 Yield

Functor (Yield a)

yield :: (Typeable a, Member (Yield a) r) => a -> Eff r ()

runC :: Typeable a => Eff (Yield a :> r) w -> Eff r (Y r a)

Launch a thread and report its status.

data Y r a

Status of a thread: done or reporting the value of the type a (For simplicity, a co-routine reports a value but accepts unit)

Constructors

Done

Y a (() -> Eff r (Y r a))

data State s w

Strict state. Example: Implementing Fresh in terms of State but not revealing that fact. runFresh' :: (Typeable i, Enum i, Num i) => Eff (Fresh i :> r) w -> i -> Eff r w runFresh' m s = fst $ runState s (loop $ admin m) where loop (Val x) = return x loop (E u) = case decomp u of Right (Fresh k) -> do n <- getState putState (n + 1) loop (k n) Left u' -> send (k -> unsafeReUnion $ k $ u') >>= loop

Instances

Typeable2 State

Functor (State s)

getState :: Typeable e => Member (State e) r => Eff r e

putState :: Typeable e => Member (State e) r => e -> Eff r ()

onState :: (Typeable s, Member (State s) r) => (s -> s) -> Eff r ()

runState :: Typeable s => s -> Eff (State s :> r) w -> Eff r (w, s)

data Choose v

Instances

Functor Choose

Typeable1 Choose

choose :: Member Choose r => [a] -> Eff r a

runChoice :: forall a r. Eff (Choose :> r) a -> Eff r [a]

data Lift m v

Instances

Functor (Lift m)

Typeable1 m => Typeable1 (Lift m)

lift :: (Typeable1 m, Member (Lift m) r) => m a -> Eff r a

Lift a Monad to an Effect.

runLift :: (Monad m, Typeable1 m) => Eff (Lift m :> Void) w -> m w

The handler of Lift requests. It is meant to be terminal: we only allow a single Lifted Monad because Monads aren't commutative (e.g. Maybe (IO a) is functionally different from IO (Maybe a)).

data Exc e v

Instances

Typeable2 Exc

Functor (Exc e)

throwError :: (Typeable e, Member (Exc e) r) => e -> Eff r a

runError :: Typeable e => Eff (Exc e :> r) a -> Eff r (Either e a)

catchError :: (Typeable e, Member (Exc e) r) => Eff r a -> (e -> Eff r a) -> Eff r a

data Fresh i v

Instances

Typeable2 Fresh

Functor (Fresh i)

fresh :: (Typeable i, Enum i, Member (Fresh i) r) => Eff r i

runFresh :: (Typeable i, Enum i) => Eff (Fresh i :> r) w -> i -> Eff r w

data CutFalse

Instances

Typeable CutFalse

call :: Member Choose r => Eff (Exc CutFalse :> r) a -> Eff r a

cutfalse :: Member (Exc CutFalse) r => Eff r a