Hello, Oleg has a introduction for delimited continuations which he presented during ICFP: http://okmij.org/ftp/continuations/index.html#tutorial Of course, it's worth mentioning that the Cont monad is actually doing delimited continuations, cf.: http://okmij.org/ftp/continuations/ContExample.hs Ultimately, the idea is simple, which may be part of the reason why it's so hard to explain (cf., monads). The short version is that at any point in the execution of a program we have some part of the program which has already run, and some part which has yet to run; the latter is the "continuation", which is also often called the calling "context". All the hoopla about continuations comes from the tricksy things we can do once we realize that programs have these two parts instead of only thinking about the history of the execution. Operationally, the way the Cont monad works is that we explicitly build up the continuation as a function to be called, and then runCont actually applies that function in order to yield a result. What use is this? Well, it gives us a version of the goto statement, namely call/cc. Another part of the problem (other than the simplicity) is that the term "continuation" has many different meanings in computer science. On the one hand we have the call/cc notion of continuations, which is what's captured by Scheme's call/cc and by the Cont monad. On the other hand we have the CPS transformation that many compilers use when optimizing code. But the topics of discussion for call/cc and CPS are very different, and so it's easy to get confused if you try to think of them as the same thing. They are closely related, but they're different enough that you should keep them separate until you have some understanding of what they're about. -- Live well, ~wren