What are modern continuation operators all about?

Question

Back in the day, I thought I understood call/cc. These days I'm seeing a lot more references to "delimited" continuation operators, which seem to come in pairs like shift/reset, prompt/control, and sometimes more exotic ones. But I haven't seen a clear explanation anywhere of the basics, so

1. What do they do?
2. What are they for?
3. What might make one set of operators better for a particular language/context/purpose than another?

Answer 1

I have read a few articles and I can explain the idea. So I do not know how to implement it and how to use it in practical way, but I understood the main idea.

Suppose you have a call like

 (f (h (g x)) 2)
^     << scheme undelimited cont. captures from here 

and g captures the continuation.

1. In scheme, if you call call/cc within g, it will copy all the execution stack starting from the top-level (starting from the point where f was invoked) -- in case you have many expressions at the top level each one will have its own stacklet and invoking the saved continuation will stop at the top level (so, in the above expression, it will stop after f and at that point it has the value of f).

2. If you want the continuation to be captured from inside g up to the exit point of h, and each invocation of the continuation to return a value to f it is enough to capture the stack starting from the point of invocation of h, not the full stacklet of the invocation of f, so you want to tell the system that calling a call/cc-like function not to duplicate the rest of computation from the top level, but from a given point, and return each time a value at that point:

   (f (h (g x)) 2)
   
      ^        << delimited cont. captures from here 
   

   In this case, you instrument the system, something like:

   (f (shift (h (g x)) 2))
   

   and call the reset inside g, in the place where you would need to capture the continuation.

3. Delimited continuations can be simulated by undelimited continuations, but I think it is more practical to be able to use delimited, in some cases. So you cannot do it in scheme in a practical way of duplicating the stack only in the region of interest, it obliges you to copy a full stacklet (I say "stacklet" instead of stack, as the real stack is bigger, and the outside chained stacklets represent the continuation of the initialization code that is executed when you quit your code).

These are a few ideas that I glaned from the papers I have read. I am also interested to hear a more detailed answer.