TypeClass Class

DECLARATION
public static partial class TypeClass
NAMESPACE
LanguageExt

Methods

abs<NUM, A>(A)
SUMMARY

Find the absolute value of a number

PARAMETERS
x
A
The value to find the absolute value of
DECLARATION
[Pure]
public static A abs<NUM, A>(A x)
RETURNS
A
The non-negative absolute value of x
CONSTRAINTS
where NUM : struct Num<A>
acos<FLOAT, A>(A)
SUMMARY

Calculates an arc-cosine.

PARAMETERS
x
A
The value for which an arc-cosine is to be calculated
DECLARATION
[Pure]
public static A acos<FLOAT, A>(A x)
RETURNS
A
The value of <c>acos(x)</c>, in radians
CONSTRAINTS
where FLOAT : struct Floating<A>
acosh<FLOAT, A>(A)
SUMMARY

Calculates an area hyperbolic cosine.

PARAMETERS
x
A
The value for which an area hyperbolic cosine is to be calculated.
DECLARATION
[Pure]
public static A acosh<FLOAT, A>(A x)
RETURNS
A
The value of <c>acosh(x)</c>.
CONSTRAINTS
where FLOAT : struct Floating<A>
append<A>(HashSet<A>, HashSet<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
HashSet<A>
The left hand side of the operation
y
HashSet<A>
The right hand side of the operation
DECLARATION
[Pure]
public static HashSet<A> append<A>(HashSet<A> x, HashSet<A> y)
RETURNS
HashSet<A>
The result of the operation
append<A>(Lst<A>, Lst<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
Lst<A>
The left hand side of the operation
y
Lst<A>
The right hand side of the operation
DECLARATION
[Pure]
public static Lst<A> append<A>(Lst<A> x, Lst<A> y)
RETURNS
Lst<A>
The result of the operation
append<K, V>(HashMap<K, V>, HashMap<K, V>)
SUMMARY

An associative binary operation

PARAMETERS
x
HashMap<K, V>
The left hand side of the operation
y
HashMap<K, V>
The right hand side of the operation
DECLARATION
[Pure]
public static HashMap<K, V> append<K, V>(HashMap<K, V> x, HashMap<K, V> y)
RETURNS
HashMap<K, V>
The result of the operation
append<K, V>(Map<K, V>, Map<K, V>)
SUMMARY

An associative binary operation

PARAMETERS
x
Map<K, V>
The left hand side of the operation
y
Map<K, V>
The right hand side of the operation
DECLARATION
[Pure]
public static Map<K, V> append<K, V>(Map<K, V> x, Map<K, V> y)
RETURNS
Map<K, V>
The result of the operation
append<NEWTYPE, SEMI, A, PRED>(NewType<NEWTYPE, A, PRED>, NewType<NEWTYPE, A, PRED>)
SUMMARY

An associative binary operation

PARAMETERS
x
NewType<NEWTYPE, A, PRED>
The left hand side of the operation
y
NewType<NEWTYPE, A, PRED>
The right hand side of the operation
DECLARATION
[Pure]
public static NEWTYPE append<NEWTYPE, SEMI, A, PRED>(NewType<NEWTYPE, A, PRED> x, NewType<NEWTYPE, A, PRED> y)
RETURNS
NEWTYPE
The result of the operation
CONSTRAINTS
where NEWTYPE : NewType<NEWTYPE, A, PRED>
where PRED : struct Pred<A>
where SEMI : struct Semigroup<A>
append<NEWTYPE, SEMI, A>(NewType<NEWTYPE, A>, NewType<NEWTYPE, A>)
SUMMARY

An associative binary operation

PARAMETERS
x
NewType<NEWTYPE, A>
The left hand side of the operation
y
NewType<NEWTYPE, A>
The right hand side of the operation
DECLARATION
[Pure]
public static NEWTYPE append<NEWTYPE, SEMI, A>(NewType<NEWTYPE, A> x, NewType<NEWTYPE, A> y)
RETURNS
NEWTYPE
The result of the operation
CONSTRAINTS
where NEWTYPE : NewType<NEWTYPE, A>
where SEMI : struct Semigroup<A>
append<NUMTYPE, NUM, A, PRED>(NumType<NUMTYPE, NUM, A, PRED>, NumType<NUMTYPE, NUM, A, PRED>)
SUMMARY

An associative binary operation

PARAMETERS
x
NumType<NUMTYPE, NUM, A, PRED>
The left hand side of the operation
y
NumType<NUMTYPE, NUM, A, PRED>
The right hand side of the operation
DECLARATION
[Pure]
public static NUMTYPE append<NUMTYPE, NUM, A, PRED>(NumType<NUMTYPE, NUM, A, PRED> x, NumType<NUMTYPE, NUM, A, PRED> y)
RETURNS
NUMTYPE
The result of the operation
CONSTRAINTS
where NUMTYPE : NumType<NUMTYPE, NUM, A, PRED>
where PRED : struct Pred<A>
where NUM : struct Num<A>
append<NUMTYPE, NUM, A>(NumType<NUMTYPE, NUM, A>, NumType<NUMTYPE, NUM, A>)
SUMMARY

An associative binary operation

PARAMETERS
x
NumType<NUMTYPE, NUM, A>
The left hand side of the operation
y
NumType<NUMTYPE, NUM, A>
The right hand side of the operation
DECLARATION
[Pure]
public static NUMTYPE append<NUMTYPE, NUM, A>(NumType<NUMTYPE, NUM, A> x, NumType<NUMTYPE, NUM, A> y)
RETURNS
NUMTYPE
The result of the operation
CONSTRAINTS
where NUMTYPE : NumType<NUMTYPE, NUM, A>
where NUM : struct Num<A>
append<SEMI, A>(A, A)
SUMMARY

An associative binary operation

PARAMETERS
x
A
The left hand side of the operation
y
A
The right hand side of the operation
DECLARATION
[Pure]
public static A append<SEMI, A>(A x, A y)
RETURNS
A
The result of the operation
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, A>(Option<A>, Option<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
Option<A>
The left hand side of the operation
y
Option<A>
The right hand side of the operation
DECLARATION
[Pure]
public static Option<A> append<SEMI, A>(Option<A> x, Option<A> y)
RETURNS
Option<A>
The result of the operation
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, A>(OptionUnsafe<A>, OptionUnsafe<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
OptionUnsafe<A>
The left hand side of the operation
y
OptionUnsafe<A>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<A> append<SEMI, A>(OptionUnsafe<A> x, OptionUnsafe<A> y)
RETURNS
OptionUnsafe<A>
The result of the operation
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, A>(IEnumerable<A>, IEnumerable<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
IEnumerable<A>
The left hand side of the operation
y
IEnumerable<A>
The right hand side of the operation
DECLARATION
[Pure]
public static IEnumerable<A> append<SEMI, A>(IEnumerable<A> x, IEnumerable<A> y)
RETURNS
IEnumerable<A>
The result of the operation
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, A>(Try<A>, Try<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
Try<A>
The left hand side of the operation
y
Try<A>
The right hand side of the operation
DECLARATION
[Pure]
public static Try<A> append<SEMI, A>(Try<A> x, Try<A> y)
RETURNS
Try<A>
The result of the operation
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, A>(TryOption<A>, TryOption<A>)
SUMMARY

An associative binary operation

PARAMETERS
x
TryOption<A>
The left hand side of the operation
y
TryOption<A>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOption<A> append<SEMI, A>(TryOption<A> x, TryOption<A> y)
RETURNS
TryOption<A>
The result of the operation
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, L, R>(Either<L, R>, Either<L, R>)
SUMMARY

An associative binary operation

PARAMETERS
lhs
Either<L, R>
Left-hand side of the operation
rhs
Either<L, R>
Right-hand side of the operation
DECLARATION
[Pure]
public static Either<L, R> append<SEMI, L, R>(Either<L, R> lhs, Either<L, R> rhs)
RETURNS
Either<L, R>
lhs + rhs
CONSTRAINTS
where SEMI : struct Semigroup<R>
append<SEMI, L, R>(EitherUnsafe<L, R>, EitherUnsafe<L, R>)
SUMMARY

An associative binary operation

PARAMETERS
lhs
EitherUnsafe<L, R>
Left-hand side of the operation
rhs
EitherUnsafe<L, R>
Right-hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, R> append<SEMI, L, R>(EitherUnsafe<L, R> lhs, EitherUnsafe<L, R> rhs)
RETURNS
EitherUnsafe<L, R>
lhs + rhs
CONSTRAINTS
where SEMI : struct Semigroup<R>
asEnumerable<OPT, OA, A>(OA)
SUMMARY

Convert the Option to an enumerable of zero or one items

PARAMETERS
ma
OA
Option
DECLARATION
[Pure]
public static Seq<A> asEnumerable<OPT, OA, A>(OA ma)
RETURNS
Seq<A>
An enumerable of zero or one items
CONSTRAINTS
where OPT : struct Optional<OA, A>
asEnumerableAsync<OPT, OA, A>(OA)
SUMMARY

Convert the Option to an enumerable of zero or one items

PARAMETERS
ma
OA
Option
DECLARATION
[Pure]
public static Task<Seq<A>> asEnumerableAsync<OPT, OA, A>(OA ma)
RETURNS
Task<Seq<A>>
An enumerable of zero or one items
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
asin<FLOAT, A>(A)
SUMMARY

Calculates an arcsine.

PARAMETERS
x
A
The value for which an arcsine is to be calculated.
DECLARATION
[Pure]
public static A asin<FLOAT, A>(A x)
RETURNS
A
The value of <c>asin(x)</c>, in radians.
CONSTRAINTS
where FLOAT : struct Floating<A>
asinh<FLOAT, A>(A)
SUMMARY

Calculates an area hyperbolic sine

PARAMETERS
x
A
The value for which an area hyperbolic sine is to be calculated.
DECLARATION
[Pure]
public static A asinh<FLOAT, A>(A x)
RETURNS
A
The value of <c>asinh(x)</c>.
CONSTRAINTS
where FLOAT : struct Floating<A>
atan<FLOAT, A>(A)
SUMMARY

Calculates an arc-tangent.

PARAMETERS
x
A
The value for which an arc-tangent is to be calculated
DECLARATION
[Pure]
public static A atan<FLOAT, A>(A x)
RETURNS
A
The value of <c>atan(x)</c>, in radians
CONSTRAINTS
where FLOAT : struct Floating<A>
atanh<FLOAT, A>(A)
SUMMARY

Calculates an area hyperbolic tangent.

PARAMETERS
x
A
The value for which an area hyperbolic tangent is to be calculated.
DECLARATION
[Pure]
public static A atanh<FLOAT, A>(A x)
RETURNS
A
The value of <c>atanh(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
biExists<FOLD, F, A, B>(F, Func<A, bool>, Func<B, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate returns true for any item then the operation immediately returns true. False is returned if no items in the structure match the predicate.

NOTE: An empty structure will return false.

PARAMETERS
foldable
F
preda
Func<A, bool>
predb
Func<B, bool>
DECLARATION
[Pure]
public static bool biExists<FOLD, F, A, B>(F foldable, Func<A, bool> preda, Func<B, bool> predb)
RETURNS
bool
True if the predicate holds for all values
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
biExistsAsync<FOLD, F, A, B>(F, Func<A, bool>, Func<B, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate returns true for any item then the operation immediately returns true. False is returned if no items in the structure match the predicate.

NOTE: An empty structure will return false.

PARAMETERS
foldable
F
preda
Func<A, bool>
predb
Func<B, bool>
DECLARATION
[Pure]
public static async Task<bool> biExistsAsync<FOLD, F, A, B>(F foldable, Func<A, bool> preda, Func<B, bool> predb)
RETURNS
Task<bool>
True if the predicate holds for all values
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFold<FOLD, F, A, B, S>(F, S, Func<S, A, S>, Func<S, B, S>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, S>
Folder function, applied for each item in foldable
fb
Func<S, B, S>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static S biFold<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, S> fa, Func<S, B, S> fb)
RETURNS
S
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
biFoldAsync<FOLD, F, A, B, S>(F, S, Func<S, A, S>, Func<S, B, S>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, S>
Folder function, applied for each item in foldable
fb
Func<S, B, S>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, S> fa, Func<S, B, S> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldAsync<FOLD, F, A, B, S>(F, S, Func<S, A, Task<S>>, Func<S, B, S>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, Task<S>>
Folder function, applied for each item in foldable
fb
Func<S, B, S>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, Task<S>> fa, Func<S, B, S> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldAsync<FOLD, F, A, B, S>(F, S, Func<S, A, S>, Func<S, B, Task<S>>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, S>
Folder function, applied for each item in foldable
fb
Func<S, B, Task<S>>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, S> fa, Func<S, B, Task<S>> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldAsync<FOLD, F, A, B, S>(F, S, Func<S, A, Task<S>>, Func<S, B, Task<S>>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, Task<S>>
Folder function, applied for each item in foldable
fb
Func<S, B, Task<S>>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, Task<S>> fa, Func<S, B, Task<S>> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldBack<FOLD, F, A, B, S>(F, S, Func<S, A, S>, Func<S, B, S>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, S>
Folder function, applied for each item in foldable
fb
Func<S, B, S>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static S biFoldBack<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, S> fa, Func<S, B, S> fb)
RETURNS
S
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
biFoldBackAsync<FOLD, F, A, B, S>(F, S, Func<S, A, S>, Func<S, B, S>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, S>
Folder function, applied for each item in foldable
fb
Func<S, B, S>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldBackAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, S> fa, Func<S, B, S> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldBackAsync<FOLD, F, A, B, S>(F, S, Func<S, A, Task<S>>, Func<S, B, S>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, Task<S>>
Folder function, applied for each item in foldable
fb
Func<S, B, S>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldBackAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, Task<S>> fa, Func<S, B, S> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldBackAsync<FOLD, F, A, B, S>(F, S, Func<S, A, S>, Func<S, B, Task<S>>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, S>
Folder function, applied for each item in foldable
fb
Func<S, B, Task<S>>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldBackAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, S> fa, Func<S, B, Task<S>> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biFoldBackAsync<FOLD, F, A, B, S>(F, S, Func<S, A, Task<S>>, Func<S, B, Task<S>>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
foldable
F
state
S
Initial state
fa
Func<S, A, Task<S>>
Folder function, applied for each item in foldable
fb
Func<S, B, Task<S>>
Folder function, applied for each item in foldable
DECLARATION
[Pure]
public static Task<S> biFoldBackAsync<FOLD, F, A, B, S>(F foldable, S state, Func<S, A, Task<S>> fa, Func<S, B, Task<S>> fb)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biForAll<FOLD, F, A, B>(F, Func<A, bool>, Func<B, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate holds for all values then true is returned.

NOTE: An empty structure will return true.

PARAMETERS
foldable
F
preda
Func<A, bool>
predb
Func<B, bool>
DECLARATION
[Pure]
public static bool biForAll<FOLD, F, A, B>(F foldable, Func<A, bool> preda, Func<B, bool> predb)
RETURNS
bool
True if the predicate holds for all values
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
biForAllAsync<FOLD, F, A, B>(F, Func<A, bool>, Func<B, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate holds for all values then true is returned.

NOTE: An empty structure will return true.

PARAMETERS
foldable
F
preda
Func<A, bool>
predb
Func<B, bool>
DECLARATION
[Pure]
public static async Task<bool> biForAllAsync<FOLD, F, A, B>(F foldable, Func<A, bool> preda, Func<B, bool> predb)
RETURNS
Task<bool>
True if the predicate holds for all values
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
biIter<FOLD, F, A, B>(F, Action<A>, Action<B>)
SUMMARY

Iterate the values in the foldable

PARAMETERS
foldable
F
Foldable to perform the operation on
fa
Action<A>
fb
Action<B>
DECLARATION
public static Unit biIter<FOLD, F, A, B>(F foldable, Action<A> fa, Action<B> fb)
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
biIterAsync<FOLD, F, A, B>(F, Action<A>, Action<B>)
SUMMARY

Iterate the values in the foldable

PARAMETERS
foldable
F
Foldable to perform the operation on
fa
Action<A>
fb
Action<B>
DECLARATION
public static Task<Unit> biIterAsync<FOLD, F, A, B>(F foldable, Action<A> fa, Action<B> fb)
RETURNS
Task<Unit>
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
bimap<BiFunctorAB, FAB, FR, A, B, R>(FAB, Func<A, R>, Func<B, R>)
SUMMARY

Projection from one bi-functor to another. This operation should map only one of the items (A, or B). The type R should match A, or B depending on which item is being mapped.

PARAMETERS
ma
FAB
Functor value to map from
fa
Func<A, R>
Projection function
fb
Func<B, R>
Projection function
DECLARATION
[Pure]
public static FR bimap<BiFunctorAB, FAB, FR, A, B, R>(FAB ma, Func<A, R> fa, Func<B, R> fb)
RETURNS
FR
Mapped functor
CONSTRAINTS
where BiFunctorAB : BiFunctor<FAB, FR, A, B, R>
bimap<BiFunctorAB, FAB, FUV, A, B, U, V>(FAB, Func<A, U>, Func<B, V>)
SUMMARY

Projection from one value to another. Both elements of the bi-functor can will be mapped to a new result value.

PARAMETERS
ma
FAB
Functor value to map from
fa
Func<A, U>
Projection function
fb
Func<B, V>
Projection function
DECLARATION
[Pure]
public static FUV bimap<BiFunctorAB, FAB, FUV, A, B, U, V>(FAB ma, Func<A, U> fa, Func<B, V> fb)
RETURNS
FUV
Mapped functor
CONSTRAINTS
where BiFunctorAB : BiFunctor<FAB, FUV, A, B, U, V>
bind<MONADA, MONADB, MA, MB, A, B>(MA, Func<A, MB>)
SUMMARY

Monadic bind

PARAMETERS
ma
MA
Monad to bind
f
Func<A, MB>
Bind function
DECLARATION
[Pure]
public static MB bind<MONADA, MONADB, MA, MB, A, B>(MA ma, Func<A, MB> f)
RETURNS
MB
Monad of B
CONSTRAINTS
where MONADA : struct Monad<MA, A>
where MONADB : struct Monad<MB, B>
collect<FOLD, F, A, B, C>(F, Func<A, C>, Func<B, C>)
SUMMARY

Convert the foldable to a sequence (IEnumerable) performing a map operation on each item in the structure

PARAMETERS
foldable
F
fa
Func<A, C>
fb
Func<B, C>
DECLARATION
[Pure]
public static IEnumerable<C> collect<FOLD, F, A, B, C>(F foldable, Func<A, C> fa, Func<B, C> fb)
RETURNS
IEnumerable<C>
Sequence of As that represent the value(s) in the structure
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
collect<FOLD, F, A, B>(F, Func<A, B>)
SUMMARY

Convert the foldable to a sequence (IEnumerable) performing a map operation on each item in the structure

PARAMETERS
self
F
Foldable to performt the operation on
f
Func<A, B>
DECLARATION
[Pure]
public static Seq<B> collect<FOLD, F, A, B>(F self, Func<A, B> f)
RETURNS
Seq<B>
Sequence of As that represent the value(s) in the structure
CONSTRAINTS
where FOLD : Foldable<F, A>
collectAsync<FOLD, F, A, B, C>(F, Func<A, C>, Func<B, C>)
SUMMARY

Convert the foldable to a sequence (IEnumerable) performing a map operation on each item in the structure

PARAMETERS
foldable
F
fa
Func<A, C>
fb
Func<B, C>
DECLARATION
[Pure]
public static Task<IEnumerable<C>> collectAsync<FOLD, F, A, B, C>(F foldable, Func<A, C> fa, Func<B, C> fb)
RETURNS
Task<IEnumerable<C>>
Sequence of As that represent the value(s) in the structure
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
collectAsync<FOLD, F, A, B>(F, Func<A, B>)
SUMMARY

Convert the foldable to a sequence (IEnumerable) performing a map operation on each item in the structure

PARAMETERS
self
F
Foldable to performt the operation on
f
Func<A, B>
DECLARATION
[Pure]
public static Task<IEnumerable<B>> collectAsync<FOLD, F, A, B>(F self, Func<A, B> f)
RETURNS
Task<IEnumerable<B>>
Sequence of As that represent the value(s) in the structure
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
compare<MonoidA, ORDA, ORDB, A, B>(Validation<MonoidA, A, B>, Validation<MonoidA, A, B>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
Validation<MonoidA, A, B>
The first item to compare
y
Validation<MonoidA, A, B>
The second item to compare
DECLARATION
[Pure]
public static int compare<MonoidA, ORDA, ORDB, A, B>(Validation<MonoidA, A, B> x, Validation<MonoidA, A, B> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where MonoidA : struct Monoid<A> Eq<A>
where ORDA : struct Ord<A>
where ORDB : struct Ord<B>
compare<NEWTYPE, NUM, T, PRED>(NEWTYPE, NumType<NEWTYPE, NUM, T, PRED>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
NEWTYPE
The first item to compare
y
NumType<NEWTYPE, NUM, T, PRED>
The second item to compare
DECLARATION
[Pure]
public static int compare<NEWTYPE, NUM, T, PRED>(NEWTYPE x, NumType<NEWTYPE, NUM, T, PRED> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where NUM : struct Num<T>
where PRED : struct Pred<T>
where NEWTYPE : NumType<NEWTYPE, NUM, T, PRED>
compare<NEWTYPE, ORD, T, PRED>(NEWTYPE, NEWTYPE)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
NEWTYPE
The first item to compare
y
NEWTYPE
The second item to compare
DECLARATION
[Pure]
public static int compare<NEWTYPE, ORD, T, PRED>(NEWTYPE x, NEWTYPE y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<T>
where PRED : struct Pred<T>
where NEWTYPE : NewType<NEWTYPE, T, PRED>
compare<ORD, A>(A, A)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
A
The first item to compare
y
A
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(A x, A y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, A>(Option<A>, Option<A>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
Option<A>
The first item to compare
y
Option<A>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(Option<A> x, Option<A> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, A>(OptionUnsafe<A>, OptionUnsafe<A>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
OptionUnsafe<A>
The first item to compare
y
OptionUnsafe<A>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(OptionUnsafe<A> x, OptionUnsafe<A> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, A>(A, A)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
A
The first item to compare
y
A
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(A x, A y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, A>(Lst<A>, Lst<A>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
Lst<A>
The first item to compare
y
Lst<A>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(Lst<A> x, Lst<A> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, A>(TryOption<A>, TryOption<A>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
TryOption<A>
The first item to compare
y
TryOption<A>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(TryOption<A> x, TryOption<A> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, A>(Try<A>, Try<A>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
Try<A>
The first item to compare
y
Try<A>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, A>(Try<A> x, Try<A> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<A>
compare<ORD, L, R>(Either<L, R>, Either<L, R>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
Either<L, R>
The first item to compare
y
Either<L, R>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, L, R>(Either<L, R> x, Either<L, R> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<R>
compare<ORD, L, R>(EitherUnsafe<L, R>, EitherUnsafe<L, R>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
EitherUnsafe<L, R>
The first item to compare
y
EitherUnsafe<L, R>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORD, L, R>(EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORD : struct Ord<R>
compare<ORDA, ORDB, A, B>(Either<A, B>, Either<A, B>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
Either<A, B>
The first item to compare
y
Either<A, B>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORDA, ORDB, A, B>(Either<A, B> x, Either<A, B> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORDA : struct Ord<A>
where ORDB : struct Ord<B>
compare<ORDA, ORDB, A, B>(EitherUnsafe<A, B>, EitherUnsafe<A, B>)
SUMMARY

Compare one item to another to ascertain ordering

PARAMETERS
x
EitherUnsafe<A, B>
The first item to compare
y
EitherUnsafe<A, B>
The second item to compare
DECLARATION
[Pure]
public static int compare<ORDA, ORDB, A, B>(EitherUnsafe<A, B> x, EitherUnsafe<A, B> y)
RETURNS
int
0 if x is equal to y -1 if x greater than y 1 if x less than y
CONSTRAINTS
where ORDA : struct Ord<A>
where ORDB : struct Ord<B>
contains<EQ, FOLD, F, A, B>(F, A)
SUMMARY

Does the element occur in the structure?

PARAMETERS
foldable
F
Foldable
item
A
Item to test
DECLARATION
[Pure]
public static bool contains<EQ, FOLD, F, A, B>(F foldable, A item)
RETURNS
bool
True if item in the structure
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
where EQ : struct Eq<A>
contains<EQ, FOLD, F, A, B>(F, B)
SUMMARY

Does the element occur in the structure?

PARAMETERS
foldable
F
Foldable
item
B
Item to test
DECLARATION
[Pure]
public static bool contains<EQ, FOLD, F, A, B>(F foldable, B item)
RETURNS
bool
True if item in the structure
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
where EQ : struct Eq<B>
contains<EQ, FOLD, F, A>(F, A)
SUMMARY

Does the element occur in the structure?

PARAMETERS
fa
F
Foldable
item
A
Item to test
DECLARATION
[Pure]
public static bool contains<EQ, FOLD, F, A>(F fa, A item)
RETURNS
bool
True if item in the structure
CONSTRAINTS
where EQ : struct Eq<A>
where FOLD : Foldable<F, A>
containsAsync<EQ, FOLD, F, A, B>(F, A)
SUMMARY

Does the element occur in the structure?

PARAMETERS
foldable
F
Foldable
item
A
Item to test
DECLARATION
[Pure]
public static async Task<bool> containsAsync<EQ, FOLD, F, A, B>(F foldable, A item)
RETURNS
Task<bool>
True if item in the structure
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
where EQ : struct Eq<A>
containsAsync<EQ, FOLD, F, A, B>(F, B)
SUMMARY

Does the element occur in the structure?

PARAMETERS
foldable
F
Foldable
item
B
Item to test
DECLARATION
[Pure]
public static async Task<bool> containsAsync<EQ, FOLD, F, A, B>(F foldable, B item)
RETURNS
Task<bool>
True if item in the structure
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
where EQ : struct Eq<B>
containsAsync<EQ, FOLD, F, A>(F, A)
SUMMARY

Does the element occur in the structure?

PARAMETERS
fa
F
Foldable
item
A
Item to test
DECLARATION
[Pure]
public static async Task<bool> containsAsync<EQ, FOLD, F, A>(F fa, A item)
RETURNS
Task<bool>
True if item in the structure
CONSTRAINTS
where EQ : struct Eq<A>
where FOLD : FoldableAsync<F, A>
cos<FLOAT, A>(A)
SUMMARY

Calculates the cosine of an angle.

PARAMETERS
x
A
An angle, in radians
DECLARATION
[Pure]
public static A cos<FLOAT, A>(A x)
RETURNS
A
The value of <c>cos(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
cosh<FLOAT, A>(A)
SUMMARY

Calculates a hyperbolic cosine.

PARAMETERS
x
A
The value for which a hyperbolic cosine is to be calculated
DECLARATION
[Pure]
public static A cosh<FLOAT, A>(A x)
RETURNS
A
The value of <c>cosh(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
count<FOLD, F, A>(F)
SUMMARY

Find the length of a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static int count<FOLD, F, A>(F fa)
RETURNS
int
True if empty, False otherwise
CONSTRAINTS
where FOLD : Foldable<F, A>
countAsync<FOLD, F, A>(F)
SUMMARY

Find the length of a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static Task<int> countAsync<FOLD, F, A>(F fa)
RETURNS
Task<int>
True if empty, False otherwise
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
divide<NUM, A>(A, A)
SUMMARY

Divide two numbers

PARAMETERS
x
A
left hand side of the division operation
y
A
right hand side of the division operation
DECLARATION
[Pure]
public static A divide<NUM, A>(A x, A y)
RETURNS
A
x / y
CONSTRAINTS
where NUM : struct Num<A>
equals<EQ, A>(A, A)
SUMMARY

Structural equality test

PARAMETERS
x
A
The left hand side of the equality operation
y
A
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(A x, A y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(Option<A>, Option<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Option<A>
The left hand side of the equality operation
y
Option<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Option<A> x, Option<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(OptionUnsafe<A>, OptionUnsafe<A>)
SUMMARY

Structural equality test

PARAMETERS
x
OptionUnsafe<A>
The left hand side of the equality operation
y
OptionUnsafe<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(OptionUnsafe<A> x, OptionUnsafe<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(A?, A?)
SUMMARY

Structural equality test

PARAMETERS
x
A?
The left hand side of the equality operation
y
A?
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(A? x, A? y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
where A : struct
equals<EQ, A>(Try<A>, Try<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Try<A>
The left hand side of the equality operation
y
Try<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Try<A> x, Try<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(TryOption<A>, TryOption<A>)
SUMMARY

Structural equality test

PARAMETERS
x
TryOption<A>
The left hand side of the equality operation
y
TryOption<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(TryOption<A> x, TryOption<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(Lst<A>, Lst<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Lst<A>
The left hand side of the equality operation
y
Lst<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Lst<A> x, Lst<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(HashSet<A>, HashSet<A>)
SUMMARY

Structural equality test

PARAMETERS
x
HashSet<A>
The left hand side of the equality operation
y
HashSet<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(HashSet<A> x, HashSet<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(Que<A>, Que<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Que<A>
The left hand side of the equality operation
y
Que<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Que<A> x, Que<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(Set<A>, Set<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Set<A>
The left hand side of the equality operation
y
Set<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Set<A> x, Set<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(Arr<A>, Arr<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Arr<A>
The left hand side of the equality operation
y
Arr<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Arr<A> x, Arr<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(A, A)
SUMMARY

Structural equality test

PARAMETERS
x
A
The left hand side of the equality operation
y
A
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(A x, A y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(IEnumerable<A>, IEnumerable<A>)
SUMMARY

Structural equality test

PARAMETERS
x
IEnumerable<A>
The left hand side of the equality operation
y
IEnumerable<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(IEnumerable<A> x, IEnumerable<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, A>(Seq<A>, Seq<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Seq<A>
The left hand side of the equality operation
y
Seq<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, A>(Seq<A> x, Seq<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(A, A)
SUMMARY

Structural equality test

PARAMETERS
x
A
The left hand side of the equality operation
y
A
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this A x, A y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(Arr<A>, Arr<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Arr<A>
The left hand side of the equality operation
y
Arr<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Arr<A> x, Arr<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(HashSet<A>, HashSet<A>)
SUMMARY

Structural equality test

PARAMETERS
x
HashSet<A>
The left hand side of the equality operation
y
HashSet<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this HashSet<A> x, HashSet<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(Que<A>, Que<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Que<A>
The left hand side of the equality operation
y
Que<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Que<A> x, Que<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(Stck<A>, Stck<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Stck<A>
The left hand side of the equality operation
y
Stck<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Stck<A> x, Stck<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(A, A)
SUMMARY

Structural equality test

PARAMETERS
x
A
The left hand side of the equality operation
y
A
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this A x, A y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(Option<A>, Option<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Option<A>
The left hand side of the equality operation
y
Option<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Option<A> x, Option<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(OptionUnsafe<A>, OptionUnsafe<A>)
SUMMARY

Structural equality test

PARAMETERS
x
OptionUnsafe<A>
The left hand side of the equality operation
y
OptionUnsafe<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this OptionUnsafe<A> x, OptionUnsafe<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(A?, A?)
SUMMARY

Structural equality test

PARAMETERS
x
A?
The left hand side of the equality operation
y
A?
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this A? x, A? y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
where A : struct
Equals<EQ, A>(Try<A>, Try<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Try<A>
The left hand side of the equality operation
y
Try<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Try<A> x, Try<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(TryOption<A>, TryOption<A>)
SUMMARY

Structural equality test

PARAMETERS
x
TryOption<A>
The left hand side of the equality operation
y
TryOption<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this TryOption<A> x, TryOption<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(Lst<A>, Lst<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Lst<A>
The left hand side of the equality operation
y
Lst<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Lst<A> x, Lst<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(IEnumerable<A>, IEnumerable<A>)
SUMMARY

Structural equality test

PARAMETERS
x
IEnumerable<A>
The left hand side of the equality operation
y
IEnumerable<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this IEnumerable<A> x, IEnumerable<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
Equals<EQ, A>(Seq<A>, Seq<A>)
SUMMARY

Structural equality test

PARAMETERS
x
Seq<A>
The left hand side of the equality operation
y
Seq<A>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, A>(this Seq<A> x, Seq<A> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
equals<EQ, L, R>(Either<L, R>, Either<L, R>)
SUMMARY

Structural equality test

PARAMETERS
x
Either<L, R>
The left hand side of the equality operation
y
Either<L, R>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, L, R>(Either<L, R> x, Either<L, R> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<R>
equals<EQ, L, R>(EitherUnsafe<L, R>, EitherUnsafe<L, R>)
SUMMARY

Structural equality test

PARAMETERS
x
EitherUnsafe<L, R>
The left hand side of the equality operation
y
EitherUnsafe<L, R>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQ, L, R>(EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<R>
Equals<EQ, L, R>(Either<L, R>, Either<L, R>)
SUMMARY

Structural equality test

PARAMETERS
x
Either<L, R>
The left hand side of the equality operation
y
Either<L, R>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, L, R>(this Either<L, R> x, Either<L, R> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<R>
Equals<EQ, L, R>(EitherUnsafe<L, R>, EitherUnsafe<L, R>)
SUMMARY

Structural equality test

PARAMETERS
x
EitherUnsafe<L, R>
The left hand side of the equality operation
y
EitherUnsafe<L, R>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQ, L, R>(this EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<R>
equals<EQA, EQB, A, B>(Either<A, B>, Either<A, B>)
SUMMARY

Structural equality test

PARAMETERS
x
Either<A, B>
The left hand side of the equality operation
y
Either<A, B>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQA, EQB, A, B>(Either<A, B> x, Either<A, B> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQA : struct Eq<A>
where EQB : struct Eq<B>
equals<EQA, EQB, A, B>(EitherUnsafe<A, B>, EitherUnsafe<A, B>)
SUMMARY

Structural equality test

PARAMETERS
x
EitherUnsafe<A, B>
The left hand side of the equality operation
y
EitherUnsafe<A, B>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<EQA, EQB, A, B>(EitherUnsafe<A, B> x, EitherUnsafe<A, B> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQA : struct Eq<A>
where EQB : struct Eq<B>
Equals<EQA, EQB, A, B>(Either<A, B>, Either<A, B>)
SUMMARY

Structural equality test

PARAMETERS
x
Either<A, B>
The left hand side of the equality operation
y
Either<A, B>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQA, EQB, A, B>(this Either<A, B> x, Either<A, B> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQA : struct Eq<A>
where EQB : struct Eq<B>
Equals<EQA, EQB, A, B>(EitherUnsafe<A, B>, EitherUnsafe<A, B>)
SUMMARY

Structural equality test

PARAMETERS
x
EitherUnsafe<A, B>
The left hand side of the equality operation
y
EitherUnsafe<A, B>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool Equals<EQA, EQB, A, B>(this EitherUnsafe<A, B> x, EitherUnsafe<A, B> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQA : struct Eq<A>
where EQB : struct Eq<B>
equals<NEWTYPE, EQ, A, PRED>(NewType<NEWTYPE, A, PRED>, NewType<NEWTYPE, A, PRED>)
SUMMARY

Structural equality test

PARAMETERS
x
NewType<NEWTYPE, A, PRED>
The left hand side of the equality operation
y
NewType<NEWTYPE, A, PRED>
The right hand side of the equality operation
DECLARATION
[Pure]
public static bool equals<NEWTYPE, EQ, A, PRED>(NewType<NEWTYPE, A, PRED> x, NewType<NEWTYPE, A, PRED> y)
RETURNS
bool
True if x and y are equal
CONSTRAINTS
where EQ : struct Eq<A>
where PRED : struct Pred<A>
where NEWTYPE : NewType<NEWTYPE, A, PRED>
exists<FOLD, F, A>(F, Func<A, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate returns true for any item then the operation immediately returns true. False is returned if no items in the structure match the predicate.

NOTE: An empty structure will return false.

PARAMETERS
fa
F
pred
Func<A, bool>
Predicate to apply
DECLARATION
[Pure]
public static bool exists<FOLD, F, A>(F fa, Func<A, bool> pred)
RETURNS
bool
True if the predicate holds for all values
CONSTRAINTS
where FOLD : Foldable<F, A>
existsAsync<FOLD, F, A>(F, Func<A, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate returns true for any item then the operation immediately returns true. False is returned if no items in the structure match the predicate.

NOTE: An empty structure will return false.

PARAMETERS
fa
F
pred
Func<A, bool>
Predicate to apply
DECLARATION
[Pure]
public static async Task<bool> existsAsync<FOLD, F, A>(F fa, Func<A, bool> pred)
RETURNS
Task<bool>
True if the predicate holds for all values
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
exp<FLOAT, A>(A)
SUMMARY

The exponential function.

PARAMETERS
x
A
The value for which we are calculating the exponential
DECLARATION
[Pure]
public static A exp<FLOAT, A>(A x)
RETURNS
A
The value of <c>e^x</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
fail<MONAD, MA, A>(Exception)
SUMMARY

Produce a failure value

PARAMETERS
err
Exception
DECLARATION
[Pure]
public static MA fail<MONAD, MA, A>(Exception err = null)
RETURNS
MA
CONSTRAINTS
where MONAD : struct Monad<MA, A>
filter<MPLUS, MA, A>(MA, Func<A, bool>)
SUMMARY

Filters the monad if the predicate doesn't hold

PARAMETERS
ma
MA
The monads filter
pred
Func<A, bool>
DECLARATION
[Pure]
public static MA filter<MPLUS, MA, A>(MA ma, Func<A, bool> pred)
RETURNS
MA
The filtered (or not) monad
CONSTRAINTS
where MPLUS : struct Monad<MA, A>
fold<FOLD, F, A, S>(F, S, Func<S, A, S>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
fa
F
state
S
Initial state
f
Func<S, A, S>
Folder function, applied for each item in fa
DECLARATION
[Pure]
public static S fold<FOLD, F, A, S>(F fa, S state, Func<S, A, S> f)
RETURNS
S
The aggregate state
CONSTRAINTS
where FOLD : Foldable<F, A>
foldAsync<FOLD, F, A, S>(F, S, Func<S, A, S>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
fa
F
state
S
Initial state
f
Func<S, A, S>
Folder function, applied for each item in fa
DECLARATION
[Pure]
public static Task<S> foldAsync<FOLD, F, A, S>(F fa, S state, Func<S, A, S> f)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
foldAsync<FOLD, F, A, S>(F, S, Func<S, A, Task<S>>)
SUMMARY

In the case of lists, 'Fold', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, 'Fold' can produce a terminating expression from an infinite list.

PARAMETERS
fa
F
state
S
Initial state
f
Func<S, A, Task<S>>
Folder function, applied for each item in fa
DECLARATION
[Pure]
public static Task<S> foldAsync<FOLD, F, A, S>(F fa, S state, Func<S, A, Task<S>> f)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
foldBack<FOLD, F, A, S>(F, S, Func<S, A, S>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
fa
F
state
S
Initial state
f
Func<S, A, S>
Folder function, applied for each item in fa
DECLARATION
[Pure]
public static S foldBack<FOLD, F, A, S>(F fa, S state, Func<S, A, S> f)
RETURNS
S
The aggregate state
CONSTRAINTS
where FOLD : Foldable<F, A>
foldBackAsync<FOLD, F, A, S>(F, S, Func<S, A, S>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
fa
F
state
S
Initial state
f
Func<S, A, S>
Folder function, applied for each item in fa
DECLARATION
[Pure]
public static Task<S> foldBackAsync<FOLD, F, A, S>(F fa, S state, Func<S, A, S> f)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
foldBackAsync<FOLD, F, A, S>(F, S, Func<S, A, Task<S>>)
SUMMARY

In the case of lists, 'FoldBack', when applied to a binary operator, a starting value(typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right.

Note that to produce the outermost application of the operator the entire input list must be traversed.

PARAMETERS
fa
F
state
S
Initial state
f
Func<S, A, Task<S>>
Folder function, applied for each item in fa
DECLARATION
[Pure]
public static Task<S> foldBackAsync<FOLD, F, A, S>(F fa, S state, Func<S, A, Task<S>> f)
RETURNS
Task<S>
The aggregate state
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
forall<FOLD, F, A>(F, Func<A, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate holds for all values then true is returned.

NOTE: An empty structure will return true.

PARAMETERS
fa
F
pred
Func<A, bool>
Predicate to apply
DECLARATION
[Pure]
public static bool forall<FOLD, F, A>(F fa, Func<A, bool> pred)
RETURNS
bool
True if the predicate holds for all values
CONSTRAINTS
where FOLD : Foldable<F, A>
forallAsync<FOLD, F, A>(F, Func<A, bool>)
SUMMARY

Runs a predicate against the bound value(s). If the predicate holds for all values then true is returned.

NOTE: An empty structure will return true.

PARAMETERS
fa
F
pred
Func<A, bool>
Predicate to apply
DECLARATION
[Pure]
public static async Task<bool> forallAsync<FOLD, F, A>(F fa, Func<A, bool> pred)
RETURNS
Task<bool>
True if the predicate holds for all values
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
fromDecimal<NUM, A>(decimal)
SUMMARY

Generate a numeric value from a float

PARAMETERS
x
decimal
The float to use
DECLARATION
[Pure]
public static A fromDecimal<NUM, A>(decimal x)
RETURNS
A
The equivalent of x in the Num<A>
CONSTRAINTS
where NUM : struct Num<A>
fromDouble<NUM, A>(double)
SUMMARY

Generate a numeric value from a decimal

PARAMETERS
x
double
The decimal to use
DECLARATION
[Pure]
public static A fromDouble<NUM, A>(double x)
RETURNS
A
The equivalent of x in the Num<A>
CONSTRAINTS
where NUM : struct Num<A>
fromFloat<NUM, A>(float)
SUMMARY

Generate a numeric value from a double

PARAMETERS
x
float
The double to use
DECLARATION
[Pure]
public static A fromFloat<NUM, A>(float x)
RETURNS
A
The equivalent of x in the Num<A>
CONSTRAINTS
where NUM : struct Num<A>
fromInteger<NUM, A>(int)
SUMMARY

Generate a numeric value from an integer

PARAMETERS
x
int
The integer to use
DECLARATION
[Pure]
public static A fromInteger<NUM, A>(int x)
RETURNS
A
The equivalent of x in the Num<A>
CONSTRAINTS
where NUM : struct Num<A>
fromRational<FRACTION, A>(Ratio<int>)
SUMMARY

Generates a fractional value from an integer ratio.

PARAMETERS
x
Ratio<int>
The ratio to convert
DECLARATION
[Pure]
public static A fromRational<FRACTION, A>(Ratio<int> x)
RETURNS
A
The equivalent of x in the implementing type.
CONSTRAINTS
where FRACTION : struct Fraction<A>
greaterOrEq<ORD, A>(A, A)
SUMMARY

Returns true if x is greater than or equal to y

PARAMETERS
x
A
The first item to compare
y
A
The second item to compare
DECLARATION
[Pure]
public static bool greaterOrEq<ORD, A>(A x, A y)
RETURNS
bool
True if x is greater than or equal to y
CONSTRAINTS
where ORD : struct Ord<A>
greaterThan<ORD, A>(A, A)
SUMMARY

Returns true if x is greater than y

PARAMETERS
x
A
The first item to compare
y
A
The second item to compare
DECLARATION
[Pure]
public static bool greaterThan<ORD, A>(A x, A y)
RETURNS
bool
True if x is greater than y
CONSTRAINTS
where ORD : struct Ord<A>
hashCode<CHOICE, CH, A, B>(CH)
PARAMETERS
ma
CH
DECLARATION
[Pure]
public static int hashCode<CHOICE, CH, A, B>(CH ma)
RETURNS
int
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
head<FOLD, F, A>(F)
SUMMARY

Get the first item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static A head<FOLD, F, A>(F fa)
RETURNS
A
First A produced by the foldable
CONSTRAINTS
where FOLD : Foldable<F, A>
headAsync<FOLD, F, A>(F)
SUMMARY

Get the first item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static async Task<A> headAsync<FOLD, F, A>(F fa)
RETURNS
Task<A>
First A produced by the foldable
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
headOrNone<FOLD, F, A>(F)
SUMMARY

Get the first item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static Option<A> headOrNone<FOLD, F, A>(F fa)
RETURNS
Option<A>
First A produced by the foldable (Or None if no items produced)
CONSTRAINTS
where FOLD : Foldable<F, A>
headOrNoneAsync<FOLD, F, A>(F)
SUMMARY

Get the first item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static async Task<Option<A>> headOrNoneAsync<FOLD, F, A>(F fa)
RETURNS
Task<Option<A>>
First A produced by the foldable (Or None if no items produced)
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
ifLeft<CHOICE, CH, A, B>(CH, Func<B>)
PARAMETERS
ma
CH
Left
Func<B>
DECLARATION
[Pure]
public static B ifLeft<CHOICE, CH, A, B>(CH ma, Func<B> Left)
RETURNS
B
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifLeft<CHOICE, CH, A, B>(CH, Func<A, B>)
PARAMETERS
ma
CH
leftMap
Func<A, B>
DECLARATION
[Pure]
public static B ifLeft<CHOICE, CH, A, B>(CH ma, Func<A, B> leftMap)
RETURNS
B
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifLeft<CHOICE, CH, A, B>(CH, B)
PARAMETERS
ma
CH
rightValue
B
DECLARATION
[Pure]
public static B ifLeft<CHOICE, CH, A, B>(CH ma, B rightValue)
RETURNS
B
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifLeft<CHOICE, CH, A, B>(CH, Action<A>)
PARAMETERS
ma
CH
Left
Action<A>
DECLARATION
public static Unit ifLeft<CHOICE, CH, A, B>(CH ma, Action<A> Left)
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifNone<OPT, OA, A>(OA, Func<A>)
SUMMARY

Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
None
Func<A>
Operation to invoke if the structure is in a None state
REMARKS
Will not accept a null return value from the None operation
DECLARATION
[Pure]
public static A ifNone<OPT, OA, A>(OA opt, Func<A> None)
RETURNS
A
Tesult of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
CONSTRAINTS
where OPT : struct Optional<OA, A>
ifNone<OPT, OA, A>(OA, A)
SUMMARY

Returns the noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
noneValue
A
Value to return if in a None state
REMARKS
Will not accept a null noneValue
DECLARATION
[Pure]
public static A ifNone<OPT, OA, A>(OA opt, A noneValue)
RETURNS
A
noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned
CONSTRAINTS
where OPT : struct Optional<OA, A>
ifNoneAsync<OPT, OA, A>(OA, Func<A>)
SUMMARY

Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
None
Func<A>
Operation to invoke if the structure is in a None state
REMARKS
Will not accept a null return value from the None operation
DECLARATION
[Pure]
public static Task<A> ifNoneAsync<OPT, OA, A>(OA opt, Func<A> None)
RETURNS
Task<A>
Tesult of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifNoneAsync<OPT, OA, A>(OA, Func<Task<A>>)
SUMMARY

Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
None
Func<Task<A>>
Operation to invoke if the structure is in a None state
REMARKS
Will not accept a null return value from the None operation
DECLARATION
[Pure]
public static Task<A> ifNoneAsync<OPT, OA, A>(OA opt, Func<Task<A>> None)
RETURNS
Task<A>
Tesult of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifNoneAsync<OPT, OA, A>(OA, A)
SUMMARY

Returns the noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
noneValue
A
Value to return if in a None state
REMARKS
Will not accept a null noneValue
DECLARATION
[Pure]
public static Task<A> ifNoneAsync<OPT, OA, A>(OA opt, A noneValue)
RETURNS
Task<A>
noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifNoneUnsafe<OPT, OA, A>(OA, Func<A>)
SUMMARY

Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
None
Func<A>
Operation to invoke if the structure is in a None state
REMARKS
Will allow null the be returned from the None operation
DECLARATION
[Pure]
public static A ifNoneUnsafe<OPT, OA, A>(OA opt, Func<A> None)
RETURNS
A
Tesult of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
CONSTRAINTS
where OPT : struct Optional<OA, A>
ifNoneUnsafe<OPT, OA, A>(OA, A)
SUMMARY

Returns the noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
noneValue
A
Value to return if in a None state
REMARKS
Will allow noneValue to be null
DECLARATION
[Pure]
public static A ifNoneUnsafe<OPT, OA, A>(OA opt, A noneValue)
RETURNS
A
noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned
CONSTRAINTS
where OPT : struct Optional<OA, A>
ifNoneUnsafeAsync<OPT, OA, A>(OA, Func<A>)
SUMMARY

Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
None
Func<A>
Operation to invoke if the structure is in a None state
REMARKS
Will allow null the be returned from the None operation
DECLARATION
[Pure]
public static Task<A> ifNoneUnsafeAsync<OPT, OA, A>(OA opt, Func<A> None)
RETURNS
Task<A>
Tesult of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifNoneUnsafeAsync<OPT, OA, A>(OA, Func<Task<A>>)
SUMMARY

Returns the result of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
None
Func<Task<A>>
Operation to invoke if the structure is in a None state
REMARKS
Will allow null the be returned from the None operation
DECLARATION
[Pure]
public static Task<A> ifNoneUnsafeAsync<OPT, OA, A>(OA opt, Func<Task<A>> None)
RETURNS
Task<A>
Tesult of invoking the None() operation if the optional is in a None state, otherwise the bound Some(x) value is returned.
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifNoneUnsafeAsync<OPT, OA, A>(OA, A)
SUMMARY

Returns the noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned.

PARAMETERS
opt
OA
noneValue
A
Value to return if in a None state
REMARKS
Will allow noneValue to be null
DECLARATION
[Pure]
public static Task<A> ifNoneUnsafeAsync<OPT, OA, A>(OA opt, A noneValue)
RETURNS
Task<A>
noneValue if the optional is in a None state, otherwise the bound Some(x) value is returned
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifRight<CHOICE, CH, A, B>(CH, Action<B>)
PARAMETERS
ma
CH
Right
Action<B>
DECLARATION
public static Unit ifRight<CHOICE, CH, A, B>(CH ma, Action<B> Right)
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifRight<CHOICE, CH, A, B>(CH, A)
SUMMARY

Returns the leftValue if the Either is in a Right state. Returns the Left value if the Either is in a Left state.

PARAMETERS
ma
CH
leftValue
A
Value to return if in the Left state
DECLARATION
[Pure]
public static A ifRight<CHOICE, CH, A, B>(CH ma, A leftValue)
RETURNS
A
Returns an unwrapped Left value
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifRight<CHOICE, CH, A, B>(CH, Func<A>)
SUMMARY

Returns the result of Right() if the Either is in a Right state. Returns the Left value if the Either is in a Left state.

PARAMETERS
ma
CH
Right
Func<A>
Function to generate a Left value if in the Right state
DECLARATION
[Pure]
public static A ifRight<CHOICE, CH, A, B>(CH ma, Func<A> Right)
RETURNS
A
Returns an unwrapped Left value
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifRight<CHOICE, CH, A, B>(CH, Func<B, A>)
SUMMARY

Returns the result of rightMap if the Either is in a Right state. Returns the Left value if the Either is in a Left state.

PARAMETERS
ma
CH
rightMap
Func<B, A>
Function to generate a Left value if in the Right state
DECLARATION
[Pure]
public static A ifRight<CHOICE, CH, A, B>(CH ma, Func<B, A> rightMap)
RETURNS
A
Returns an unwrapped Left value
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
ifSome<OPT, OA, A>(OA, Action<A>)
SUMMARY

Invokes the f action if Option is in the Some state, otherwise nothing happens.

PARAMETERS
opt
OA
f
Action<A>
DECLARATION
public static Unit ifSome<OPT, OA, A>(OA opt, Action<A> f)
CONSTRAINTS
where OPT : struct Optional<OA, A>
ifSome<OPT, OA, A>(OA, Func<A, Unit>)
SUMMARY

Invokes the f function if Option is in the Some state, otherwise nothing happens.

PARAMETERS
opt
OA
f
Func<A, Unit>
DECLARATION
public static Unit ifSome<OPT, OA, A>(OA opt, Func<A, Unit> f)
CONSTRAINTS
where OPT : struct Optional<OA, A>
ifSomeAsync<OPT, OA, A>(OA, Action<A>)
SUMMARY

Invokes the f action if Option is in the Some state, otherwise nothing happens.

PARAMETERS
opt
OA
f
Action<A>
DECLARATION
public static Task<Unit> ifSomeAsync<OPT, OA, A>(OA opt, Action<A> f)
RETURNS
Task<Unit>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifSomeAsync<OPT, OA, A>(OA, Func<A, Unit>)
SUMMARY

Invokes the f function if Option is in the Some state, otherwise nothing happens.

PARAMETERS
opt
OA
f
Func<A, Unit>
DECLARATION
public static Task<Unit> ifSomeAsync<OPT, OA, A>(OA opt, Func<A, Unit> f)
RETURNS
Task<Unit>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifSomeAsync<OPT, OA, A>(OA, Func<A, Task<Unit>>)
SUMMARY

Invokes the f function if Option is in the Some state, otherwise nothing happens.

PARAMETERS
opt
OA
f
Func<A, Task<Unit>>
DECLARATION
public static Task<Unit> ifSomeAsync<OPT, OA, A>(OA opt, Func<A, Task<Unit>> f)
RETURNS
Task<Unit>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
ifSomeAsync<OPT, OA, A>(OA, Func<A, Task>)
SUMMARY

Invokes the f function if Option is in the Some state, otherwise nothing happens.

PARAMETERS
opt
OA
f
Func<A, Task>
DECLARATION
public static Task<Unit> ifSomeAsync<OPT, OA, A>(OA opt, Func<A, Task> f)
RETURNS
Task<Unit>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
isEmpty<FOLD, F, A>(F)
SUMMARY

Tests whether the foldable structure is empty

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static bool isEmpty<FOLD, F, A>(F fa)
RETURNS
bool
True if empty, False otherwise
CONSTRAINTS
where FOLD : Foldable<F, A>
isEmptyAsync<FOLD, F, A>(F)
SUMMARY

Tests whether the foldable structure is empty

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static async Task<bool> isEmptyAsync<FOLD, F, A>(F fa)
RETURNS
Task<bool>
True if empty, False otherwise
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
iter<FOLD, F, A>(F, Action<A>)
SUMMARY

Iterate the values in the foldable

PARAMETERS
fa
F
action
Action<A>
DECLARATION
public static Unit iter<FOLD, F, A>(F fa, Action<A> action)
CONSTRAINTS
where FOLD : Foldable<F, A>
iterAsync<FOLD, F, A>(F, Action<A>)
SUMMARY

Iterate the values in the foldable

PARAMETERS
fa
F
action
Action<A>
DECLARATION
public static async Task<Unit> iterAsync<FOLD, F, A>(F fa, Action<A> action)
RETURNS
Task<Unit>
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
join<EQ, MONADA, MONADB, MONADD, MA, MB, MD, A, B, C, D>(MA, MB, Func<A, C>, Func<B, C>, Func<A, B, D>)
SUMMARY

Monad join

PARAMETERS
self
MA
inner
MB
outerKeyMap
Func<A, C>
innerKeyMap
Func<B, C>
project
Func<A, B, D>
DECLARATION
[Pure]
public static MD join<EQ, MONADA, MONADB, MONADD, MA, MB, MD, A, B, C, D>(MA self, MB inner, Func<A, C> outerKeyMap, Func<B, C> innerKeyMap, Func<A, B, D> project)
RETURNS
MD
CONSTRAINTS
where EQ : struct Eq<C>
where MONADA : struct Monad<MA, A>
where MONADB : struct Monad<MB, B>
where MONADD : struct Monad<MD, D>
last<FOLD, F, A>(F)
SUMMARY

Get the last item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static A last<FOLD, F, A>(F fa)
RETURNS
A
Last A produced by the foldable
CONSTRAINTS
where FOLD : Foldable<F, A>
lastAsync<FOLD, F, A>(F)
SUMMARY

Get the last item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static async Task<A> lastAsync<FOLD, F, A>(F fa)
RETURNS
Task<A>
Last A produced by the foldable
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
lastOrNone<FOLD, F, A>(F)
SUMMARY

Get the last item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static Option<A> lastOrNone<FOLD, F, A>(F fa)
RETURNS
Option<A>
Last A produced by the foldable (Or None if no items produced)
CONSTRAINTS
where FOLD : Foldable<F, A>
lastOrNoneAsync<FOLD, F, A>(F)
SUMMARY

Get the last item in a foldable structure

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static async Task<Option<A>> lastOrNoneAsync<FOLD, F, A>(F fa)
RETURNS
Task<Option<A>>
Last A produced by the foldable (Or None if no items produced)
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
leftAsEnumerable<CHOICE, CH, A, B>(CH)
SUMMARY

Project the Either into a IEnumerable L

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Seq<A> leftAsEnumerable<CHOICE, CH, A, B>(CH ma)
RETURNS
Seq<A>
If the Either is in a Left state, a IEnumerable of L with one item. A zero length IEnumerable L otherwise
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
lefts<CHOICE, CH, A, B>(IEnumerable<CH>)
SUMMARY

Extracts from a list of 'Either' all the 'Left' elements. All the 'Left' elements are extracted in order.

PARAMETERS
ma
IEnumerable<CH>
Either list
DECLARATION
[Pure]
public static IEnumerable<A> lefts<CHOICE, CH, A, B>(IEnumerable<CH> ma)
RETURNS
IEnumerable<A>
An enumerable of L
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
lefts<CHOICE, CH, A, B>(Seq<CH>)
SUMMARY

Extracts from a list of 'Either' all the 'Left' elements. All the 'Left' elements are extracted in order.

PARAMETERS
ma
Seq<CH>
Either list
DECLARATION
[Pure]
public static Seq<A> lefts<CHOICE, CH, A, B>(Seq<CH> ma)
RETURNS
Seq<A>
An enumerable of L
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
leftToArray<CHOICE, CH, A, B>(CH)
SUMMARY

Project the Either into an ImmutableArray R

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Arr<A> leftToArray<CHOICE, CH, A, B>(CH ma)
RETURNS
Arr<A>
If the Either is in a Right state, a ImmutableArray of R with one item. A zero length ImmutableArray of R otherwise
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
leftToList<CHOICE, CH, A, B>(CH)
SUMMARY

Project the Either into a Lst R

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Lst<A> leftToList<CHOICE, CH, A, B>(CH ma)
RETURNS
Lst<A>
If the Either is in a Right state, a Lst of R with one item. A zero length Lst R otherwise
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
lessOrEq<ORD, A>(A, A)
SUMMARY

Returns true if x is less than or equal to y

PARAMETERS
x
A
The first item to compare
y
A
The second item to compare
DECLARATION
[Pure]
public static bool lessOrEq<ORD, A>(A x, A y)
RETURNS
bool
True if x is less than or equal to y
CONSTRAINTS
where ORD : struct Ord<A>
lessThan<ORD, A>(A, A)
SUMMARY

Returns true if x is less than y

PARAMETERS
x
A
The first item to compare
y
A
The second item to compare
DECLARATION
[Pure]
public static bool lessThan<ORD, A>(A x, A y)
RETURNS
bool
True if x is less than y
CONSTRAINTS
where ORD : struct Ord<A>
liftM<MONAD, FUNCTOR, MA, MB, A, B>(MA, Func<A, B>)
SUMMARY

Performs a map operation on the monad

PARAMETERS
ma
MA
Monad to map
f
Func<A, B>
Mapping operation
DECLARATION
[Pure]
public static MB liftM<MONAD, FUNCTOR, MA, MB, A, B>(MA ma, Func<A, B> f)
RETURNS
MB
Mapped monad
CONSTRAINTS
where FUNCTOR : struct Functor<MA, MB, A, B>
where MONAD : struct Monad<MA, A>
log<FLOAT, A>(A)
SUMMARY

Calculates the natural logarithm of a value.

PARAMETERS
x
A
The value for which we are calculating the natural logarithm.
DECLARATION
[Pure]
public static A log<FLOAT, A>(A x)
RETURNS
A
The value of <c>ln(x)</c>.
CONSTRAINTS
where FLOAT : struct Floating<A>
logBase<FLOAT, A>(A, A)
SUMMARY

Calculates the logarithm of a value with respect to an arbitrary base.

PARAMETERS
x
A
The value for which we are calculating the logarithm.
y
A
DECLARATION
[Pure]
public static A logBase<FLOAT, A>(A x, A y)
RETURNS
A
The value of <c>log b (x)</c>.
CONSTRAINTS
where FLOAT : struct Floating<A>
map<FunctorAB, FA, FB, A, B>(FA, Func<A, B>)
SUMMARY

Projection from one value to another

PARAMETERS
ma
FA
Functor value to map from
f
Func<A, B>
Projection function
DECLARATION
[Pure]
public static FB map<FunctorAB, FA, FB, A, B>(FA ma, Func<A, B> f)
RETURNS
FB
Mapped functor
CONSTRAINTS
where FunctorAB : Functor<FA, FB, A, B>
matchAsync<CHOICE, CH, A, B, R>(CH, Func<A, R>, Func<B, Task<R>>)
PARAMETERS
ma
CH
Left
Func<A, R>
Right
Func<B, Task<R>>
DECLARATION
[Pure]
public static Task<R> matchAsync<CHOICE, CH, A, B, R>(CH ma, Func<A, R> Left, Func<B, Task<R>> Right)
RETURNS
Task<R>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
matchAsync<CHOICE, CH, A, B, R>(CH, Func<A, Task<R>>, Func<B, Task<R>>)
PARAMETERS
ma
CH
Left
Func<A, Task<R>>
Right
Func<B, Task<R>>
DECLARATION
[Pure]
public static Task<R> matchAsync<CHOICE, CH, A, B, R>(CH ma, Func<A, Task<R>> Left, Func<B, Task<R>> Right)
RETURNS
Task<R>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
matchAsync<OPT, OA, A, R>(OA, Func<A, R>, Func<R>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, R>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchAsync<OPT, OA, A, R>(OA ma, Func<A, R> Some, Func<R> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchAsync<OPT, OA, A, R>(OA, Func<A, Task<R>>, Func<R>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, Task<R>>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchAsync<OPT, OA, A, R>(OA ma, Func<A, Task<R>> Some, Func<R> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchAsync<OPT, OA, A, R>(OA, Func<A, R>, Func<Task<R>>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, R>
Operation to perform if the option is in a Some state
None
Func<Task<R>>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchAsync<OPT, OA, A, R>(OA ma, Func<A, R> Some, Func<Task<R>> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchAsync<OPT, OA, A, R>(OA, Func<A, Task<R>>, Func<Task<R>>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, Task<R>>
Operation to perform if the option is in a Some state
None
Func<Task<R>>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchAsync<OPT, OA, A, R>(OA ma, Func<A, Task<R>> Some, Func<Task<R>> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchObservable<CHOICE, CH, A, B, R>(CH, Func<A, R>, Func<B, IObservable<R>>)
PARAMETERS
ma
CH
Left
Func<A, R>
Right
Func<B, IObservable<R>>
DECLARATION
[Pure]
public static IObservable<R> matchObservable<CHOICE, CH, A, B, R>(CH ma, Func<A, R> Left, Func<B, IObservable<R>> Right)
RETURNS
IObservable<R>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
matchObservable<CHOICE, CH, A, B, R>(CH, Func<A, IObservable<R>>, Func<B, IObservable<R>>)
PARAMETERS
ma
CH
Left
Func<A, IObservable<R>>
Right
Func<B, IObservable<R>>
DECLARATION
[Pure]
public static IObservable<R> matchObservable<CHOICE, CH, A, B, R>(CH ma, Func<A, IObservable<R>> Left, Func<B, IObservable<R>> Right)
RETURNS
IObservable<R>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
matchUnsafeAsync<OPT, OA, A, R>(OA, Func<A, R>, Func<R>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, R>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUnsafeAsync<OPT, OA, A, R>(OA ma, Func<A, R> Some, Func<R> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUnsafeAsync<OPT, OA, A, R>(OA, Func<A, Task<R>>, Func<R>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, Task<R>>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUnsafeAsync<OPT, OA, A, R>(OA ma, Func<A, Task<R>> Some, Func<R> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUnsafeAsync<OPT, OA, A, R>(OA, Func<A, R>, Func<Task<R>>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, R>
Operation to perform if the option is in a Some state
None
Func<Task<R>>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUnsafeAsync<OPT, OA, A, R>(OA ma, Func<A, R> Some, Func<Task<R>> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUnsafeAsync<OPT, OA, A, R>(OA, Func<A, Task<R>>, Func<Task<R>>)
SUMMARY

Pattern match operation

PARAMETERS
ma
OA
Some
Func<A, Task<R>>
Operation to perform if the option is in a Some state
None
Func<Task<R>>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUnsafeAsync<OPT, OA, A, R>(OA ma, Func<A, Task<R>> Some, Func<Task<R>> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUntyped<CHOICE, CH, A, B, R>(CH, Func<object, R>, Func<object, R>, Func<R>)
SUMMARY

Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface

PARAMETERS
ma
CH
Left
Func<object, R>
Right
Func<object, R>
Bottom
Func<R>
DECLARATION
[Pure]
public static R matchUntyped<CHOICE, CH, A, B, R>(CH ma, Func<object, R> Left, Func<object, R> Right, Func<R> Bottom = null)
RETURNS
R
The result of the match operation
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
matchUntyped<OPT, OA, A, R>(OA, Func<object, R>, Func<R>)
SUMMARY

Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface

PARAMETERS
ma
OA
Some
Func<object, R>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static R matchUntyped<OPT, OA, A, R>(OA ma, Func<object, R> Some, Func<R> None)
RETURNS
R
The result of the match operation
CONSTRAINTS
where OPT : struct Optional<OA, A>
matchUntypedAsync<OPT, OA, A, R>(OA, Func<object, R>, Func<R>)
SUMMARY

Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface

PARAMETERS
ma
OA
Some
Func<object, R>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUntypedAsync<OPT, OA, A, R>(OA ma, Func<object, R> Some, Func<R> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUntypedAsync<OPT, OA, A, R>(OA, Func<object, Task<R>>, Func<R>)
SUMMARY

Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface

PARAMETERS
ma
OA
Some
Func<object, Task<R>>
Operation to perform if the option is in a Some state
None
Func<R>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUntypedAsync<OPT, OA, A, R>(OA ma, Func<object, Task<R>> Some, Func<R> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUntypedAsync<OPT, OA, A, R>(OA, Func<object, R>, Func<Task<R>>)
SUMMARY

Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface

PARAMETERS
ma
OA
Some
Func<object, R>
Operation to perform if the option is in a Some state
None
Func<Task<R>>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUntypedAsync<OPT, OA, A, R>(OA ma, Func<object, R> Some, Func<Task<R>> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
matchUntypedAsync<OPT, OA, A, R>(OA, Func<object, Task<R>>, Func<Task<R>>)
SUMMARY

Match operation with an untyped value for Some. This can be useful for serialisation and dealing with the IOptional interface

PARAMETERS
ma
OA
Some
Func<object, Task<R>>
Operation to perform if the option is in a Some state
None
Func<Task<R>>
Operation to perform if the option is in a None state
DECLARATION
[Pure]
public static Task<R> matchUntypedAsync<OPT, OA, A, R>(OA ma, Func<object, Task<R>> Some, Func<Task<R>> None)
RETURNS
Task<R>
The result of the match operation
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
mconcat<MONOID, A>(IEnumerable<A>)
SUMMARY

Fold a list using the monoid.

PARAMETERS
xs
IEnumerable<A>
DECLARATION
[Pure]
public static A mconcat<MONOID, A>(IEnumerable<A> xs)
RETURNS
A
CONSTRAINTS
where MONOID : struct Monoid<A>
mconcat<MONOID, A>(A)
SUMMARY

Fold a list using the monoid.

PARAMETERS
xs
A
DECLARATION
[Pure]
public static A mconcat<MONOID, A>(A xs)
RETURNS
A
CONSTRAINTS
where MONOID : struct Monoid<A>
mempty<MONOID, A>()
SUMMARY

DECLARATION
[Pure]
public static A mempty<MONOID, A>()
RETURNS
A
CONSTRAINTS
where MONOID : struct Monoid<A>
mplus<MPLUS, MA, A>(MA, MA)
SUMMARY

Return monad x 'plus' monad y

Note, this doesn't add the bound values, it works on the monad state itself.

For example with Option:

None 'plus' None = None
Some a 'plus' None = Some a
None 'plus' Some b = Some b
Some a 'plus' Some b = Some a


PARAMETERS
x
MA
Left hand side of the operation
y
MA
Right hand side of the operation
DECLARATION
[Pure]
public static MA mplus<MPLUS, MA, A>(MA x, MA y)
RETURNS
MA
x 'plus' y
CONSTRAINTS
where MPLUS : struct Monad<MA, A>
msum<MPLUS, MA, A>(MA)
SUMMARY

Performs the following fold operation: fold(xs, mzero, mplus)

PARAMETERS
xs
MA
The monads to sum
DECLARATION
[Pure]
public static MA msum<MPLUS, MA, A>(MA xs)
RETURNS
MA
The summed monads
CONSTRAINTS
where MPLUS : struct Monad<MA, A>
msum<MPLUS, MA, A>(IEnumerable<MA>)
SUMMARY

Performs the following fold operation: fold(xs, mzero, mplus)

PARAMETERS
xs
IEnumerable<MA>
The monads to sum
DECLARATION
[Pure]
public static MA msum<MPLUS, MA, A>(IEnumerable<MA> xs)
RETURNS
MA
The summed monads
CONSTRAINTS
where MPLUS : struct Monad<MA, A>
mzero<MPLUS, MA, A>()
SUMMARY

Return monad 'zero'. None for Option, [] for Lst, ...

DECLARATION
[Pure]
public static MA mzero<MPLUS, MA, A>()
RETURNS
MA
Zero for the structure
CONSTRAINTS
where MPLUS : struct Monad<MA, A>
negate<NUM, A>(A)
SUMMARY

Negate the value

PARAMETERS
x
A
Value to negate
DECLARATION
[Pure]
public static A negate<NUM, A>(A x)
RETURNS
A
The negated source value
CONSTRAINTS
where NUM : struct Num<A>
partition<CHOICE, CH, A, B>(IEnumerable<CH>)
SUMMARY

Partitions a list of 'Either' into two lists. All the 'Left' elements are extracted, in order, to the first component of the output. Similarly the 'Right' elements are extracted to the second component of the output.

PARAMETERS
ma
IEnumerable<CH>
Choice list
DECLARATION
[Pure]
public static ValueTuple<IEnumerable<A>, IEnumerable<B>> partition<CHOICE, CH, A, B>(IEnumerable<CH> ma)
RETURNS
ValueTuple<IEnumerable<A>, IEnumerable<B>>
A tuple containing the an enumerable of L and an enumerable of R
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
partition<CHOICE, CH, A, B>(Seq<CH>)
SUMMARY

Partitions a list of 'Either' into two lists. All the 'Left' elements are extracted, in order, to the first component of the output. Similarly the 'Right' elements are extracted to the second component of the output.

PARAMETERS
ma
Seq<CH>
Choice list
DECLARATION
[Pure]
public static ValueTuple<Seq<A>, Seq<B>> partition<CHOICE, CH, A, B>(Seq<CH> ma)
RETURNS
ValueTuple<Seq<A>, Seq<B>>
A tuple containing the an enumerable of L and an enumerable of R
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
pi<FLOAT, A>()
SUMMARY

Returns an approximation of pi.

DECLARATION
[Pure]
public static A pi<FLOAT, A>()
RETURNS
A
A reasonable approximation of pi in this type
CONSTRAINTS
where FLOAT : struct Floating<A>
plus<NUM, A>(A, A)
SUMMARY

Find the sum of two numbers

PARAMETERS
x
A
left hand side of the addition operation
y
A
right hand side of the addition operation
DECLARATION
[Pure]
public static A plus<NUM, A>(A x, A y)
RETURNS
A
The sum of x and y
CONSTRAINTS
where NUM : struct Num<A>
pow<FLOAT, A>(A, A)
SUMMARY

Raises x to the power y

PARAMETERS
x
A
The base to be raised to y
y
A
The exponent to which we are raising x
DECLARATION
[Pure]
public static A pow<FLOAT, A>(A x, A y)
RETURNS
A
The value of <c>x^y</c>.
CONSTRAINTS
where FLOAT : struct Floating<A>
product<NUM, A>(A, A)
SUMMARY

Find the product of two numbers

PARAMETERS
x
A
left hand side of the product operation
y
A
right hand side of the product operation
DECLARATION
[Pure]
public static A product<NUM, A>(A x, A y)
RETURNS
A
The product of x and y
CONSTRAINTS
where NUM : struct Num<A>
product<NUM, FOLD, F, A>(F)
SUMMARY

The 'product' function computes the product of the numbers of a structure.

PARAMETERS
fa
F
DECLARATION
[Pure]
public static A product<NUM, FOLD, F, A>(F fa)
RETURNS
A
Product of the numbers in the structure
CONSTRAINTS
where FOLD : Foldable<F, A>
where NUM : struct Num<A>
productAsync<NUM, FOLD, F, A>(F)
SUMMARY

The 'product' function computes the product of the numbers of a structure.

PARAMETERS
fa
F
DECLARATION
[Pure]
public static Task<A> productAsync<NUM, FOLD, F, A>(F fa)
RETURNS
Task<A>
Product of the numbers in the structure
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
where NUM : struct Num<A>
Ratio<A>(A, A)
SUMMARY

Ratio constructor

PARAMETERS
num
A
Numerator
den
A
Denominator
DECLARATION
[Pure]
public static Ratio<A> Ratio<A>(A num, A den)
RETURNS
Ratio<A>
Ratio struct
Return<MONAD, MA, A>(A)
SUMMARY

Monad return

PARAMETERS
x
A
The bound monad value
DECLARATION
[Pure]
public static MA Return<MONAD, MA, A>(A x)
RETURNS
MA
Monad of A
CONSTRAINTS
where MONAD : struct Monad<MA, A>
rightAsEnumerable<CHOICE, CH, A, B>(CH)
SUMMARY

Project the Either into a IEnumerable R

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Seq<B> rightAsEnumerable<CHOICE, CH, A, B>(CH ma)
RETURNS
Seq<B>
If the Either is in a Right state, a IEnumerable of R with one item. A zero length IEnumerable R otherwise
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
rights<CHOICE, CH, A, B>(IEnumerable<CH>)
SUMMARY

Extracts from a list of 'Either' all the 'Right' elements. All the 'Right' elements are extracted in order.

PARAMETERS
ma
IEnumerable<CH>
Choice list
DECLARATION
[Pure]
public static IEnumerable<B> rights<CHOICE, CH, A, B>(IEnumerable<CH> ma)
RETURNS
IEnumerable<B>
An enumerable of L
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
rights<CHOICE, CH, A, B>(Seq<CH>)
SUMMARY

Extracts from a list of 'Either' all the 'Right' elements. All the 'Right' elements are extracted in order.

PARAMETERS
ma
Seq<CH>
Choice list
DECLARATION
[Pure]
public static Seq<B> rights<CHOICE, CH, A, B>(Seq<CH> ma)
RETURNS
Seq<B>
An enumerable of L
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
rightToArray<CHOICE, CH, A, B>(CH)
SUMMARY

Project the Either into an ImmutableArray R

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Arr<B> rightToArray<CHOICE, CH, A, B>(CH ma)
RETURNS
Arr<B>
If the Either is in a Right state, a ImmutableArray of R with one item. A zero length ImmutableArray of R otherwise
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
rightToList<CHOICE, CH, A, B>(CH)
SUMMARY

Project the Either into a Lst R

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Lst<B> rightToList<CHOICE, CH, A, B>(CH ma)
RETURNS
Lst<B>
If the Either is in a Right state, a Lst of R with one item. A zero length Lst R otherwise
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
SelectMany<MONADA, MA, A, B, C>(MA, Func<A, IEnumerable<B>>, Func<A, B, C>)
PARAMETERS
self
MA
bind
Func<A, IEnumerable<B>>
project
Func<A, B, C>
DECLARATION
[Pure]
public static IEnumerable<C> SelectMany<MONADA, MA, A, B, C>(MA self, Func<A, IEnumerable<B>> bind, Func<A, B, C> project)
RETURNS
IEnumerable<C>
CONSTRAINTS
where MONADA : struct Monad<MA, A>
SelectMany<MONADA, MA, A, B, C>(MA, Func<A, Seq<B>>, Func<A, B, C>)
PARAMETERS
self
MA
bind
Func<A, Seq<B>>
project
Func<A, B, C>
DECLARATION
[Pure]
public static Seq<C> SelectMany<MONADA, MA, A, B, C>(MA self, Func<A, Seq<B>> bind, Func<A, B, C> project)
RETURNS
Seq<C>
CONSTRAINTS
where MONADA : struct Monad<MA, A>
SelectMany<MONADA, MONADB, MONADC, MA, MB, MC, A, B, C>(MA, Func<A, MB>, Func<A, B, C>)
SUMMARY

Monadic bind and project

PARAMETERS
self
MA
bind
Func<A, MB>
project
Func<A, B, C>
DECLARATION
[Pure]
public static MC SelectMany<MONADA, MONADB, MONADC, MA, MB, MC, A, B, C>(MA self, Func<A, MB> bind, Func<A, B, C> project)
RETURNS
MC
CONSTRAINTS
where MONADA : struct Monad<MA, A>
where MONADB : struct Monad<MB, B>
where MONADC : struct Monad<MC, C>
signum<NUM, A>(A)
SUMMARY

Find the sign of x

PARAMETERS
x
A
The value to find the sign of
DECLARATION
[Pure]
public static A signum<NUM, A>(A x)
RETURNS
A
-1, 0, or +1
CONSTRAINTS
where NUM : struct Num<A>
sin<FLOAT, A>(A)
SUMMARY

Calculates the sine of an angle.

PARAMETERS
x
A
An angle, in radians
DECLARATION
[Pure]
public static A sin<FLOAT, A>(A x)
RETURNS
A
The value of <c>sin(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
sinh<FLOAT, A>(A)
SUMMARY

Calculates a hyperbolic sine.

PARAMETERS
x
A
The value for which a hyperbolic sine is to be calculated
DECLARATION
[Pure]
public static A sinh<FLOAT, A>(A x)
RETURNS
A
The value of <c>sinh(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
Some<OPT, OA, A, B>(OA, Func<A, B>)
SUMMARY

Fluent pattern matching. Provide a Some handler and then follow on fluently with .None(...) to complete the matching operation. This is for returning a value from the match operation, to dispatch an action instead, use Some<A>(...)

PARAMETERS
ma
OA
Option to match
f
Func<A, B>
The Some(x) match operation
DECLARATION
[Pure]
public static SomeContext<OPT, OA, A, B> Some<OPT, OA, A, B>(OA ma, Func<A, B> f)
RETURNS
SomeContext<OPT, OA, A, B>
The result of the match operation
CONSTRAINTS
where OPT : struct Optional<OA, A>
Some<OPT, OA, A>(OA, Action<A>)
SUMMARY

Fluent pattern matching. Provide a Some handler and then follow on fluently with .None(...) to complete the matching operation. This is for dispatching actions, use Some<A,B>(...) to return a value from the match operation.

PARAMETERS
ma
OA
Option to match
f
Action<A>
The Some(x) match operation
DECLARATION
[Pure]
public static SomeUnitContext<OPT, OA, A> Some<OPT, OA, A>(OA ma, Action<A> f)
RETURNS
SomeUnitContext<OPT, OA, A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
sqrt<FLOAT, A>(A)
SUMMARY

Calculates the square root of a value.

PARAMETERS
x
A
The value for which we are calculating the square root.
DECLARATION
[Pure]
public static A sqrt<FLOAT, A>(A x)
RETURNS
A
The value of <c>sqrt(x)</c>.
CONSTRAINTS
where FLOAT : struct Floating<A>
subtract<NUM, A>(A, A)
SUMMARY

Find the subtract between two numbers

PARAMETERS
x
A
left hand side of the subtraction operation
y
A
right hand side of the subtraction operation
DECLARATION
[Pure]
public static A subtract<NUM, A>(A x, A y)
RETURNS
A
The sum subtract between x and y
CONSTRAINTS
where NUM : struct Num<A>
sum<NUM, FOLD, F, A>(F)
SUMMARY

The 'sum' function computes the sum of the numbers of a structure.

PARAMETERS
fa
F
DECLARATION
[Pure]
public static A sum<NUM, FOLD, F, A>(F fa)
RETURNS
A
Sum of the numbers in the structure
CONSTRAINTS
where FOLD : Foldable<F, A>
where NUM : struct Num<A>
sumAsync<NUM, FOLD, F, A>(F)
SUMMARY

The 'sum' function computes the sum of the numbers of a structure.

PARAMETERS
fa
F
DECLARATION
[Pure]
public static Task<A> sumAsync<NUM, FOLD, F, A>(F fa)
RETURNS
Task<A>
Sum of the numbers in the structure
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
where NUM : struct Num<A>
tan<FLOAT, A>(A)
SUMMARY

Calculates the tangent of an angle.

PARAMETERS
x
A
An angle, in radians
DECLARATION
[Pure]
public static A tan<FLOAT, A>(A x)
RETURNS
A
The value of <c>tan(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
tanh<FLOAT, A>(A)
SUMMARY

Calculates a hyperbolic tangent.

PARAMETERS
x
A
The value for which a hyperbolic tangent is to be calculated.
DECLARATION
[Pure]
public static A tanh<FLOAT, A>(A x)
RETURNS
A
The value of <c>tanh(x)</c>
CONSTRAINTS
where FLOAT : struct Floating<A>
toArray<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the Option to an enumerable of zero or one items

PARAMETERS
ma
CH
Option
DECLARATION
[Pure]
public static Arr<B> toArray<CHOICE, CH, A, B>(CH ma)
RETURNS
Arr<B>
An enumerable of zero or one items
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toArray<OPT, OA, A>(OA)
SUMMARY

Convert the Option to an enumerable of zero or one items

PARAMETERS
ma
OA
Option
DECLARATION
[Pure]
public static Arr<A> toArray<OPT, OA, A>(OA ma)
RETURNS
Arr<A>
An enumerable of zero or one items
CONSTRAINTS
where OPT : struct Optional<OA, A>
toArrayAsync<OPT, OA, A>(OA)
SUMMARY

Convert the Option to an enumerable of zero or one items

PARAMETERS
ma
OA
Option
DECLARATION
[Pure]
public static Task<Arr<A>> toArrayAsync<OPT, OA, A>(OA ma)
RETURNS
Task<Arr<A>>
An enumerable of zero or one items
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toBiSeq<FOLD, F, A, B>(F)
SUMMARY

Turn any foldable into a sequence

PARAMETERS
foldable
F
Foldable
DECLARATION
[Pure]
public static IEnumerable<Either<A, B>> toBiSeq<FOLD, F, A, B>(F foldable)
RETURNS
IEnumerable<Either<A, B>>
Sequence of As
CONSTRAINTS
where FOLD : struct BiFoldable<F, A, B>
toBiSeqAsync<FOLD, F, A, B>(F)
SUMMARY

Turn any foldable into a sequence

PARAMETERS
foldable
F
Foldable
DECLARATION
[Pure]
public static Task<IEnumerable<Either<A, B>>> toBiSeqAsync<FOLD, F, A, B>(F foldable)
RETURNS
Task<IEnumerable<Either<A, B>>>
Sequence of As
CONSTRAINTS
where FOLD : struct BiFoldableAsync<F, A, B>
toEither<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the structure to an Either

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Either<A, B> toEither<CHOICE, CH, A, B>(CH ma)
RETURNS
Either<A, B>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toEither<OPT, OA, L, A>(OA, L)
SUMMARY

Convert the structure to an Either

PARAMETERS
ma
OA
defaultLeftValue
L
DECLARATION
[Pure]
public static Either<L, A> toEither<OPT, OA, L, A>(OA ma, L defaultLeftValue)
RETURNS
Either<L, A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toEither<OPT, OA, L, A>(OA, Func<L>)
SUMMARY

Convert the structure to an Either

PARAMETERS
ma
OA
Left
Func<L>
DECLARATION
[Pure]
public static Either<L, A> toEither<OPT, OA, L, A>(OA ma, Func<L> Left)
RETURNS
Either<L, A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toEitherAsync<OPT, OA, L, A>(OA, L)
SUMMARY

Convert the structure to an Either

PARAMETERS
ma
OA
defaultLeftValue
L
DECLARATION
[Pure]
public static Task<Either<L, A>> toEitherAsync<OPT, OA, L, A>(OA ma, L defaultLeftValue)
RETURNS
Task<Either<L, A>>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toEitherAsync<OPT, OA, L, A>(OA, Func<L>)
SUMMARY

Convert the structure to an Either

PARAMETERS
ma
OA
Left
Func<L>
DECLARATION
[Pure]
public static Task<Either<L, A>> toEitherAsync<OPT, OA, L, A>(OA ma, Func<L> Left)
RETURNS
Task<Either<L, A>>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toEitherUnsafe<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the structure to an EitherUnsafe

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static EitherUnsafe<A, B> toEitherUnsafe<CHOICE, CH, A, B>(CH ma)
RETURNS
EitherUnsafe<A, B>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toEitherUnsafe<OPT, OA, L, A>(OA, L)
SUMMARY

Convert the structure to an EitherUnsafe

PARAMETERS
ma
OA
defaultLeftValue
L
DECLARATION
[Pure]
public static EitherUnsafe<L, A> toEitherUnsafe<OPT, OA, L, A>(OA ma, L defaultLeftValue)
RETURNS
EitherUnsafe<L, A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toEitherUnsafe<OPT, OA, L, A>(OA, Func<L>)
SUMMARY

Convert the structure to an EitherUnsafe

PARAMETERS
ma
OA
Left
Func<L>
DECLARATION
[Pure]
public static EitherUnsafe<L, A> toEitherUnsafe<OPT, OA, L, A>(OA ma, Func<L> Left)
RETURNS
EitherUnsafe<L, A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toEitherUnsafeAsync<OPT, OA, L, A>(OA, L)
SUMMARY

Convert the structure to an EitherUnsafe

PARAMETERS
ma
OA
defaultLeftValue
L
DECLARATION
[Pure]
public static Task<EitherUnsafe<L, A>> toEitherUnsafeAsync<OPT, OA, L, A>(OA ma, L defaultLeftValue)
RETURNS
Task<EitherUnsafe<L, A>>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toEitherUnsafeAsync<OPT, OA, L, A>(OA, Func<L>)
SUMMARY

Convert the structure to an EitherUnsafe

PARAMETERS
ma
OA
Left
Func<L>
DECLARATION
[Pure]
public static Task<EitherUnsafe<L, A>> toEitherUnsafeAsync<OPT, OA, L, A>(OA ma, Func<L> Left)
RETURNS
Task<EitherUnsafe<L, A>>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toList<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the Option to an immutable list of zero or one items

PARAMETERS
ma
CH
Option
DECLARATION
[Pure]
public static Lst<B> toList<CHOICE, CH, A, B>(CH ma)
RETURNS
Lst<B>
An immutable list of zero or one items
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toList<OPT, OA, A>(OA)
SUMMARY

Convert the Option to an immutable list of zero or one items

PARAMETERS
ma
OA
Option
DECLARATION
[Pure]
public static Lst<A> toList<OPT, OA, A>(OA ma)
RETURNS
Lst<A>
An immutable list of zero or one items
CONSTRAINTS
where OPT : struct Optional<OA, A>
toListAsync<OPT, OA, A>(OA)
SUMMARY

Convert the Option to an immutable list of zero or one items

PARAMETERS
ma
OA
Option
DECLARATION
[Pure]
public static Task<Lst<A>> toListAsync<OPT, OA, A>(OA ma)
RETURNS
Task<Lst<A>>
An immutable list of zero or one items
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toOption<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the structure to a Option

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static Option<B> toOption<CHOICE, CH, A, B>(CH ma)
RETURNS
Option<B>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toOption<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a Option

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static Option<A> toOption<OPT, OA, A>(OA ma)
RETURNS
Option<A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toOptionAsync<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a Option

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static OptionAsync<A> toOptionAsync<OPT, OA, A>(OA ma)
RETURNS
OptionAsync<A>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toOptionUnsafe<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the structure to a OptionUnsafe

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static OptionUnsafe<B> toOptionUnsafe<CHOICE, CH, A, B>(CH ma)
RETURNS
OptionUnsafe<B>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toOptionUnsafe<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a OptionUnsafe

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static OptionUnsafe<A> toOptionUnsafe<OPT, OA, A>(OA ma)
RETURNS
OptionUnsafe<A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toOptionUnsafeAsync<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a OptionUnsafe

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static Task<OptionUnsafe<A>> toOptionUnsafeAsync<OPT, OA, A>(OA ma)
RETURNS
Task<OptionUnsafe<A>>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toSeq<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the Option to an enumerable sequence of zero or one items

PARAMETERS
ma
CH
Option
DECLARATION
[Pure]
public static IEnumerable<B> toSeq<CHOICE, CH, A, B>(CH ma)
RETURNS
IEnumerable<B>
An enumerable sequence of zero or one items
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toSeq<FOLD, F, A>(F)
SUMMARY

Turn any foldable into a sequence

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static Seq<A> toSeq<FOLD, F, A>(F fa)
RETURNS
Seq<A>
Sequence of As
CONSTRAINTS
where FOLD : Foldable<F, A>
toSeqAsync<FOLD, F, A>(F)
SUMMARY

Turn any foldable into a sequence

PARAMETERS
fa
F
Foldable
DECLARATION
[Pure]
public static Task<Seq<A>> toSeqAsync<FOLD, F, A>(F fa)
RETURNS
Task<Seq<A>>
Sequence of As
CONSTRAINTS
where FOLD : FoldableAsync<F, A>
toTryAsync<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a TryAsync

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static TryAsync<A> toTryAsync<OPT, OA, A>(OA ma)
RETURNS
TryAsync<A>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
toTryOption<CHOICE, CH, A, B>(CH)
SUMMARY

Convert the structure to a TryOption

PARAMETERS
ma
CH
DECLARATION
[Pure]
public static TryOption<B> toTryOption<CHOICE, CH, A, B>(CH ma)
RETURNS
TryOption<B>
CONSTRAINTS
where CHOICE : struct Choice<CH, A, B>
toTryOption<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a TryOption

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static TryOption<A> toTryOption<OPT, OA, A>(OA ma)
RETURNS
TryOption<A>
CONSTRAINTS
where OPT : struct Optional<OA, A>
toTryOptionAsync<OPT, OA, A>(OA)
SUMMARY

Convert the structure to a TryOptionAsync

PARAMETERS
ma
OA
DECLARATION
[Pure]
public static TryOptionAsync<A> toTryOptionAsync<OPT, OA, A>(OA ma)
RETURNS
TryOptionAsync<A>
CONSTRAINTS
where OPT : struct OptionalAsync<OA, A>
traverse<Env, Out, MonadA, MonadB, MA, MB, A, B>(MA, Func<A, B>)
PARAMETERS
ma
MA
f
Func<A, B>
DECLARATION
public static Func<Env, MB> traverse<Env, Out, MonadA, MonadB, MA, MB, A, B>(MA ma, Func<A, B> f)
RETURNS
Func<Env, MB>
CONSTRAINTS
where MonadA : struct Monad<Env, Out, MA, A>
where MonadB : struct Monad<Env, Out, MB, B>
traverse<Env, Out, MonadA, MonadB, MA, MB, A, B>(MA, Func<A, MB>)
PARAMETERS
ma
MA
f
Func<A, MB>
DECLARATION
public static Func<Env, MB> traverse<Env, Out, MonadA, MonadB, MA, MB, A, B>(MA ma, Func<A, MB> f)
RETURNS
Func<Env, MB>
CONSTRAINTS
where MonadA : struct Monad<Env, Out, MA, A>
where MonadB : struct Monad<Env, Out, MB, B>
traverse<MonadA, MonadB, MA, MB, A, B>(MA, Func<A, B>)
PARAMETERS
ma
MA
f
Func<A, B>
DECLARATION
public static MB traverse<MonadA, MonadB, MA, MB, A, B>(MA ma, Func<A, B> f)
RETURNS
MB
CONSTRAINTS
where MonadA : struct Monad<Unit, Unit, MA, A>
where MonadB : struct Monad<Unit, Unit, MB, B>
traverse<MonadA, MonadB, MA, MB, A, B>(MA, Func<A, MB>)
PARAMETERS
ma
MA
f
Func<A, MB>
DECLARATION
public static MB traverse<MonadA, MonadB, MA, MB, A, B>(MA ma, Func<A, MB> f)
RETURNS
MB
CONSTRAINTS
where MonadA : struct Monad<Unit, Unit, MA, A>
where MonadB : struct Monad<Unit, Unit, MB, B>
trimap<TriFunctorABC, FABC, FR, A, B, C, R>(FABC, Func<A, R>, Func<B, R>, Func<B, R>)
SUMMARY

Projection from one tri-functor to another. This operation should map only one of the items (A, B, or C). The type R should match A, B, or C depending on which item is being mapped.

PARAMETERS
ma
FABC
Functor value to map from
fa
Func<A, R>
Projection function
fb
Func<B, R>
Projection function
fc
Func<B, R>
DECLARATION
[Pure]
public static FR trimap<TriFunctorABC, FABC, FR, A, B, C, R>(FABC ma, Func<A, R> fa, Func<B, R> fb, Func<B, R> fc)
RETURNS
FR
Mapped functor
CONSTRAINTS
where TriFunctorABC : TriFunctor<FABC, FR, A, B, C, R>
trimap<TriFunctorABC, FABC, FTUV, A, B, C, T, U, V>(FABC, Func<A, T>, Func<B, U>, Func<C, V>)
SUMMARY

Projection from one value to another. All three elements of the tri-functor can will be mapped to a new result value.

PARAMETERS
ma
FABC
Functor value to map from
fa
Func<A, T>
Projection function
fb
Func<B, U>
Projection function
fc
Func<C, V>
Projection function
DECLARATION
[Pure]
public static FTUV trimap<TriFunctorABC, FABC, FTUV, A, B, C, T, U, V>(FABC ma, Func<A, T> fa, Func<B, U> fb, Func<C, V> fc)
RETURNS
FTUV
Mapped functor
CONSTRAINTS
where TriFunctorABC : TriFunctor<FABC, FTUV, A, B, C, T, U, V>