I can't seem to wrap my mind around call/cc in Scheme

Question

Does anyone have a good guide as to how it works? Something with visual aids would be nice, every guide I've come across all seem to say the same thing I need a fresh take on it.

Are you referring to "continuation-passing style" by any chance? — user541686, Mar 14 '11 at 17:56
@Afnan: The question should be perfectly clear. "What's `call/cc`?" - what else can he add? — configurator, Mar 18 '11 at 13:29

score 11 · Answer 1 · answered Mar 15 '11 at 01:48

11

Here's the diagram that was left on our CS lab's whiteboard. So you're going to fetch some apples, and you grab a continuation before you begin. You wander through the forest, collecting apples, when at the end you apply your continuation on your apples. Suddenly, you find yourself where you were before you went into the forest, except with all of your apples.

call/cc

(display
  (call/cc (lambda (k)
             (begin
               (call-with-forest
                 (lambda (f)
                   (k (collect-apples f))))
               (get-eaten-by-a-bear)))))

=> some apples (and you're not eaten by a bear)

I think a Bar Mitzvah and buried gold might have been involved.

answered Mar 15 '11 at 01:48

erjiang

44,417
10
64
100

Really, how much better of a visual aid can you get than an underground wormhole?? – erjiang Mar 15 '11 at 01:49
1

The problem: You can not understand the picture if you do not understand continuations. On the other hand it is a good visualization ... +1 – knivil Mar 15 '11 at 09:57
1

knivil: I never said it was a good explanation, but I felt like it should be preserved here for posterity. – erjiang Mar 15 '11 at 23:30
Friedman-style time tunnels! I've never seen the variation with the bear, though. – acfoltzer Mar 21 '11 at 22:14
I'm pretty sure this was Dustin's drawing. – erjiang Mar 22 '11 at 12:44

score 5 · Answer 2 · answered Mar 14 '11 at 17:57

5

Have a look at the continuation part of PLAI -- it's very "practical oriented", and it uses a "black-hole" visualization for continuations that can help you understand it.

answered Mar 14 '11 at 17:57

Eli Barzilay

29,301
3
67
110

New version out. Used in the author's recent Brown-plus-online course. – Jesse Millikan Dec 11 '12 at 07:40

score 0 · Answer 3 · answered Apr 10 '12 at 14:01

Never likes visual representation of call/cc as I can't reflect it back to the code (yes, poor imagination) ;)

Anyway, I think it is easier start not with call/cc but with call/ec (escape continuation) if you already familiar with exceptions in other languages.

Here is some code which should evaluate to value:

(lambda (x) (/ 1 x))

What if x will be equal '0'? In other languages we can throw exception, what about scheme? We can throw it too!

(lambda (x) (call/ec (cont) 
 (if (= x 0) (cont "Oh noes!") (/ 1 x))))

call/ec (as well as call/cc) is works like "try" here. In imperative languages you can easily jump out of function simply returning value or throwing exception. In functional you can't jump out, you should evaluate something. And call/* comes to rescue. What it does it represent expression under "call/ec" as function (this named "cont" in my case) with one argument. When this function is called it replaces the WHOLE call/* to it's argument.

So, when (cont "Oh noes!") replaces (call/ec (cont) (if (= x 0) (cont "Oh noes!") (/ 1 x))) to "Oh noes!" string.

call/cc and call/ec are almost equals to each other except ec simplier to implement. It allows only jump up, whil cc may be jumped down from outside.

knivil · Answer 4 · 2011-03-15T11:06:42.920

0

There is no shortcut in learning call/cc. Read the chapters in The Scheme Programming Language or Teach Yourself Scheme in Fixnum Days.

edited Mar 15 '11 at 11:06

answered Mar 15 '11 at 09:50

knivil

916
5
10

You might want to fix your link, as either refer to the same source. – YasirA Mar 15 '11 at 10:49

score 0 · Answer 5 · answered Mar 31 '12 at 09:22

I found that it helps to visualize the call stack. When evaluating an expression, keep track of the call stack at every step. (See for example http://4.flowsnake.org/archives/602) This may be non-intuitive at first, because in most languages the call stack is implicit; you don't get to manipulate it directly.

Now think of a continuation as a function that saves the call stack. When that function is called (with a value X), it restores the saved call stack, then passes X to it.

I can't seem to wrap my mind around call/cc in Scheme

5 Answers5