Option.Make2
Make2(M)
composes the option monad with the monad M
.
include Monad2 with type ('a, 'e) t := ('a, 'e) T2(M).t
sequence xs
computes a sequence of computations xs
in the left to right order.
forever xs
creates a computationt that never returns.
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.S2 interface for lists
module Seq : Collection.S with type 'a t := 'a Core_kernel.Sequence.t
The Monad.Collection.S2 interface for sequences
include Syntax.S2 with type ('a, 'e) t := ('a, 'e) T2(M).t
f >=> g
is fun x -> f x >>= g
val (!!) : 'a -> ('a, 'e) T2(M).t
!!x
is return x
!$$f
is Lift.binary f
val (!$$$) :
('a -> 'b -> 'c -> 'd) ->
('a, 'e) T2(M).t ->
('b, 'e) T2(M).t ->
('c, 'e) T2(M).t ->
('d, 'e) T2(M).t
!$$$f
is Lift.ternary f
include Syntax.Let.S2 with type ('a, 'e) t := ('a, 'e) T2(M).t
let* r = f x in b
is f x >>= fun r -> b
let+ r = f x in b
is f x >>| fun r -> b
include Core_kernel.Monad.S2 with type ('a, 'e) t := ('a, 'e) T2(M).t
module Let_syntax : sig ... end
module Monad_infix : sig ... end
val return : 'a -> ('a, 'b) T2(M).t
module Let : Syntax.Let.S2 with type ('a, 'e) t := ('a, 'e) T2(M).t
Monadic Binding Operators.
Monadic operators, see Monad.Syntax.S2 for more.
include Choice.S2 with type ('a, 'e) t := ('a, 'e) T2(M).t
include Choice.Basic2 with type ('a, 'e) t := ('a, 'e) T2(M).t
val pure : 'a -> ('a, 'e) T2(M).t
pure x
creates a computation that results in x
.
val accept : 'a -> ('a, 'e) T2(M).t
accept x
accepts x
as a result of computation. (Same as pure x
.
val reject : unit -> ('a, 'e) T2(M).t
reject ()
rejects the rest of computation sequence, and terminate the computation with the zero
result (Same as zero ()
val guard : bool -> (unit, 'e) T2(M).t
guard cond
ensures cond
is true
in the rest of computation. Otherwise the rest of the computation is rejected.