Prelude Class

DECLARATION
public static partial class Prelude
NAMESPACE
LanguageExt

Fields

centimeter
SUMMARY

Centimeter

DECLARATION
public static readonly Length centimeter
centimeter2
SUMMARY

Centimeter squared

DECLARATION
public static readonly Area centimeter2
centimeters
SUMMARY

Centimeters

DECLARATION
public static readonly Length centimeters
centimetre
SUMMARY

Centimetre

DECLARATION
public static readonly Length centimetre
centimetre2
SUMMARY

Centimetre squared

DECLARATION
public static readonly Area centimetre2
centimetres
SUMMARY

Centimetres

DECLARATION
public static readonly Length centimetres
cm
SUMMARY

Centimetre

DECLARATION
public static readonly Length cm
cm2
SUMMARY

Centimetre squared

DECLARATION
public static readonly Area cm2
day
SUMMARY

Day

DECLARATION
public static readonly Time day
days
SUMMARY

Day

DECLARATION
public static readonly Time days
Empty
SUMMARY

Represents an empty sequence

DECLARATION
public static readonly SeqEmpty Empty
feet
SUMMARY

Feet

DECLARATION
public static readonly Length feet
foot
SUMMARY

Feet

DECLARATION
public static readonly Length foot
ft
SUMMARY

Feet

DECLARATION
public static readonly Length ft
hour
SUMMARY

Hour

DECLARATION
public static readonly Time hour
hours
SUMMARY

Hour

DECLARATION
public static readonly Time hours
hr
SUMMARY

Hour

DECLARATION
public static readonly Time hr
hrs
SUMMARY

Hour

DECLARATION
public static readonly Time hrs
inch
SUMMARY

Inch

DECLARATION
public static readonly Length inch
inches
SUMMARY

Inch

DECLARATION
public static readonly Length inches
kilometer
SUMMARY

Kilometer

DECLARATION
public static readonly Length kilometer
kilometer2
SUMMARY

Kilometer squared

DECLARATION
public static readonly Area kilometer2
kilometers
SUMMARY

Kilometers

DECLARATION
public static readonly Length kilometers
kilometre
SUMMARY

Kilometre

DECLARATION
public static readonly Length kilometre
kilometre2
SUMMARY

Kilometre squared

DECLARATION
public static readonly Area kilometre2
kilometres
SUMMARY

Kilometres

DECLARATION
public static readonly Length kilometres
km
SUMMARY

Kilometre

DECLARATION
public static readonly Length km
km2
SUMMARY

Kilometre squared

DECLARATION
public static readonly Area km2
kph
SUMMARY

Kilometres per hour

DECLARATION
public static readonly Velocity kph
m
SUMMARY

Metre

DECLARATION
public static readonly Length m
m2
SUMMARY

Metre squared

DECLARATION
public static readonly Area m2
meter
SUMMARY

Meter

DECLARATION
public static readonly Length meter
meter2
SUMMARY

Meter squared

DECLARATION
public static readonly Area meter2
meters
SUMMARY

Meters

DECLARATION
public static readonly Length meters
metre
SUMMARY

Metre

DECLARATION
public static readonly Length metre
metre2
SUMMARY

Metre squared

DECLARATION
public static readonly Area metre2
metres
SUMMARY

Metres

DECLARATION
public static readonly Length metres
mile
SUMMARY

Mile

DECLARATION
public static readonly Length mile
miles
SUMMARY

Mile

DECLARATION
public static readonly Length miles
millimeter
SUMMARY

Millimeter

DECLARATION
public static readonly Length millimeter
millimeter2
SUMMARY

Millimeter squared

DECLARATION
public static readonly Area millimeter2
millimeters
SUMMARY

Millimeters

DECLARATION
public static readonly Length millimeters
millimetre
SUMMARY

Millimetre

DECLARATION
public static readonly Length millimetre
millimetre2
SUMMARY

Millimetre squared

DECLARATION
public static readonly Area millimetre2
millimetres
SUMMARY

Millimetre

DECLARATION
public static readonly Length millimetres
millisecond
SUMMARY

Millisecond

DECLARATION
public static readonly Time millisecond
milliseconds
SUMMARY

Millisecond

DECLARATION
public static readonly Time milliseconds
min
SUMMARY

Minute

DECLARATION
public static readonly Time min
mins
SUMMARY

Minute

DECLARATION
public static readonly Time mins
minute
SUMMARY

Minute

DECLARATION
public static readonly Time minute
minutes
SUMMARY

Minute

DECLARATION
public static readonly Time minutes
mm
SUMMARY

Millimetre

DECLARATION
public static readonly Length mm
mm2
SUMMARY

Millimetre squared

DECLARATION
public static readonly Area mm2
mph
SUMMARY

Miles per hour

DECLARATION
public static readonly Velocity mph
ms
SUMMARY

Millisecond

DECLARATION
public static readonly Time ms
ms2
SUMMARY

Metres per-second squared

DECLARATION
public static readonly Accel ms2
s
SUMMARY

Second

DECLARATION
public static readonly Time s
sec
SUMMARY

Second

DECLARATION
public static readonly Time sec
second
SUMMARY

Second

DECLARATION
public static readonly Time second
seconds
SUMMARY

Second

DECLARATION
public static readonly Time seconds
yard
SUMMARY

Yard

DECLARATION
public static readonly Length yard
yards
SUMMARY

Yard

DECLARATION
public static readonly Length yards
yd
SUMMARY

Yard

DECLARATION
public static readonly Length yd

Properties

None
SUMMARY

'No value' state of Option T.

DECLARATION
public static OptionNone None { get; }
RETURNS
OptionNone
unit
SUMMARY

Unit constructor

DECLARATION
public static Unit unit { get; }

Methods

act(Action)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action
Action to infer
DECLARATION
[Pure]
public static Action act(Action f)
RETURNS
Action
The same Action you gave it, but allows the type system to work out what f is
act<R>(Func<R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<R>
Function to infer
DECLARATION
[Pure]
public static Action act<R>(Func<R> f)
RETURNS
Action
Action that is the same as the Func passed in, but with the return type dropped
act<T1, R>(Func<T1, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1> act<T1, R>(Func<T1, R> f)
RETURNS
Action<T1>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, R>(Func<T1, T2, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, T2, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1, T2> act<T1, T2, R>(Func<T1, T2, R> f)
RETURNS
Action<T1, T2>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, T3, R>(Func<T1, T2, T3, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, T2, T3, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3> act<T1, T2, T3, R>(Func<T1, T2, T3, R> f)
RETURNS
Action<T1, T2, T3>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, T3, T4, R>(Func<T1, T2, T3, T4, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, T2, T3, T4, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4> act<T1, T2, T3, T4, R>(Func<T1, T2, T3, T4, R> f)
RETURNS
Action<T1, T2, T3, T4>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, T3, T4, T5, R>(Func<T1, T2, T3, T4, T5, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, T2, T3, T4, T5, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4, T5> act<T1, T2, T3, T4, T5, R>(Func<T1, T2, T3, T4, T5, R> f)
RETURNS
Action<T1, T2, T3, T4, T5>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, T3, T4, T5, T6, R>(Func<T1, T2, T3, T4, T5, T6, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, T2, T3, T4, T5, T6, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4, T5, T6> act<T1, T2, T3, T4, T5, T6, R>(Func<T1, T2, T3, T4, T5, T6, R> f)
RETURNS
Action<T1, T2, T3, T4, T5, T6>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, T3, T4, T5, T6, T7, R>(Func<T1, T2, T3, T4, T5, T6, T7, R>)
SUMMARY

Func type inference helper; converts it to an Action by dropping the return value

Try it with lambdas, instead of doing:

Func<string, string> thereIs = ...


Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };


You can use this function and do:

var thereIsNoReturn = act(thereIs);


PARAMETERS
f
Func<T1, T2, T3, T4, T5, T6, T7, R>
Function to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4, T5, T6, T7> act<T1, T2, T3, T4, T5, T6, T7, R>(Func<T1, T2, T3, T4, T5, T6, T7, R> f)
RETURNS
Action<T1, T2, T3, T4, T5, T6, T7>
Action that is the same as the Func passed in, but with the return type dropped
act<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1, T2, T3, T4, T5, T6, T7>
Action to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4, T5, T6, T7> act<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> f)
RETURNS
Action<T1, T2, T3, T4, T5, T6, T7>
The same Action you gave it, but allows the type system to work out what f is
act<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1, T2, T3, T4, T5, T6>
Action to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4, T5, T6> act<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> f)
RETURNS
Action<T1, T2, T3, T4, T5, T6>
The same Action you gave it, but allows the type system to work out what f is
act<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1, T2, T3, T4, T5>
Action to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4, T5> act<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> f)
RETURNS
Action<T1, T2, T3, T4, T5>
The same Action you gave it, but allows the type system to work out what f is
act<T1, T2, T3, T4>(Action<T1, T2, T3, T4>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1, T2, T3, T4>
Action to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3, T4> act<T1, T2, T3, T4>(Action<T1, T2, T3, T4> f)
RETURNS
Action<T1, T2, T3, T4>
The same Action you gave it, but allows the type system to work out what f is
act<T1, T2, T3>(Action<T1, T2, T3>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1, T2, T3>
Action to infer
DECLARATION
[Pure]
public static Action<T1, T2, T3> act<T1, T2, T3>(Action<T1, T2, T3> f)
RETURNS
Action<T1, T2, T3>
The same Action you gave it, but allows the type system to work out what f is
act<T1, T2>(Action<T1, T2>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1, T2>
Action to infer
DECLARATION
[Pure]
public static Action<T1, T2> act<T1, T2>(Action<T1, T2> f)
RETURNS
Action<T1, T2>
The same Action you gave it, but allows the type system to work out what f is
act<T1>(Action<T1>)
SUMMARY

Action type inference helper

Try it with lambdas, instead of doing:

Action<string> putStr = (string x) => Console.WriteLine(x);


You can use this function and do:

var putStr = act((string x) => Console.WriteLine(x));


PARAMETERS
f
Action<T1>
Action to infer
DECLARATION
[Pure]
public static Action<T1> act<T1>(Action<T1> f)
RETURNS
Action<T1>
The same Action you gave it, but allows the type system to work out what f is
action<A, B>(Option<A>, Option<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
Option<A>
Applicative to evaluate first
fb
Option<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static Option<B> action<A, B>(Option<A> fa, Option<B> fb)
RETURNS
Option<B>
Applicative of type Option<B>
action<A, B>(OptionAsync<A>, OptionAsync<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
OptionAsync<A>
Applicative to evaluate first
fb
OptionAsync<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static OptionAsync<B> action<A, B>(OptionAsync<A> fa, OptionAsync<B> fb)
RETURNS
OptionAsync<B>
Applicative of type OptionAsync<B>
action<A, B>(OptionUnsafe<A>, OptionUnsafe<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
OptionUnsafe<A>
Applicative to evaluate first
fb
OptionUnsafe<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static OptionUnsafe<B> action<A, B>(OptionUnsafe<A> fa, OptionUnsafe<B> fb)
RETURNS
OptionUnsafe<B>
Applicative of type Option<B>
action<A, B>(Try<A>, Try<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
Try<A>
Applicative to evaluate first
fb
Try<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static Try<B> action<A, B>(Try<A> fa, Try<B> fb)
RETURNS
Try<B>
Applicative of type Option<B>
action<A, B>(TryAsync<A>, TryAsync<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
TryAsync<A>
Applicative to evaluate first
fb
TryAsync<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static TryAsync<B> action<A, B>(TryAsync<A> fa, TryAsync<B> fb)
RETURNS
TryAsync<B>
Applicative of type Option<B>
action<A, B>(TryOption<A>, TryOption<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
TryOption<A>
Applicative to evaluate first
fb
TryOption<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static TryOption<B> action<A, B>(TryOption<A> fa, TryOption<B> fb)
RETURNS
TryOption<B>
Applicative of type Option<B>
action<A, B>(TryOptionAsync<A>, TryOptionAsync<B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
TryOptionAsync<A>
Applicative to evaluate first
fb
TryOptionAsync<B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static TryOptionAsync<B> action<A, B>(TryOptionAsync<A> fa, TryOptionAsync<B> fb)
RETURNS
TryOptionAsync<B>
Applicative of type Option<B>
action<L, A, B>(Either<L, A>, Either<L, B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
Either<L, A>
Applicative to evaluate first
fb
Either<L, B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static Either<L, B> action<L, A, B>(Either<L, A> fa, Either<L, B> fb)
RETURNS
Either<L, B>
Applicative of type Option<B>
action<L, A, B>(EitherUnsafe<L, A>, EitherUnsafe<L, B>)
SUMMARY

Evaluate fa, then fb, ignoring the result of fa

PARAMETERS
fa
EitherUnsafe<L, A>
Applicative to evaluate first
fb
EitherUnsafe<L, B>
Applicative to evaluate second and then return
DECLARATION
[Pure]
public static EitherUnsafe<L, B> action<L, A, B>(EitherUnsafe<L, A> fa, EitherUnsafe<L, B> fb)
RETURNS
EitherUnsafe<L, B>
Applicative of type Option<B>
ad<T1, T2, T3>(ValueTuple<T1, T2>, T3)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<T1, T2>
third
T3
DECLARATION
[Pure]
public static ValueTuple<T1, T2, T3> ad<T1, T2, T3>(ValueTuple<T1, T2> self, T3 third)
RETURNS
ValueTuple<T1, T2, T3>
add<A, B, C, D, E, F, G, H>(ValueTuple<A, B, C, D, E, F, G>, H)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<A, B, C, D, E, F, G>
eighth
H
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F, G, H> add<A, B, C, D, E, F, G, H>(ValueTuple<A, B, C, D, E, F, G> self, H eighth)
RETURNS
ValueTuple<A, B, C, D, E, F, G, H>
add<A, B, C, D, E, F, G>(Tuple<A, B, C, D, E, F>, G)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
Tuple<A, B, C, D, E, F>
seventh
G
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E, F, G> add<A, B, C, D, E, F, G>(Tuple<A, B, C, D, E, F> self, G seventh)
RETURNS
Tuple<A, B, C, D, E, F, G>
add<A, B, C, D, E, F, G>(ValueTuple<A, B, C, D, E, F>, G)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<A, B, C, D, E, F>
seventh
G
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F, G> add<A, B, C, D, E, F, G>(ValueTuple<A, B, C, D, E, F> self, G seventh)
RETURNS
ValueTuple<A, B, C, D, E, F, G>
add<A, B, C, D, E, F>(Tuple<A, B, C, D, E>, F)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
Tuple<A, B, C, D, E>
sixth
F
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E, F> add<A, B, C, D, E, F>(Tuple<A, B, C, D, E> self, F sixth)
RETURNS
Tuple<A, B, C, D, E, F>
add<A, B, C, D, E, F>(ValueTuple<A, B, C, D, E>, F)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<A, B, C, D, E>
sixth
F
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F> add<A, B, C, D, E, F>(this ValueTuple<A, B, C, D, E> self, F sixth)
RETURNS
ValueTuple<A, B, C, D, E, F>
add<A, B, C, D, E>(Tuple<A, B, C, D>, E)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
Tuple<A, B, C, D>
fifth
E
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E> add<A, B, C, D, E>(Tuple<A, B, C, D> self, E fifth)
RETURNS
Tuple<A, B, C, D, E>
add<A, B, C, D, E>(ValueTuple<A, B, C, D>, E)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<A, B, C, D>
fifth
E
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E> add<A, B, C, D, E>(ValueTuple<A, B, C, D> self, E fifth)
RETURNS
ValueTuple<A, B, C, D, E>
add<A, B>(Tuple<A>, B)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
Tuple<A>
second
B
DECLARATION
[Pure]
public static Tuple<A, B> add<A, B>(Tuple<A> self, B second)
RETURNS
Tuple<A, B>
add<A, B>(ValueTuple<A>, B)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<A>
second
B
DECLARATION
[Pure]
public static ValueTuple<A, B> add<A, B>(ValueTuple<A> self, B second)
RETURNS
ValueTuple<A, B>
add<NUM, A>(Try<A>, Try<A>)
SUMMARY

Add the bound value of Try(x) to Try(y). If either of the Trys are Fail then the result is Fail

PARAMETERS
lhs
Try<A>
Left-hand side of the operation
rhs
Try<A>
Right-hand side of the operation
DECLARATION
[Pure]
public static Try<A> add<NUM, A>(Try<A> lhs, Try<A> rhs)
RETURNS
Try<A>
lhs + rhs
CONSTRAINTS
where NUM : struct Num<A>
add<NUM, A>(TryAsync<A>, TryAsync<A>)
SUMMARY

Add the bound value of TryAsync(x) to TryAsync(y). If either of the Trys are Fail then the result is Fail

PARAMETERS
lhs
TryAsync<A>
Left-hand side of the operation
rhs
TryAsync<A>
Right-hand side of the operation
DECLARATION
[Pure]
public static TryAsync<A> add<NUM, A>(TryAsync<A> lhs, TryAsync<A> rhs)
RETURNS
TryAsync<A>
lhs + rhs
CONSTRAINTS
where NUM : struct Num<A>
add<NUM, A>(TryOption<A>, TryOption<A>)
SUMMARY

Add the bound value of Try(x) to Try(y). If either of the Trys are Fail then the result is Fail

PARAMETERS
lhs
TryOption<A>
Left-hand side of the operation
rhs
TryOption<A>
Right-hand side of the operation
DECLARATION
[Pure]
public static TryOption<A> add<NUM, A>(TryOption<A> lhs, TryOption<A> rhs)
RETURNS
TryOption<A>
lhs + rhs
CONSTRAINTS
where NUM : struct Num<A>
add<NUM, A>(TryOptionAsync<A>, TryOptionAsync<A>)
SUMMARY

Add the bound value of TryOptionAsync(x) to TryOptionAsync(y). If either of the Trys are Fail then the result is Fail

PARAMETERS
lhs
TryOptionAsync<A>
Left-hand side of the operation
rhs
TryOptionAsync<A>
Right-hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<A> add<NUM, A>(TryOptionAsync<A> lhs, TryOptionAsync<A> rhs)
RETURNS
TryOptionAsync<A>
lhs + rhs
CONSTRAINTS
where NUM : struct Num<A>
add<NUM, T>(Option<T>, Option<T>)
SUMMARY

Add the Ts

PARAMETERS
lhs
Option<T>
Left-hand side of the operation
rhs
Option<T>
Right-hand side of the operation
DECLARATION
[Pure]
public static Option<T> add<NUM, T>(Option<T> lhs, Option<T> rhs)
RETURNS
Option<T>
lhs / rhs
CONSTRAINTS
where NUM : struct Num<T>
add<NUM, T>(OptionAsync<T>, OptionAsync<T>)
SUMMARY

Add the Ts

PARAMETERS
lhs
OptionAsync<T>
Left-hand side of the operation
rhs
OptionAsync<T>
Right-hand side of the operation
DECLARATION
[Pure]
public static OptionAsync<T> add<NUM, T>(OptionAsync<T> lhs, OptionAsync<T> rhs)
RETURNS
OptionAsync<T>
lhs / rhs
CONSTRAINTS
where NUM : struct Num<T>
add<NUM, T>(OptionUnsafe<T>, OptionUnsafe<T>)
SUMMARY

Add the Ts

PARAMETERS
lhs
OptionUnsafe<T>
Left-hand side of the operation
rhs
OptionUnsafe<T>
Right-hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<T> add<NUM, T>(OptionUnsafe<T> lhs, OptionUnsafe<T> rhs)
RETURNS
OptionUnsafe<T>
lhs / rhs
CONSTRAINTS
where NUM : struct Num<T>
add<NUMTYPE, NUM, A, PRED>(NumType<NUMTYPE, NUM, A, PRED>, NUMTYPE)
SUMMARY

Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<Metres, TInt, int>(y)

PARAMETERS
x
NumType<NUMTYPE, NUM, A, PRED>
Left hand side of the operation
y
NUMTYPE
Right hand side of the operation
DECLARATION
[Pure]
public static NUMTYPE add<NUMTYPE, NUM, A, PRED>(NumType<NUMTYPE, NUM, A, PRED> x, NUMTYPE y)
RETURNS
NUMTYPE
An NewType with y added to x
CONSTRAINTS
where NUM : struct Num<A>
where PRED : struct Pred<A>
where NUMTYPE : NumType<NUMTYPE, NUM, A, PRED>
add<NUMTYPE, NUM, A>(NumType<NUMTYPE, NUM, A>, NUMTYPE)
SUMMARY

Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<Metres, TInt, int>(y)

PARAMETERS
x
NumType<NUMTYPE, NUM, A>
Left hand side of the operation
y
NUMTYPE
Right hand side of the operation
DECLARATION
[Pure]
public static NUMTYPE add<NUMTYPE, NUM, A>(NumType<NUMTYPE, NUM, A> x, NUMTYPE y)
RETURNS
NUMTYPE
An NewType with y added to x
CONSTRAINTS
where NUM : struct Num<A>
where NUMTYPE : NumType<NUMTYPE, NUM, A>
add<SELF, FLOAT, A, PRED>(FloatType<SELF, FLOAT, A, PRED>, SELF)
SUMMARY

Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<Metres, TInt, int>(y)

PARAMETERS
x
FloatType<SELF, FLOAT, A, PRED>
Left hand side of the operation
y
SELF
Right hand side of the operation
DECLARATION
[Pure]
public static SELF add<SELF, FLOAT, A, PRED>(FloatType<SELF, FLOAT, A, PRED> x, SELF y)
RETURNS
SELF
An NewType with y added to x
CONSTRAINTS
where FLOAT : struct Floating<A>
where PRED : struct Pred<A>
where SELF : FloatType<SELF, FLOAT, A, PRED>
add<SELF, FLOAT, A>(FloatType<SELF, FLOAT, A>, SELF)
SUMMARY

Add the bound values of x and y, uses an Add type-class to provide the add operation for type A. For example x.Add<Metres, TInt, int>(y)

PARAMETERS
x
FloatType<SELF, FLOAT, A>
Left hand side of the operation
y
SELF
Right hand side of the operation
DECLARATION
[Pure]
public static SELF add<SELF, FLOAT, A>(FloatType<SELF, FLOAT, A> x, SELF y)
RETURNS
SELF
An NewType with y added to x
CONSTRAINTS
where FLOAT : struct Floating<A>
where SELF : FloatType<SELF, FLOAT, A>
add<T1, T2, T3, T4>(ValueTuple<T1, T2, T3>, T4)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
ValueTuple<T1, T2, T3>
fourth
T4
DECLARATION
[Pure]
public static ValueTuple<T1, T2, T3, T4> add<T1, T2, T3, T4>(ValueTuple<T1, T2, T3> self, T4 fourth)
RETURNS
ValueTuple<T1, T2, T3, T4>
add<T1, T2, T3>(Tuple<T1, T2>, T3)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
Tuple<T1, T2>
third
T3
DECLARATION
[Pure]
public static Tuple<T1, T2, T3> add<T1, T2, T3>(Tuple<T1, T2> self, T3 third)
RETURNS
Tuple<T1, T2, T3>
append<SEMI, A>(Try<A>, Try<A>)
SUMMARY

Append the bound value of Try(x) to Try(y). If either of the Trys are Fail then the result is Fail

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

Append the bound value of TryAsync(x) to TryAsync(y). If either of the Trys are Fail then the result is Fail

PARAMETERS
lhs
TryAsync<A>
Left-hand side of the operation
rhs
TryAsync<A>
Right-hand side of the operation
DECLARATION
[Pure]
public static TryAsync<A> Append<SEMI, A>(this TryAsync<A> lhs, TryAsync<A> rhs)
RETURNS
TryAsync<A>
lhs ++ rhs
CONSTRAINTS
where SEMI : struct Semigroup<A>
Append<SEMI, A>(TryOptionAsync<A>, TryOptionAsync<A>)
SUMMARY

Append the bound value of TryOptionAsync(x) to TryOptionAsync(y). If either of the Trys are Fail then the result is Fail

PARAMETERS
lhs
TryOptionAsync<A>
Left-hand side of the operation
rhs
TryOptionAsync<A>
Right-hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<A> Append<SEMI, A>(this TryOptionAsync<A> lhs, TryOptionAsync<A> rhs)
RETURNS
TryOptionAsync<A>
lhs ++ rhs
CONSTRAINTS
where SEMI : struct Semigroup<A>
append<SEMI, T>(T?, T?)
SUMMARY

Append the Some(x) of one option to the Some(y) of another. For numeric values the behaviour is to sum the Somes (lhs + rhs) For string values the behaviour is to concatenate the strings For Lst/Stck/Que values the behaviour is to concatenate the lists For Map or Set values the behaviour is to merge the sets Otherwise if the T type derives from IAppendable then the behaviour is to call lhs.Append(rhs);

PARAMETERS
lhs
T?
Left-hand side of the operation
rhs
T?
Right-hand side of the operation
DECLARATION
[Pure]
public static T? append<SEMI, T>(T? lhs, T? rhs)
RETURNS
T?
lhs + rhs
CONSTRAINTS
where SEMI : struct Semigroup<T>
where T : struct
append<SemiA, A>(Tuple<A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(Tuple<A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(Tuple<A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(Tuple<A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(Tuple<A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(Tuple<A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(Tuple<A, A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(Tuple<A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(Tuple<A, A, A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, A, A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(Tuple<A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(Tuple<A, A, A, A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, A, A, A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(Tuple<A, A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(ValueTuple<A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(ValueTuple<A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(ValueTuple<A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(ValueTuple<A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(ValueTuple<A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(ValueTuple<A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(ValueTuple<A, A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(ValueTuple<A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(ValueTuple<A, A, A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, A, A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(ValueTuple<A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, A>(ValueTuple<A, A, A, A, A, A, A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, A, A, A, A, A, A>
DECLARATION
[Pure]
public static A append<SemiA, A>(ValueTuple<A, A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, SemiB, A, B>(Tuple<A>, Tuple<A>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A>
b
Tuple<A>
DECLARATION
[Pure]
public static Tuple<A> append<SemiA, SemiB, A, B>(Tuple<A> a, Tuple<A> b)
RETURNS
Tuple<A>
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, SemiB, A, B>(Tuple<A, B>, Tuple<A, B>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, B>
b
Tuple<A, B>
DECLARATION
[Pure]
public static Tuple<A, B> append<SemiA, SemiB, A, B>(Tuple<A, B> a, Tuple<A, B> b)
RETURNS
Tuple<A, B>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
append<SemiA, SemiB, A, B>(ValueTuple<A>, ValueTuple<A>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A>
b
ValueTuple<A>
DECLARATION
[Pure]
public static ValueTuple<A> append<SemiA, SemiB, A, B>(ValueTuple<A> a, ValueTuple<A> b)
RETURNS
ValueTuple<A>
CONSTRAINTS
where SemiA : struct Semigroup<A>
append<SemiA, SemiB, A, B>(ValueTuple<A, B>, ValueTuple<A, B>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, B>
b
ValueTuple<A, B>
DECLARATION
[Pure]
public static ValueTuple<A, B> append<SemiA, SemiB, A, B>(ValueTuple<A, B> a, ValueTuple<A, B> b)
RETURNS
ValueTuple<A, B>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
append<SemiA, SemiB, SemiC, A, B, C>(Tuple<A, B, C>, Tuple<A, B, C>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, B, C>
b
Tuple<A, B, C>
DECLARATION
[Pure]
public static Tuple<A, B, C> append<SemiA, SemiB, SemiC, A, B, C>(Tuple<A, B, C> a, Tuple<A, B, C> b)
RETURNS
Tuple<A, B, C>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
append<SemiA, SemiB, SemiC, A, B, C>(ValueTuple<A, B, C>, ValueTuple<A, B, C>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, B, C>
b
ValueTuple<A, B, C>
DECLARATION
[Pure]
public static ValueTuple<A, B, C> append<SemiA, SemiB, SemiC, A, B, C>(ValueTuple<A, B, C> a, ValueTuple<A, B, C> b)
RETURNS
ValueTuple<A, B, C>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
append<SemiA, SemiB, SemiC, SemiD, A, B, C, D>(Tuple<A, B, C, D>, Tuple<A, B, C, D>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, B, C, D>
b
Tuple<A, B, C, D>
DECLARATION
[Pure]
public static Tuple<A, B, C, D> append<SemiA, SemiB, SemiC, SemiD, A, B, C, D>(Tuple<A, B, C, D> a, Tuple<A, B, C, D> b)
RETURNS
Tuple<A, B, C, D>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
append<SemiA, SemiB, SemiC, SemiD, A, B, C, D>(ValueTuple<A, B, C, D>, ValueTuple<A, B, C, D>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, B, C, D>
b
ValueTuple<A, B, C, D>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D> append<SemiA, SemiB, SemiC, SemiD, A, B, C, D>(ValueTuple<A, B, C, D> a, ValueTuple<A, B, C, D> b)
RETURNS
ValueTuple<A, B, C, D>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
append<SemiA, SemiB, SemiC, SemiD, SemiE, A, B, C, D, E>(Tuple<A, B, C, D, E>, Tuple<A, B, C, D, E>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, B, C, D, E>
b
Tuple<A, B, C, D, E>
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E> append<SemiA, SemiB, SemiC, SemiD, SemiE, A, B, C, D, E>(Tuple<A, B, C, D, E> a, Tuple<A, B, C, D, E> b)
RETURNS
Tuple<A, B, C, D, E>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
where SemiE : struct Semigroup<E>
append<SemiA, SemiB, SemiC, SemiD, SemiE, A, B, C, D, E>(ValueTuple<A, B, C, D, E>, ValueTuple<A, B, C, D, E>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, B, C, D, E>
b
ValueTuple<A, B, C, D, E>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E> append<SemiA, SemiB, SemiC, SemiD, SemiE, A, B, C, D, E>(this ValueTuple<A, B, C, D, E> a, ValueTuple<A, B, C, D, E> b)
RETURNS
ValueTuple<A, B, C, D, E>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
where SemiE : struct Semigroup<E>
append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, A, B, C, D, E, F>(Tuple<A, B, C, D, E, F>, Tuple<A, B, C, D, E, F>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, B, C, D, E, F>
b
Tuple<A, B, C, D, E, F>
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E, F> append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, A, B, C, D, E, F>(Tuple<A, B, C, D, E, F> a, Tuple<A, B, C, D, E, F> b)
RETURNS
Tuple<A, B, C, D, E, F>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
where SemiE : struct Semigroup<E>
where SemiF : struct Semigroup<F>
append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, A, B, C, D, E, F>(ValueTuple<A, B, C, D, E, F>, ValueTuple<A, B, C, D, E, F>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, B, C, D, E, F>
b
ValueTuple<A, B, C, D, E, F>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F> append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, A, B, C, D, E, F>(ValueTuple<A, B, C, D, E, F> a, ValueTuple<A, B, C, D, E, F> b)
RETURNS
ValueTuple<A, B, C, D, E, F>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
where SemiE : struct Semigroup<E>
where SemiF : struct Semigroup<F>
append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, SemiG, A, B, C, D, E, F, G>(Tuple<A, B, C, D, E, F, G>, Tuple<A, B, C, D, E, F, G>)
SUMMARY

Semigroup append

PARAMETERS
a
Tuple<A, B, C, D, E, F, G>
b
Tuple<A, B, C, D, E, F, G>
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E, F, G> append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, SemiG, A, B, C, D, E, F, G>(Tuple<A, B, C, D, E, F, G> a, Tuple<A, B, C, D, E, F, G> b)
RETURNS
Tuple<A, B, C, D, E, F, G>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
where SemiE : struct Semigroup<E>
where SemiF : struct Semigroup<F>
where SemiG : struct Semigroup<G>
append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, SemiG, A, B, C, D, E, F, G>(ValueTuple<A, B, C, D, E, F, G>, ValueTuple<A, B, C, D, E, F, G>)
SUMMARY

Semigroup append

PARAMETERS
a
ValueTuple<A, B, C, D, E, F, G>
b
ValueTuple<A, B, C, D, E, F, G>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F, G> append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, SemiG, A, B, C, D, E, F, G>(ValueTuple<A, B, C, D, E, F, G> a, ValueTuple<A, B, C, D, E, F, G> b)
RETURNS
ValueTuple<A, B, C, D, E, F, G>
CONSTRAINTS
where SemiA : struct Semigroup<A>
where SemiB : struct Semigroup<B>
where SemiC : struct Semigroup<C>
where SemiD : struct Semigroup<D>
where SemiE : struct Semigroup<E>
where SemiF : struct Semigroup<F>
where SemiG : struct Semigroup<G>
append<T1, T2, T3, T4>(Tuple<T1, T2, T3>, T4)
SUMMARY

Append an extra item to the tuple

PARAMETERS
self
Tuple<T1, T2, T3>
fourth
T4
DECLARATION
[Pure]
public static Tuple<T1, T2, T3, T4> append<T1, T2, T3, T4>(Tuple<T1, T2, T3> self, T4 fourth)
RETURNS
Tuple<T1, T2, T3, T4>
apply<A, B, C>(Option<Func<A, B, C>>, Option<A>, Option<B>)
SUMMARY

Apply

PARAMETERS
fabc
Option<Func<A, B, C>>
fa
Option<A>
Applicative a to apply
fb
Option<B>
Applicative b to apply
DECLARATION
[Pure]
public static Option<C> apply<A, B, C>(Option<Func<A, B, C>> fabc, Option<A> fa, Option<B> fb)
RETURNS
Option<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, Option<A>, Option<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
Option<A>
Applicative a to apply
fb
Option<B>
Applicative b to apply
DECLARATION
[Pure]
public static Option<C> apply<A, B, C>(Func<A, B, C> fabc, Option<A> fa, Option<B> fb)
RETURNS
Option<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Option<Func<A, B, C>>, Option<A>)
SUMMARY

Apply

PARAMETERS
fabc
Option<Func<A, B, C>>
fa
Option<A>
Applicative to apply
DECLARATION
[Pure]
public static Option<Func<B, C>> apply<A, B, C>(Option<Func<A, B, C>> fabc, Option<A> fa)
RETURNS
Option<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, Option<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
Option<A>
Applicative to apply
DECLARATION
[Pure]
public static Option<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, Option<A> fa)
RETURNS
Option<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Option<Func<A, Func<B, C>>>, Option<A>)
SUMMARY

Apply

PARAMETERS
fabc
Option<Func<A, Func<B, C>>>
fa
Option<A>
Applicative to apply
DECLARATION
[Pure]
public static Option<Func<B, C>> apply<A, B, C>(Option<Func<A, Func<B, C>>> fabc, Option<A> fa)
RETURNS
Option<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, Option<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
Option<A>
Applicative to apply
DECLARATION
[Pure]
public static Option<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, Option<A> fa)
RETURNS
Option<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(OptionAsync<Func<A, B, C>>, OptionAsync<A>, OptionAsync<B>)
SUMMARY

Apply

PARAMETERS
fabc
OptionAsync<Func<A, B, C>>
fa
OptionAsync<A>
Applicative a to apply
fb
OptionAsync<B>
Applicative b to apply
DECLARATION
[Pure]
public static OptionAsync<C> apply<A, B, C>(OptionAsync<Func<A, B, C>> fabc, OptionAsync<A> fa, OptionAsync<B> fb)
RETURNS
OptionAsync<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, OptionAsync<A>, OptionAsync<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
OptionAsync<A>
Applicative a to apply
fb
OptionAsync<B>
Applicative b to apply
DECLARATION
[Pure]
public static OptionAsync<C> apply<A, B, C>(Func<A, B, C> fabc, OptionAsync<A> fa, OptionAsync<B> fb)
RETURNS
OptionAsync<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(OptionAsync<Func<A, B, C>>, OptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
OptionAsync<Func<A, B, C>>
fa
OptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionAsync<Func<B, C>> apply<A, B, C>(OptionAsync<Func<A, B, C>> fabc, OptionAsync<A> fa)
RETURNS
OptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, OptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
OptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionAsync<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, OptionAsync<A> fa)
RETURNS
OptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(OptionAsync<Func<A, Func<B, C>>>, OptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
OptionAsync<Func<A, Func<B, C>>>
fa
OptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionAsync<Func<B, C>> apply<A, B, C>(OptionAsync<Func<A, Func<B, C>>> fabc, OptionAsync<A> fa)
RETURNS
OptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, OptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
OptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionAsync<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, OptionAsync<A> fa)
RETURNS
OptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(OptionUnsafe<Func<A, B, C>>, OptionUnsafe<A>, OptionUnsafe<B>)
SUMMARY

Apply

PARAMETERS
fabc
OptionUnsafe<Func<A, B, C>>
fa
OptionUnsafe<A>
Applicative a to apply
fb
OptionUnsafe<B>
Applicative b to apply
DECLARATION
[Pure]
public static OptionUnsafe<C> apply<A, B, C>(OptionUnsafe<Func<A, B, C>> fabc, OptionUnsafe<A> fa, OptionUnsafe<B> fb)
RETURNS
OptionUnsafe<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, OptionUnsafe<A>, OptionUnsafe<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
OptionUnsafe<A>
Applicative a to apply
fb
OptionUnsafe<B>
Applicative b to apply
DECLARATION
[Pure]
public static OptionUnsafe<C> apply<A, B, C>(Func<A, B, C> fabc, OptionUnsafe<A> fa, OptionUnsafe<B> fb)
RETURNS
OptionUnsafe<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(OptionUnsafe<Func<A, B, C>>, OptionUnsafe<A>)
SUMMARY

Apply

PARAMETERS
fabc
OptionUnsafe<Func<A, B, C>>
fa
OptionUnsafe<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionUnsafe<Func<B, C>> apply<A, B, C>(OptionUnsafe<Func<A, B, C>> fabc, OptionUnsafe<A> fa)
RETURNS
OptionUnsafe<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, OptionUnsafe<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
OptionUnsafe<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionUnsafe<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, OptionUnsafe<A> fa)
RETURNS
OptionUnsafe<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(OptionUnsafe<Func<A, Func<B, C>>>, OptionUnsafe<A>)
SUMMARY

Apply

PARAMETERS
fabc
OptionUnsafe<Func<A, Func<B, C>>>
fa
OptionUnsafe<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionUnsafe<Func<B, C>> apply<A, B, C>(OptionUnsafe<Func<A, Func<B, C>>> fabc, OptionUnsafe<A> fa)
RETURNS
OptionUnsafe<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, OptionUnsafe<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
OptionUnsafe<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionUnsafe<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, OptionUnsafe<A> fa)
RETURNS
OptionUnsafe<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Try<Func<A, B, C>>, Try<A>, Try<B>)
SUMMARY

Apply

PARAMETERS
fabc
Try<Func<A, B, C>>
fa
Try<A>
Applicative a to apply
fb
Try<B>
Applicative b to apply
DECLARATION
[Pure]
public static Try<C> apply<A, B, C>(Try<Func<A, B, C>> fabc, Try<A> fa, Try<B> fb)
RETURNS
Try<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, Try<A>, Try<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
Try<A>
Applicative a to apply
fb
Try<B>
Applicative b to apply
DECLARATION
[Pure]
public static Try<C> apply<A, B, C>(Func<A, B, C> fabc, Try<A> fa, Try<B> fb)
RETURNS
Try<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Try<Func<A, B, C>>, Try<A>)
SUMMARY

Apply

PARAMETERS
fabc
Try<Func<A, B, C>>
fa
Try<A>
Applicative to apply
DECLARATION
[Pure]
public static Try<Func<B, C>> apply<A, B, C>(Try<Func<A, B, C>> fabc, Try<A> fa)
RETURNS
Try<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, Try<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
Try<A>
Applicative to apply
DECLARATION
[Pure]
public static Try<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, Try<A> fa)
RETURNS
Try<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Try<Func<A, Func<B, C>>>, Try<A>)
SUMMARY

Apply

PARAMETERS
fabc
Try<Func<A, Func<B, C>>>
fa
Try<A>
Applicative to apply
DECLARATION
[Pure]
public static Try<Func<B, C>> apply<A, B, C>(Try<Func<A, Func<B, C>>> fabc, Try<A> fa)
RETURNS
Try<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, Try<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
Try<A>
Applicative to apply
DECLARATION
[Pure]
public static Try<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, Try<A> fa)
RETURNS
Try<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(TryAsync<Func<A, B, C>>, TryAsync<A>, TryAsync<B>)
SUMMARY

Apply

PARAMETERS
fabc
TryAsync<Func<A, B, C>>
fa
TryAsync<A>
Applicative a to apply
fb
TryAsync<B>
Applicative b to apply
DECLARATION
[Pure]
public static TryAsync<C> apply<A, B, C>(TryAsync<Func<A, B, C>> fabc, TryAsync<A> fa, TryAsync<B> fb)
RETURNS
TryAsync<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, TryAsync<A>, TryAsync<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
TryAsync<A>
Applicative a to apply
fb
TryAsync<B>
Applicative b to apply
DECLARATION
[Pure]
public static TryAsync<C> apply<A, B, C>(Func<A, B, C> fabc, TryAsync<A> fa, TryAsync<B> fb)
RETURNS
TryAsync<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(TryAsync<Func<A, B, C>>, TryAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
TryAsync<Func<A, B, C>>
fa
TryAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryAsync<Func<B, C>> apply<A, B, C>(TryAsync<Func<A, B, C>> fabc, TryAsync<A> fa)
RETURNS
TryAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, TryAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
TryAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryAsync<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, TryAsync<A> fa)
RETURNS
TryAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(TryAsync<Func<A, Func<B, C>>>, TryAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
TryAsync<Func<A, Func<B, C>>>
fa
TryAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryAsync<Func<B, C>> apply<A, B, C>(TryAsync<Func<A, Func<B, C>>> fabc, TryAsync<A> fa)
RETURNS
TryAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, TryAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
TryAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryAsync<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, TryAsync<A> fa)
RETURNS
TryAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(TryOption<Func<A, B, C>>, TryOption<A>, TryOption<B>)
SUMMARY

Apply

PARAMETERS
fabc
TryOption<Func<A, B, C>>
fa
TryOption<A>
Applicative a to apply
fb
TryOption<B>
Applicative b to apply
DECLARATION
[Pure]
public static TryOption<C> apply<A, B, C>(TryOption<Func<A, B, C>> fabc, TryOption<A> fa, TryOption<B> fb)
RETURNS
TryOption<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, TryOption<A>, TryOption<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
TryOption<A>
Applicative a to apply
fb
TryOption<B>
Applicative b to apply
DECLARATION
[Pure]
public static TryOption<C> apply<A, B, C>(Func<A, B, C> fabc, TryOption<A> fa, TryOption<B> fb)
RETURNS
TryOption<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(TryOption<Func<A, B, C>>, TryOption<A>)
SUMMARY

Apply

PARAMETERS
fabc
TryOption<Func<A, B, C>>
fa
TryOption<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOption<Func<B, C>> apply<A, B, C>(TryOption<Func<A, B, C>> fabc, TryOption<A> fa)
RETURNS
TryOption<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, TryOption<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
TryOption<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOption<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, TryOption<A> fa)
RETURNS
TryOption<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(TryOption<Func<A, Func<B, C>>>, TryOption<A>)
SUMMARY

Apply

PARAMETERS
fabc
TryOption<Func<A, Func<B, C>>>
fa
TryOption<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOption<Func<B, C>> apply<A, B, C>(TryOption<Func<A, Func<B, C>>> fabc, TryOption<A> fa)
RETURNS
TryOption<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, TryOption<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
TryOption<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOption<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, TryOption<A> fa)
RETURNS
TryOption<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(TryOptionAsync<Func<A, B, C>>, TryOptionAsync<A>, TryOptionAsync<B>)
SUMMARY

Apply

PARAMETERS
fabc
TryOptionAsync<Func<A, B, C>>
fa
TryOptionAsync<A>
Applicative a to apply
fb
TryOptionAsync<B>
Applicative b to apply
DECLARATION
[Pure]
public static TryOptionAsync<C> apply<A, B, C>(TryOptionAsync<Func<A, B, C>> fabc, TryOptionAsync<A> fa, TryOptionAsync<B> fb)
RETURNS
TryOptionAsync<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(Func<A, B, C>, TryOptionAsync<A>, TryOptionAsync<B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
TryOptionAsync<A>
Applicative a to apply
fb
TryOptionAsync<B>
Applicative b to apply
DECLARATION
[Pure]
public static TryOptionAsync<C> apply<A, B, C>(Func<A, B, C> fabc, TryOptionAsync<A> fa, TryOptionAsync<B> fb)
RETURNS
TryOptionAsync<C>
Applicative of type FC derived from Applicative of C
apply<A, B, C>(TryOptionAsync<Func<A, B, C>>, TryOptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
TryOptionAsync<Func<A, B, C>>
fa
TryOptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOptionAsync<Func<B, C>> apply<A, B, C>(TryOptionAsync<Func<A, B, C>> fabc, TryOptionAsync<A> fa)
RETURNS
TryOptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, B, C>, TryOptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
TryOptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOptionAsync<Func<B, C>> apply<A, B, C>(Func<A, B, C> fabc, TryOptionAsync<A> fa)
RETURNS
TryOptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(TryOptionAsync<Func<A, Func<B, C>>>, TryOptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
TryOptionAsync<Func<A, Func<B, C>>>
fa
TryOptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOptionAsync<Func<B, C>> apply<A, B, C>(TryOptionAsync<Func<A, Func<B, C>>> fabc, TryOptionAsync<A> fa)
RETURNS
TryOptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B, C>(Func<A, Func<B, C>>, TryOptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
TryOptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOptionAsync<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>> fabc, TryOptionAsync<A> fa)
RETURNS
TryOptionAsync<Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<A, B>(Option<Func<A, B>>, Option<A>)
SUMMARY

Apply

PARAMETERS
fab
Option<Func<A, B>>
Function to apply the applicative to
fa
Option<A>
Applicative to apply
DECLARATION
[Pure]
public static Option<B> apply<A, B>(Option<Func<A, B>> fab, Option<A> fa)
RETURNS
Option<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, Option<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
Option<A>
Applicative to apply
DECLARATION
[Pure]
public static Option<B> apply<A, B>(Func<A, B> fab, Option<A> fa)
RETURNS
Option<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(OptionAsync<Func<A, B>>, OptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fab
OptionAsync<Func<A, B>>
Function to apply the applicative to
fa
OptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionAsync<B> apply<A, B>(OptionAsync<Func<A, B>> fab, OptionAsync<A> fa)
RETURNS
OptionAsync<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, OptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
OptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionAsync<B> apply<A, B>(Func<A, B> fab, OptionAsync<A> fa)
RETURNS
OptionAsync<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(OptionUnsafe<Func<A, B>>, OptionUnsafe<A>)
SUMMARY

Apply

PARAMETERS
fab
OptionUnsafe<Func<A, B>>
Function to apply the applicative to
fa
OptionUnsafe<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionUnsafe<B> apply<A, B>(OptionUnsafe<Func<A, B>> fab, OptionUnsafe<A> fa)
RETURNS
OptionUnsafe<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, OptionUnsafe<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
OptionUnsafe<A>
Applicative to apply
DECLARATION
[Pure]
public static OptionUnsafe<B> apply<A, B>(Func<A, B> fab, OptionUnsafe<A> fa)
RETURNS
OptionUnsafe<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Try<Func<A, B>>, Try<A>)
SUMMARY

Apply

PARAMETERS
fab
Try<Func<A, B>>
Function to apply the applicative to
fa
Try<A>
Applicative to apply
DECLARATION
[Pure]
public static Try<B> apply<A, B>(Try<Func<A, B>> fab, Try<A> fa)
RETURNS
Try<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, Try<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
Try<A>
Applicative to apply
DECLARATION
[Pure]
public static Try<B> apply<A, B>(Func<A, B> fab, Try<A> fa)
RETURNS
Try<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(TryAsync<Func<A, B>>, TryAsync<A>)
SUMMARY

Apply

PARAMETERS
fab
TryAsync<Func<A, B>>
Function to apply the applicative to
fa
TryAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryAsync<B> apply<A, B>(TryAsync<Func<A, B>> fab, TryAsync<A> fa)
RETURNS
TryAsync<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, TryAsync<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
TryAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryAsync<B> apply<A, B>(Func<A, B> fab, TryAsync<A> fa)
RETURNS
TryAsync<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(TryOption<Func<A, B>>, TryOption<A>)
SUMMARY

Apply

PARAMETERS
fab
TryOption<Func<A, B>>
Function to apply the applicative to
fa
TryOption<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOption<B> apply<A, B>(TryOption<Func<A, B>> fab, TryOption<A> fa)
RETURNS
TryOption<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, TryOption<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
TryOption<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOption<B> apply<A, B>(Func<A, B> fab, TryOption<A> fa)
RETURNS
TryOption<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(TryOptionAsync<Func<A, B>>, TryOptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fab
TryOptionAsync<Func<A, B>>
Function to apply the applicative to
fa
TryOptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOptionAsync<B> apply<A, B>(TryOptionAsync<Func<A, B>> fab, TryOptionAsync<A> fa)
RETURNS
TryOptionAsync<B>
Applicative of type FB derived from Applicative of B
apply<A, B>(Func<A, B>, TryOptionAsync<A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
TryOptionAsync<A>
Applicative to apply
DECLARATION
[Pure]
public static TryOptionAsync<B> apply<A, B>(Func<A, B> fab, TryOptionAsync<A> fa)
RETURNS
TryOptionAsync<B>
Applicative of type FB derived from Applicative of B
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>, Validation<FAIL, O>, Validation<FAIL, P>>, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>, Validation<FAIL, O>, Validation<FAIL, P>>
f
Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>, Validation<FAIL, O>, Validation<FAIL, P>> items, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>, Validation<FAIL, O>>, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>, Validation<FAIL, O>>
f
Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>, Validation<FAIL, O>> items, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, N, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>>, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>>
f
Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, N, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>, Validation<FAIL, N>> items, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, N, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>>, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>>
f
Func<A, B, C, D, E, F, G, H, I, J, K, L, M, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, M, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>, Validation<FAIL, M>> items, Func<A, B, C, D, E, F, G, H, I, J, K, L, M, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>>, Func<A, B, C, D, E, F, G, H, I, J, K, L, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>>
f
Func<A, B, C, D, E, F, G, H, I, J, K, L, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, L, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>, Validation<FAIL, L>> items, Func<A, B, C, D, E, F, G, H, I, J, K, L, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>>, Func<A, B, C, D, E, F, G, H, I, J, K, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>>
f
Func<A, B, C, D, E, F, G, H, I, J, K, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, K, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>, Validation<FAIL, K>> items, Func<A, B, C, D, E, F, G, H, I, J, K, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, J, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>>, Func<A, B, C, D, E, F, G, H, I, J, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>>
f
Func<A, B, C, D, E, F, G, H, I, J, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, J, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>, Validation<FAIL, J>> items, Func<A, B, C, D, E, F, G, H, I, J, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, I, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>>, Func<A, B, C, D, E, F, G, H, I, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>>
f
Func<A, B, C, D, E, F, G, H, I, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, I, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>, Validation<FAIL, I>> items, Func<A, B, C, D, E, F, G, H, I, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, H, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>>, Func<A, B, C, D, E, F, G, H, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>>
f
Func<A, B, C, D, E, F, G, H, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, H, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>, Validation<FAIL, H>> items, Func<A, B, C, D, E, F, G, H, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, G, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>>, Func<A, B, C, D, E, F, G, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>>
f
Func<A, B, C, D, E, F, G, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, G, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>, Validation<FAIL, G>> items, Func<A, B, C, D, E, F, G, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, F, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>>, Func<A, B, C, D, E, F, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>>
f
Func<A, B, C, D, E, F, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, F, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>, Validation<FAIL, F>> items, Func<A, B, C, D, E, F, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, E, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>>, Func<A, B, C, D, E, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>>
f
Func<A, B, C, D, E, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, E, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>, Validation<FAIL, E>> items, Func<A, B, C, D, E, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, D, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>>, Func<A, B, C, D, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>>
f
Func<A, B, C, D, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, D, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>, Validation<FAIL, D>> items, Func<A, B, C, D, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, C, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>>, Func<A, B, C, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>>
f
Func<A, B, C, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, C, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>, Validation<FAIL, C>> items, Func<A, B, C, R> f)
RETURNS
Validation<FAIL, R>
Apply<FAIL, A, B, R>(ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>>, Func<A, B, R>)
PARAMETERS
items
ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>>
f
Func<A, B, R>
DECLARATION
public static Validation<FAIL, R> Apply<FAIL, A, B, R>(this ValueTuple<Validation<FAIL, A>, Validation<FAIL, B>> items, Func<A, B, R> f)
RETURNS
Validation<FAIL, R>
apply<L, A, B, C>(Either<L, Func<A, B, C>>, Either<L, A>, Either<L, B>)
SUMMARY

Apply

PARAMETERS
fabc
Either<L, Func<A, B, C>>
fa
Either<L, A>
Applicative a to apply
fb
Either<L, B>
Applicative b to apply
DECLARATION
[Pure]
public static Either<L, C> apply<L, A, B, C>(Either<L, Func<A, B, C>> fabc, Either<L, A> fa, Either<L, B> fb)
RETURNS
Either<L, C>
Applicative of type FC derived from Applicative of C
apply<L, A, B, C>(Func<A, B, C>, Either<L, A>, Either<L, B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
Either<L, A>
Applicative a to apply
fb
Either<L, B>
Applicative b to apply
DECLARATION
[Pure]
public static Either<L, C> apply<L, A, B, C>(Func<A, B, C> fabc, Either<L, A> fa, Either<L, B> fb)
RETURNS
Either<L, C>
Applicative of type FC derived from Applicative of C
apply<L, A, B, C>(Either<L, Func<A, B, C>>, Either<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
Either<L, Func<A, B, C>>
fa
Either<L, A>
Applicative to apply
DECLARATION
[Pure]
public static Either<L, Func<B, C>> apply<L, A, B, C>(Either<L, Func<A, B, C>> fabc, Either<L, A> fa)
RETURNS
Either<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(Func<A, B, C>, Either<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
Either<L, A>
Applicative to apply
DECLARATION
[Pure]
public static Either<L, Func<B, C>> apply<L, A, B, C>(Func<A, B, C> fabc, Either<L, A> fa)
RETURNS
Either<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(Either<L, Func<A, Func<B, C>>>, Either<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
Either<L, Func<A, Func<B, C>>>
fa
Either<L, A>
Applicative to apply
DECLARATION
[Pure]
public static Either<L, Func<B, C>> apply<L, A, B, C>(Either<L, Func<A, Func<B, C>>> fabc, Either<L, A> fa)
RETURNS
Either<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(Func<A, Func<B, C>>, Either<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
Either<L, A>
Applicative to apply
DECLARATION
[Pure]
public static Either<L, Func<B, C>> apply<L, A, B, C>(Func<A, Func<B, C>> fabc, Either<L, A> fa)
RETURNS
Either<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(EitherUnsafe<L, Func<A, B, C>>, EitherUnsafe<L, A>, EitherUnsafe<L, B>)
SUMMARY

Apply

PARAMETERS
fabc
EitherUnsafe<L, Func<A, B, C>>
fa
EitherUnsafe<L, A>
Applicative a to apply
fb
EitherUnsafe<L, B>
Applicative b to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, C> apply<L, A, B, C>(EitherUnsafe<L, Func<A, B, C>> fabc, EitherUnsafe<L, A> fa, EitherUnsafe<L, B> fb)
RETURNS
EitherUnsafe<L, C>
Applicative of type FC derived from Applicative of C
apply<L, A, B, C>(Func<A, B, C>, EitherUnsafe<L, A>, EitherUnsafe<L, B>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
EitherUnsafe<L, A>
Applicative a to apply
fb
EitherUnsafe<L, B>
Applicative b to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, C> apply<L, A, B, C>(Func<A, B, C> fabc, EitherUnsafe<L, A> fa, EitherUnsafe<L, B> fb)
RETURNS
EitherUnsafe<L, C>
Applicative of type FC derived from Applicative of C
apply<L, A, B, C>(EitherUnsafe<L, Func<A, B, C>>, EitherUnsafe<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
EitherUnsafe<L, Func<A, B, C>>
fa
EitherUnsafe<L, A>
Applicative to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, Func<B, C>> apply<L, A, B, C>(EitherUnsafe<L, Func<A, B, C>> fabc, EitherUnsafe<L, A> fa)
RETURNS
EitherUnsafe<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(Func<A, B, C>, EitherUnsafe<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, B, C>
fa
EitherUnsafe<L, A>
Applicative to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, Func<B, C>> apply<L, A, B, C>(Func<A, B, C> fabc, EitherUnsafe<L, A> fa)
RETURNS
EitherUnsafe<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(EitherUnsafe<L, Func<A, Func<B, C>>>, EitherUnsafe<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
EitherUnsafe<L, Func<A, Func<B, C>>>
fa
EitherUnsafe<L, A>
Applicative to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, Func<B, C>> apply<L, A, B, C>(EitherUnsafe<L, Func<A, Func<B, C>>> fabc, EitherUnsafe<L, A> fa)
RETURNS
EitherUnsafe<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B, C>(Func<A, Func<B, C>>, EitherUnsafe<L, A>)
SUMMARY

Apply

PARAMETERS
fabc
Func<A, Func<B, C>>
fa
EitherUnsafe<L, A>
Applicative to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, Func<B, C>> apply<L, A, B, C>(Func<A, Func<B, C>> fabc, EitherUnsafe<L, A> fa)
RETURNS
EitherUnsafe<L, Func<B, C>>
Applicative of type f(b -> c) derived from Applicative of Func<B, C>
apply<L, A, B>(Either<L, Func<A, B>>, Either<L, A>)
SUMMARY

Apply

PARAMETERS
fab
Either<L, Func<A, B>>
Function to apply the applicative to
fa
Either<L, A>
Applicative to apply
DECLARATION
[Pure]
public static Either<L, B> apply<L, A, B>(Either<L, Func<A, B>> fab, Either<L, A> fa)
RETURNS
Either<L, B>
Applicative of type FB derived from Applicative of B
apply<L, A, B>(Func<A, B>, Either<L, A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
Either<L, A>
Applicative to apply
DECLARATION
[Pure]
public static Either<L, B> apply<L, A, B>(Func<A, B> fab, Either<L, A> fa)
RETURNS
Either<L, B>
Applicative of type FB derived from Applicative of B
apply<L, A, B>(EitherUnsafe<L, Func<A, B>>, EitherUnsafe<L, A>)
SUMMARY

Apply

PARAMETERS
fab
EitherUnsafe<L, Func<A, B>>
Function to apply the applicative to
fa
EitherUnsafe<L, A>
Applicative to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, B> apply<L, A, B>(EitherUnsafe<L, Func<A, B>> fab, EitherUnsafe<L, A> fa)
RETURNS
EitherUnsafe<L, B>
Applicative of type FB derived from Applicative of B
apply<L, A, B>(Func<A, B>, EitherUnsafe<L, A>)
SUMMARY

Apply

PARAMETERS
fab
Func<A, B>
Function to apply the applicative to
fa
EitherUnsafe<L, A>
Applicative to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, B> apply<L, A, B>(Func<A, B> fab, EitherUnsafe<L, A> fa)
RETURNS
EitherUnsafe<L, B>
Applicative of type FB derived from Applicative of B
Apply<MonoidFail, FAIL, A, B, C, D, E, F, G, R>(ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>, Validation<MonoidFail, FAIL, F>, Validation<MonoidFail, FAIL, G>>, Func<A, B, C, D, E, F, G, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>, Validation<MonoidFail, FAIL, F>, Validation<MonoidFail, FAIL, G>>
f
Func<A, B, C, D, E, F, G, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, B, C, D, E, F, G, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>, Validation<MonoidFail, FAIL, F>, Validation<MonoidFail, FAIL, G>> items, Func<A, B, C, D, E, F, G, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
Apply<MonoidFail, FAIL, A, B, C, D, E, F, R>(ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>, Validation<MonoidFail, FAIL, F>>, Func<A, B, C, D, E, F, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>, Validation<MonoidFail, FAIL, F>>
f
Func<A, B, C, D, E, F, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, B, C, D, E, F, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>, Validation<MonoidFail, FAIL, F>> items, Func<A, B, C, D, E, F, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
Apply<MonoidFail, FAIL, A, B, C, D, E, R>(ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>>, Func<A, B, C, D, E, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>>
f
Func<A, B, C, D, E, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, B, C, D, E, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>, Validation<MonoidFail, FAIL, E>> items, Func<A, B, C, D, E, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
Apply<MonoidFail, FAIL, A, B, C, D, R>(ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>>, Func<A, B, C, D, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>>
f
Func<A, B, C, D, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, B, C, D, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>, Validation<MonoidFail, FAIL, D>> items, Func<A, B, C, D, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
Apply<MonoidFail, FAIL, A, B, C, R>(ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>>, Func<A, B, C, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>>
f
Func<A, B, C, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, B, C, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>, Validation<MonoidFail, FAIL, C>> items, Func<A, B, C, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
Apply<MonoidFail, FAIL, A, B, R>(ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>>, Func<A, B, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>>
f
Func<A, B, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, B, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>, Validation<MonoidFail, FAIL, B>> items, Func<A, B, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
Apply<MonoidFail, FAIL, A, R>(ValueTuple<Validation<MonoidFail, FAIL, A>>, Func<A, R>)
PARAMETERS
items
ValueTuple<Validation<MonoidFail, FAIL, A>>
f
Func<A, R>
DECLARATION
public static Validation<MonoidFail, FAIL, R> Apply<MonoidFail, FAIL, A, R>(this ValueTuple<Validation<MonoidFail, FAIL, A>> items, Func<A, R> f)
RETURNS
Validation<MonoidFail, FAIL, R>
CONSTRAINTS
where MonoidFail : struct Monoid<FAIL> Eq<FAIL>
array<T>()
SUMMARY

Create an immutable queue

DECLARATION
[Obsolete("Use 'Array'. All constructor functions are renamed to have their first letter as a capital.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static T array<T>()
RETURNS
T
array<T>(T)
SUMMARY

Create an immutable queue

PARAMETERS
item
T
DECLARATION
[Obsolete("Use 'Array'. All constructor functions are renamed to have their first letter as a capital.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static T array<T>(T item)
RETURNS
T
array<T>(T)
SUMMARY

Create an immutable queue

PARAMETERS
items
T
DECLARATION
[Obsolete("Use 'Array'. All constructor functions are renamed to have their first letter as a capital.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static T array<T>(T items)
RETURNS
T
Array<T>()
SUMMARY

Create an immutable queue

DECLARATION
[Pure]
public static Arr<T> Array<T>()
RETURNS
Arr<T>
Array<T>(T, T)
SUMMARY

Create an immutable queue

PARAMETERS
x
T
xs
T
DECLARATION
[Pure]
public static Arr<T> Array<T>(T x, T xs)
RETURNS
Arr<T>
ask<Env>()
SUMMARY

Retrieves the reader monad environment.

DECLARATION
[Pure]
public static Reader<Env, Env> ask<Env>()
RETURNS
Reader<Env, Env>
Reader monad with the environment in as the bound value
asks<Env, R>(Func<Env, R>)
SUMMARY

Retrieves a function of the current environment.

PARAMETERS
f
Func<Env, R>
DECLARATION
[Pure]
public static Reader<Env, R> asks<Env, R>(Func<Env, R> f)
RETURNS
Reader<Env, R>
Reader monad with the mapped environment in as the bound value
bibind<T, R>(Try<T>, Func<T, Try<R>>, Func<Exception, Try<R>>)
PARAMETERS
self
Try<T>
Succ
Func<T, Try<R>>
Fail
Func<Exception, Try<R>>
DECLARATION
[Pure]
public static Try<R> bibind<T, R>(Try<T> self, Func<T, Try<R>> Succ, Func<Exception, Try<R>> Fail)
RETURNS
Try<R>
bibind<T, R>(TryAsync<T>, Func<T, TryAsync<R>>, Func<Exception, TryAsync<R>>)
PARAMETERS
self
TryAsync<T>
Succ
Func<T, TryAsync<R>>
Fail
Func<Exception, TryAsync<R>>
DECLARATION
[Pure]
public static TryAsync<R> bibind<T, R>(TryAsync<T> self, Func<T, TryAsync<R>> Succ, Func<Exception, TryAsync<R>> Fail)
RETURNS
TryAsync<R>
bibind<T, R>(TryOption<T>, Func<T, TryOption<R>>, Func<TryOption<R>>)
PARAMETERS
self
TryOption<T>
Some
Func<T, TryOption<R>>
Fail
Func<TryOption<R>>
DECLARATION
[Pure]
public static TryOption<R> bibind<T, R>(TryOption<T> self, Func<T, TryOption<R>> Some, Func<TryOption<R>> Fail)
RETURNS
TryOption<R>
bibind<T, R>(TryOptionAsync<T>, Func<T, TryOptionAsync<R>>, Func<TryOptionAsync<R>>)
PARAMETERS
self
TryOptionAsync<T>
Succ
Func<T, TryOptionAsync<R>>
Fail
Func<TryOptionAsync<R>>
DECLARATION
[Pure]
public static TryOptionAsync<R> bibind<T, R>(TryOptionAsync<T> self, Func<T, TryOptionAsync<R>> Succ, Func<TryOptionAsync<R>> Fail)
RETURNS
TryOptionAsync<R>
biexists<A>(Option<A>, Func<A, bool>, Func<Unit, bool>)
SUMMARY

Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
Option<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<Unit, bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biexists<A>(Option<A> option, Func<A, bool> Some, Func<Unit, bool> None)
RETURNS
bool
If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biexists<A>(Option<A>, Func<A, bool>, Func<bool>)
SUMMARY

Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
Option<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biexists<A>(Option<A> option, Func<A, bool> Some, Func<bool> None)
RETURNS
bool
If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biexists<A>(OptionAsync<A>, Func<A, bool>, Func<Unit, bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
ma
OptionAsync<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<Unit, bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static Task<bool> biexists<A>(OptionAsync<A> ma, Func<A, bool> Some, Func<Unit, bool> None)
RETURNS
Task<bool>
If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biexists<A>(OptionAsync<A>, Func<A, bool>, Func<bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
ma
OptionAsync<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static Task<bool> biexists<A>(OptionAsync<A> ma, Func<A, bool> Some, Func<bool> None)
RETURNS
Task<bool>
If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biexists<A>(OptionUnsafe<A>, Func<A, bool>, Func<Unit, bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
OptionUnsafe<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<Unit, bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biexists<A>(OptionUnsafe<A> option, Func<A, bool> Some, Func<Unit, bool> None)
RETURNS
bool
If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biexists<A>(OptionUnsafe<A>, Func<A, bool>, Func<bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
OptionUnsafe<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biexists<A>(OptionUnsafe<A> option, Func<A, bool> Some, Func<bool> None)
RETURNS
bool
If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biexists<L, R>(Either<L, R>, Func<R, bool>, Func<L, bool>)
SUMMARY

Invokes a predicate on the value of the Either

PARAMETERS
either
Either<L, R>
Right
Func<R, bool>
Right predicate
Left
Func<L, bool>
Left predicate
DECLARATION
[Pure]
public static bool biexists<L, R>(Either<L, R> either, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
True if the predicate returns True. False otherwise or if the Either is in a bottom state.
biexists<L, R>(EitherUnsafe<L, R>, Func<R, bool>, Func<L, bool>)
SUMMARY

Invokes a predicate on the value of the Either

PARAMETERS
either
EitherUnsafe<L, R>
Right
Func<R, bool>
Right predicate
Left
Func<L, bool>
Left predicate
DECLARATION
[Pure]
public static bool biexists<L, R>(EitherUnsafe<L, R> either, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
True if the predicate returns True. False otherwise or if the Either is in a bottom state.
biexistsT<L, R>(IEnumerable<Either<L, R>>, Func<R, bool>, Func<L, bool>)
PARAMETERS
self
IEnumerable<Either<L, R>>
Right
Func<R, bool>
Left
Func<L, bool>
DECLARATION
[Pure]
public static bool biexistsT<L, R>(IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
biexistsT<L, R>(IEnumerable<EitherUnsafe<L, R>>, Func<R, bool>, Func<L, bool>)
PARAMETERS
self
IEnumerable<EitherUnsafe<L, R>>
Right
Func<R, bool>
Left
Func<L, bool>
DECLARATION
[Pure]
public static bool biexistsT<L, R>(IEnumerable<EitherUnsafe<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
bifilter<T>(Try<T>, Func<T, bool>, Func<Exception, bool>)
PARAMETERS
self
Try<T>
Succ
Func<T, bool>
Fail
Func<Exception, bool>
DECLARATION
[Pure]
public static Try<T> bifilter<T>(Try<T> self, Func<T, bool> Succ, Func<Exception, bool> Fail)
RETURNS
Try<T>
bifilter<T>(TryAsync<T>, Func<T, bool>, Func<Exception, bool>)
PARAMETERS
self
TryAsync<T>
Succ
Func<T, bool>
Fail
Func<Exception, bool>
DECLARATION
[Pure]
public static TryAsync<T> bifilter<T>(TryAsync<T> self, Func<T, bool> Succ, Func<Exception, bool> Fail)
RETURNS
TryAsync<T>
bifilter<T>(TryOptionAsync<T>, Func<T, bool>, Func<bool>)
PARAMETERS
self
TryOptionAsync<T>
Succ
Func<T, bool>
Fail
Func<bool>
DECLARATION
[Pure]
public static TryOptionAsync<T> bifilter<T>(TryOptionAsync<T> self, Func<T, bool> Succ, Func<bool> Fail)
RETURNS
TryOptionAsync<T>
bifold<L, R, S>(Either<L, R>, S, Func<S, R, S>, Func<S, L, S>)
SUMMARY

Either types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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:

PARAMETERS
either
Either<L, R>
state
S
Initial state
Right
Func<S, R, S>
Folder function, applied if Either is in a Right state
Left
Func<S, L, S>
Folder function, applied if Either is in a Left state
DECLARATION
[Pure]
public static S bifold<L, R, S>(Either<L, R> either, S state, Func<S, R, S> Right, Func<S, L, S> Left)
RETURNS
S
The aggregate state
bifold<L, R, S>(EitherUnsafe<L, R>, S, Func<S, R, S>, Func<S, L, S>)
SUMMARY

Either types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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:

PARAMETERS
either
EitherUnsafe<L, R>
state
S
Initial state
Right
Func<S, R, S>
Folder function, applied if Either is in a Right state
Left
Func<S, L, S>
Folder function, applied if Either is in a Left state
DECLARATION
[Pure]
public static S bifold<L, R, S>(EitherUnsafe<L, R> either, S state, Func<S, R, S> Right, Func<S, L, S> Left)
RETURNS
S
The aggregate state
bifold<S, A>(Option<A>, S, Func<S, A, S>, Func<S, S>)
SUMMARY

Option types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
option
Option<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if Option is in a Some state
None
Func<S, S>
Folder function, applied if Option is in a None state
DECLARATION
[Pure]
public static S bifold<S, A>(Option<A> option, S state, Func<S, A, S> Some, Func<S, S> None)
RETURNS
S
The aggregate state
bifold<S, A>(Option<A>, S, Func<S, A, S>, Func<S, Unit, S>)
SUMMARY

Option types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
option
Option<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if Option is in a Some state
None
Func<S, Unit, S>
Folder function, applied if Option is in a None state
DECLARATION
[Pure]
public static S bifold<S, A>(Option<A> option, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
RETURNS
S
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, S>, Func<S, S>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, S>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, S> Some, Func<S, S> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, Task<S>>, Func<S, S>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, Task<S>>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, S>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, Task<S>> Some, Func<S, S> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, S>, Func<S, Task<S>>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, Task<S>>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Task<S>> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, Task<S>>, Func<S, Task<S>>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, Task<S>>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, Task<S>>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, Task<S>> Some, Func<S, Task<S>> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, S>, Func<S, Unit, S>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, Unit, S>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, Task<S>>, Func<S, Unit, S>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, Task<S>>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, Unit, S>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, Task<S>> Some, Func<S, Unit, S> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, S>, Func<S, Unit, Task<S>>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, Unit, Task<S>>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionAsync<A>, S, Func<S, A, Task<S>>, Func<S, Unit, Task<S>>)
SUMMARY

OptionAsync types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
ma
OptionAsync<A>
state
S
Initial state
Some
Func<S, A, Task<S>>
Folder function, applied if OptionAsync is in a Some state
None
Func<S, Unit, Task<S>>
Folder function, applied if OptionAsync is in a None state
DECLARATION
[Pure]
public static Task<S> bifold<S, A>(OptionAsync<A> ma, S state, Func<S, A, Task<S>> Some, Func<S, Unit, Task<S>> None)
RETURNS
Task<S>
The aggregate state
bifold<S, A>(OptionUnsafe<A>, S, Func<S, A, S>, Func<S, S>)
SUMMARY

OptionUnsafe types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
option
OptionUnsafe<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if OptionUnsafe is in a Some state
None
Func<S, S>
Folder function, applied if OptionUnsafe is in a None state
DECLARATION
[Pure]
public static S bifold<S, A>(OptionUnsafe<A> option, S state, Func<S, A, S> Some, Func<S, S> None)
RETURNS
S
The aggregate state
bifold<S, A>(OptionUnsafe<A>, S, Func<S, A, S>, Func<S, Unit, S>)
SUMMARY

OptionUnsafe types are like lists of 0 or 1 items, and therefore follow the same rules when folding.

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
option
OptionUnsafe<A>
state
S
Initial state
Some
Func<S, A, S>
Folder function, applied if OptionUnsafe is in a Some state
None
Func<S, Unit, S>
Folder function, applied if OptionUnsafe is in a None state
DECLARATION
[Pure]
public static S bifold<S, A>(OptionUnsafe<A> option, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
RETURNS
S
The aggregate state
bifold<S, T>(TryOption<T>, S, Func<S, T, S>, Func<S, S>)
SUMMARY

Folds the result of Try into an S. https://en.wikipedia.org/wiki/Fold_(higher-order_function)

PARAMETERS
self
TryOption<T>
state
S
Initial state
Some
Func<S, T, S>
Fold function when Try succeeds
Fail
Func<S, S>
Fold function when Try fails
DECLARATION
[Pure]
public static S bifold<S, T>(TryOption<T> self, S state, Func<S, T, S> Some, Func<S, S> Fail)
RETURNS
S
Folded state
bifold<T1, T2, S>(Tuple<T1, T2>, S, Func<S, T1, S>, Func<S, T2, S>)
SUMMARY

Bi-fold

PARAMETERS
self
Tuple<T1, T2>
state
S
firstFold
Func<S, T1, S>
secondFold
Func<S, T2, S>
DECLARATION
[Pure]
public static S bifold<T1, T2, S>(Tuple<T1, T2> self, S state, Func<S, T1, S> firstFold, Func<S, T2, S> secondFold)
RETURNS
S
bifold<T1, T2, S>(ValueTuple<T1, T2>, S, Func<S, T1, S>, Func<S, T2, S>)
SUMMARY

Bi-fold

PARAMETERS
self
ValueTuple<T1, T2>
state
S
firstFold
Func<S, T1, S>
secondFold
Func<S, T2, S>
DECLARATION
[Pure]
public static S bifold<T1, T2, S>(ValueTuple<T1, T2> self, S state, Func<S, T1, S> firstFold, Func<S, T2, S> secondFold)
RETURNS
S
bifoldBack<T1, T2, S>(Tuple<T1, T2>, S, Func<S, T2, S>, Func<S, T1, S>)
SUMMARY

Bi-fold back

PARAMETERS
self
Tuple<T1, T2>
state
S
firstFold
Func<S, T2, S>
secondFold
Func<S, T1, S>
DECLARATION
[Pure]
public static S bifoldBack<T1, T2, S>(Tuple<T1, T2> self, S state, Func<S, T2, S> firstFold, Func<S, T1, S> secondFold)
RETURNS
S
bifoldBack<T1, T2, S>(ValueTuple<T1, T2>, S, Func<S, T2, S>, Func<S, T1, S>)
SUMMARY

Bi-fold back

PARAMETERS
self
ValueTuple<T1, T2>
state
S
firstFold
Func<S, T2, S>
secondFold
Func<S, T1, S>
DECLARATION
[Pure]
public static S bifoldBack<T1, T2, S>(ValueTuple<T1, T2> self, S state, Func<S, T2, S> firstFold, Func<S, T1, S> secondFold)
RETURNS
S
bifoldT<L, R, S>(IEnumerable<Either<L, R>>, S, Func<S, R, S>, Func<S, L, S>)
PARAMETERS
self
IEnumerable<Either<L, R>>
state
S
Right
Func<S, R, S>
Left
Func<S, L, S>
DECLARATION
[Pure]
public static S bifoldT<L, R, S>(IEnumerable<Either<L, R>> self, S state, Func<S, R, S> Right, Func<S, L, S> Left)
RETURNS
S
bifoldT<L, R, S>(IEnumerable<EitherUnsafe<L, R>>, S, Func<S, R, S>, Func<S, L, S>)
PARAMETERS
self
IEnumerable<EitherUnsafe<L, R>>
state
S
Right
Func<S, R, S>
Left
Func<S, L, S>
DECLARATION
[Pure]
public static S bifoldT<L, R, S>(IEnumerable<EitherUnsafe<L, R>> self, S state, Func<S, R, S> Right, Func<S, L, S> Left)
RETURNS
S
biforall<A>(Option<A>, Func<A, bool>, Func<Unit, bool>)
SUMMARY

Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
Option<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<Unit, bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biforall<A>(Option<A> option, Func<A, bool> Some, Func<Unit, bool> None)
RETURNS
bool
If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biforall<A>(Option<A>, Func<A, bool>, Func<bool>)
SUMMARY

Apply a predicate to the bound value. If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
Option<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biforall<A>(Option<A> option, Func<A, bool> Some, Func<bool> None)
RETURNS
bool
If the Option is in a None state then True is returned if invoking None returns True. If the Option is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biforall<A>(OptionAsync<A>, Func<A, bool>, Func<Unit, bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
ma
OptionAsync<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<Unit, bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static Task<bool> biforall<A>(OptionAsync<A> ma, Func<A, bool> Some, Func<Unit, bool> None)
RETURNS
Task<bool>
If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biforall<A>(OptionAsync<A>, Func<A, bool>, Func<bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
ma
OptionAsync<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static Task<bool> biforall<A>(OptionAsync<A> ma, Func<A, bool> Some, Func<bool> None)
RETURNS
Task<bool>
If the OptionAsync is in a None state then True is returned if invoking None returns True. If the OptionAsync is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biforall<A>(OptionUnsafe<A>, Func<A, bool>, Func<Unit, bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
OptionUnsafe<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<Unit, bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biforall<A>(OptionUnsafe<A> option, Func<A, bool> Some, Func<Unit, bool> None)
RETURNS
bool
If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biforall<A>(OptionUnsafe<A>, Func<A, bool>, Func<bool>)
SUMMARY

Apply a predicate to the bound value. If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.

PARAMETERS
option
OptionUnsafe<A>
Some
Func<A, bool>
Predicate to apply if in a Some state
None
Func<bool>
Predicate to apply if in a None state
DECLARATION
[Pure]
public static bool biforall<A>(OptionUnsafe<A> option, Func<A, bool> Some, Func<bool> None)
RETURNS
bool
If the OptionUnsafe is in a None state then True is returned if invoking None returns True. If the OptionUnsafe is in a Some state the value is the result of running applying the bound value to the Some predicate supplied.
biforall<L, R>(Either<L, R>, Func<R, bool>, Func<L, bool>)
SUMMARY

Invokes a predicate on the value of the Either if it's in the Right state

PARAMETERS
either
Either<L, R>
Right
Func<R, bool>
Right predicate
Left
Func<L, bool>
Left predicate
DECLARATION
[Pure]
public static bool biforall<L, R>(Either<L, R> either, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
True if the predicate returns True. True if the Either is in a bottom state.
biforall<L, R>(EitherUnsafe<L, R>, Func<R, bool>, Func<L, bool>)
SUMMARY

Invokes a predicate on the value of the Either if it's in the Right state

PARAMETERS
either
EitherUnsafe<L, R>
Right
Func<R, bool>
Right predicate
Left
Func<L, bool>
Left predicate
DECLARATION
[Pure]
public static bool biforall<L, R>(EitherUnsafe<L, R> either, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
True if the predicate returns True. True if the Either is in a bottom state.
biforallT<L, R>(IEnumerable<Either<L, R>>, Func<R, bool>, Func<L, bool>)
PARAMETERS
self
IEnumerable<Either<L, R>>
Right
Func<R, bool>
Left
Func<L, bool>
DECLARATION
[Pure]
public static bool biforallT<L, R>(IEnumerable<Either<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
biforallT<L, R>(IEnumerable<EitherUnsafe<L, R>>, Func<R, bool>, Func<L, bool>)
PARAMETERS
self
IEnumerable<EitherUnsafe<L, R>>
Right
Func<R, bool>
Left
Func<L, bool>
DECLARATION
[Pure]
public static bool biforallT<L, R>(IEnumerable<EitherUnsafe<L, R>> self, Func<R, bool> Right, Func<L, bool> Left)
RETURNS
bool
bimap<A, B>(Option<A>, Func<A, B>, Func<B>)
SUMMARY

Projection from one value to another

PARAMETERS
option
Option<A>
Some
Func<A, B>
Projection function
None
Func<B>
Projection function
DECLARATION
[Pure]
public static Option<B> bimap<A, B>(Option<A> option, Func<A, B> Some, Func<B> None)
RETURNS
Option<B>
Mapped functor
bimap<A, B>(Option<A>, Func<A, B>, Func<Unit, B>)
SUMMARY

Projection from one value to another

PARAMETERS
option
Option<A>
Some
Func<A, B>
Projection function
None
Func<Unit, B>
Projection function
DECLARATION
[Pure]
public static Option<B> bimap<A, B>(Option<A> option, Func<A, B> Some, Func<Unit, B> None)
RETURNS
Option<B>
Mapped functor
bimap<A, B>(OptionAsync<A>, Func<A, B>, Func<B>)
SUMMARY

Projection from one value to another

PARAMETERS
ma
OptionAsync<A>
Some
Func<A, B>
Projection function
None
Func<B>
Projection function
DECLARATION
[Pure]
public static OptionAsync<B> bimap<A, B>(OptionAsync<A> ma, Func<A, B> Some, Func<B> None)
RETURNS
OptionAsync<B>
Mapped functor
bimap<A, B>(OptionAsync<A>, Func<A, B>, Func<Unit, B>)
SUMMARY

Projection from one value to another

PARAMETERS
ma
OptionAsync<A>
Some
Func<A, B>
Projection function
None
Func<Unit, B>
Projection function
DECLARATION
[Pure]
public static OptionAsync<B> bimap<A, B>(OptionAsync<A> ma, Func<A, B> Some, Func<Unit, B> None)
RETURNS
OptionAsync<B>
Mapped functor
bimap<A, B>(OptionUnsafe<A>, Func<A, B>, Func<B>)
SUMMARY

Projection from one value to another

PARAMETERS
option
OptionUnsafe<A>
Some
Func<A, B>
Projection function
None
Func<B>
Projection function
DECLARATION
[Pure]
public static OptionUnsafe<B> bimap<A, B>(OptionUnsafe<A> option, Func<A, B> Some, Func<B> None)
RETURNS
OptionUnsafe<B>
Mapped functor
bimap<A, B>(OptionUnsafe<A>, Func<A, B>, Func<Unit, B>)
SUMMARY

Projection from one value to another

PARAMETERS
option
OptionUnsafe<A>
Some
Func<A, B>
Projection function
None
Func<Unit, B>
Projection function
DECLARATION
[Pure]
public static OptionUnsafe<B> bimap<A, B>(OptionUnsafe<A> option, Func<A, B> Some, Func<Unit, B> None)
RETURNS
OptionUnsafe<B>
Mapped functor
bimap<L, R, LRet, RRet>(Either<L, R>, Func<R, RRet>, Func<L, LRet>)
SUMMARY

Bi-maps the value in the Either if it's in a Right state

PARAMETERS
either
Either<L, R>
Right
Func<R, RRet>
Right map function
Left
Func<L, LRet>
Left map function
DECLARATION
[Pure]
public static Either<LRet, RRet> bimap<L, R, LRet, RRet>(Either<L, R> either, Func<R, RRet> Right, Func<L, LRet> Left)
RETURNS
Either<LRet, RRet>
Mapped Either
bimap<L, R, LRet, RRet>(EitherUnsafe<L, R>, Func<R, RRet>, Func<L, LRet>)
SUMMARY

Bi-maps the value in the Either if it's in a Right state

PARAMETERS
either
EitherUnsafe<L, R>
Right
Func<R, RRet>
Right map function
Left
Func<L, LRet>
Left map function
DECLARATION
[Pure]
public static EitherUnsafe<LRet, RRet> bimap<L, R, LRet, RRet>(EitherUnsafe<L, R> either, Func<R, RRet> Right, Func<L, LRet> Left)
RETURNS
EitherUnsafe<LRet, RRet>
Mapped EitherUnsafe
bimap<T, R>(Try<T>, Func<T, R>, Func<Exception, R>)
SUMMARY

Maps the bound value

PARAMETERS
tryDel
Try<T>
Succ
Func<T, R>
Delegate to map the bound value
Fail
Func<Exception, R>
Delegate to map the exception to the desired bound result type
DECLARATION
[Pure]
public static Try<R> bimap<T, R>(Try<T> tryDel, Func<T, R> Succ, Func<Exception, R> Fail)
RETURNS
Try<R>
Mapped Try computation
bimap<T, R>(TryAsync<T>, Func<T, R>, Func<Exception, R>)
SUMMARY

Maps the bound value

PARAMETERS
tryDel
TryAsync<T>
Succ
Func<T, R>
Delegate to map the bound value
Fail
Func<Exception, R>
Delegate to map the exception to the desired bound result type
DECLARATION
[Pure]
public static TryAsync<R> bimap<T, R>(TryAsync<T> tryDel, Func<T, R> Succ, Func<Exception, R> Fail)
RETURNS
TryAsync<R>
Mapped Try computation
bimap<T, R>(TryOption<T>, Func<T, R>, Func<R>)
SUMMARY

Maps the bound value

PARAMETERS
tryDel
TryOption<T>
Some
Func<T, R>
Delegate to map the bound value
Fail
Func<R>
Delegate to map the exception to the desired bound result type
DECLARATION
[Pure]
public static TryOption<R> bimap<T, R>(TryOption<T> tryDel, Func<T, R> Some, Func<R> Fail)
RETURNS
TryOption<R>
Mapped Try computation
bimap<T, R>(TryOptionAsync<T>, Func<T, R>, Func<R>)
SUMMARY

Maps the bound value

PARAMETERS
tryDel
TryOptionAsync<T>
Succ
Func<T, R>
Delegate to map the bound value
Fail
Func<R>
Delegate to map the exception to the desired bound result type
DECLARATION
[Pure]
public static TryOptionAsync<R> bimap<T, R>(TryOptionAsync<T> tryDel, Func<T, R> Succ, Func<R> Fail)
RETURNS
TryOptionAsync<R>
Mapped Try computation
bimap<T1, T2, R1, R2>(Tuple<T1, T2>, Func<T1, R1>, Func<T2, R2>)
SUMMARY

Bi-map to tuple

PARAMETERS
self
Tuple<T1, T2>
firstMap
Func<T1, R1>
secondMap
Func<T2, R2>
DECLARATION
[Pure]
public static Tuple<R1, R2> bimap<T1, T2, R1, R2>(Tuple<T1, T2> self, Func<T1, R1> firstMap, Func<T2, R2> secondMap)
RETURNS
Tuple<R1, R2>
bimap<T1, T2, R1, R2>(ValueTuple<T1, T2>, Func<T1, R1>, Func<T2, R2>)
SUMMARY

Bi-map to tuple

PARAMETERS
self
ValueTuple<T1, T2>
firstMap
Func<T1, R1>
secondMap
Func<T2, R2>
DECLARATION
[Pure]
public static ValueTuple<R1, R2> bimap<T1, T2, R1, R2>(ValueTuple<T1, T2> self, Func<T1, R1> firstMap, Func<T2, R2> secondMap)
RETURNS
ValueTuple<R1, R2>
bimapT<L, R, LRet, RRet>(IEnumerable<Either<L, R>>, Func<R, RRet>, Func<L, LRet>)
PARAMETERS
self
IEnumerable<Either<L, R>>
Right
Func<R, RRet>
Left
Func<L, LRet>
DECLARATION
[Pure]
public static IEnumerable<Either<LRet, RRet>> bimapT<L, R, LRet, RRet>(IEnumerable<Either<L, R>> self, Func<R, RRet> Right, Func<L, LRet> Left)
RETURNS
IEnumerable<Either<LRet, RRet>>
bimapT<L, R, LRet, RRet>(IEnumerable<EitherUnsafe<L, R>>, Func<R, RRet>, Func<L, LRet>)
PARAMETERS
self
IEnumerable<EitherUnsafe<L, R>>
Right
Func<R, RRet>
Left
Func<L, LRet>
DECLARATION
[Pure]
public static IEnumerable<EitherUnsafe<LRet, RRet>> bimapT<L, R, LRet, RRet>(IEnumerable<EitherUnsafe<L, R>> self, Func<R, RRet> Right, Func<L, LRet> Left)
RETURNS
IEnumerable<EitherUnsafe<LRet, RRet>>
bind<L, R, Ret>(Either<L, R>, Func<R, Either<L, Ret>>)
SUMMARY

Monadic bind function https://en.wikipedia.org/wiki/Monad_(functional_programming)

PARAMETERS
either
Either<L, R>
binder
Func<R, Either<L, Ret>>
DECLARATION
[Pure]
public static Either<L, Ret> bind<L, R, Ret>(Either<L, R> either, Func<R, Either<L, Ret>> binder)
RETURNS
Either<L, Ret>
Bound Either
bind<L, R, Ret>(EitherUnsafe<L, R>, Func<R, EitherUnsafe<L, Ret>>)
SUMMARY

Monadic bind function https://en.wikipedia.org/wiki/Monad_(functional_programming)

PARAMETERS
either
EitherUnsafe<L, R>
binder
Func<R, EitherUnsafe<L, Ret>>
DECLARATION
[Pure]
public static EitherUnsafe<L, Ret> bind<L, R, Ret>(EitherUnsafe<L, R> either, Func<R, EitherUnsafe<L, Ret>> binder)
RETURNS
EitherUnsafe<L, Ret>
Bound EitherUnsafe
bind<MonoidW, W, A, B>(Writer<MonoidW, W, A>, Func<A, Writer<MonoidW, W, B>>)
PARAMETERS
self
Writer<MonoidW, W, A>
f
Func<A, Writer<MonoidW, W, B>>
DECLARATION
[Pure]
public static Writer<MonoidW, W, B> bind<MonoidW, W, A, B>(Writer<MonoidW, W, A> self, Func<A, Writer<MonoidW, W, B>> f)
RETURNS
Writer<MonoidW, W, B>
CONSTRAINTS
where MonoidW : struct Monoid<W>
bind<NEWTYPE, T, PRED>(NewType<NEWTYPE, T, PRED>, Func<T, NEWTYPE>)
PARAMETERS
value
NewType<NEWTYPE, T, PRED>
bind
Func<T, NEWTYPE>
DECLARATION
[Pure]
public static NEWTYPE bind<NEWTYPE, T, PRED>(NewType<NEWTYPE, T, PRED> value, Func<T, NEWTYPE> bind)
RETURNS
NEWTYPE
CONSTRAINTS
where PRED : struct Pred<T>
where NEWTYPE : NewType<NEWTYPE, T, PRED>
bind<NUMTYPE, NUM, T, PRED>(NumType<NUMTYPE, NUM, T, PRED>, Func<T, NUMTYPE>)
PARAMETERS
value
NumType<NUMTYPE, NUM, T, PRED>
bind
Func<T, NUMTYPE>
DECLARATION
[Pure]
public static NUMTYPE bind<NUMTYPE, NUM, T, PRED>(NumType<NUMTYPE, NUM, T, PRED> value, Func<T, NUMTYPE> bind)
RETURNS
NUMTYPE
CONSTRAINTS
where NUM : struct Num<T>
where PRED : struct Pred<T>
where NUMTYPE : NumType<NUMTYPE, NUM, T, PRED>
bind<NUMTYPE, NUM, T>(NumType<NUMTYPE, NUM, T>, Func<T, NUMTYPE>)
PARAMETERS
value
NumType<NUMTYPE, NUM, T>
bind
Func<T, NUMTYPE>
DECLARATION
[Pure]
public static NUMTYPE bind<NUMTYPE, NUM, T>(NumType<NUMTYPE, NUM, T> value, Func<T, NUMTYPE> bind)
RETURNS
NUMTYPE
CONSTRAINTS
where NUM : struct Num<T>
where NUMTYPE : NumType<NUMTYPE, NUM, T>
bind<SELF, FLOAT, T, PRED>(FloatType<SELF, FLOAT, T, PRED>, Func<T, SELF>)
PARAMETERS
value
FloatType<SELF, FLOAT, T, PRED>
bind
Func<T, SELF>
DECLARATION
[Pure]
public static SELF bind<SELF, FLOAT, T, PRED>(FloatType<SELF, FLOAT, T, PRED> value, Func<T, SELF> bind)
RETURNS
SELF
CONSTRAINTS
where FLOAT : struct Floating<T>
where PRED : struct Pred<T>
where SELF : FloatType<SELF, FLOAT, T, PRED>
bind<SELF, FLOAT, T>(FloatType<SELF, FLOAT, T>, Func<T, SELF>)
PARAMETERS
value
FloatType<SELF, FLOAT, T>
bind
Func<T, SELF>
DECLARATION
[Pure]
public static SELF bind<SELF, FLOAT, T>(FloatType<SELF, FLOAT, T> value, Func<T, SELF> bind)
RETURNS
SELF
CONSTRAINTS
where FLOAT : struct Floating<T>
where SELF : FloatType<SELF, FLOAT, T>
bind<T, R>(T?, Func<T, R?>)
PARAMETERS
self
T?
binder
Func<T, R?>
DECLARATION
[Pure]
public static R? bind<T, R>(T? self, Func<T, R?> binder)
RETURNS
R?
CONSTRAINTS
where T : struct
where R : struct
bind<T, R>(T?, Func<T, R?>, Func<R?>)
PARAMETERS
self
T?
Some
Func<T, R?>
None
Func<R?>
DECLARATION
[Pure]
public static R? bind<T, R>(T? self, Func<T, R?> Some, Func<R?> None)
RETURNS
R?
CONSTRAINTS
where T : struct
where R : struct
bind<T, R>(Option<T>, Func<T, Option<R>>)
SUMMARY

Monadic bind operation

PARAMETERS
option
Option<T>
binder
Func<T, Option<R>>
DECLARATION
[Pure]
public static Option<R> bind<T, R>(Option<T> option, Func<T, Option<R>> binder)
RETURNS
Option<R>
bind<T, R>(OptionAsync<T>, Func<T, OptionAsync<R>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
OptionAsync<T>
binder
Func<T, OptionAsync<R>>
DECLARATION
[Pure]
public static OptionAsync<R> bind<T, R>(OptionAsync<T> ma, Func<T, OptionAsync<R>> binder)
RETURNS
OptionAsync<R>
bind<T, R>(OptionUnsafe<T>, Func<T, OptionUnsafe<R>>)
SUMMARY

Monadic bind operation

PARAMETERS
option
OptionUnsafe<T>
binder
Func<T, OptionUnsafe<R>>
DECLARATION
[Pure]
public static OptionUnsafe<R> bind<T, R>(OptionUnsafe<T> option, Func<T, OptionUnsafe<R>> binder)
RETURNS
OptionUnsafe<R>
bind<T, R>(Try<T>, Func<T, Try<R>>)
PARAMETERS
tryDel
Try<T>
binder
Func<T, Try<R>>
DECLARATION
[Pure]
public static Try<R> bind<T, R>(Try<T> tryDel, Func<T, Try<R>> binder)
RETURNS
Try<R>
bind<T, R>(Try<T>, Func<T, Try<R>>, Func<Exception, Try<R>>)
PARAMETERS
self
Try<T>
Succ
Func<T, Try<R>>
Fail
Func<Exception, Try<R>>
DECLARATION
[Obsolete]
public static Try<R> bind<T, R>(Try<T> self, Func<T, Try<R>> Succ, Func<Exception, Try<R>> Fail)
RETURNS
Try<R>
bind<T, R>(TryAsync<T>, Func<T, TryAsync<R>>)
PARAMETERS
tryDel
TryAsync<T>
binder
Func<T, TryAsync<R>>
DECLARATION
[Pure]
public static TryAsync<R> bind<T, R>(TryAsync<T> tryDel, Func<T, TryAsync<R>> binder)
RETURNS
TryAsync<R>
bind<T, R>(TryOption<T>, Func<T, TryOption<R>>)
PARAMETERS
tryDel
TryOption<T>
binder
Func<T, TryOption<R>>
DECLARATION
[Pure]
public static TryOption<R> bind<T, R>(TryOption<T> tryDel, Func<T, TryOption<R>> binder)
RETURNS
TryOption<R>
bind<T, R>(TryOptionAsync<T>, Func<T, TryOptionAsync<R>>)
PARAMETERS
tryDel
TryOptionAsync<T>
binder
Func<T, TryOptionAsync<R>>
DECLARATION
[Pure]
public static TryOptionAsync<R> bind<T, R>(TryOptionAsync<T> tryDel, Func<T, TryOptionAsync<R>> binder)
RETURNS
TryOptionAsync<R>
bind<T, U>(Task<T>, Func<T, Task<U>>)
SUMMARY

Monadic bind operation for Task

PARAMETERS
self
Task<T>
bind
Func<T, Task<U>>
DECLARATION
public static Task<U> bind<T, U>(Task<T> self, Func<T, Task<U>> bind)
RETURNS
Task<U>
censor<MonoidW, W, A>(Writer<MonoidW, W, A>, Func<W, W>)
SUMMARY

Censor is an action that executes the writer monad and applies the function f to its output, leaving the return value, leaving the return value unchanged.

PARAMETERS
self
Writer<MonoidW, W, A>
f
Func<W, W>
DECLARATION
public static Writer<MonoidW, W, A> censor<MonoidW, W, A>(Writer<MonoidW, W, A> self, Func<W, W> f)
RETURNS
Writer<MonoidW, W, A>
CONSTRAINTS
where MonoidW : struct Monoid<W>
choose<Env, A>(Reader<Env, Option<A>>)
SUMMARY

Chooses the first monad result that has a Some(x) for the value

PARAMETERS
monads
Reader<Env, Option<A>>
DECLARATION
[Pure]
public static Reader<Env, Option<A>> choose<Env, A>(Reader<Env, Option<A>> monads)
RETURNS
Reader<Env, Option<A>>
choose<S, A>(State<S, Option<A>>)
SUMMARY

Chooses the first monad result that has a Some(x) for the value

PARAMETERS
monads
State<S, Option<A>>
DECLARATION
[Pure]
public static State<S, Option<A>> choose<S, A>(State<S, Option<A>> monads)
RETURNS
State<S, Option<A>>
compose<T1, T2, T3, T4, T5, T6, T7>(Func<T1, T2>, Func<T2, T3>, Func<T3, T4>, Func<T4, T5>, Func<T5, T6>, Func<T6, T7>)
SUMMARY

Function composition

PARAMETERS
a
Func<T1, T2>
b
Func<T2, T3>
c
Func<T3, T4>
d
Func<T4, T5>
e
Func<T5, T6>
f
Func<T6, T7>
DECLARATION
[Pure]
public static Func<T1, T7> compose<T1, T2, T3, T4, T5, T6, T7>(Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d, Func<T5, T6> e, Func<T6, T7> f)
RETURNS
Func<T1, T7>
c(b(a(v)))
compose<T1, T2, T3, T4, T5, T6>(Func<T1, T2>, Func<T2, T3>, Func<T3, T4>, Func<T4, T5>, Func<T5, T6>)
SUMMARY

Function composition

PARAMETERS
a
Func<T1, T2>
b
Func<T2, T3>
c
Func<T3, T4>
d
Func<T4, T5>
e
Func<T5, T6>
DECLARATION
[Pure]
public static Func<T1, T6> compose<T1, T2, T3, T4, T5, T6>(Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d, Func<T5, T6> e)
RETURNS
Func<T1, T6>
c(b(a(v)))
compose<T1, T2, T3, T4, T5>(Func<T1, T2>, Func<T2, T3>, Func<T3, T4>, Func<T4, T5>)
SUMMARY

Function composition

PARAMETERS
a
Func<T1, T2>
b
Func<T2, T3>
c
Func<T3, T4>
d
Func<T4, T5>
DECLARATION
[Pure]
public static Func<T1, T5> compose<T1, T2, T3, T4, T5>(Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d)
RETURNS
Func<T1, T5>
c(b(a(v)))
compose<T1, T2, T3, T4>(Func<T1, T2>, Func<T2, T3>, Func<T3, T4>)
SUMMARY

Function composition

PARAMETERS
a
Func<T1, T2>
b
Func<T2, T3>
c
Func<T3, T4>
DECLARATION
[Pure]
public static Func<T1, T4> compose<T1, T2, T3, T4>(Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c)
RETURNS
Func<T1, T4>
c(b(a(v)))
compose<T1, T2, T3>(Func<T1, T2>, Func<T2, T3>)
SUMMARY

Function composition

PARAMETERS
a
Func<T1, T2>
b
Func<T2, T3>
DECLARATION
[Pure]
public static Func<T1, T3> compose<T1, T2, T3>(Func<T1, T2> a, Func<T2, T3> b)
RETURNS
Func<T1, T3>
b(a(v))
concat<MonoidA, A, B>(Tuple<A>, Tuple<A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A>
b
Tuple<A>
DECLARATION
[Pure]
public static Tuple<A> concat<MonoidA, A, B>(Tuple<A> a, Tuple<A> b)
RETURNS
Tuple<A>
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(Tuple<A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(Tuple<A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(Tuple<A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(Tuple<A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(Tuple<A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(Tuple<A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(Tuple<A, A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(Tuple<A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(Tuple<A, A, A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, A, A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(Tuple<A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(Tuple<A, A, A, A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, A, A, A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(Tuple<A, A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(ValueTuple<A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(ValueTuple<A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(ValueTuple<A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(ValueTuple<A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(ValueTuple<A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(ValueTuple<A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(ValueTuple<A, A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(ValueTuple<A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(ValueTuple<A, A, A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, A, A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(ValueTuple<A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, A>(ValueTuple<A, A, A, A, A, A, A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, A, A, A, A, A, A>
DECLARATION
[Pure]
public static A concat<MonoidA, A>(ValueTuple<A, A, A, A, A, A, A> a)
RETURNS
A
CONSTRAINTS
where MonoidA : struct Monoid<A>
concat<MonoidA, MonoidB, A, B>(Tuple<A, B>, Tuple<A, B>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, B>
b
Tuple<A, B>
DECLARATION
[Pure]
public static Tuple<A, B> concat<MonoidA, MonoidB, A, B>(Tuple<A, B> a, Tuple<A, B> b)
RETURNS
Tuple<A, B>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
concat<MonoidA, MonoidB, A, B>(ValueTuple<A>, ValueTuple<A>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A>
b
ValueTuple<A>
DECLARATION
[Pure]
public static ValueTuple<A> concat<MonoidA, MonoidB, A, B>(ValueTuple<A> a, ValueTuple<A> b)
RETURNS
ValueTuple<A>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
concat<MonoidA, MonoidB, A, B>(ValueTuple<A, B>, ValueTuple<A, B>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, B>
b
ValueTuple<A, B>
DECLARATION
[Pure]
public static ValueTuple<A, B> concat<MonoidA, MonoidB, A, B>(ValueTuple<A, B> a, ValueTuple<A, B> b)
RETURNS
ValueTuple<A, B>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
concat<MonoidA, MonoidB, MonoidC, A, B, C>(Tuple<A, B, C>, Tuple<A, B, C>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, B, C>
b
Tuple<A, B, C>
DECLARATION
[Pure]
public static Tuple<A, B, C> concat<MonoidA, MonoidB, MonoidC, A, B, C>(Tuple<A, B, C> a, Tuple<A, B, C> b)
RETURNS
Tuple<A, B, C>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
concat<MonoidA, MonoidB, MonoidC, A, B, C>(ValueTuple<A, B, C>, ValueTuple<A, B, C>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, B, C>
b
ValueTuple<A, B, C>
DECLARATION
[Pure]
public static ValueTuple<A, B, C> concat<MonoidA, MonoidB, MonoidC, A, B, C>(ValueTuple<A, B, C> a, ValueTuple<A, B, C> b)
RETURNS
ValueTuple<A, B, C>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
concat<MonoidA, MonoidB, MonoidC, MonoidD, A, B, C, D>(Tuple<A, B, C, D>, Tuple<A, B, C, D>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, B, C, D>
b
Tuple<A, B, C, D>
DECLARATION
[Pure]
public static Tuple<A, B, C, D> concat<MonoidA, MonoidB, MonoidC, MonoidD, A, B, C, D>(Tuple<A, B, C, D> a, Tuple<A, B, C, D> b)
RETURNS
Tuple<A, B, C, D>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
concat<MonoidA, MonoidB, MonoidC, MonoidD, A, B, C, D>(ValueTuple<A, B, C, D>, ValueTuple<A, B, C, D>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, B, C, D>
b
ValueTuple<A, B, C, D>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D> concat<MonoidA, MonoidB, MonoidC, MonoidD, A, B, C, D>(ValueTuple<A, B, C, D> a, ValueTuple<A, B, C, D> b)
RETURNS
ValueTuple<A, B, C, D>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, A, B, C, D, E>(Tuple<A, B, C, D, E>, Tuple<A, B, C, D, E>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, B, C, D, E>
b
Tuple<A, B, C, D, E>
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E> concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, A, B, C, D, E>(Tuple<A, B, C, D, E> a, Tuple<A, B, C, D, E> b)
RETURNS
Tuple<A, B, C, D, E>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
where MonoidE : struct Monoid<E>
concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, A, B, C, D, E>(ValueTuple<A, B, C, D, E>, ValueTuple<A, B, C, D, E>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, B, C, D, E>
b
ValueTuple<A, B, C, D, E>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E> concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, A, B, C, D, E>(this ValueTuple<A, B, C, D, E> a, ValueTuple<A, B, C, D, E> b)
RETURNS
ValueTuple<A, B, C, D, E>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
where MonoidE : struct Monoid<E>
concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, A, B, C, D, E, F>(Tuple<A, B, C, D, E, F>, Tuple<A, B, C, D, E, F>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, B, C, D, E, F>
b
Tuple<A, B, C, D, E, F>
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E, F> concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, A, B, C, D, E, F>(Tuple<A, B, C, D, E, F> a, Tuple<A, B, C, D, E, F> b)
RETURNS
Tuple<A, B, C, D, E, F>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
where MonoidE : struct Monoid<E>
where MonoidF : struct Monoid<F>
concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, A, B, C, D, E, F>(ValueTuple<A, B, C, D, E, F>, ValueTuple<A, B, C, D, E, F>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, B, C, D, E, F>
b
ValueTuple<A, B, C, D, E, F>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F> concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, A, B, C, D, E, F>(ValueTuple<A, B, C, D, E, F> a, ValueTuple<A, B, C, D, E, F> b)
RETURNS
ValueTuple<A, B, C, D, E, F>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
where MonoidE : struct Monoid<E>
where MonoidF : struct Monoid<F>
concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, MonoidG, A, B, C, D, E, F, G>(Tuple<A, B, C, D, E, F, G>, Tuple<A, B, C, D, E, F, G>)
SUMMARY

Monoid concat

PARAMETERS
a
Tuple<A, B, C, D, E, F, G>
b
Tuple<A, B, C, D, E, F, G>
DECLARATION
[Pure]
public static Tuple<A, B, C, D, E, F, G> concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, MonoidG, A, B, C, D, E, F, G>(Tuple<A, B, C, D, E, F, G> a, Tuple<A, B, C, D, E, F, G> b)
RETURNS
Tuple<A, B, C, D, E, F, G>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
where MonoidE : struct Monoid<E>
where MonoidF : struct Monoid<F>
where MonoidG : struct Monoid<G>
concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, MonoidG, A, B, C, D, E, F, G>(ValueTuple<A, B, C, D, E, F, G>, ValueTuple<A, B, C, D, E, F, G>)
SUMMARY

Monoid concat

PARAMETERS
a
ValueTuple<A, B, C, D, E, F, G>
b
ValueTuple<A, B, C, D, E, F, G>
DECLARATION
[Pure]
public static ValueTuple<A, B, C, D, E, F, G> concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, MonoidG, A, B, C, D, E, F, G>(ValueTuple<A, B, C, D, E, F, G> a, ValueTuple<A, B, C, D, E, F, G> b)
RETURNS
ValueTuple<A, B, C, D, E, F, G>
CONSTRAINTS
where MonoidA : struct Monoid<A>
where MonoidB : struct Monoid<B>
where MonoidC : struct Monoid<C>
where MonoidD : struct Monoid<D>
where MonoidE : struct Monoid<E>
where MonoidF : struct Monoid<F>
where MonoidG : struct Monoid<G>
Cond<A>(Func<A, bool>)
SUMMARY

Conditional computation constructor. Represents a computation that could succeed or fail. The result of the computation is an Option data-type. Use the fluent API methods of Then and Else to extract the monadic value.

PARAMETERS
pred
Func<A, bool>
Predicate to apply to the input value
DECLARATION
[Pure]
public static Cond<A, A> Cond<A>(Func<A, bool> pred)
RETURNS
Cond<A, A>
Conditional computation
Cond<A>(Func<A, Task<bool>>)
SUMMARY

Conditional asynchronous computation constructor. Represents a computation that could succeed or fail. The result of the computation is an Option data-type. Use the fluent API methods of Then and Else to extract the monadic value.

PARAMETERS
pred
Func<A, Task<bool>>
Predicate to apply to the input value
DECLARATION
[Pure]
public static CondAsync<A, A> Cond<A>(Func<A, Task<bool>> pred)
RETURNS
CondAsync<A, A>
Conditional computation
Cons<A>(A)
SUMMARY

Construct a list from head and tail head becomes the first item in the list.

PARAMETERS
head
A
Head item in the sequence
DECLARATION
[Pure]
public static Seq<A> Cons<A>(this A head)
RETURNS
Seq<A>
Cons<A>(A, Seq<A>)
SUMMARY

Construct a list from head and tail head becomes the first item in the list.

PARAMETERS
head
A
Head item in the sequence
tail
Seq<A>
Tail of the sequence
DECLARATION
[Pure]
public static Seq<A> Cons<A>(this A head, Seq<A> tail)
RETURNS
Seq<A>
Cons<A>(A, A)
SUMMARY

Construct a list from head and tail head becomes the first item in the list.

PARAMETERS
head
A
Head item in the sequence
tail
A
Tail of the sequence
DECLARATION
[Pure]
public static Seq<A> Cons<A>(this A head, A tail)
RETURNS
Seq<A>
Cons<A>(A, Arr<A>)
SUMMARY

Construct a list from head and tail head becomes the first item in the list.

PARAMETERS
head
A
Head item in the sequence
tail
Arr<A>
Tail of the sequence
DECLARATION
[Pure]
public static Seq<A> Cons<A>(this A head, Arr<A> tail)
RETURNS
Seq<A>
Cons<A>(A, IEnumerable<A>)
SUMMARY

Construct a list from head and tail; head becomes the first item in the list.

PARAMETERS
head
A
Head item in the sequence
tail
IEnumerable<A>
Tail of the sequence
DECLARATION
[Pure]
public static Seq<A> Cons<A>(this A head, IEnumerable<A> tail)
RETURNS
Seq<A>
cons<T>(T, IEnumerable<T>)
SUMMARY

Construct a list from head and tail head becomes the first item in the list Is lazy

PARAMETERS
head
T
tail
IEnumerable<T>
DECLARATION
[Obsolete("Use 'Cons'. All constructor functions are renamed to have their first letter as a capital.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static IEnumerable<T> cons<T>(T head, IEnumerable<T> tail)
RETURNS
IEnumerable<T>
cons<T>(T, Lst<T>)
SUMMARY

Construct a list from head and tail

PARAMETERS
head
T
tail
Lst<T>
DECLARATION
[Obsolete("Use 'Cons'. All constructor functions are renamed to have their first letter as a capital.")]
[EditorBrowsable(EditorBrowsableState.Never)]
public static Lst<T> cons<T>(T head, Lst<T> tail)
RETURNS
Lst<T>
Cons<T>(T, Lst<T>)
SUMMARY

Construct a list from head and tail

PARAMETERS
head
T
tail
Lst<T>
DECLARATION
[Pure]
public static Lst<T> Cons<T>(this T head, Lst<T> tail)
RETURNS
Lst<T>
contains<EQ, A>(Tuple<A>, A)
SUMMARY

One of the items matches the value passed

PARAMETERS
self
Tuple<A>
value
A
DECLARATION
[Pure]
public static bool contains<EQ, A>(Tuple<A> self, A value)
RETURNS
bool
CONSTRAINTS
where EQ : struct Eq<A>
contains<EQ, A>(Tuple<A, A>, A)
SUMMARY

One of the items matches the value passed

PARAMETERS
self
Tuple<A, A>
value
A
DECLARATION
[Pure]
public static bool contains<EQ, A>(this Tuple<A, A> self, A value)
RETURNS
bool
CONSTRAINTS
where EQ : struct Eq<A>
contains<EQ, A>(Tuple<A, A, A>, A)
SUMMARY

One of the items matches the value passed

PARAMETERS
self
Tuple<A, A, A>
value
A
DECLARATION
[Pure]
public static bool contains<EQ, A>(Tuple<A, A, A> self, A value)
RETURNS
bool
CONSTRAINTS
where EQ : struct Eq<A>
contains<EQ, A>(Tuple<A, A, A, A>, A)
SUMMARY

One of the items matches the value passed

PARAMETERS
self
Tuple<A, A, A, A>
value
A
DECLARATION
[Pure]
public static bool contains<EQ, A>(Tuple<A, A, A, A> self, A value)
RETURNS
bool
CONSTRAINTS
where EQ : struct Eq<A>
contains<EQ, A>(Tuple<A, A, A, A, A>, A)
SUMMARY

One of the items matches the value passed

PARAMETERS
self
Tuple<A, A, A, A, A>
value
A
DECLARATION
[Pure]
public static bool contains<EQ, A>(Tuple<A, A, A, A, A> self, A value)
RETURNS
bool
CONSTRAINTS
where EQ : struct Eq<A>
contains<EQ, A>(Tuple<A, A, A, A, A, A>, A)
SUMMARY

One of the items matches the value passed

PARAMETERS
self
Tuple<A, A, A, A, A, A>
value
A
DECLARATION
[Pure]
public static bool contains<EQ, A>(Tuple<A, A, A, A, A, A> self, A value)
RETURNS
bool
CONSTRAINTS
where EQ :