# Module type Monad_intf.S

    module type S = sig .. end

    include Monad_intf.Infix

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.

    module Monad_infix: Monad_intf.Infix  with type 'a t := 'a t

    val bind : 'a t -> ('a -> 'b t) -> 'b t

`bind t f` = `t >>= f`

    val return : 'a -> 'a t

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

    val map : 'a t -> f:('a -> 'b) -> 'b t

`map t ~f` is t >>| f.

    val join : 'a t t -> 'a t

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

    val ignore_m : 'a t -> unit 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.

    val all : 'a t list -> 'a list t

    val all_ignore : unit t list -> unit t