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