note
andrewc
<p>Well, I can't claim to great knowledge on this, but I'll give it a go. Schemers out there will probably laugh their heads off.</p>
<p>Essentially, a continuation is the abstract notion of "what do do next".</p>
<readmore>
<p>Languages like Scheme carry one of these around on each of their stack frames as something accessible from the language itself. call-with-current-continuation is simply a [Higher Order Function]ish way of doing this.</p>
<code>
;; Guile scheme
(call-with-current-continuation
;; Often abbr'd to call-cc. Takes a function as arg.
(lambda (fred)
(+ 3 4)
(do-something 42 fred)
(fred 42) ))
</code>
<p>What's happening here is that when the outer call-cc is run, it takes the continuation of its current context -- where the call-cc would go next if it exited normally -- and
calls (lambda (fred) ...) with the continuation in the formal parameter 'fred'.</p>
<p>When the function object in fred is called, the call-cc exits, and the interpreter goes merrily on its way. The call-cc call itself evaluates to whatever is passed to 'fred' when (or if) that gets called.</p>
<p>Note that the function in 'fred' can be passed around too, and called by other functions. The do-something function used above might decide to call its 'fred' argument with some answer other than 42.</p>
</readmore>
<p>You could fake Scheme's call-cc behaviour in Perl using an eval-BLOCK/if($@){} combo. The trick is distinguishing our fake death from a real thrown error:</p>
<code>
sub call_cc (&)
{
my $clause = shift;
my @fake_returns;
my $fake_continuation;
$fake_continuation = sub {
@fake_returns = @_;
die $fake_continuation;
};
eval {
return $clause->($fake_continuation);
};
if ($@)
{
die $@ unless $@ == $fake_continuation;
return @fake_returns;
}
#NOTREACHED
}
print STDERR call_cc {
my $fred = shift;
$fred->(42);
return 64; # NOTREACHED
};
print STDERR "\n";
</code>
<p>But no, it's not a <em>real</em> continuation.<p>
248935
248935