- 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.
- 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))
- 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.
- return : a ->
EffM m
a
xs
(\v =>
xs)
- 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 5
- (<*>) : EffM m
(a ->
b)
xs
(\v =>
xs) ->
EffM m
a
xs
(\v8 =>
xs) ->
EffM m
b
xs
(\v9 =>
xs)
- Fixity
- Left associative, precedence 2
- (<$>) : (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 2