Module Monad_intf

module Monad_intf: sig .. end

The following identities ought to hold (for some value of =):

return x >>= f = f x
t >>= fun x -> return x = t
(t >>= f) >>= g = t >>= fun x -> (f x >>= g)

Note: >>= is the infix notation for bind)

module type Basic = sig .. end

module type Infix = sig .. end

module type S = sig .. end

module type Basic2 = sig .. end

Multi parameter monad.

module type Infix2 = sig .. end

Same as Infix, except the monad type has two arguments.

module type S2 = sig .. end

The same as S except the monad type has two arguments.

module S_to_S2: functor (X : S) -> sig .. end

module type Monad = sig .. end

The following identities ought to hold (for some value of =):

return x >>= f = f x
t >>= fun x -> return x = t
(t >>= f) >>= g = t >>= fun x -> (f x >>= g)

Note: >>= is the infix notation for bind)

The map argument to Monad.Make says how to implement the monad's map function. `Define_using_bind means to define map t ~f = bind t (fun a -> return (f a)). `Custom overrides the default implementation, presumably with something more efficient.

Some other functions returned by Monad.Make are defined in terms of map, so passing in a more efficient map will improve their efficiency as well.

t >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t to yield a value v, and then runs the computation returned by f v.

t >>| f is t >>= (fun a -> return (f a)).

A monad is an abstraction of the concept of sequencing of computations. A value of type 'a monad represents a computation that returns a value of type 'a.

bind t f = t >>= f

return v returns the (trivial) computation that returns v.

map t ~f is t >>| f.

join t is t >>= (fun t' -> t').

ignore_m t is map t ~f:(fun _ -> ()). ignore_m used to be called ignore, but we decided that was a bad name, because it shadowed the widely used Pervasives.ignore. Some monads still do let ignore = ignore_m for historical reasons.

Multi parameter monad. The second parameter get unified across all the computation. This is used to encode monads working on a multi parameter data structure like (('a,'b result)).

Same as Infix, except the monad type has two arguments. The second is always just passed through.

The same as S except the monad type has two arguments. The second is always just passed through.