Cont.S
The unary monad interface
include Monad with type 'a t := 'a t
sequence xs
computes a sequence of computations xs
in the left to right order.
module Fn : sig ... end
Various function combinators lifted into the Kleisli category.
module Pair : sig ... end
The pair interface lifted into the monad.
module Triple : sig ... end
The triple interface lifted into a monad.
module Lift : sig ... end
Lifts functions into the monad.
module Exn : sig ... end
Interacting between monads and language exceptions
module Collection : sig ... end
Lifts collection interface into the monad.
module List : Collection.S with type 'a t := 'a list
The Monad.Collection.S interface for lists
module Seq : Collection.S with type 'a t := 'a Core_kernel.Sequence.t
The Monad.Collection.S interface for sequences
include Syntax.Let.S with type 'a t := 'a t
include Core_kernel.Monad.S with type 'a t := 'a t
module Monad_infix : sig ... end
val return : 'a -> 'a t
module Let_syntax : sig ... end
module Let : Syntax.Let.S with type 'a t := 'a t
Monadic operators, see Monad.Syntax.S for more.
Monadic operators, see Monad.Syntax.S for more.
call ~f
calls f ~cc
with the current continuation cc
.
The call ~f
computation may be computed more than once, i.e., it would be resumed every time the continuation is invoked. The captured continuation represents the computation around the call
. Thus invoking this computation will effectively escape the f
function (discarding the consequent computations) and continue with a computation that follows the call
. The continuation is multi-shot, in the sense that it can be called (resumed) multiple times (or not called at all). Every time it is called, the computation will resume at the same point, thus a computation that contains the call
can be seen as a reenterable computation, and the call
itself marks the entry point, and the continuation acts like a key that allows any computation that has it to reenter the subroutine at this point.