# Nice explanation of call/cc

**URL:** <https://www.ruby-forum.com/t/nice-explanation-of-call-cc/85294>\
**Category:** Ruby\
**Created:** [February 12, 2007, 12:43pm UTC](https://www.ruby-forum.com/t/nice-explanation-of-call-cc/85294 "2007-02-12T12:43:50Z")\
**Posts on this page:** 4\
**Page:** 1

<div class="post-metadata">

**Author:** ![Martin\_DeMello](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/f17d59/32.png) [@Martin\_DeMello](https://www.ruby-forum.com/u/Martin_DeMello)\
**Post date:** [February 12, 2007, 12:43pm UTC](https://www.ruby-forum.com/t/nice-explanation-of-call-cc/85294/1 "2007-02-12T12:43:50Z")

</div>

From  
[http://sigfpe.blogspot.com/2007/02/exceptions-disjunctions-and.html:](http://sigfpe.blogspot.com/2007/02/exceptions-disjunctions-and.html:)

In functional languages exceptions tend to be handled a little  
differently. Whereas C++ has a throw keyword, there is no equivalent  
in Scheme, say. Instead  
the call-with-current-continuation function acts like catch. The  
argument to call-with-current-continuation is a function (lambda  
(throw) …) and the argument to this function (itself a function),  
here called throw, does the throwing. For example consider the scheme  
expression:

(call-with-current-continuation  
(lambda (throw) (+ 1 (throw 7))))

[a = callcc {|c| c[7] + 1} in ruby - martin ]

The result is 7, not 8. The 7 is thrown ‘past’ the (+ 1 …) and is  
caught by the surrounding call-with-current-continuation. The  
important difference from C++ is that if any subexpression is to throw  
some value, it must be ‘handed’ a suitable throw function.

---

<div class="post-metadata">

**Author:** ![Martin\_DeMello](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/f17d59/32.png) [@Martin\_DeMello](https://www.ruby-forum.com/u/Martin_DeMello)\
**Post date:** [February 12, 2007, 5:11pm UTC](https://www.ruby-forum.com/t/nice-explanation-of-call-cc/85294/2 "2007-02-12T17:11:28Z")

</div>

Martin DeMello schrieb:

> > From [http://sigfpe.blogspot.com/2007/02/exceptions-disjunctions-and.html:](http://sigfpe.blogspot.com/2007/02/exceptions-disjunctions-and.html:)

Martin, thanks for the link. Its nice that we (still) can easily  
implement both versions of the code in Ruby, using catch/throw and  
continuations.

Regards,  
Pit

---

<div class="post-metadata">

**Author:** ![Martin\_DeMello](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/f17d59/32.png) [@Martin\_DeMello](https://www.ruby-forum.com/u/Martin_DeMello)\
**Post date:** [February 13, 2007, 5:20pm UTC](https://www.ruby-forum.com/t/nice-explanation-of-call-cc/85294/3 "2007-02-13T17:20:20Z")

</div>

I picked up a book on Scheme and seeing call/cc there very much  
surprised me. I had seen it Ruby before, I guess it came directly from  
Scheme. Anyway there’s a neat chapter in that book on  
continuation-passing style, which was much different than I expected  
it to be. Unfortunately I just relocated and the book’s packed in a  
box, but the basic idea revolved around that aspect of call/cc. It  
didn’t actually seem that different from the sequences of methods with  
dots style that allows you to feed the output of one method into the  
next method, but the syntax was very different (and probably there  
were some significant differences to the internals as well).

---

<div class="post-metadata">

**Author:** ![Martin\_DeMello](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/f17d59/32.png) [@Martin\_DeMello](https://www.ruby-forum.com/u/Martin_DeMello)\
**Post date:** [February 13, 2007, 5:28pm UTC](https://www.ruby-forum.com/t/nice-explanation-of-call-cc/85294/4 "2007-02-13T17:28:20Z")

</div>

Continuation passing style is actually most used as a compilation  
stage in several functional languages - the program is first  
transformed to cps and that is then used to generate executable code.  
I don’t think I’ve seen any language encourage it as an actual coding  
style. I agree, it’s a very interesting approach, and well worth  
reading up on.

martin