If the continuation could be resumed at most once, this would be more like suspending a thread/fiber and resuming it later.
- if you call the callback before you save the continuation, then the callback isn't ever called again (unless you call the whole function again, of course).
- if you call the callback after saving the continuation, then the callback is called whenever you resume the continuation.
So basically, resuming the continuation is equivalent to either never calling the callback, or calling the callback like normal. It sounds weird, but everything works out.
EDIT: Sorry, I think you were saying you know what they do but that it seems like that'd break all kinds of invariants. It's true that you have to consider scenarios a bit more carefully, but I find it's not that much of a burden compared to the benefits.
As you may know, Oleg makes the same argument, that call/cc has a lot of problems, and, in practice, isn't really used anyway: http://okmij.org/ftp/continuations/against-callcc.html#illus... . (EDIT: I see that sillysaurus (https://news.ycombinator.com/item?id=14680711) linked this same discussion a while ago.)
The so-called full continuations lack the flexibility to put the delimiting prompt anywhere but the top-level entry point to the program or thread.
Delimited continuations are complete in the sense that they let the programmer control where the top is.
Put the delimiting prompt around the top-level startup function and you have a "full" continuation.
The obvious fix would be to never modify the content of a stack frame, instead recreating it with a different value for each iteration, but that doesn't strike me as very efficient.
A continuation captures variable bindings similarly to a closure. (It just captures more than just variable bindings and more than just the lexically apparent ones.)
A function that has arguments on the stack and really returns and all that will not be happy if it invokes a callback and that callback is actually a continuation of yours that doesn't return. You have stuff on the stack that hasn't been cleaned away.