#### preface 1.0.0 0.1.0

An opinionated library for function programming (à La Haskell)
IN THIS PACKAGE
Module . . .

## Type

`type 'a t = 'a t`

The type held by the `Monad`.

## Functions

`include Monad.WITH_RETURN with type 'a t := 'a t`
`include Bind.WITH_BIND with type 'a t := 'a t`
`val bind : ( 'a -> 'b t ) -> 'a t -> 'b t`

`bind f m` passes the result of computation `m` to function `f`.

`include Monad.WITH_RETURN with type 'a t := 'a t`
`include Bind.WITH_MAP_AND_JOIN with type 'a t := 'a t`
`val map : ( 'a -> 'b ) -> 'a t -> 'b t`

Mapping over from `'a` to `'b` over `'a t` to `'b t`.

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

`join` remove one level of monadic structure, projecting its bound argument into the outer level.

`include Monad.WITH_RETURN with type 'a t := 'a t`
`val return : 'a -> 'a t`

Lift a value from `'a` into a new `'a t`.

`include Bind.WITH_KLEISLI_COMPOSITION with type 'a t := 'a t`
`val compose_left_to_right : ( 'a -> 'b t ) -> ( 'b -> 'c t ) -> 'a -> 'c t`

Composing monadic functions using Kleisli Arrow (from left to right).

`val compose_right_to_left : ( 'b -> 'c t ) -> ( 'a -> 'b t ) -> 'a -> 'c t`

Composing monadic functions using Kleisli Arrow (from right to left).

`val lift : ( 'a -> 'b ) -> 'a t -> 'b t`

Mapping over from `'a` to `'b` over `'a t` to `'b t`.

`val lift2 : ( 'a -> 'b -> 'c ) -> 'a t -> 'b t -> 'c t`

Mapping over from `'a` and `'b` to `'c` over `'a t` and `'b t` to `'c t`.

`val lift3 : ( 'a -> 'b -> 'c -> 'd ) -> 'a t -> 'b t -> 'c t -> 'd t`

Mapping over from `'a` and `'b` and `'c` to `'d` over `'a t` and `'b t` and `'c t` to `'d t`.

`val replace : 'a -> 'b t -> 'a t`

Create a new `'a t`, replacing all values in the `'b t` by given a value of `'a`.

`val void : 'a t -> unit t`

Create a new `unit t`, replacing all values in the `'a t` by `unit`.

## Infix operators

`module Infix : Monad.INFIX with type 'a t = 'a t`
`val (=|<) : ( 'a -> 'b ) -> 'a t -> 'b t`

Infix version of `CORE`.map.

`val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t`

Infix flipped version of `CORE`.map.

`val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t`

Infix flipped version of `CORE`.bind.

`val (=<<) : ( 'a -> 'b t ) -> 'a t -> 'b t`

Infix version of `CORE`.bind.

`val (>=>) : ( 'a -> 'b t ) -> ( 'b -> 'c t ) -> 'a -> 'c t`

Infix version of `CORE`.compose_left_to_right.

`val (<=<) : ( 'b -> 'c t ) -> ( 'a -> 'b t ) -> 'a -> 'c t`

Infix version of `OPERATION`.compose_right_to_left.

`val (>>) : unit t -> 'b t -> 'b t`

Sequentially compose two actions, discarding any value produced by the first.

`val (<<) : 'a t -> unit t -> 'a t`

Sequentially compose two actions, discarding any value produced by the second.

`val (<\$>) : ( 'a -> 'b ) -> 'a t -> 'b t`
`val (<&>) : 'a t -> ( 'a -> 'b ) -> 'b t`

Flipped and infix version of `Preface_specs.Functor.CORE.map`.

`val (<\$) : 'a -> 'b t -> 'a t`
`val (\$>) : 'a t -> 'b -> 'b t`

## Syntax

`module Syntax : Monad.SYNTAX with type 'a t = 'a t`
`val let* : 'a t -> ( 'a -> 'b t ) -> 'b t`

Syntactic shortcuts for flipped version of `CORE`.bind:

`let* x = e in f` is equals to `bind (fun x -> f) e`.

`val let+ : 'a t -> ( 'a -> 'b ) -> 'b t`

Syntactic shortcuts for flipped version of `CORE`.map:

`let+ x = e in f` is equals to `map (fun x -> f) e`.