Effects

when : Bool -> Lazy (EffM m () xs (\underscore => xs)) -> EffM m () xs (\underscore => xs)

updateWith : (ys' : List EFFECT) -> (xs : List EFFECT) -> SubList ys xs -> List EFFECT

updateResTy : (val : t) -> (xs : List EFFECT) -> Elem (MkEff a e) xs -> e t a b -> List EFFECT

updateAt : (idx : SubElem x' xs) -> (a : Type) -> List EFFECT -> List EFFECT

toEff : (xs' : List EFFECT) -> EffM m a xs (\v => xs') -> EffM m a xs (\v6 => xs')

Explicitly give the expected set of result effects for an effectful
operation.

subListId : (xs : List a) -> SubList xs xs

staticEff : EffM m a xs (\v => xs) -> EffM m a xs (\v5 => xs)

Run a subprogram which results in an effect state the same as the input.

runWith : (a -> m a) -> Env m xs -> EffM m a xs xs' -> m a

runPureInit : (env : Env id xs) -> (prog : EffM id a xs xs') -> a

Run an effectful program with a given default value for the environment.

A helper function useful for when the given context is 'pure' and there is no default environment.

env

The environment to use.

prog

The effectful program to run.

runPureEnv : (env : Env id xs) -> (prog : EffM id a xs xs') -> (x : a ** Env id (xs' x))

Similar to 'runEnv', but the context (m) is 'pure'

runPure : (prog : EffM id a xs xs') -> {default missing pretty-printer for term env : Env id xs} -> a

Run an effectful program in the identity context.

A helper function useful for when the given context is 'pure'.
The env argument is implicit and initialised automatically.

prog

The effectful program to run.

runInit : Applicative m => (env : Env m xs) -> (prog : EffM m a xs xs') -> m a

Run an effectful program in a given context m with a default value for the environment.

This is useful for when there is no default environment for the given context.

env

The environment to use.

prog

The effectful program to run.

runEnv : Applicative m => Env m xs -> EffM m a xs xs' -> m (x : a ** Env m (xs' x))

Similar to 'runInit', but take the result of Env.

run : Applicative m => (prog : EffM m a xs xs') -> {default missing pretty-printer for term env : Env m xs} -> m a

Run an effectful program.

The content (m) in which to run the program is taken from the
environment in which the program is called. The env argument is
implicit and initialised automatically.

prog

The effectful program to run.

resourceType : EFFECT -> Type

Get the resource type (handy at the REPL to find out about an effect)

replaceEnvAt : (x : a) -> (idx : SubElem x' xs) -> Env m ys -> Env m (updateAt idx a ys)

rebuildEnv : Env m ys' -> (prf : SubList ys xs) -> Env m xs -> Env m (updateWith ys' xs prf)

Put things back, replacing old with new in the sub-environment

pureM : (val : a) -> EffM m a (xs val) xs

pure : a -> EffM m a xs (\v => xs)

new : Handler e' m => (e : EFFECT) -> resTy -> {auto prf : e = MkEff resTy e'} -> EffM m t (e :: es) (\v => e :: es) -> EffM m t es (\v11 => es)

mapVE : (a -> EffM m b xs (\underscore => xs)) -> Vect n a -> EffM m (Vect n b) xs (\underscore => xs)

mapE : (a -> EffM m b xs (\underscore => xs)) -> List a -> EffM m (List b) xs (\underscore => xs)

lift : EffM m t ys ys' -> {auto prf : SubList ys xs} -> EffM m t xs (\v => updateWith (ys' v) xs prf)

inSuffix : SubElem x ys -> SubList xs ys -> SubElem x (zs ++ ys)

inPrefix : SubElem x ys -> SubList xs ys -> SubElem x (ys ++ zs)

envElem : SubElem x xs -> Env m xs -> Env m [x]

eff : Env m xs -> EffM m a xs xs' -> ((x : a) -> Env m (xs' x) -> m b) -> m b

dropSuffix : SubList xs ys -> SubList xs (ys ++ zs)

dropPrefix : SubList xs ys -> SubList xs (zs ++ ys)

dropFirst : SubList xs ys -> SubList xs (x :: ys)

dropEnv : Env m ys -> SubList xs ys -> Env m xs

make an environment corresponding to a sub-list

call : (eff : e t a b) -> {auto prf : Elem (MkEff a e) xs} -> EffM m t xs (\v => updateResTy v xs prf eff)

data SubList : List a -> List a -> Type

SubNil : SubList [] xs

InList : SubElem x ys -> SubList xs ys -> SubList (x :: xs) ys

data SubElem : a -> List a -> Type

Z : SubElem a (a :: as)

S : SubElem a as -> SubElem a (b :: as)

data LRes : lbl -> Type -> Type

(:=) : (x : lbl) -> res -> LRes x res

Fixity

Non-associative, precedence 5

interface Handler 

Handler interfaces describe how an effect e is translated to the
underlying computation context m for execution.

handle : Handler e m => (r : res) -> (eff : e t res resk) -> (k : (x : t) -> resk x -> m a) -> m a

How to handle the effect.

Effect : Type

The Effect type describes effectful computations.

This type is parameterised by:

• The return type of the computation.
• The input resource.
• The computation to run on the resource given the return value.

data EffM : (m : Type -> Type) -> (x : Type) -> (es : List EFFECT) -> (ce : x -> List EFFECT) -> Type

Definition of a language of effectful programs.

x

The return type of the result.

es

The list of allowed side-effects.

ce

Function to compute a new list of allowed side-effects.

Value : (val : a) -> EffM m a (xs val) xs

EBind : EffM m a xs xs' -> ((val : a) -> EffM m b (xs' val) xs'') -> EffM m b xs xs''

CallP : (prf : Elem (MkEff a e) xs) -> (eff : e t a b) -> EffM m t xs (\v => updateResTy v xs prf eff)

LiftP : (prf : SubList ys xs) -> EffM m t ys ys' -> EffM m t xs (\v => updateWith (ys' v) xs prf)

New : Handler e' m => (e : EFFECT) -> resTy -> {auto prf : e = MkEff resTy e'} -> EffM m t (e :: es) (\v => e :: es) -> EffM m t es (\v11 => es)

(:-) : (l : ty) -> EffM m t [x] xs' -> EffM m t [l ::: x] (\v => map (\ARG => l ::: ARG) (xs' v))

Fixity

Non-associative, precedence 5

data EFFECT : Type

The EFFECT Data type describes how to promote the Effect
description into a concrete effect.

MkEff : Type -> Effect -> EFFECT

(>>=) : EffM m a xs xs' -> ((val : a) -> EffM m b (xs' val) xs'') -> EffM m b xs xs''

Fixity

Left associative, precedence 1

(<*>) : EffM m (a -> b) xs (\v => xs) -> EffM m a xs (\v8 => xs) -> EffM m b xs (\v9 => xs)

Fixity

Left associative, precedence 3

(<$>) : (a -> b) -> EffM m a xs (\v => xs) -> EffM m b xs (\v8 => xs)

Fixity

Left associative, precedence 4

(:::) : lbl -> EFFECT -> EFFECT

Fixity

Non-associative, precedence 5

(*>) : EffM m a xs (\v => xs) -> EffM m b xs (\v7 => xs) -> EffM m b xs (\v8 => xs)

Fixity

Left associative, precedence 3