FSharpPlus


FSharpPlus.Data Namespace

Type/Module Description

All

Boolean monoid under conjunction.

Any

Boolean monoid under disjunction.

ChoiceT

ChoiceT<'monad>>

Compose

Basic operations on Compose

Compose<'functorF<'functorG<'t>>>

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

Const

Basic operations on Const

Const<'t, 'u>

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.

Cont

Basic operations on Cont

Cont<'r, 't>

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.

ContT

Basic operations on ContT

ContT<'r, 't>

Monad Transformer for Cont<'R,'T>

Coproduct<'functorL<'t>, 'functorR<'t>>

CoproductBase<'functorL<'t>, 'functorR<'t>>

CoproductPrimitives

DList

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

DListData<'T>

Dual

Basic operations on Dual

Dual<'t>

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

Endo

Basic operations on Endo

Endo<'t>

The monoid of endomorphisms under composition.

First<'t>

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

Free

Basic operations on Free Monads

Free<'functor<'t>, 't>

FreePrimitives

Identity

Basic operations on Identity

Identity<'t>

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.

IEnumerableM<'Monad, 'T>

IEnumeratorM<'Monad, 'T>

Internal

Kleisli

Basic operations on Kleisli

Kleisli<'t, 'monad<'u>>

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

Last<'t>

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

List

Additional operations on List

ListT

Basic operations on ListT

ListT<'monad>>

Monad Transformer for list<'T>

MonadFxStrictBuilderMod<'monad<'t>>

MonadFxStrictBuilderMod2<'monad<'t>, 'monad>

MonadPlusStrictBuilderMod<'monad<'t>>

Mult<'a>

Numeric wrapper for multiplication monoid (*, 1)

MultiMap

MultiMap<'Key, 'Value>

A Map where keys are not unique.

nelist<'t>

A type alias for NonEmptyList<'t>

nemap<'Key, 'Value>

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

neseq<'t>

A type alias for NonEmptySeq<'t>

neset<'t>

A type alias for NonEmptySet<'t>

NonEmptyList

Basic operations on NonEmptyList

NonEmptyList<'t>

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

NonEmptyListBuilder

NonEmptyListBuilderExtensions

NonEmptyMap

Basic operations on NonEmptyMap

NonEmptyMap<'Key, 'Value>

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

NonEmptySeq

NonEmptySeq<'T>

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

NonEmptySeqBuilder

NonEmptySet

Basic operations on NonEmptySet

NonEmptySet<'a>

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

Option

Additional operations on Option

OptionT

Basic operations on OptionT

OptionT<'monad>>

Monad Transformer for Option<'T>

ParallelArray

Basic operations on ParallelArray

ParallelArray<'t>

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

ParallelArrayOperators

parray<'t>

A type alias for ParallelArray<'T>

Reader

Basic operations on Reader

Reader<'r, 't>

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.

ReaderT

Basic operations on Reader

ReaderT<'r, 'monad<'t>>

Monad Transformer for Reader<'R, 'T>

Result

Additional operations on Result

ResultOrException

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

ResultT

Basic operations on ResultT

ResultT<'monad>>

Monad Transformer for Result<'T, 'E>

Seq

Additional operations on Seq

SeqT

Basic operations on SeqT

SeqT<'monad>>

SeqT<'monad, 't>

SeqT_V2

SeqTOperations (Module)

SeqTOperations (Type)

SpecialBuilders

State

Basic operations on State

State<'s, 't>

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.

StateT

Basic operations on StateT

StateT<'s, 'monad<'t * 's>>

Monad Transformer for State<'S, 'T>

Validation

Validation<'error, '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.

ValueOption

Additional operations on ValueOption

ValueOptionT

Basic operations on ValueOptionT

ValueOptionT<'monad>>

Monad Transformer for ValueOption<'T>

Writer

Basic operations on Writer

Writer<'monoid, 't>

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

WriterT

Basic operations on WriterT

WriterT<'monad<'t * 'monoid>>

Monad Transformer for Writer<'Monoid, 'T>

ZipList

Basic operations on ZipList

ZipList<'s>

A sequence with an Applicative functor based on zipping.