(struct box (default))

(effect box-get(b))
(effect box-set(bv))

(define (store-service[store(hasheq )])
(handler
[(box-getb)
(define r(hash-ref storeb(box-defaultb)))
(continue r)]
[(box-setbv)
(define store*(hash-set storebv))
(with ((store-servicestore*))
(continue* (void )))]))

We define a struct named box that will hold a default value, i.e., the value to return if the box has no mapping in the store. Two operations, declared with effect , will be interpreted by an effect handler. The store-service function takes in a store and returns a first-class handler that interprets box effects in that store.

For box-get, we look up the given box in the store. If the box has a mapping in the store, then the mapped value is returned. Otherwise, the default value is returned. To return a value, the continue function is invoked. This function is bound to a delimited continuation from the point where the effect was requested up to and including the handler itself. In the effect handler literature, this is known as a deep handler.

For box-set, we construct a new store that maps the box to its new value. The continuation is then executed in a context where operations are handled by a new handler, with the updated store. This time, we use continue* to invoke the delimited continuation up to but not including the handler itself. In the effect handler literature, this is known as a shallow handler. Using continue* allows us to reinterpret subsequent effects using a different handler.

Here is how this box implementation is used:

> (with ((store-service))
(define b(box 0))
(box-setb(add1 (box-getb)))
(box-getb))

1

1Language🔗 i

#lang effect/racket package: effect-racket-lib

A language, effect/racket, provides effect handlers and ensures that all built-in operations cooperate with effect handlers too.

This program reinterprets read to take input from a list of strings, rather than standard in.

#lang effect/racket

(define (add-from-inputs)
(+ (read )(read )))

(define (fixed-input-serviceins)
(handler
[(read )
(with ((fixed-input-service(cdr ins)))
(continue* (car ins)))]))

The function fixed-input-service takes in a list of values and feeds that list to read , one by one. Here is how that might be used:

> (with ((fixed-input-service'(12)))
(add-from-inputs))

3

Note that an effect/racket module can only require from other effect/racket modules. There is no interoperability between effect/racket and other languages. Higher-order values imported across the language boundary will be sealed, i.e, unusable.

2Effects🔗 i

syntax
( effect id(param...))

Declares id as an effect with the given parameters. A number of definitions are created by this declaration:

id as a procedure that performs the given effect. This procedure accepts an optional keyword argument #:fail that, given a failure-result/c , calls that thunk (or yields that value) when no handler exists for the effect in the current context.
id as a match pattern that matches effect values created by id.
id? is a predicate that succeeds on effect values created by id.

procedure
( effect-value? v)→boolean?
v:any/c

Returns if v is an effect value. An effect value is a first-class value that represents a request to perform an effect. These are the values that handlers match on.

syntax
( return val...)

Once the body expression evaluates to a sequence of values, they are implicitly handed to the built-in return effect. Here is a definition of the amb operator:

(effect choice())
(effect fail())

(define amb-service
(handler
[(choice)(append (continue #t)(continue #f))]
[(fail)'()]
[(return v)(list v)]))

So that the append works uniformly, return is used to inject values from pure expressions into a list. It can be used as such:

> (with (amb-service)
(define a(choice))
(define b(choice))
(if (and ab)(fail)(cons ab)))

'((#t . #f) (#f . #t) (#f . #f))

This effect can also be invoked directly, for early return behavior.

> (with ()
(+ 1(return 10)))

10

3Handlers🔗 i

syntax
( handler [patbody...+]...)

Yields an ordinary effect handler that interprets the given effect-value patterns. If no pattern matches the requested effect, then the effect is propagated to the next handler. This form can only handle effects performed in normal code, not code executed while checking a contract.

Both continue and continue* are bound in the bodies of each handler arm to a deep and shallow delimited continuation, respectively.

syntax
( contract-handler [patbody...+]...)

Similar to handler , except it only interprets effects performed while checking contracts. The body expressions don’t have direct access to the continuation, rather each body should return several values. Initial values are provided to the continuation, while the final returned value is a handler to be reinstalled.

> (effect increment())

> (define (limited?_ )
(< (increment)2))

> (define/contract (fx)
(-> limited?any )
x)

> (define (increment-servicen)
(contract-handler
[(increment)(values n(increment-service(add1 n)))]))

> (with ((increment-service0))
(f1)
(f1))

1

> (with ((increment-service0))
(f1)
(f1)
(f1))

f: contract violation

expected: limited?

given: 1

in: the 1st argument of

(-> limited? any)

contract from: (function f)

blaming: top-level

(assuming the contract is correct)

at: eval:17:0

procedure
( handler-append v...)→handler?
v:handler?

Appends the given handlers.

> (effect go(x))

> (define twice-service
(handler
[(gox)(continue (go(* x2)))]))

> (define decr-service
(handler
[(gox)(continue (sub1 x))]))

> (define twice-then-decr-service
(handler-append decr-servicetwice-service))

> (with (twice-then-decr-service)
(go10))

19

procedure
( handler? v)→boolean?
v:any/c

Returns if v is a handler (either an ordinary handler or a contract handler).

procedure
( continue v...)→any
v:any/c

Bound to the deep delimited continuation in the arms of with .

procedure
( continue* v...)→any
v:any/c

Bound to the shallow delimited continuation in the arms of with .

syntax
( with (handler...)body...+)

Executes body with the given handlers installed, nested in the given order.

syntax
( splicing-with (handler...)body...+)

Variant of with that splices forms into the enclosing definition context (similar to begin ).

4Contracts🔗 i

procedure
( ->e effret)→contract?
eff:contract?
ret:contract?

Returns a contract that protects functions by ensuring all effects performed when that function is applied satisfy eff and all values provided to the continuation by a handler satisfy ret.

> (define pure/c(->e none/c any/c ))

> (define/contract (my-mapfxs)
(-> pure/clist? list? )
(map fxs))
> (my-map(λ (x)(add1 x))'(123))

'(2 3 4)
> (my-map(λ (x)(write x)x)'(123))

my-map: contract violation;

none/c allows no values

given: (write 1)

in: the performed effect

the 1st argument of

(->

(->e none/c ...rivate/contract.rkt:40:3)

(listof any/c)

(listof any/c))

contract from: (function my-map)

blaming: top-level

(assuming the contract is correct)

at: eval:27:0

procedure
( dependent->e effmake-ret)→contract?
eff:contract?
make-ret:(-> effect-value? contract? )

A dependent variant of ->e where the continuation contract relies on the effect value.

> (effect id(v))

> (define/contract (f)
(dependent->e id?(match-lambda [(idv)(=/c v)]))
(id42))

> (with ((handler [(idv)(continue v)]))
(f))

42

> (with ((handler [(idv)(continue 0)]))
(f))

f: contract violation

expected: (=/c 42)

given: 0

in: the effect response

(->e id? composed)

contract from: (function f)

blaming: top-level

(assuming the contract is correct)

at: eval:31:0

procedure
( with/c handler...)→contract?
handler:handler?

Returns a contract that protects functions by installing the given contract handler whenever that function is applied.

> (effect id-callable?())

> (define no-id/c
(let ()
(define no-id-handler
(contract-handler
[(id-callable?)(values #fno-id-handler)]))
(with/c no-id-handler)))

> (define/contract (do-itthk)
(-> no-id/cany )
(thk))

> (define/contract (idx)
(->* (any/c )#:pre(id-callable?)any )
x)
> (do-it(λ ()(+ 11)))

2
> (do-it(λ ()(id1)))

id: contract violation

#:pre condition

in: (->* (any/c) #:pre ... any)

contract from: (function id)

blaming: top-level

(assuming the contract is correct)

at: eval:37:0

top ← prev up next →