Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.

The Const functor, defined as Const<'T, 'U> where 'U is a phantom type. Useful for: Lens getters Its applicative instance plays a fundamental role in Lens.

Useful for: Lens getters.
Its applicative instance plays a fundamental role in Lens.

Computation type: Computations which can be interrupted and resumed.

Binding strategy: Binding a function to a monadic value creates a new continuation which uses the function as the continuation of the monadic computation.
Useful for: Complex control structures, error handling, and creating co-routines.

DList is an ordered linear structure implementing the List signature (head, tail, cons),
end-insertion (add), and O(1) append. Ordering is by insertion history.
DList is an implementation of [John Hughes' append list](http://dl.acm.org/citation.cfm?id=8475).

Binding strategy: The bound function is applied to the input value. Identity x >>= f = Identity (f x)
Useful for: Lens setters and updaters - Monads can be derived from monad transformers applied to the Identity monad.
The Identity monad is a monad that does not embody any computational strategy.
It simply applies the bound function to its input without any modification.
Computationally, there is no reason to use the Identity monad instead of the much simpler act of simply applying functions to their arguments.
The purpose of the Identity monad is its fundamental role in the theory of monad transformers.
Any monad transformer applied to the Identity monad yields a non-transformer version of that monad.
Its applicative instance plays a fundamental role in Lens.

Computation type: Computations which read values from a shared environment.

Binding strategy: Monad values are functions from the environment to a value. The bound function is applied to the bound value, and both have access to the shared environment.
Useful for: Maintaining variable bindings, or other shared environment.

Computation type: Computations which maintain state.

Binding strategy: Threads a state parameter through the sequence of bound functions so that the same state value is never used twice, giving the illusion of in-place update.

Useful for: Building computations from sequences of operations that require a shared state.

The indicates the computation state, while indicates the result.

A 'Validation' is either a value of the type 'error or 't, similar to 'Result'. However,
the 'Applicative' instance for 'Validation' accumulates errors using a 'Semigroup' on 'error.
In contrast, the Applicative for 'Result' returns only the first error.
A consequence of this is that 'Validation' is not a monad. There is no F#+ 'Bind' method since
that would violate monad rules.

Computation type: Computations which produce a stream of data in addition to the computed values.

Binding strategy: Combines the outputs of the subcomputations using mappend.
Useful for: Logging, or other computations that produce output "on the side".