The type of a delimited continuation, which is answer-type polymorphic.

Functions of type a -> Delim s t b can be thought of as functions of type a / s -> b / t, which means given an a we return b, changing the answer type of the delimited computation from s to t. The take away from this is that the s and t variables representing the input and output answer type, respectively. (This notation is used in both OchaCaml and the definition of Asai's lambda/shift calculus.)

If a Delim operation does not capture the computation using one of the various shift operators (or shift does not change the answer type,) then the term is polymorphic in the answer type.

Consider a term like:

 reset $ [...] !>>= \r -> returnI (r ++ " world")

Here, the answer type of the enclosing reset is String. If the hole (specified by [...]) does not have a shift operator, or the shift operator does not change the answer type, then the answer type of the hole is polymorphic: the hole cannot change the answer type of the enclosing reset.

To make this clear, consider using a shift operator to deliver the delimited continuation to the outer reset. Doing this means you cannot modify the answer type: the returned continuation may only return a value whose type is that of the enclosing reset (because all it can do is fill in the hole):

>>> let f :: Int -> Int; f = (+1)
>>> let k = runDelim $ reset (shift2 returnI !>>= returnI . f)
>>> :t k
k :: Int -> Delim s s Int
>>> runDelim (k 5)
6

Here, the return type of the overall reset is Int. Note how the quantified variable s is both the input and output answer type of k, and the input and return are fixed to Int: thus, k cannot change the answer type of reset.

This is a simple alias for a delimited continuation which is polymorphic in its answer type. This corresponds directly to the definition of shift2.

This is a simple alias for a delimited continuation which is polymorphic in its answer type, but where the continuation is monadic even in the input. This corresponds directly to the definition of shift3.

Delimit a computation. The type variable a indicates that reset is polymorphic in its answer type.

>>> runDelim (reset $ returnI "hello")
"hello"

>>> runDelim (returnI 5)
5

Clear the current continuation and invoke our handler with it bound as a parameter.

This is the most pure definition of shift: both the continuation k and the enclosed body are pure, and may be composed with ..

This is defined in terms of Delim.

>>> runDelim $ reset $ shift0 (const "hello") !>>= returnI . (+1)
"hello"

>>> runDelim $ reset $ shift0 (\k -> (k . k) 3) !>>= returnI . (+1)
5

Clear the current continuation and invoke our handler with it bound as a parameter.

This definition of shift prohibits the continuation k from being monadic, while allowing the body to be monadic (this means k is trivially polymorphic in its answer type, while remaining Haskell98.) For this reason it is less pure than shift0 but more pure than shift2.

This is defined in terms of shift0.

>>> runDelim $ reset $ shift1 (const $ returnI "hello") !>>= returnI . (+1)
"hello"

>>> runDelim $ reset $ shift1 (\k -> returnI $ (k . k) 3) !>>= returnI . (+1)
5

Clear the current continuation and invoke our handler with it bound as a parameter.

This definition of shift is the most "genuine" as it perfectly encapsulates the typing rules of Asai's lambda/shift calculus using rank-2 polymorphism: the continuation's answer type is fully polymorphic.

This is defined in terms of shift1.

>>> runDelim $ reset $ shift2 (const $ returnI "hello") !>>= returnI . (+1)
"hello"

>>> runDelim $ reset $ shift2 (\k -> (k !>=> k) 3) !>>= returnI . (+1)
5

Clear the current continuation and invoke our handler with it bound as a parameter.

This is the most impure definition of shift in that all components of the delimited computation are monadic. It is akin to the definition of withSubCont in Amr Sabry's paper "A Monadic Framework for Delimited Continuations", available in the CC-delcont package.

Like shift2, this uses rank-2 polymorphism to ensure that the continuation k is polymorphic in its answer type.

This is defined in terms of shift2.

>>> runDelim $ reset $ shift3 (const $ returnI "hello") !>>= returnI . (+1)
"hello"

>>> runDelim $ reset $ shift3 (\k -> k $ returnI 3) !>>= returnI . (+1)
4

Traditional call/cc operator.

This is defined in terms of shift0 and Delim internally.

Run a delimited computation.

>>> runDelim (reset $ returnI "hello")
"hello"

>>> runDelim (returnI 5)
5