Boolean monoid under conjunction.

Boolean monoid under disjunction.

Basic operations on Compose

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

Basic operations on Const

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.

Basic operations on Cont

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.

Basic operations on ContT

Monad Transformer for Cont<'R,'T>

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).

Basic operations on Dual

The dual of a monoid, obtained by swapping the arguments of append.

Basic operations on Endo

The monoid of endomorphisms under composition.

Option<'T> monoid returning the leftmost non-None value.

Basic operations on Free Monads

Basic operations on Identity

Computation type: Simple function application.

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.

Basic operations on Kleisli

Kleisli arrows of a monad. Represents a function 'T -> 'Monad<'U>

Option<'T> monoid returning the rightmost non-None value.

Additional operations on List

Basic operations on ListT

Monad Transformer for list<'T>

Numeric wrapper for multiplication monoid (*, 1)

A Map where keys are not unique.

A type alias for NonEmptyList<'t>

A type alias for NonEmptyMap<'Key,'Value>

A type alias for NonEmptySeq<'t>

A type alias for NonEmptySet<'t>

Basic operations on NonEmptyList

A type-safe list that contains at least one element.

Basic operations on NonEmptyMap

A type-safe map that contains at least one element.

A type-safe sequence that contains at least one element.

Basic operations on NonEmptySet

A type-safe set that contains at least one element.

Additional operations on Option

Basic operations on OptionT

Monad Transformer for Option<'T>

Basic operations on ParallelArray

Array with an Applicative functor based on zipping and parallel execution.

A type alias for ParallelArray<'T>

Basic operations on Reader

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.

Basic operations on Reader

Monad Transformer for Reader<'R, 'T>

Additional operations on Result

Result<'TSuccess,'TFailure> specialized in 'TFailure = Exception

Basic operations on ResultT

Monad Transformer for Result<'T, 'E>

Additional operations on Seq

Basic operations on SeqT

Monad Transformer for seq<'T>

Basic operations on State

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.

Basic operations on StateT

Monad Transformer for State<'S, 'T>

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.

Additional operations on ValueOption

Basic operations on ValueOptionT

Monad Transformer for ValueOption<'T>

Basic operations on Writer

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".

Basic operations on WriterT

Monad Transformer for Writer<'Monoid, 'T>

Basic operations on ZipList

A sequence with an Applicative functor based on zipping.