curious for those deep in programming languages, what's the general lang design community's take on continuation style passing i.e. • what're the unexpected problems in practice • why are they not commonly used/popular given they seem to keep getting reinvented

👍 thanks, reading them now

I came here to say what the slides to of compilers: that static-single assignment is easier to think about. Though continuations have a certain theoretical elegance, they generally mismatch use-cases so that you always end up wrapping them. Common Lisp conditions have always seemed better to me than exception mechanisms. Most exception (maybe just my exceptions) are bugs, and then you want to keep the stack, be able to drop into a REPL, figure out what's going on. The fact that exceptions often have a print_stack_trace method just goes to show that you actually want to keep the stack. The other main use of exceptions is for a quick escape from nested computation. After years, I think I've come over to the checked exception camp on those. In other words, if a checked exception doesn't feel good in a situation, an unchecked one isn't either, and you should be using a sort of condition system. AND then if the condition is the kind of thing where you may, for instance, want to get feedback to from the user, then you're likely going to want coroutines of some sort. I mean you were doing something step-by-step, but now it's broken, so set that aside, look for a fix, then come back to it.

so from my day of research, the tldr algebraic effects are structured delimited continuations that solve a lot of the problems with delimited continuations (~= all problems of unbounded dynamic typed callback programming)

I don't know how deep you want to go with this question, but the best web-visible resource regarding continuations of which I'm aware is: http://okmij.org/ftp/continuations/ ... in particular, on the topic of

call/cc

, I recommend: http://okmij.org/ftp/continuations/against-callcc.html

I think it's useful for a programming language to use CPS behind the scenes (i.e. using callbacks in place of call stacks), as opposed to something one done manually (e.g. explicitly passing callbacks) just for the utility that it opens up: * Easy debugger (stop time, go back in time) * Easy implementation of exceptions, etc. * Async code can be written as if it's synchronous But I'm not sure CPS works that great unless you're essentially using a Scheme-like runtime

concur with @Jack Rusher @Dan Cook comments