EitherT Class

DECLARATION
public static partial class EitherT
NAMESPACE
LanguageExt

Methods

appendT<SEMI, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, A>> appendT<SEMI, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
Validation<FAIL, Either<L, A>>
Validation<FAIL, Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Arr<Either<L, A>> appendT<SEMI, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
Arr<Either<L, A>>
Arr<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static HashSet<Either<L, A>> appendT<SEMI, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
HashSet<Either<L, A>>
HashSet<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Lst<Either<L, A>> appendT<SEMI, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
Lst<Either<L, A>>
Lst<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Option<Either<L, A>> appendT<SEMI, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
Option<Either<L, A>>
Option<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionAsync<Either<L, A>> appendT<SEMI, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
OptionAsync<Either<L, A>>
OptionAsync<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, A>> appendT<SEMI, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
OptionUnsafe<Either<L, A>>
OptionUnsafe<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Either<L, Either<L, A>> appendT<SEMI, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, A>> appendT<SEMI, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
EitherUnsafe<L, Either<L, A>>
EitherUnsafe<L, Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Task<Either<L, A>> appendT<SEMI, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
Task<Either<L, A>>
Task<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Try<Either<L, A>> appendT<SEMI, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
Try<Either<L, A>>
Try<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, A>> appendT<SEMI, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
TryOptionAsync<Either<L, A>>
TryOptionAsync<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static IEnumerable<Either<L, A>> appendT<SEMI, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
IEnumerable<Either<L, A>>
IEnumerable<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Seq<Either<L, A>> appendT<SEMI, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
Seq<Either<L, A>>
Seq<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
appendT<SEMI, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Semigroup append operation on the inner bound values

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Set<Either<L, A>> appendT<SEMI, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
Set<Either<L, A>>
Set<Either<L, A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
applyT<FAIL, L, A, B, C>(Func<A, B, C>, Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Validation<FAIL, Either<L, A>>
Monad of Validation<FAIL, Either<L, A>>
fb
Validation<FAIL, Either<L, B>>
Monad of Validation<FAIL, Either<L, A>>
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, C>> applyT<FAIL, L, A, B, C>(Func<A, B, C> fabc, Validation<FAIL, Either<L, A>> fa, Validation<FAIL, Either<L, B>> fb)
RETURNS
Validation<FAIL, Either<L, C>>
Validation<FAIL, Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<FAIL, L, A, B>(Func<A, B>, Validation<FAIL, Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Validation<FAIL, Either<L, A>>
Monad of Validation<FAIL, Either<L, A>>
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, B>> applyT<FAIL, L, A, B>(Func<A, B> fab, Validation<FAIL, Either<L, A>> fa)
RETURNS
Validation<FAIL, Either<L, B>>
Validation<FAIL, Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B, C>(Func<A, B, C>, Arr<Either<L, A>>, Arr<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Arr<Either<L, A>>
Monad of Arr<Either<L, A>>
fb
Arr<Either<L, B>>
Monad of Arr<Either<L, A>>
DECLARATION
[Pure]
public static Arr<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Arr<Either<L, A>> fa, Arr<Either<L, B>> fb)
RETURNS
Arr<Either<L, C>>
Arr<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, HashSet<Either<L, A>>, HashSet<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
HashSet<Either<L, A>>
Monad of HashSet<Either<L, A>>
fb
HashSet<Either<L, B>>
Monad of HashSet<Either<L, A>>
DECLARATION
[Pure]
public static HashSet<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, HashSet<Either<L, A>> fa, HashSet<Either<L, B>> fb)
RETURNS
HashSet<Either<L, C>>
HashSet<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Lst<Either<L, A>>, Lst<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Lst<Either<L, A>>
Monad of Lst<Either<L, A>>
fb
Lst<Either<L, B>>
Monad of Lst<Either<L, A>>
DECLARATION
[Pure]
public static Lst<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Lst<Either<L, A>> fa, Lst<Either<L, B>> fb)
RETURNS
Lst<Either<L, C>>
Lst<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Option<Either<L, A>>, Option<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Option<Either<L, A>>
Monad of Option<Either<L, A>>
fb
Option<Either<L, B>>
Monad of Option<Either<L, A>>
DECLARATION
[Pure]
public static Option<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Option<Either<L, A>> fa, Option<Either<L, B>> fb)
RETURNS
Option<Either<L, C>>
Option<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, OptionAsync<Either<L, A>>, OptionAsync<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
OptionAsync<Either<L, A>>
Monad of OptionAsync<Either<L, A>>
fb
OptionAsync<Either<L, B>>
Monad of OptionAsync<Either<L, A>>
DECLARATION
[Pure]
public static OptionAsync<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, OptionAsync<Either<L, A>> fa, OptionAsync<Either<L, B>> fb)
RETURNS
OptionAsync<Either<L, C>>
OptionAsync<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
OptionUnsafe<Either<L, A>>
Monad of OptionUnsafe<Either<L, A>>
fb
OptionUnsafe<Either<L, B>>
Monad of OptionUnsafe<Either<L, A>>
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, OptionUnsafe<Either<L, A>> fa, OptionUnsafe<Either<L, B>> fb)
RETURNS
OptionUnsafe<Either<L, C>>
OptionUnsafe<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Either<L, Either<L, A>>, Either<L, Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Either<L, Either<L, A>>
Monad of Either<L, Either<L, A>>
fb
Either<L, Either<L, B>>
Monad of Either<L, Either<L, A>>
DECLARATION
[Pure]
public static Either<L, Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Either<L, Either<L, A>> fa, Either<L, Either<L, B>> fb)
RETURNS
Either<L, Either<L, C>>
Either<L, Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
EitherUnsafe<L, Either<L, A>>
Monad of EitherUnsafe<L, Either<L, A>>
fb
EitherUnsafe<L, Either<L, B>>
Monad of EitherUnsafe<L, Either<L, A>>
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, EitherUnsafe<L, Either<L, A>> fa, EitherUnsafe<L, Either<L, B>> fb)
RETURNS
EitherUnsafe<L, Either<L, C>>
EitherUnsafe<L, Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Task<Either<L, A>>, Task<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Task<Either<L, A>>
Monad of Task<Either<L, A>>
fb
Task<Either<L, B>>
Monad of Task<Either<L, A>>
DECLARATION
[Pure]
public static Task<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Task<Either<L, A>> fa, Task<Either<L, B>> fb)
RETURNS
Task<Either<L, C>>
Task<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Try<Either<L, A>>, Try<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Try<Either<L, A>>
Monad of Try<Either<L, A>>
fb
Try<Either<L, B>>
Monad of Try<Either<L, A>>
DECLARATION
[Pure]
public static Try<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Try<Either<L, A>> fa, Try<Either<L, B>> fb)
RETURNS
Try<Either<L, C>>
Try<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, TryAsync<Either<L, A>>, TryAsync<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
TryAsync<Either<L, A>>
Monad of TryAsync<Either<L, A>>
fb
TryAsync<Either<L, B>>
Monad of TryAsync<Either<L, A>>
DECLARATION
[Pure]
public static TryAsync<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, TryAsync<Either<L, A>> fa, TryAsync<Either<L, B>> fb)
RETURNS
TryAsync<Either<L, C>>
TryAsync<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, TryOption<Either<L, A>>, TryOption<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
TryOption<Either<L, A>>
Monad of TryOption<Either<L, A>>
fb
TryOption<Either<L, B>>
Monad of TryOption<Either<L, A>>
DECLARATION
[Pure]
public static TryOption<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, TryOption<Either<L, A>> fa, TryOption<Either<L, B>> fb)
RETURNS
TryOption<Either<L, C>>
TryOption<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
TryOptionAsync<Either<L, A>>
Monad of TryOptionAsync<Either<L, A>>
fb
TryOptionAsync<Either<L, B>>
Monad of TryOptionAsync<Either<L, A>>
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, TryOptionAsync<Either<L, A>> fa, TryOptionAsync<Either<L, B>> fb)
RETURNS
TryOptionAsync<Either<L, C>>
TryOptionAsync<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, IEnumerable<Either<L, A>>, IEnumerable<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
IEnumerable<Either<L, A>>
Monad of IEnumerable<Either<L, A>>
fb
IEnumerable<Either<L, B>>
Monad of IEnumerable<Either<L, A>>
DECLARATION
[Pure]
public static IEnumerable<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, IEnumerable<Either<L, A>> fa, IEnumerable<Either<L, B>> fb)
RETURNS
IEnumerable<Either<L, C>>
IEnumerable<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Seq<Either<L, A>>, Seq<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Seq<Either<L, A>>
Monad of Seq<Either<L, A>>
fb
Seq<Either<L, B>>
Monad of Seq<Either<L, A>>
DECLARATION
[Pure]
public static Seq<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Seq<Either<L, A>> fa, Seq<Either<L, B>> fb)
RETURNS
Seq<Either<L, C>>
Seq<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B, C>(Func<A, B, C>, Set<Either<L, A>>, Set<Either<L, B>>)
SUMMARY

Apply fa and fb to fabc

PARAMETERS
fabc
Func<A, B, C>
Functor
fa
Set<Either<L, A>>
Monad of Set<Either<L, A>>
fb
Set<Either<L, B>>
Monad of Set<Either<L, A>>
DECLARATION
[Pure]
public static Set<Either<L, C>> applyT<L, A, B, C>(Func<A, B, C> fabc, Set<Either<L, A>> fa, Set<Either<L, B>> fb)
RETURNS
Set<Either<L, C>>
Set<Either<L, B>> which is the result of performing fabc(fa, fb)
applyT<L, A, B>(Func<A, B>, Arr<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Arr<Either<L, A>>
Monad of Arr<Either<L, A>>
DECLARATION
[Pure]
public static Arr<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Arr<Either<L, A>> fa)
RETURNS
Arr<Either<L, B>>
Arr<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, HashSet<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
HashSet<Either<L, A>>
Monad of HashSet<Either<L, A>>
DECLARATION
[Pure]
public static HashSet<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, HashSet<Either<L, A>> fa)
RETURNS
HashSet<Either<L, B>>
HashSet<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Lst<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Lst<Either<L, A>>
Monad of Lst<Either<L, A>>
DECLARATION
[Pure]
public static Lst<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Lst<Either<L, A>> fa)
RETURNS
Lst<Either<L, B>>
Lst<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Option<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Option<Either<L, A>>
Monad of Option<Either<L, A>>
DECLARATION
[Pure]
public static Option<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Option<Either<L, A>> fa)
RETURNS
Option<Either<L, B>>
Option<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, OptionAsync<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
OptionAsync<Either<L, A>>
Monad of OptionAsync<Either<L, A>>
DECLARATION
[Pure]
public static OptionAsync<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, OptionAsync<Either<L, A>> fa)
RETURNS
OptionAsync<Either<L, B>>
OptionAsync<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, OptionUnsafe<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
OptionUnsafe<Either<L, A>>
Monad of OptionUnsafe<Either<L, A>>
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, OptionUnsafe<Either<L, A>> fa)
RETURNS
OptionUnsafe<Either<L, B>>
OptionUnsafe<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Either<L, Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Either<L, Either<L, A>>
Monad of Either<L, Either<L, A>>
DECLARATION
[Pure]
public static Either<L, Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Either<L, Either<L, A>> fa)
RETURNS
Either<L, Either<L, B>>
Either<L, Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
EitherUnsafe<L, Either<L, A>>
Monad of EitherUnsafe<L, Either<L, A>>
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, B>> applyT<L, A, B>(Func<A, B> fab, EitherUnsafe<L, Either<L, A>> fa)
RETURNS
EitherUnsafe<L, Either<L, B>>
EitherUnsafe<L, Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Task<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Task<Either<L, A>>
Monad of Task<Either<L, A>>
DECLARATION
[Pure]
public static Task<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Task<Either<L, A>> fa)
RETURNS
Task<Either<L, B>>
Task<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Try<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Try<Either<L, A>>
Monad of Try<Either<L, A>>
DECLARATION
[Pure]
public static Try<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Try<Either<L, A>> fa)
RETURNS
Try<Either<L, B>>
Try<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, TryAsync<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
TryAsync<Either<L, A>>
Monad of TryAsync<Either<L, A>>
DECLARATION
[Pure]
public static TryAsync<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, TryAsync<Either<L, A>> fa)
RETURNS
TryAsync<Either<L, B>>
TryAsync<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, TryOption<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
TryOption<Either<L, A>>
Monad of TryOption<Either<L, A>>
DECLARATION
[Pure]
public static TryOption<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, TryOption<Either<L, A>> fa)
RETURNS
TryOption<Either<L, B>>
TryOption<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, TryOptionAsync<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
TryOptionAsync<Either<L, A>>
Monad of TryOptionAsync<Either<L, A>>
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, TryOptionAsync<Either<L, A>> fa)
RETURNS
TryOptionAsync<Either<L, B>>
TryOptionAsync<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, IEnumerable<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
IEnumerable<Either<L, A>>
Monad of IEnumerable<Either<L, A>>
DECLARATION
[Pure]
public static IEnumerable<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, IEnumerable<Either<L, A>> fa)
RETURNS
IEnumerable<Either<L, B>>
IEnumerable<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Seq<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Seq<Either<L, A>>
Monad of Seq<Either<L, A>>
DECLARATION
[Pure]
public static Seq<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Seq<Either<L, A>> fa)
RETURNS
Seq<Either<L, B>>
Seq<Either<L, B>> which is the result of performing fab(fa)
applyT<L, A, B>(Func<A, B>, Set<Either<L, A>>)
SUMMARY

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Set<Either<L, A>>
Monad of Set<Either<L, A>>
DECLARATION
[Pure]
public static Set<Either<L, B>> applyT<L, A, B>(Func<A, B> fab, Set<Either<L, A>> fa)
RETURNS
Set<Either<L, B>>
Set<Either<L, B>> which is the result of performing fab(fa)
bindT<FAIL, L, A, B>(Validation<FAIL, Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, B>> bindT<FAIL, L, A, B>(Validation<FAIL, Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Validation<FAIL, Either<L, B>>
Validation<FAIL, Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Arr<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Arr<Either<L, B>> bindT<L, A, B>(Arr<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Arr<Either<L, B>>
Arr<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(HashSet<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static HashSet<Either<L, B>> bindT<L, A, B>(HashSet<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
HashSet<Either<L, B>>
HashSet<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Lst<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Lst<Either<L, B>> bindT<L, A, B>(Lst<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Lst<Either<L, B>>
Lst<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Option<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Option<Either<L, B>> bindT<L, A, B>(Option<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Option<Either<L, B>>
Option<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(OptionAsync<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static OptionAsync<Either<L, B>> bindT<L, A, B>(OptionAsync<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
OptionAsync<Either<L, B>>
OptionAsync<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(OptionUnsafe<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, B>> bindT<L, A, B>(OptionUnsafe<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
OptionUnsafe<Either<L, B>>
OptionUnsafe<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Either<L, Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Either<L, Either<L, B>> bindT<L, A, B>(Either<L, Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Either<L, Either<L, B>>
Either<L, Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(EitherUnsafe<L, Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, B>> bindT<L, A, B>(EitherUnsafe<L, Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
EitherUnsafe<L, Either<L, B>>
EitherUnsafe<L, Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Task<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Task<Either<L, B>> bindT<L, A, B>(Task<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Task<Either<L, B>>
Task<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Try<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Try<Either<L, B>> bindT<L, A, B>(Try<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Try<Either<L, B>>
Try<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(TryAsync<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static TryAsync<Either<L, B>> bindT<L, A, B>(TryAsync<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
TryAsync<Either<L, B>>
TryAsync<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(TryOption<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static TryOption<Either<L, B>> bindT<L, A, B>(TryOption<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
TryOption<Either<L, B>>
TryOption<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(TryOptionAsync<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, B>> bindT<L, A, B>(TryOptionAsync<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
TryOptionAsync<Either<L, B>>
TryOptionAsync<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(IEnumerable<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static IEnumerable<Either<L, B>> bindT<L, A, B>(IEnumerable<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
IEnumerable<Either<L, B>>
IEnumerable<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Seq<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Seq<Either<L, B>> bindT<L, A, B>(Seq<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Seq<Either<L, B>>
Seq<Either<L, B>> which is the result of performing f(a)
bindT<L, A, B>(Set<Either<L, A>>, Func<A, Either<L, B>>)
SUMMARY

Monadic bind operation

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
f
Func<A, Either<L, B>>
The bind function to apply
DECLARATION
[Pure]
public static Set<Either<L, B>> bindT<L, A, B>(Set<Either<L, A>> ma, Func<A, Either<L, B>> f)
RETURNS
Set<Either<L, B>>
Set<Either<L, B>> which is the result of performing f(a)
compareT<ORD, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
TryAsync<Either<L, A>>
The left hand side of the operation
y
TryAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(TryAsync<Either<L, A>> x, TryAsync<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(TryOption<Either<L, A>>, TryOption<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
TryOption<Either<L, A>>
The left hand side of the operation
y
TryOption<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(TryOption<Either<L, A>> x, TryOption<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
compareT<ORD, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int compareT<ORD, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
int
If x is less than y: -1. If x is greater than y: +1. If x is equal to y: 0
CONSTRAINTS
where ORD : struct Ord<A>
countT<FAIL, L, A>(Validation<FAIL, Either<L, A>>)
SUMMARY

Finds the number of bound values in the Validation<FAIL, Either<L, A>>

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<FAIL, L, A>(Validation<FAIL, Either<L, A>> ma)
RETURNS
int
Number of As in Validation<FAIL, Either<L, A>>
countT<L, A>(Arr<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Arr<Either<L, A>>

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Arr<Either<L, A>> ma)
RETURNS
int
Number of As in Arr<Either<L, A>>
countT<L, A>(HashSet<Either<L, A>>)
SUMMARY

Finds the number of bound values in the HashSet<Either<L, A>>

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(HashSet<Either<L, A>> ma)
RETURNS
int
Number of As in HashSet<Either<L, A>>
countT<L, A>(Lst<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Lst<Either<L, A>>

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Lst<Either<L, A>> ma)
RETURNS
int
Number of As in Lst<Either<L, A>>
countT<L, A>(Option<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Option<Either<L, A>>

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Option<Either<L, A>> ma)
RETURNS
int
Number of As in Option<Either<L, A>>
countT<L, A>(OptionAsync<Either<L, A>>)
SUMMARY

Finds the number of bound values in the OptionAsync<Either<L, A>>

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(OptionAsync<Either<L, A>> ma)
RETURNS
int
Number of As in OptionAsync<Either<L, A>>
countT<L, A>(OptionUnsafe<Either<L, A>>)
SUMMARY

Finds the number of bound values in the OptionUnsafe<Either<L, A>>

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(OptionUnsafe<Either<L, A>> ma)
RETURNS
int
Number of As in OptionUnsafe<Either<L, A>>
countT<L, A>(Either<L, Either<L, A>>)
SUMMARY

Finds the number of bound values in the Either<L, Either<L, A>>

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Either<L, Either<L, A>> ma)
RETURNS
int
Number of As in Either<L, Either<L, A>>
countT<L, A>(EitherUnsafe<L, Either<L, A>>)
SUMMARY

Finds the number of bound values in the EitherUnsafe<L, Either<L, A>>

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(EitherUnsafe<L, Either<L, A>> ma)
RETURNS
int
Number of As in EitherUnsafe<L, Either<L, A>>
countT<L, A>(Task<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Task<Either<L, A>>

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Task<Either<L, A>> ma)
RETURNS
int
Number of As in Task<Either<L, A>>
countT<L, A>(Try<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Try<Either<L, A>>

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Try<Either<L, A>> ma)
RETURNS
int
Number of As in Try<Either<L, A>>
countT<L, A>(TryAsync<Either<L, A>>)
SUMMARY

Finds the number of bound values in the TryAsync<Either<L, A>>

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(TryAsync<Either<L, A>> ma)
RETURNS
int
Number of As in TryAsync<Either<L, A>>
countT<L, A>(TryOption<Either<L, A>>)
SUMMARY

Finds the number of bound values in the TryOption<Either<L, A>>

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(TryOption<Either<L, A>> ma)
RETURNS
int
Number of As in TryOption<Either<L, A>>
countT<L, A>(TryOptionAsync<Either<L, A>>)
SUMMARY

Finds the number of bound values in the TryOptionAsync<Either<L, A>>

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(TryOptionAsync<Either<L, A>> ma)
RETURNS
int
Number of As in TryOptionAsync<Either<L, A>>
countT<L, A>(IEnumerable<Either<L, A>>)
SUMMARY

Finds the number of bound values in the IEnumerable<Either<L, A>>

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(IEnumerable<Either<L, A>> ma)
RETURNS
int
Number of As in IEnumerable<Either<L, A>>
countT<L, A>(Seq<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Seq<Either<L, A>>

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Seq<Either<L, A>> ma)
RETURNS
int
Number of As in Seq<Either<L, A>>
countT<L, A>(Set<Either<L, A>>)
SUMMARY

Finds the number of bound values in the Set<Either<L, A>>

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the count operation on
DECLARATION
[Pure]
public static int countT<L, A>(Set<Either<L, A>> ma)
RETURNS
int
Number of As in Set<Either<L, A>>
divideT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, A>> divideT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
Validation<FAIL, Either<L, A>>
Validation<FAIL, Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Arr<Either<L, A>> divideT<NUM, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
Arr<Either<L, A>>
Arr<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static HashSet<Either<L, A>> divideT<NUM, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
HashSet<Either<L, A>>
HashSet<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Lst<Either<L, A>> divideT<NUM, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
Lst<Either<L, A>>
Lst<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Option<Either<L, A>> divideT<NUM, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
Option<Either<L, A>>
Option<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionAsync<Either<L, A>> divideT<NUM, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
OptionAsync<Either<L, A>>
OptionAsync<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, A>> divideT<NUM, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
OptionUnsafe<Either<L, A>>
OptionUnsafe<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Either<L, Either<L, A>> divideT<NUM, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, A>> divideT<NUM, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
EitherUnsafe<L, Either<L, A>>
EitherUnsafe<L, Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Task<Either<L, A>> divideT<NUM, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
Task<Either<L, A>>
Task<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Try<Either<L, A>> divideT<NUM, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
Try<Either<L, A>>
Try<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
TryAsync<Either<L, A>>
The left hand side of the operation
y
TryAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryAsync<Either<L, A>> divideT<NUM, L, A>(TryAsync<Either<L, A>> x, TryAsync<Either<L, A>> y)
RETURNS
TryAsync<Either<L, A>>
TryAsync<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(TryOption<Either<L, A>>, TryOption<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
TryOption<Either<L, A>>
The left hand side of the operation
y
TryOption<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOption<Either<L, A>> divideT<NUM, L, A>(TryOption<Either<L, A>> x, TryOption<Either<L, A>> y)
RETURNS
TryOption<Either<L, A>>
TryOption<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, A>> divideT<NUM, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
TryOptionAsync<Either<L, A>>
TryOptionAsync<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static IEnumerable<Either<L, A>> divideT<NUM, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
IEnumerable<Either<L, A>>
IEnumerable<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Seq<Either<L, A>> divideT<NUM, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
Seq<Either<L, A>>
Seq<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
divideT<NUM, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Divides x by y, which are both Num<A>s

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Set<Either<L, A>> divideT<NUM, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
Set<Either<L, A>>
Set<Either<L, A>> which is the result of performing x / y
CONSTRAINTS
where NUM : struct Num<A>
equalsT<EQ, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
bool
Validation<FAIL, Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
bool
Arr<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
bool
HashSet<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
bool
Lst<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
bool
Option<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
bool
OptionAsync<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
bool
OptionUnsafe<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
bool
Either<L, Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
bool
EitherUnsafe<L, Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
bool
Task<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
bool
Try<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
TryAsync<Either<L, A>>
The left hand side of the operation
y
TryAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(TryAsync<Either<L, A>> x, TryAsync<Either<L, A>> y)
RETURNS
bool
TryAsync<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(TryOption<Either<L, A>>, TryOption<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
TryOption<Either<L, A>>
The left hand side of the operation
y
TryOption<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(TryOption<Either<L, A>> x, TryOption<Either<L, A>> y)
RETURNS
bool
TryOption<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
bool
TryOptionAsync<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
bool
IEnumerable<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
bool
Seq<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
equalsT<EQ, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Eq compare operation on the inner bound values

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool equalsT<EQ, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
bool
Set<Either<L, A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
existsT<FAIL, L, A>(Validation<FAIL, Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<FAIL, L, A>(Validation<FAIL, Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Arr<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Arr<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(HashSet<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(HashSet<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Lst<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Lst<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Option<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Option<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(OptionAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(OptionAsync<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(OptionUnsafe<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(OptionUnsafe<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Either<L, Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Either<L, Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(EitherUnsafe<L, Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(EitherUnsafe<L, Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Task<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Task<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Try<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Try<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(TryAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(TryAsync<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(TryOption<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(TryOption<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(TryOptionAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(TryOptionAsync<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(IEnumerable<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(IEnumerable<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Seq<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Seq<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
existsT<L, A>(Set<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool existsT<L, A>(Set<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if any of the bound value(s) return true when applied to the predicate f. If there are no bound values then false is returned.
filterT<FAIL, L, A>(Validation<FAIL, Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, A>> filterT<FAIL, L, A>(Validation<FAIL, Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Validation<FAIL, Either<L, A>>
Validation<FAIL, Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Arr<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Arr<Either<L, A>> filterT<L, A>(Arr<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Arr<Either<L, A>>
Arr<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(HashSet<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static HashSet<Either<L, A>> filterT<L, A>(HashSet<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
HashSet<Either<L, A>>
HashSet<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Lst<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Lst<Either<L, A>> filterT<L, A>(Lst<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Lst<Either<L, A>>
Lst<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Option<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Option<Either<L, A>> filterT<L, A>(Option<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Option<Either<L, A>>
Option<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(OptionAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static OptionAsync<Either<L, A>> filterT<L, A>(OptionAsync<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
OptionAsync<Either<L, A>>
OptionAsync<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(OptionUnsafe<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, A>> filterT<L, A>(OptionUnsafe<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
OptionUnsafe<Either<L, A>>
OptionUnsafe<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Either<L, Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Either<L, Either<L, A>> filterT<L, A>(Either<L, Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>> with the predicate f(a) applied
filterT<L, A>(EitherUnsafe<L, Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, A>> filterT<L, A>(EitherUnsafe<L, Either<L, A>> ma, Func<A, bool> pred)
RETURNS
EitherUnsafe<L, Either<L, A>>
EitherUnsafe<L, Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Task<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Task<Either<L, A>> filterT<L, A>(Task<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Task<Either<L, A>>
Task<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Try<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Try<Either<L, A>> filterT<L, A>(Try<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Try<Either<L, A>>
Try<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(TryAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static TryAsync<Either<L, A>> filterT<L, A>(TryAsync<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
TryAsync<Either<L, A>>
TryAsync<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(TryOption<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static TryOption<Either<L, A>> filterT<L, A>(TryOption<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
TryOption<Either<L, A>>
TryOption<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(TryOptionAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, A>> filterT<L, A>(TryOptionAsync<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
TryOptionAsync<Either<L, A>>
TryOptionAsync<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(IEnumerable<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static IEnumerable<Either<L, A>> filterT<L, A>(IEnumerable<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
IEnumerable<Either<L, A>>
IEnumerable<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Seq<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Seq<Either<L, A>> filterT<L, A>(Seq<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Seq<Either<L, A>>
Seq<Either<L, A>> with the predicate f(a) applied
filterT<L, A>(Set<Either<L, A>>, Func<A, bool>)
SUMMARY

Filter operation. Applies the bound value to the predicate f. If true then that value is retained, else filtered out.

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Set<Either<L, A>> filterT<L, A>(Set<Either<L, A>> ma, Func<A, bool> pred)
RETURNS
Set<Either<L, A>>
Set<Either<L, A>> with the predicate f(a) applied
foldBackT<S, FAIL, L, A>(Validation<FAIL, Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, FAIL, L, A>(Validation<FAIL, Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Arr<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Arr<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(HashSet<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(HashSet<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Lst<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Lst<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Option<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Option<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(OptionAsync<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(OptionAsync<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(OptionUnsafe<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(OptionUnsafe<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Either<L, Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Either<L, Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(EitherUnsafe<L, Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(EitherUnsafe<L, Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Task<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Task<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Try<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Try<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(TryAsync<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(TryAsync<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(TryOption<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(TryOption<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(TryOptionAsync<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(TryOptionAsync<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(IEnumerable<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(IEnumerable<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Seq<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Seq<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldBackT<S, L, A>(Set<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing (in the opposite direction to Fold) the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldBackT<S, L, A>(Set<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, FAIL, L, A>(Validation<FAIL, Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, FAIL, L, A>(Validation<FAIL, Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Arr<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Arr<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(HashSet<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(HashSet<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Lst<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Lst<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Option<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Option<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(OptionAsync<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(OptionAsync<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(OptionUnsafe<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(OptionUnsafe<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Either<L, Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Either<L, Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(EitherUnsafe<L, Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(EitherUnsafe<L, Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Task<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Task<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Try<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Try<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(TryAsync<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(TryAsync<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(TryOption<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(TryOption<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(TryOptionAsync<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(TryOptionAsync<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(IEnumerable<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(IEnumerable<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Seq<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Seq<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
foldT<S, L, A>(Set<Either<L, A>>, S, Func<S, A, S>)
SUMMARY

Create an aggregate value by traversing the bound value(s) of the nested monadic type, whilst applying the aggregate state and bound value to f to produce the new aggregate state (which is then returned).

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
state
S
f
Func<S, A, S>
The folding function to apply
DECLARATION
[Pure]
public static S foldT<S, L, A>(Set<Either<L, A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
forallT<FAIL, L, A>(Validation<FAIL, Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<FAIL, L, A>(Validation<FAIL, Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Arr<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Arr<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(HashSet<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(HashSet<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Lst<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Lst<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Option<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Option<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(OptionAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(OptionAsync<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(OptionUnsafe<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(OptionUnsafe<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Either<L, Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Either<L, Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(EitherUnsafe<L, Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(EitherUnsafe<L, Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Task<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Task<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Try<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Try<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(TryAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(TryAsync<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(TryOption<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(TryOption<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(TryOptionAsync<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(TryOptionAsync<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(IEnumerable<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(IEnumerable<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Seq<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Seq<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
forallT<L, A>(Set<Either<L, A>>, Func<A, bool>)
SUMMARY

Returns true if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool forallT<L, A>(Set<Either<L, A>> ma, Func<A, bool> f)
RETURNS
bool
True if all of the bound value(s) return true when applied to the predicate f. If there are no bound values then true is returned.
iterT<FAIL, L, A>(Validation<FAIL, Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Validation<FAIL, Either<L, A>>

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<FAIL, L, A>(Validation<FAIL, Either<L, A>> ma, Action<A> f)
iterT<L, A>(Arr<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Arr<Either<L, A>>

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Arr<Either<L, A>> ma, Action<A> f)
iterT<L, A>(HashSet<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in HashSet<Either<L, A>>

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(HashSet<Either<L, A>> ma, Action<A> f)
iterT<L, A>(Lst<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Lst<Either<L, A>>

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Lst<Either<L, A>> ma, Action<A> f)
iterT<L, A>(Option<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Option<Either<L, A>>

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Option<Either<L, A>> ma, Action<A> f)
iterT<L, A>(OptionAsync<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in OptionAsync<Either<L, A>>

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(OptionAsync<Either<L, A>> ma, Action<A> f)
iterT<L, A>(OptionUnsafe<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in OptionUnsafe<Either<L, A>>

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(OptionUnsafe<Either<L, A>> ma, Action<A> f)
iterT<L, A>(Either<L, Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Either<L, Either<L, A>>

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Either<L, Either<L, A>> ma, Action<A> f)
iterT<L, A>(EitherUnsafe<L, Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in EitherUnsafe<L, Either<L, A>>

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(EitherUnsafe<L, Either<L, A>> ma, Action<A> f)
iterT<L, A>(Task<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Task<Either<L, A>>

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Task<Either<L, A>> ma, Action<A> f)
iterT<L, A>(Try<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Try<Either<L, A>>

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Try<Either<L, A>> ma, Action<A> f)
iterT<L, A>(TryAsync<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in TryAsync<Either<L, A>>

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(TryAsync<Either<L, A>> ma, Action<A> f)
iterT<L, A>(TryOption<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in TryOption<Either<L, A>>

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(TryOption<Either<L, A>> ma, Action<A> f)
iterT<L, A>(TryOptionAsync<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in TryOptionAsync<Either<L, A>>

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(TryOptionAsync<Either<L, A>> ma, Action<A> f)
iterT<L, A>(IEnumerable<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in IEnumerable<Either<L, A>>

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(IEnumerable<Either<L, A>> ma, Action<A> f)
iterT<L, A>(Seq<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Seq<Either<L, A>>

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Seq<Either<L, A>> ma, Action<A> f)
iterT<L, A>(Set<Either<L, A>>, Action<A>)
SUMMARY

Side-effecting operation to iterate all of the bound value(s) in Set<Either<L, A>>

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit iterT<L, A>(Set<Either<L, A>> ma, Action<A> f)
mapT<FAIL, L, A, B>(Validation<FAIL, Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, B>> mapT<FAIL, L, A, B>(Validation<FAIL, Either<L, A>> ma, Func<A, B> f)
RETURNS
Validation<FAIL, Either<L, B>>
Validation<FAIL, Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Arr<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Arr<Either<L, B>> mapT<L, A, B>(Arr<Either<L, A>> ma, Func<A, B> f)
RETURNS
Arr<Either<L, B>>
Arr<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(HashSet<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static HashSet<Either<L, B>> mapT<L, A, B>(HashSet<Either<L, A>> ma, Func<A, B> f)
RETURNS
HashSet<Either<L, B>>
HashSet<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Lst<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Lst<Either<L, B>> mapT<L, A, B>(Lst<Either<L, A>> ma, Func<A, B> f)
RETURNS
Lst<Either<L, B>>
Lst<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Option<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Option<Either<L, B>> mapT<L, A, B>(Option<Either<L, A>> ma, Func<A, B> f)
RETURNS
Option<Either<L, B>>
Option<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(OptionAsync<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static OptionAsync<Either<L, B>> mapT<L, A, B>(OptionAsync<Either<L, A>> ma, Func<A, B> f)
RETURNS
OptionAsync<Either<L, B>>
OptionAsync<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(OptionUnsafe<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, B>> mapT<L, A, B>(OptionUnsafe<Either<L, A>> ma, Func<A, B> f)
RETURNS
OptionUnsafe<Either<L, B>>
OptionUnsafe<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Either<L, Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Either<L, B>> mapT<L, A, B>(Either<L, Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Either<L, B>>
Either<L, Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(EitherUnsafe<L, Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, B>> mapT<L, A, B>(EitherUnsafe<L, Either<L, A>> ma, Func<A, B> f)
RETURNS
EitherUnsafe<L, Either<L, B>>
EitherUnsafe<L, Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Task<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Task<Either<L, B>> mapT<L, A, B>(Task<Either<L, A>> ma, Func<A, B> f)
RETURNS
Task<Either<L, B>>
Task<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Try<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Try<Either<L, B>> mapT<L, A, B>(Try<Either<L, A>> ma, Func<A, B> f)
RETURNS
Try<Either<L, B>>
Try<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(TryAsync<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryAsync<Either<L, B>> mapT<L, A, B>(TryAsync<Either<L, A>> ma, Func<A, B> f)
RETURNS
TryAsync<Either<L, B>>
TryAsync<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(TryOption<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryOption<Either<L, B>> mapT<L, A, B>(TryOption<Either<L, A>> ma, Func<A, B> f)
RETURNS
TryOption<Either<L, B>>
TryOption<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(TryOptionAsync<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, B>> mapT<L, A, B>(TryOptionAsync<Either<L, A>> ma, Func<A, B> f)
RETURNS
TryOptionAsync<Either<L, B>>
TryOptionAsync<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(IEnumerable<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static IEnumerable<Either<L, B>> mapT<L, A, B>(IEnumerable<Either<L, A>> ma, Func<A, B> f)
RETURNS
IEnumerable<Either<L, B>>
IEnumerable<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Seq<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Seq<Either<L, B>> mapT<L, A, B>(Seq<Either<L, A>> ma, Func<A, B> f)
RETURNS
Seq<Either<L, B>>
Seq<Either<L, B>> which is the result of performing f(a)
mapT<L, A, B>(Set<Either<L, A>>, Func<A, B>)
SUMMARY

Functor map operation. This maps the bound value(s) of the nested monads using the provided function f.

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Set<Either<L, B>> mapT<L, A, B>(Set<Either<L, A>> ma, Func<A, B> f)
RETURNS
Set<Either<L, B>>
Set<Either<L, B>> which is the result of performing f(a)
plusT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, A>> plusT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
Validation<FAIL, Either<L, A>>
Validation<FAIL, Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Arr<Either<L, A>> plusT<NUM, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
Arr<Either<L, A>>
Arr<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static HashSet<Either<L, A>> plusT<NUM, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
HashSet<Either<L, A>>
HashSet<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Lst<Either<L, A>> plusT<NUM, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
Lst<Either<L, A>>
Lst<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Option<Either<L, A>> plusT<NUM, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
Option<Either<L, A>>
Option<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionAsync<Either<L, A>> plusT<NUM, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
OptionAsync<Either<L, A>>
OptionAsync<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, A>> plusT<NUM, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
OptionUnsafe<Either<L, A>>
OptionUnsafe<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Either<L, Either<L, A>> plusT<NUM, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, A>> plusT<NUM, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
EitherUnsafe<L, Either<L, A>>
EitherUnsafe<L, Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Task<Either<L, A>> plusT<NUM, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
Task<Either<L, A>>
Task<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Try<Either<L, A>> plusT<NUM, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
Try<Either<L, A>>
Try<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
TryAsync<Either<L, A>>
The left hand side of the operation
y
TryAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryAsync<Either<L, A>> plusT<NUM, L, A>(TryAsync<Either<L, A>> x, TryAsync<Either<L, A>> y)
RETURNS
TryAsync<Either<L, A>>
TryAsync<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(TryOption<Either<L, A>>, TryOption<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
TryOption<Either<L, A>>
The left hand side of the operation
y
TryOption<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOption<Either<L, A>> plusT<NUM, L, A>(TryOption<Either<L, A>> x, TryOption<Either<L, A>> y)
RETURNS
TryOption<Either<L, A>>
TryOption<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, A>> plusT<NUM, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
TryOptionAsync<Either<L, A>>
TryOptionAsync<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static IEnumerable<Either<L, A>> plusT<NUM, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
IEnumerable<Either<L, A>>
IEnumerable<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Seq<Either<L, A>> plusT<NUM, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
Seq<Either<L, A>>
Seq<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
plusT<NUM, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Adds the two inner Num<A> types together

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Set<Either<L, A>> plusT<NUM, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
Set<Either<L, A>>
Set<Either<L, A>> which is the result of performing x + y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, A>> productT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
Validation<FAIL, Either<L, A>>
Validation<FAIL, Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Arr<Either<L, A>> productT<NUM, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
Arr<Either<L, A>>
Arr<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static HashSet<Either<L, A>> productT<NUM, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
HashSet<Either<L, A>>
HashSet<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Lst<Either<L, A>> productT<NUM, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
Lst<Either<L, A>>
Lst<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Option<Either<L, A>> productT<NUM, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
Option<Either<L, A>>
Option<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionAsync<Either<L, A>> productT<NUM, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
OptionAsync<Either<L, A>>
OptionAsync<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, A>> productT<NUM, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
OptionUnsafe<Either<L, A>>
OptionUnsafe<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Either<L, Either<L, A>> productT<NUM, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, A>> productT<NUM, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
EitherUnsafe<L, Either<L, A>>
EitherUnsafe<L, Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Task<Either<L, A>> productT<NUM, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
Task<Either<L, A>>
Task<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Try<Either<L, A>> productT<NUM, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
Try<Either<L, A>>
Try<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
TryAsync<Either<L, A>>
The left hand side of the operation
y
TryAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryAsync<Either<L, A>> productT<NUM, L, A>(TryAsync<Either<L, A>> x, TryAsync<Either<L, A>> y)
RETURNS
TryAsync<Either<L, A>>
TryAsync<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(TryOption<Either<L, A>>, TryOption<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
TryOption<Either<L, A>>
The left hand side of the operation
y
TryOption<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOption<Either<L, A>> productT<NUM, L, A>(TryOption<Either<L, A>> x, TryOption<Either<L, A>> y)
RETURNS
TryOption<Either<L, A>>
TryOption<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, A>> productT<NUM, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
TryOptionAsync<Either<L, A>>
TryOptionAsync<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static IEnumerable<Either<L, A>> productT<NUM, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
IEnumerable<Either<L, A>>
IEnumerable<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Seq<Either<L, A>> productT<NUM, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
Seq<Either<L, A>>
Seq<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
productT<NUM, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Finds the product of two inner Num<A> types

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Set<Either<L, A>> productT<NUM, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
Set<Either<L, A>>
Set<Either<L, A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
sequence<FAIL, L, A>(Validation<FAIL, Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Validation<FAIL, Either<L, A>>, traverses the inner values of type A, and returns Either<L, Validation<FAIL, A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<FAIL, L, A, A>(identity).

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Validation<FAIL, A>> sequence<FAIL, L, A>(Validation<FAIL, Either<L, A>> ma)
RETURNS
Either<L, Validation<FAIL, A>>
Either<L, Validation<FAIL, A>>
sequence<L, A>(Arr<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Arr<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Arr<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Arr<A>> sequence<L, A>(Arr<Either<L, A>> ma)
RETURNS
Either<L, Arr<A>>
Either<L, Arr<A>>
sequence<L, A>(HashSet<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type HashSet<Either<L, A>>, traverses the inner values of type A, and returns Either<L, HashSet<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, HashSet<A>> sequence<L, A>(HashSet<Either<L, A>> ma)
RETURNS
Either<L, HashSet<A>>
Either<L, HashSet<A>>
sequence<L, A>(Lst<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Lst<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Lst<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Lst<A>> sequence<L, A>(Lst<Either<L, A>> ma)
RETURNS
Either<L, Lst<A>>
Either<L, Lst<A>>
sequence<L, A>(Option<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Option<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Option<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Option<A>> sequence<L, A>(Option<Either<L, A>> ma)
RETURNS
Either<L, Option<A>>
Either<L, Option<A>>
sequence<L, A>(OptionAsync<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type OptionAsync<Either<L, A>>, traverses the inner values of type A, and returns Either<L, OptionAsync<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, OptionAsync<A>> sequence<L, A>(OptionAsync<Either<L, A>> ma)
RETURNS
Either<L, OptionAsync<A>>
Either<L, OptionAsync<A>>
sequence<L, A>(OptionUnsafe<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type OptionUnsafe<Either<L, A>>, traverses the inner values of type A, and returns Either<L, OptionUnsafe<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, OptionUnsafe<A>> sequence<L, A>(OptionUnsafe<Either<L, A>> ma)
RETURNS
Either<L, OptionUnsafe<A>>
Either<L, OptionUnsafe<A>>
sequence<L, A>(Either<L, Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Either<L, Either<L, A>>, traverses the inner values of type A, and returns Either<L, Either<L, A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Either<L, A>> sequence<L, A>(Either<L, Either<L, A>> ma)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>>
sequence<L, A>(EitherUnsafe<L, Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type EitherUnsafe<L, Either<L, A>>, traverses the inner values of type A, and returns Either<L, EitherUnsafe<L, A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, EitherUnsafe<L, A>> sequence<L, A>(EitherUnsafe<L, Either<L, A>> ma)
RETURNS
Either<L, EitherUnsafe<L, A>>
Either<L, EitherUnsafe<L, A>>
sequence<L, A>(Task<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Task<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Task<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Task<A>> sequence<L, A>(Task<Either<L, A>> ma)
RETURNS
Either<L, Task<A>>
Either<L, Task<A>>
sequence<L, A>(Try<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Try<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Try<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Try<A>> sequence<L, A>(Try<Either<L, A>> ma)
RETURNS
Either<L, Try<A>>
Either<L, Try<A>>
sequence<L, A>(TryAsync<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type TryAsync<Either<L, A>>, traverses the inner values of type A, and returns Either<L, TryAsync<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, TryAsync<A>> sequence<L, A>(TryAsync<Either<L, A>> ma)
RETURNS
Either<L, TryAsync<A>>
Either<L, TryAsync<A>>
sequence<L, A>(TryOption<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type TryOption<Either<L, A>>, traverses the inner values of type A, and returns Either<L, TryOption<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, TryOption<A>> sequence<L, A>(TryOption<Either<L, A>> ma)
RETURNS
Either<L, TryOption<A>>
Either<L, TryOption<A>>
sequence<L, A>(TryOptionAsync<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type TryOptionAsync<Either<L, A>>, traverses the inner values of type A, and returns Either<L, TryOptionAsync<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, TryOptionAsync<A>> sequence<L, A>(TryOptionAsync<Either<L, A>> ma)
RETURNS
Either<L, TryOptionAsync<A>>
Either<L, TryOptionAsync<A>>
sequence<L, A>(IEnumerable<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type IEnumerable<Either<L, A>>, traverses the inner values of type A, and returns Either<L, IEnumerable<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, IEnumerable<A>> sequence<L, A>(IEnumerable<Either<L, A>> ma)
RETURNS
Either<L, IEnumerable<A>>
Either<L, IEnumerable<A>>
sequence<L, A>(Seq<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Seq<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Seq<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Seq<A>> sequence<L, A>(Seq<Either<L, A>> ma)
RETURNS
Either<L, Seq<A>>
Either<L, Seq<A>>
sequence<L, A>(Set<Either<L, A>>)
SUMMARY

Sequence operation. Takes a value of type Set<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Set<A>>. So it 'flips' the types whilst maintaining the rules of the inner and outer types. This is the same as calling ma.Traverse<L, A, A>(identity).

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the operation on
DECLARATION
[Pure]
public static Either<L, Set<A>> sequence<L, A>(Set<Either<L, A>> ma)
RETURNS
Either<L, Set<A>>
Either<L, Set<A>>
subtractT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>>, Validation<FAIL, Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Validation<FAIL, Either<L, A>>
The left hand side of the operation
y
Validation<FAIL, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Validation<FAIL, Either<L, A>> subtractT<NUM, FAIL, L, A>(Validation<FAIL, Either<L, A>> x, Validation<FAIL, Either<L, A>> y)
RETURNS
Validation<FAIL, Either<L, A>>
Validation<FAIL, Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Arr<Either<L, A>>, Arr<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Arr<Either<L, A>>
The left hand side of the operation
y
Arr<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Arr<Either<L, A>> subtractT<NUM, L, A>(Arr<Either<L, A>> x, Arr<Either<L, A>> y)
RETURNS
Arr<Either<L, A>>
Arr<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(HashSet<Either<L, A>>, HashSet<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
HashSet<Either<L, A>>
The left hand side of the operation
y
HashSet<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static HashSet<Either<L, A>> subtractT<NUM, L, A>(HashSet<Either<L, A>> x, HashSet<Either<L, A>> y)
RETURNS
HashSet<Either<L, A>>
HashSet<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Lst<Either<L, A>>, Lst<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Lst<Either<L, A>>
The left hand side of the operation
y
Lst<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Lst<Either<L, A>> subtractT<NUM, L, A>(Lst<Either<L, A>> x, Lst<Either<L, A>> y)
RETURNS
Lst<Either<L, A>>
Lst<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Option<Either<L, A>>, Option<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Option<Either<L, A>>
The left hand side of the operation
y
Option<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Option<Either<L, A>> subtractT<NUM, L, A>(Option<Either<L, A>> x, Option<Either<L, A>> y)
RETURNS
Option<Either<L, A>>
Option<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(OptionAsync<Either<L, A>>, OptionAsync<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
OptionAsync<Either<L, A>>
The left hand side of the operation
y
OptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionAsync<Either<L, A>> subtractT<NUM, L, A>(OptionAsync<Either<L, A>> x, OptionAsync<Either<L, A>> y)
RETURNS
OptionAsync<Either<L, A>>
OptionAsync<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(OptionUnsafe<Either<L, A>>, OptionUnsafe<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
OptionUnsafe<Either<L, A>>
The left hand side of the operation
y
OptionUnsafe<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static OptionUnsafe<Either<L, A>> subtractT<NUM, L, A>(OptionUnsafe<Either<L, A>> x, OptionUnsafe<Either<L, A>> y)
RETURNS
OptionUnsafe<Either<L, A>>
OptionUnsafe<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Either<L, Either<L, A>>, Either<L, Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Either<L, Either<L, A>>
The left hand side of the operation
y
Either<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Either<L, Either<L, A>> subtractT<NUM, L, A>(Either<L, Either<L, A>> x, Either<L, Either<L, A>> y)
RETURNS
Either<L, Either<L, A>>
Either<L, Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(EitherUnsafe<L, Either<L, A>>, EitherUnsafe<L, Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
EitherUnsafe<L, Either<L, A>>
The left hand side of the operation
y
EitherUnsafe<L, Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, Either<L, A>> subtractT<NUM, L, A>(EitherUnsafe<L, Either<L, A>> x, EitherUnsafe<L, Either<L, A>> y)
RETURNS
EitherUnsafe<L, Either<L, A>>
EitherUnsafe<L, Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Task<Either<L, A>>, Task<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Task<Either<L, A>>
The left hand side of the operation
y
Task<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Task<Either<L, A>> subtractT<NUM, L, A>(Task<Either<L, A>> x, Task<Either<L, A>> y)
RETURNS
Task<Either<L, A>>
Task<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Try<Either<L, A>>, Try<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Try<Either<L, A>>
The left hand side of the operation
y
Try<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Try<Either<L, A>> subtractT<NUM, L, A>(Try<Either<L, A>> x, Try<Either<L, A>> y)
RETURNS
Try<Either<L, A>>
Try<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(TryAsync<Either<L, A>>, TryAsync<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
TryAsync<Either<L, A>>
The left hand side of the operation
y
TryAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryAsync<Either<L, A>> subtractT<NUM, L, A>(TryAsync<Either<L, A>> x, TryAsync<Either<L, A>> y)
RETURNS
TryAsync<Either<L, A>>
TryAsync<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(TryOption<Either<L, A>>, TryOption<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
TryOption<Either<L, A>>
The left hand side of the operation
y
TryOption<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOption<Either<L, A>> subtractT<NUM, L, A>(TryOption<Either<L, A>> x, TryOption<Either<L, A>> y)
RETURNS
TryOption<Either<L, A>>
TryOption<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(TryOptionAsync<Either<L, A>>, TryOptionAsync<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
TryOptionAsync<Either<L, A>>
The left hand side of the operation
y
TryOptionAsync<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static TryOptionAsync<Either<L, A>> subtractT<NUM, L, A>(TryOptionAsync<Either<L, A>> x, TryOptionAsync<Either<L, A>> y)
RETURNS
TryOptionAsync<Either<L, A>>
TryOptionAsync<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(IEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
IEnumerable<Either<L, A>>
The left hand side of the operation
y
IEnumerable<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static IEnumerable<Either<L, A>> subtractT<NUM, L, A>(IEnumerable<Either<L, A>> x, IEnumerable<Either<L, A>> y)
RETURNS
IEnumerable<Either<L, A>>
IEnumerable<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Seq<Either<L, A>>, Seq<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Seq<Either<L, A>>
The left hand side of the operation
y
Seq<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Seq<Either<L, A>> subtractT<NUM, L, A>(Seq<Either<L, A>> x, Seq<Either<L, A>> y)
RETURNS
Seq<Either<L, A>>
Seq<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
subtractT<NUM, L, A>(Set<Either<L, A>>, Set<Either<L, A>>)
SUMMARY

Finds the difference between two inner Num<A> types

PARAMETERS
x
Set<Either<L, A>>
The left hand side of the operation
y
Set<Either<L, A>>
The right hand side of the operation
DECLARATION
[Pure]
public static Set<Either<L, A>> subtractT<NUM, L, A>(Set<Either<L, A>> x, Set<Either<L, A>> y)
RETURNS
Set<Either<L, A>>
Set<Either<L, A>> which is the result of performing x - y
CONSTRAINTS
where NUM : struct Num<A>
sumT<NumA, FAIL, L, A>(Validation<FAIL, Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Validation<FAIL, Either<L, A>>

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, FAIL, L, A>(Validation<FAIL, Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Validation<FAIL, Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Arr<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Arr<Either<L, A>>

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Arr<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Arr<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(HashSet<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in HashSet<Either<L, A>>

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(HashSet<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in HashSet<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Lst<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Lst<Either<L, A>>

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Lst<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Lst<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Option<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Option<Either<L, A>>

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Option<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Option<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(OptionAsync<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in OptionAsync<Either<L, A>>

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(OptionAsync<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in OptionAsync<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(OptionUnsafe<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in OptionUnsafe<Either<L, A>>

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(OptionUnsafe<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in OptionUnsafe<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Either<L, Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Either<L, Either<L, A>>

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Either<L, Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Either<L, Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(EitherUnsafe<L, Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in EitherUnsafe<L, Either<L, A>>

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(EitherUnsafe<L, Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in EitherUnsafe<L, Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Task<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Task<Either<L, A>>

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Task<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Task<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Try<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Try<Either<L, A>>

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Try<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Try<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(TryAsync<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in TryAsync<Either<L, A>>

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(TryAsync<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in TryAsync<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(TryOption<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in TryOption<Either<L, A>>

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(TryOption<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in TryOption<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(TryOptionAsync<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in TryOptionAsync<Either<L, A>>

PARAMETERS
ma
TryOptionAsync<Either<L, A>>
The TryOptionAsync<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(TryOptionAsync<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in TryOptionAsync<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(IEnumerable<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in IEnumerable<Either<L, A>>

PARAMETERS
ma
IEnumerable<Either<L, A>>
The IEnumerable<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(IEnumerable<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in IEnumerable<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Seq<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Seq<Either<L, A>>

PARAMETERS
ma
Seq<Either<L, A>>
The Seq<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Seq<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Seq<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
sumT<NumA, L, A>(Set<Either<L, A>>)
SUMMARY

Finds total of all the Num<A>s in Set<Either<L, A>>

PARAMETERS
ma
Set<Either<L, A>>
The Set<Either<L, A>> to perform the sum operation on
DECLARATION
[Pure]
public static A sumT<NumA, L, A>(Set<Either<L, A>> ma)
RETURNS
A
Total of all Num<A>s in Set<Either<L, A>>
CONSTRAINTS
where NumA : struct Num<A>
traverse<FAIL, L, A, B>(Validation<FAIL, Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Validation<FAIL, Either<L, A>>, traverses the inner values of type A, and returns Either<L, Validation<FAIL, B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Validation<FAIL, Either<L, A>>
The Validation<FAIL, Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Validation<FAIL, B>> traverse<FAIL, L, A, B>(Validation<FAIL, Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Validation<FAIL, B>>
Either<L, Validation<FAIL, B>>
traverse<L, A, B>(Arr<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Arr<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Arr<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Arr<Either<L, A>>
The Arr<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Arr<B>> traverse<L, A, B>(Arr<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Arr<B>>
Either<L, Arr<B>>
traverse<L, A, B>(HashSet<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type HashSet<Either<L, A>>, traverses the inner values of type A, and returns Either<L, HashSet<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
HashSet<Either<L, A>>
The HashSet<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, HashSet<B>> traverse<L, A, B>(HashSet<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, HashSet<B>>
Either<L, HashSet<B>>
traverse<L, A, B>(Lst<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Lst<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Lst<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Lst<Either<L, A>>
The Lst<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Lst<B>> traverse<L, A, B>(Lst<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Lst<B>>
Either<L, Lst<B>>
traverse<L, A, B>(Option<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Option<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Option<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Option<Either<L, A>>
The Option<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Option<B>> traverse<L, A, B>(Option<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Option<B>>
Either<L, Option<B>>
traverse<L, A, B>(OptionAsync<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type OptionAsync<Either<L, A>>, traverses the inner values of type A, and returns Either<L, OptionAsync<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
OptionAsync<Either<L, A>>
The OptionAsync<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, OptionAsync<B>> traverse<L, A, B>(OptionAsync<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, OptionAsync<B>>
Either<L, OptionAsync<B>>
traverse<L, A, B>(OptionUnsafe<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type OptionUnsafe<Either<L, A>>, traverses the inner values of type A, and returns Either<L, OptionUnsafe<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
OptionUnsafe<Either<L, A>>
The OptionUnsafe<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, OptionUnsafe<B>> traverse<L, A, B>(OptionUnsafe<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, OptionUnsafe<B>>
Either<L, OptionUnsafe<B>>
traverse<L, A, B>(Either<L, Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Either<L, Either<L, A>>, traverses the inner values of type A, and returns Either<L, Either<L, B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Either<L, Either<L, A>>
The Either<L, Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Either<L, B>> traverse<L, A, B>(Either<L, Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Either<L, B>>
Either<L, Either<L, B>>
traverse<L, A, B>(EitherUnsafe<L, Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type EitherUnsafe<L, Either<L, A>>, traverses the inner values of type A, and returns Either<L, EitherUnsafe<L, B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
EitherUnsafe<L, Either<L, A>>
The EitherUnsafe<L, Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, EitherUnsafe<L, B>> traverse<L, A, B>(EitherUnsafe<L, Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, EitherUnsafe<L, B>>
Either<L, EitherUnsafe<L, B>>
traverse<L, A, B>(Task<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Task<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Task<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Task<Either<L, A>>
The Task<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Task<B>> traverse<L, A, B>(Task<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Task<B>>
Either<L, Task<B>>
traverse<L, A, B>(Try<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type Try<Either<L, A>>, traverses the inner values of type A, and returns Either<L, Try<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
Try<Either<L, A>>
The Try<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, Try<B>> traverse<L, A, B>(Try<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, Try<B>>
Either<L, Try<B>>
traverse<L, A, B>(TryAsync<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type TryAsync<Either<L, A>>, traverses the inner values of type A, and returns Either<L, TryAsync<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
TryAsync<Either<L, A>>
The TryAsync<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, TryAsync<B>> traverse<L, A, B>(TryAsync<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, TryAsync<B>>
Either<L, TryAsync<B>>
traverse<L, A, B>(TryOption<Either<L, A>>, Func<A, B>)
SUMMARY

Traverse operation. Takes a value of type TryOption<Either<L, A>>, traverses the inner values of type A, and returns Either<L, TryOption<B>> (by applying a to f). So it 'flips' the types whilst maintaining the rules of the inner and outer types.

PARAMETERS
ma
TryOption<Either<L, A>>
The TryOption<Either<L, A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, TryOption<B>> traverse<L, A, B>(TryOption<Either<L, A>> ma, Func<A, B> f)
RETURNS
Either<L, TryOption<B>>
Either<L, TryOption<B>>