The continuation monad.
The continuation monad reifies computations by making them available as first class values. A continuation encapsulates an evaluation context of a host language (OCaml in our case). The continuation monad behaves like it is a function monad, except that it provides the call/cc operator. The call/cc operator calls a user provided function with a current continuaton. This continuation can be stored in a state (i.e., if the Continuation monad is composed with the State monad) and later resumed. It may also be used to implement various control structures, i.e., exceptions or coroutines.
The same as with the state monad we provide two interfaces, one with the type of final result of the computation is fixed on the module level, and another where it is a type variable.
module type S = sig ... end The unary monad interface
module type S2 = sig ... end The binary monad interface.
type of continuation monads
include S2
with type ('a, 'r) t = ('a , 'r ) cont and type 'a m = 'a and type ('a, 'e) e = ('a -> 'e ) -> 'e include Trans.S1
with type ('a, 'r) t = ('a , 'r ) cont with type 'a m = 'a with type ('a, 'e) e = ('a -> 'e ) -> 'e type ('a, 'r) t = ('a , 'r ) cont type ('a, 'e) e = ('a -> 'e ) -> 'e val lift : 'a m -> ('a , 'e ) t lifts inner monad into the resulting monad
val run : ('a , 'e ) t -> ('a , 'e ) e include Monad2 with type ('a, 'e) t := ('a , 'e ) t val void : ('a , 'e ) t -> (unit, 'e ) t void m computes m and discrards the result.
val sequence : (unit, 'e ) t -> (unit, 'e ) t sequence xs computes a sequence of computations xs in the left to right order.
val forever : ('a , 'e ) t -> ('b , 'e ) t forever xs creates a computationt that never returns.
Various function combinators lifted into the Kleisli category.
module Pair : sig ... end The pair interface lifted into the monad.
The triple interface lifted into a monad.
module Lift : sig ... end Lifts functions into the monad.
Interacting between monads and language exceptions
Lifts collection interface into the monad.
include Syntax.S2 with type ('a, 'e) t := ('a , 'e ) t val (>=>) : ('a -> ('b , 'e ) t -> ('b -> ('c , 'e ) t -> 'a -> ('c , 'e ) t f >=> g is fun x -> f x >>= g
val (!!) : 'a -> ('a , 'e ) t val (!$) : ('a -> 'b ) -> ('a , 'e ) t -> ('b , 'e ) t val (!$$) : ('a -> 'b -> 'c ) -> ('a , 'e ) t -> ('b , 'e ) t -> ('c , 'e ) t val (!$$$) :
('a -> 'b -> 'c -> 'd ) -> ('a , 'e ) t -> ('b , 'e ) t -> ('c , 'e ) t -> ('d , 'e ) t val (!$$$$) :
('a -> 'b -> 'c -> 'd -> 'e ) -> ('a , 's ) t -> ('b , 's ) t -> ('c , 's ) t -> ('d , 's ) t -> ('e , 's ) t !$$$$f is Lift.quaternary f
val (!$$$$$) :
('a -> 'b -> 'c -> 'd -> 'e -> 'f ) -> ('a , 's ) t -> ('b , 's ) t -> ('c , 's ) t -> ('d , 's ) t -> ('e , 's ) t -> ('f , 's ) t !$$$$$f is Lift.quinary f
include Syntax.Let.S2 with type ('a, 'e) t := ('a , 'e ) t val let* : ('a , 'e ) t -> ('a -> ('b , 'e ) t -> ('b , 'e ) t let* r = f x in b is f x >>= fun r -> b
val and* : ('a , 'e ) t -> ('b , 'e ) t -> ('a * 'b , 'e ) t val let+ : ('a , 'e ) t -> ('a -> 'b ) -> ('b , 'e ) t let+ r = f x in b is f x >>| fun r -> b
val and+ : ('a , 'e ) t -> ('b , 'e ) t -> ('a * 'b , 'e ) t include Core_kernel.Monad.S2 with type ('a, 'e) t := ('a , 'e ) t val (>>=) : ('a , 'e ) t -> ('a -> ('b , 'e ) t -> ('b , 'e ) t val (>>|) : ('a , 'e ) t -> ('a -> 'b ) -> ('b , 'e ) t Same as Infix, except the monad type has two arguments. The second is always just passed through.
val bind : ('a , 'e ) t -> f :('a -> ('b , 'e ) t -> ('b , 'e ) t val return : 'a -> ('a , _ ) t val map : ('a , 'e ) t -> f :('a -> 'b ) -> ('b , 'e ) t val join : (('a , 'e ) t 'e ) t -> ('a , 'e ) t val ignore_m : (_ , 'e ) t -> (unit, 'e ) t val all : ('a , 'e ) t -> ('a list'e ) t val all_unit : (unit, 'e ) t -> (unit, 'e ) t Monadic Binding Operators.
val call : f :(cc :('a -> (_ , 'e ) t -> ('a , 'e ) t -> ('a , 'e ) t Make(T)(M) wraps the monad M into the continuation monad and fix the type of the whole computation to T.t
Make2(M) wrapes the monad M into the continuation monad.