An effect for abortive continuations.

An effect for non-abortive continuations of a program that eventually produces a result of type r.

This isn't quite as powerful as proper delimited continuations, as this doesn't provide any equivalent of the reset operator.

This can be useful as a helper effect.

Call with current continuation. The argument computation is provided the continuation of the program at the point that callCC was invoked. If the continuation is executed, then control will immediately abort and jump to the point callCC was invoked, which will then return the argument provided to the continuation.

The way higher-order actions interact with the continuation depends on the interpretation of Cont. In general, you cannot expect to interact with the continuation in any meaningful way: for example, you should not assume that you will be able to catch an exception thrown at some point in the future of the computation by using catch on the continuation.

Non-abortive call with current continuation. The argument computation is provided the continuation of the program at the point that shift was invoked. If the continuation is executed, then control will jump to the point shift was invoked, which will then return the argument provided to the continuation.

Once the program finishes, and produces an r, control will jump back to where the continuation was executed, and return that r. From that point, you may decide whether or not to modify the final r, or invoke the continuation again with a different argument.

You can also use shift to abort the execution of the program early by simply not executing the provided continuation, and instead provide the final r directly.

The way higher-order actions interact with the continuation depends on the interpretation of Shift. In general, you cannot expect to interact with the continuation in any meaningful way: for example, you should not assume that you will be able to catch an exception thrown at some point in the future of the computation by using catch on the continuation.

Run a Cont effect.

Derivs (ContC r m) = Cont ': Derivs m

Prims  (ContC r m) = Prims m

Run a Cont effect.

Compared to runCont, this is quite a bit faster, but is significantly more restrictive in what interpreters are used after it, since there are very few primitive effects that the carrier for runContFast is able to thread. In fact, of all the primitive effects provided by this library, only one satisfies ContFastThreads: namely, ReaderPrim.

Derivs (ContFastC r m) = Cont ': Derivs m

Prims  (ContFastC r m) = Prims m

Run a Shift r effect if the program returns r.

Derivs (ShiftC r m) = Shift r ': Derivs m

Prims  (ShiftC r m) = Prims m

Run a Shift r effect if the program returns r.

Compared to runShift, this is quite a bit faster, but is significantly more restrictive in what interpreters are used after it, since there are very few primitive effects that the carrier for runContFast is able to thread. In fact, of all the primitive effects provided by this library, only one satisfies ContFastThreads: namely, ReaderPrim.

Derivs (ShiftFastC r m) = Shift r ': Derivs m

Prims  (ShiftFastC r m) = Prims m

Transform a Cont effect into a Shift r effect.

ContThreads accepts the following primitive effects:

• Regional s
• Optional s (when s is a functor)
• Unravel p
• ListenPrim o (when o is a Monoid)
• ReaderPrim i

ContFastThreads accepts the following primitive effects:

• ReaderPrim i