Thanks for reading my blog and posting comments. I agree with what you said. But I think you haven’t read the whole article. I explain later that a continuation actually represents the call stack.

Thanks,

– Vijay

However, there is a small bug in your first example. Sure enough, if you invoke (frozen 10), the repl will print 12. But if you invoke (+ 1 (frozen 10)), it will _again_ print 12, not 13. “frozen” doesn’t represent (+ 2 []), but it represents _all_ of the program state up the call stack, including the fact that you entered it at the repl — invoking “frozen” could even lead to _undefining_ things you defined after setting “frozen”, because you invoked a continuation that captured the REPL at an earlier point in time.

Here’s the repro in SISC:

$> sisc
SISC (1.16.6)
#;> (define call/cc call-with-current-continuation)
#;> (define frozen #f)
#;> (+ 2 (call/cc (lambda (k) (set! frozen k) 3)))
5
#;> (frozen 10)
12
#;> (+ 1 (frozen 10))
12
#;>

I covered this a bit here: http://bit.ly/jOPKU . I’ve since learned about delimited continuations in PLT Scheme, and they may also be an interesting read — http://bit.ly/14kufm .

Have you looked at Termite?

I have not in depth to contribute here; but if you are interested in distributed computing I know enough to suggest that you check it out.

As I said in my earlier comment, my intention was to show the power of simple and elegent language design without the distractions of an elaborate sample. So I choose a damn simple example.

>> set.select({|x| x>10}).inject(0,{|a,b| a+b})

I guess this is Haskell. The code is short and serves the purpose of displaying the elegance of higher-order functional programming. But the syntax might scare someone new to Haskell. I think the simple, one-line Scheme code snippet I gave is much more merciful to someone uninitiated.

However, I can totally understand scolebourne when saying that noone would use inner classes for this in Java. I don’t think I’d believe in these ideas about language design after reading your article when I just had a background in a no-closures language…

It’s hard to find an example that shows the power of closures to people who don’t know them. I usually ask people how they’d do operations on a large set of objects that are contained in collection objects. Then I ask them to contemplate how often they do that in their projects. Finally, I show them something like this:

set.select({|x| x>10}).inject(0,{|a,b| a+b})

This does of course not show the full potential of closures, however it does make clear why one may want to pass around stuff like the function that calculates n+k.