The predicates reset/3
and shift/1
implement delimited continuations for Prolog. Delimited
continuations for Prolog are described in Schrijvers et
al., 2013 (preprint
PDF). The mechanism allows for proper coroutines, two or
more routines whose execution is interleaved, while they exchange data.
Note that coroutines in this sense differ from coroutines realised using
attributed variables as described in chapter
8.
Note that shift/1
captures the forward continuation. It notably does not capture
choicepoints. Choicepoints created before the continuation is captured
remain open, while choicepoints created when the continuation is
executed live their normal life. Unfortunately the consequences for committing
a choicepoint is complicated. In general a cut (!/0)
in the continuation does not have the expected result. Negation (\+/1)
and if-then(-else) (->/2)
behave as expected, provided the continuation is called immediately.
This works because for \+/1
and
->/2 the continuation
contains a reference to the choicepoint that must be cancelled and this
reference is restored when possible. If, as with tabling, the
continuation is saved and called later, the commit has no effect. We
illustrate the three scenarios using with the programs below.
t1 :-
reset(gbad, ball, Cont),
( Cont == 0
-> true
; writeln(resuming),
call(Cont)
).
gbad :-
n, !, fail.
gbad.
n :-
shift(ball),
writeln(n).
Here, the !/0 has no
effect:
?- t1.
resuming
n
true.
The second example uses \+/1,
which is essentially
(G->fail;true).
t2 :-
reset(gok, ball, Cont),
( Cont == 0
-> true
; writeln(resuming),
call(Cont)
).
gok :-
\+ n.
In this scenario the normal semantics of \+/1
is preserved:
?- t1.
resuming
n
false.
In the last example we illustrate what happens if we assert the
continuation to be executed later. We write the negation using
if-then-else to make it easier to explain the behaviour.
:- dynamic cont/1.
t3 :-
retractall(cont(_)),
reset(gassert, ball, Cont),
( Cont == 0
-> true
; asserta(cont(Cont))
).
c3 :-
cont(Cont),
writeln(resuming),
call(Cont).
gassert :-
( n
-> fail
; true
).
Now, t3/0 succeeds twice. This is because n/0 shifts, so the
commit to the fail/0
branch is not executed and the true/0
branch is evaluated normally. Calling the continuation later using c3/0
fails because the choicepoint that realised the if-then-else does not
exist in the continuation and thus the effective continuation is the
remainder of n/0 and
fail/0
in gassert/0 .
?- t3.
true ;
true.
?- c3.
resuming
n
false.
The suspension mechanism provided by delimited continuations is used
to implement tabling Desouter et
al., 2015, (available
here). See section 7.
- reset(:Goal,
?Ball, -Continuation)
- Call Goal. If Goal calls shift/1
and the argument of shift/1
can be unified with Ball,80The
argument order described in Schrijvers et
al., 2013 is
reset(Goal,Continuation,Ball).
We swapped the argument order for compatibility with catch/3 shift/1
causes reset/3
to return, unifying
Continuation with a goal that represents the continuation
after shift/1.
In other words, meta-calling Continuation completes the
execution where shift left it. If Goal does not call shift/1,
Continuation are unified with the integer 0
(zero).81Note that older versions
also unify Ball with 0. Testing whether or not
shift happened on Ball however is always ambiguous.
- shift(+Ball)
- Abandon the execution of the current goal, returning control to just
after the matching reset/3
call. This is similar to throw/1
except that (1) nothing is‘undone’and (2) the 3th argument
of
reset/3
is unified with the continuation, which allows the code calling reset/3
to resume the current goal.
- [experimental]shift_for_copy(+Ball)
- Similar to shift/1.
This version is intended for situations where it is assumed the
continuation is copied and saved to be executed one or multiple times in
a different context. This notably prevents restoring choice points saved
for \+/1,
If
->Then;Else, etc.
0 
