# Module type List.S2

include Trans.S2
type ('a, 'e) t
type ('a, 'e) m
type ('a, 'e) e
val lift : ('a, 'e) m -> ('a, 'e) t

val run : ('a, 'e) t -> ('a, 'e) e

runs the computation

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 list -> (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.

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

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

module Seq : Collection.S with type 'a t := 'a Core_kernel.Sequence.t

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

!!x is return x

val (!\$) : ('a -> 'b) -> ('a, 'e) t -> ('b, 'e) t

!\$f is Lift.unary f

val (!\$\$) : ('a -> 'b -> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t

!\$\$f is Lift.binary f

val (!\$\$\$) : ('a -> 'b -> 'c -> 'd) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t

!\$\$\$f is Lift.ternary f

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

monoidal product

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

monoidal product

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
module Let_syntax : sig ... end
module Monad_infix : sig ... end
val bind : ('a, 'e) t -> f:('a -> ('b, 'e) t) -> ('b, 'e) t
val return : 'a -> ('a, 'b) 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 : ('a, 'e) t -> (unit, 'e) t
val all : ('a, 'e) t list -> ('a list, 'e) t
val all_unit : (unit, 'e) t list -> (unit, 'e) t
module Let : Syntax.Let.S2 with type ('a, 'e) t := ('a, 'e) t

module Syntax : Syntax.S2 with type ('a, 'e) t := ('a, 'e) t

include Choice.S2 with type ('a, 'e) t := ('a, 'e) t
include Choice.Basic2 with type ('a, 'e) t := ('a, 'e) t
val pure : 'a -> ('a, 'e) t

pure x creates a computation that results in x.

val accept : 'a -> ('a, 'e) t

accept x accepts x as a result of computation. (Same as pure x.

val reject : unit -> ('a, 'e) t

reject () rejects the rest of computation sequence, and terminate the computation with the zero result (Same as zero ()

val guard : bool -> (unit, 'e) t

guard cond ensures cond is true in the rest of computation. Otherwise the rest of the computation is rejected.

val on : bool -> (unit, 'e) t -> (unit, 'e) t

on cond x computes x only iff cond is true

val unless : bool -> (unit, 'e) t -> (unit, 'e) t

unless cond x computes x unless cond is true.

include Plus.S2 with type ('a, 'e) t := ('a, 'e) t
val zero : unit -> ('a, 'e) t

zero () constructs a zero element

val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t

plus x y an associative operation.