- (*>) : EffM m
a
xs
(\v =>
xs) ->
EffM m
b
xs
(\v7 =>
xs) ->
EffM m
b
xs
(\v8 =>
xs)
- Fixity
- Left associative, precedence 3
- (:::) : lbl ->
EFFECT ->
EFFECT
- Fixity
- Non-associative, precedence 5
- (<$>) : (a ->
b) ->
EffM m
a
xs
(\v =>
xs) ->
EffM m
b
xs
(\v8 =>
xs)
- Fixity
- Left associative, precedence 4
- (<*>) : EffM m
(a ->
b)
xs
(\v =>
xs) ->
EffM m
a
xs
(\v8 =>
xs) ->
EffM m
b
xs
(\v9 =>
xs)
- Fixity
- Left associative, precedence 3
- (>>=) : EffM m
a
xs
xs' ->
((val : a) ->
EffM m
b
(xs' val)
xs'') ->
EffM m
b
xs
xs''
- Fixity
- Left associative, precedence 1
- data EFFECT : Type
The EFFECT Data type describes how to promote the Effect
description into a concrete effect.
- MkEff : Type ->
Effect ->
EFFECT
- 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
- 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.
- 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.
- data LRes : lbl ->
Type ->
Type
- (:=) : (x : lbl) ->
res ->
LRes x
res
- Fixity
- Non-associative, precedence 5
- data SubElem : a ->
List a ->
Type
- Z : SubElem a
(a ::
as)
- S : SubElem a
as ->
SubElem a
(b ::
as)
- data SubList : List a ->
List a ->
Type
- SubNil : SubList []
xs
- InList : SubElem x
ys ->
SubList xs
ys ->
SubList (x ::
xs)
ys
- call : (eff : e t
a
b) ->
{auto prf : Elem (MkEff a
e)
xs} ->
EffM m
t
xs
(\v =>
updateResTy v
xs
prf
eff)
- dropEnv : Env m
ys ->
SubList xs
ys ->
Env m
xs
make an environment corresponding to a sub-list
- dropFirst : SubList xs
ys ->
SubList xs
(x ::
ys)
- dropPrefix : SubList xs
ys ->
SubList xs
(zs ++
ys)
- dropSuffix : SubList xs
ys ->
SubList xs
(ys ++
zs)
- eff : Env m
xs ->
EffM m
a
xs
xs' ->
((x : a) ->
Env m
(xs' x) ->
m b) ->
m b
- envElem : SubElem x
xs ->
Env m
xs ->
Env m
[x]
- inPrefix : SubElem x
ys ->
SubList xs
ys ->
SubElem x
(ys ++
zs)
- inSuffix : SubElem x
ys ->
SubList xs
ys ->
SubElem x
(zs ++
ys)
- lift : EffM m
t
ys
ys' ->
{auto prf : SubList ys
xs} ->
EffM m
t
xs
(\v =>
updateWith (ys' v)
xs
prf)
- mapE : (a ->
EffM m
b
xs
(\underscore =>
xs)) ->
List a ->
EffM m
(List b)
xs
(\underscore =>
xs)
- mapVE : (a ->
EffM m
b
xs
(\underscore =>
xs)) ->
Vect n
a ->
EffM m
(Vect n
b)
xs
(\underscore =>
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)
- pure : a ->
EffM m
a
xs
(\v =>
xs)
- pureM : (val : a) ->
EffM m
a
(xs val)
xs
- 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
- replaceEnvAt : (x : a) ->
(idx : SubElem x'
xs) ->
Env m
ys ->
Env m
(updateAt idx
a
ys)
- resourceType : EFFECT ->
Type
Get the resource type (handy at the REPL to find out about an effect)
- 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.
- 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.
- 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.
- 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.
- 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'
- 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.
- runWith : (a ->
m a) ->
Env m
xs ->
EffM m
a
xs
xs' ->
m a
- 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.
- subListId : (xs : List a) ->
SubList xs
xs
- 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.
- updateAt : (idx : SubElem x'
xs) ->
(a : Type) ->
List EFFECT ->
List EFFECT
- updateResTy : (val : t) ->
(xs : List EFFECT) ->
Elem (MkEff a
e)
xs ->
e t
a
b ->
List EFFECT
- updateWith : (ys' : List EFFECT) ->
(xs : List EFFECT) ->
SubList ys
xs ->
List EFFECT
- when : Bool ->
Lazy (EffM m
()
xs
(\underscore =>
xs)) ->
EffM m
()
xs
(\underscore =>
xs)