Continuations by example: Exceptions, time-traveling search, threads, and more (opens in new tab)

(matt.might.net)

151 pointsalschwalm5y ago15 comments

15 comments

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.

azeirah5y ago

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.

hencq5y ago

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...

DonaldPShimoda5y ago

For what it's worth, almost any time Matt writes about Scheme he's likely using Racket so it'd be worth trying that for his posts!

vincnetas5y ago

Me to. Level failed, but then i found this cheat code from apache and at lest i now understand basics.

http://commons.apache.org/sandbox/commons-javaflow/

offbynull5y ago

AFAIK Javaflow's been inactive for over a decade. Newer implementations for the same concept include https://github.com/offbynull/coroutines and https://github.com/vsilaev/tascalate-javaflow/.

Full disclosure: I'm the one who built / owns the first project.

3 more replies

emmanueloga_5y ago

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

2: https://en.wikipedia.org/wiki/Delimited_continuation

jolmg5y ago

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_massa5y ago

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.

kazinator5y ago

Continuations can be implicitly used. If you have a language that is compiled using transformation to CPS. Then continuations are everywhere under the hood.

a13692099935y ago

You could dispute "serious", but I've used it in a not!lisp for various control flow purposes.

  func a0 a1 = callcc \return:
    # ...
    callcc (again =)
      # ...
      x ?? return y
    again again

Google2345y ago

Wow, imagine writing in such an unreadable language

j / k navigate · click thread line to collapse