
Continuations by example: Exceptions, time-traveling search, threads, and more - alschwalm
http://matt.might.net/articles/programming-with-continuations--exceptions-backtracking-search-threads-generators-coroutines/
======
verytrivial
I always start Matt Might articles thinking "Okay, THIS is the one I'm going
to understand all the way to the very end without unlearning what I just read,
else I die," and alas, I have again died.

~~~
azeirah
I'm having an ADHD night and I had the same thought, except I haven't died
yet. Felt like giving up three times already, but I did have a click moment
after playing around with a scheme repl for a couple of minutes. I understand
the first example of call/cc now!

    
    
      (display
        (call/cc (lambda (cc)
                  (display "I got here.\n")
                  (cc "This string was passed to the continuation.\n")
                  (display "But not here.\n"))))
    

Edit: Tried playing around with mit-scheme, but it doesn't work with the
ctrl-v'ing the examples. Chezscheme does work.

~~~
hencq
It seems that MIT-Scheme needs the cc function to be a function of 1 argument
(the return value for the continuation)[0]

Changing it to the following should work:

    
    
      (let ((start #f))
        (if (not start)
          (call/cc (lambda (cc)
                     (set! start cc))))
      
        (display "Going to invoke (start)\n")
        
        (start #f))
    

[0] [https://www.gnu.org/software/mit-
scheme/documentation/stable...](https://www.gnu.org/software/mit-
scheme/documentation/stable/mit-scheme-ref/Continuations.html#Continuations)

------
emmanueloga_
I was actually relieved when I found this article [1] which argues against
call/cc as a core language feature. Alas, I think the argument does not
dismiss _delimited continuations_, so now my burden has shifted from mastering
call/cc to mastering shift/reset :-/ [2].

1: [http://okmij.org/ftp/continuations/against-
callcc.html](http://okmij.org/ftp/continuations/against-callcc.html)

2:
[https://en.wikipedia.org/wiki/Delimited_continuation](https://en.wikipedia.org/wiki/Delimited_continuation)

------
jolmg
I think I've found a good use for continuations in a parser combinator library
I'm writing, though I haven't gotten around to working on the corresponding
feature yet.

Has anyone used continuations in a serious/non-academic way?

~~~
gus_massa
I used to implement an equivalent of exit or return statement, like in this
example.

    
    
      #lang racket
    
      ; implement sqrt in a very inefficient way
      (let/ec exit
        (for ([i 10])
          (when (= (* i i) 49)
            (exit i)))
        "not found :(")
      ;==> 7
     

There are more idiomatic and easy ways to write this, but when you have to
many nested and not nested for's, sometimes it is useful to have a magical
exit-everything-now.

------
Google234
Wow, imagine writing in such an unreadable language

