TryOptionT_Extensions Class

Monad transformer for TryOption, provides functionality for working with the inner value of the nested type.

DECLARATION
public static partial class TryOptionT_Extensions
NAMESPACE
LanguageExt

Methods

AppendT<SEMI, A>(Arr<TryOption<A>>, Arr<TryOption<A>>)
SUMMARY

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

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

Semigroup append operation on the inner bound values

PARAMETERS
x
EitherUnsafe<L, TryOption<A>>
The left hand side of the operation
y
EitherUnsafe<L, TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, TryOption<A>> AppendT<SEMI, L, A>(this EitherUnsafe<L, TryOption<A>> x, EitherUnsafe<L, TryOption<A>> y)
RETURNS
EitherUnsafe<L, TryOption<A>>
EitherUnsafe<L, TryOption<A>> which is the result of performing x ++ y
CONSTRAINTS
where SEMI : struct Semigroup<A>
ApplyT<A, B, C>(Func<A, B, C>, Arr<TryOption<A>>, Arr<TryOption<B>>)
SUMMARY

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

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

Apply fa to fab

PARAMETERS
fab
Func<A, B>
Functor
fa
Set<TryOption<A>>
Monad of Set<TryOption<A>>
DECLARATION
[Pure]
public static Set<TryOption<B>> ApplyT<A, B>(this Func<A, B> fab, Set<TryOption<A>> fa)
RETURNS
Set<TryOption<B>>
Set<TryOption<B>> which is the result of performing fab(fa)
ApplyT<FAIL, A, B, C>(Func<A, B, C>, Validation<FAIL, TryOption<A>>, Validation<FAIL, TryOption<B>>)
SUMMARY

Apply fa and fb to fabc

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

Apply fa to fab

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

Apply fa and fb to fabc

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

Apply fa and fb to fabc

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

Apply fa to fab

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

Apply fa to fab

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Monadic bind operation

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

Ord compare operation on the inner bound values

PARAMETERS
x
Arr<TryOption<A>>
The left hand side of the operation
y
Arr<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Arr<TryOption<A>> x, Arr<TryOption<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, A>(HashSet<TryOption<A>>, HashSet<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
HashSet<TryOption<A>>
The left hand side of the operation
y
HashSet<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this HashSet<TryOption<A>> x, HashSet<TryOption<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, A>(Lst<TryOption<A>>, Lst<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Lst<TryOption<A>>
The left hand side of the operation
y
Lst<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Lst<TryOption<A>> x, Lst<TryOption<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, A>(Option<TryOption<A>>, Option<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Option<TryOption<A>>
The left hand side of the operation
y
Option<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Option<TryOption<A>> x, Option<TryOption<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, A>(OptionAsync<TryOption<A>>, OptionAsync<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
OptionAsync<TryOption<A>>
The left hand side of the operation
y
OptionAsync<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this OptionAsync<TryOption<A>> x, OptionAsync<TryOption<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, A>(OptionUnsafe<TryOption<A>>, OptionUnsafe<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
OptionUnsafe<TryOption<A>>
The left hand side of the operation
y
OptionUnsafe<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this OptionUnsafe<TryOption<A>> x, OptionUnsafe<TryOption<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, A>(Task<TryOption<A>>, Task<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Task<TryOption<A>>
The left hand side of the operation
y
Task<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Task<TryOption<A>> x, Task<TryOption<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, A>(Try<TryOption<A>>, Try<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Try<TryOption<A>>
The left hand side of the operation
y
Try<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Try<TryOption<A>> x, Try<TryOption<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, A>(TryAsync<TryOption<A>>, TryAsync<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
TryAsync<TryOption<A>>
The left hand side of the operation
y
TryAsync<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this TryAsync<TryOption<A>> x, TryAsync<TryOption<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, A>(TryOption<TryOption<A>>, TryOption<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
TryOption<TryOption<A>>
The left hand side of the operation
y
TryOption<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this TryOption<TryOption<A>> x, TryOption<TryOption<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, A>(TryOptionAsync<TryOption<A>>, TryOptionAsync<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
TryOptionAsync<TryOption<A>>
The left hand side of the operation
y
TryOptionAsync<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this TryOptionAsync<TryOption<A>> x, TryOptionAsync<TryOption<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, A>(IEnumerable<TryOption<A>>, IEnumerable<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
IEnumerable<TryOption<A>>
The left hand side of the operation
y
IEnumerable<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this IEnumerable<TryOption<A>> x, IEnumerable<TryOption<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, A>(Seq<TryOption<A>>, Seq<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Seq<TryOption<A>>
The left hand side of the operation
y
Seq<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Seq<TryOption<A>> x, Seq<TryOption<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, A>(Set<TryOption<A>>, Set<TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Set<TryOption<A>>
The left hand side of the operation
y
Set<TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, A>(this Set<TryOption<A>> x, Set<TryOption<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, FAIL, A>(Validation<FAIL, TryOption<A>>, Validation<FAIL, TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Validation<FAIL, TryOption<A>>
The left hand side of the operation
y
Validation<FAIL, TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, FAIL, A>(this Validation<FAIL, TryOption<A>> x, Validation<FAIL, TryOption<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, TryOption<A>>, Either<L, TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
Either<L, TryOption<A>>
The left hand side of the operation
y
Either<L, TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, L, A>(this Either<L, TryOption<A>> x, Either<L, TryOption<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, TryOption<A>>, EitherUnsafe<L, TryOption<A>>)
SUMMARY

Ord compare operation on the inner bound values

PARAMETERS
x
EitherUnsafe<L, TryOption<A>>
The left hand side of the operation
y
EitherUnsafe<L, TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static int CompareT<ORD, L, A>(this EitherUnsafe<L, TryOption<A>> x, EitherUnsafe<L, TryOption<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<A>(Arr<TryOption<A>>)
SUMMARY

Finds the number of bound values in the Arr<TryOption<A>>

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

Finds the number of bound values in the HashSet<TryOption<A>>

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

Finds the number of bound values in the Lst<TryOption<A>>

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

Finds the number of bound values in the Option<TryOption<A>>

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

Finds the number of bound values in the OptionAsync<TryOption<A>>

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

Finds the number of bound values in the OptionUnsafe<TryOption<A>>

PARAMETERS
ma
OptionUnsafe<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the count operation on
DECLARATION
[Pure]
public static int CountT<A>(this OptionUnsafe<TryOption<A>> ma)
RETURNS
int
Number of As in OptionUnsafe<TryOption<A>>
CountT<A>(Task<TryOption<A>>)
SUMMARY

Finds the number of bound values in the Task<TryOption<A>>

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

Finds the number of bound values in the Try<TryOption<A>>

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

Finds the number of bound values in the TryAsync<TryOption<A>>

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

Finds the number of bound values in the TryOption<TryOption<A>>

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

Finds the number of bound values in the TryOptionAsync<TryOption<A>>

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

Finds the number of bound values in the IEnumerable<TryOption<A>>

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

Finds the number of bound values in the Seq<TryOption<A>>

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

Finds the number of bound values in the Set<TryOption<A>>

PARAMETERS
ma
Set<TryOption<A>>
The Set<TryOption<A>> to perform the count operation on
DECLARATION
[Pure]
public static int CountT<A>(this Set<TryOption<A>> ma)
RETURNS
int
Number of As in Set<TryOption<A>>
CountT<FAIL, A>(Validation<FAIL, TryOption<A>>)
SUMMARY

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

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

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

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

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

PARAMETERS
ma
EitherUnsafe<L, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the count operation on
DECLARATION
[Pure]
public static int CountT<L, A>(this EitherUnsafe<L, TryOption<A>> ma)
RETURNS
int
Number of As in EitherUnsafe<L, TryOption<A>>
DivideT<NUM, A>(Arr<TryOption<A>>, Arr<TryOption<A>>)
SUMMARY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

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

Eq compare operation on the inner bound values

PARAMETERS
x
EitherUnsafe<L, TryOption<A>>
The left hand side of the operation
y
EitherUnsafe<L, TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static bool EqualsT<EQ, L, A>(this EitherUnsafe<L, TryOption<A>> x, EitherUnsafe<L, TryOption<A>> y)
RETURNS
bool
EitherUnsafe<L, TryOption<A>> which is the result of performing x == y
CONSTRAINTS
where EQ : struct Eq<A>
ExistsT<A>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Arr<TryOption<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<A>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this HashSet<TryOption<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<A>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Lst<TryOption<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<A>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Option<TryOption<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<A>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this OptionAsync<TryOption<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<A>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this OptionUnsafe<TryOption<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<A>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Task<TryOption<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<A>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Try<TryOption<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<A>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this TryAsync<TryOption<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<A>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this TryOption<TryOption<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<A>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this TryOptionAsync<TryOption<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<A>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this IEnumerable<TryOption<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<A>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Seq<TryOption<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<A>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<A>(this Set<TryOption<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<FAIL, A>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<FAIL, A>(this Validation<FAIL, TryOption<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, TryOption<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, TryOption<A>>
The Either<L, TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<L, A>(this Either<L, TryOption<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, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ExistsT<L, A>(this EitherUnsafe<L, TryOption<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<A>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Arr<TryOption<A>> FilterT<A>(this Arr<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Arr<TryOption<A>>
Arr<TryOption<A>> with the predicate f(a) applied
FilterT<A>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static HashSet<TryOption<A>> FilterT<A>(this HashSet<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
HashSet<TryOption<A>>
HashSet<TryOption<A>> with the predicate f(a) applied
FilterT<A>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Lst<TryOption<A>> FilterT<A>(this Lst<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Lst<TryOption<A>>
Lst<TryOption<A>> with the predicate f(a) applied
FilterT<A>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Option<TryOption<A>> FilterT<A>(this Option<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Option<TryOption<A>>
Option<TryOption<A>> with the predicate f(a) applied
FilterT<A>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static OptionAsync<TryOption<A>> FilterT<A>(this OptionAsync<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
OptionAsync<TryOption<A>>
OptionAsync<TryOption<A>> with the predicate f(a) applied
FilterT<A>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static OptionUnsafe<TryOption<A>> FilterT<A>(this OptionUnsafe<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
OptionUnsafe<TryOption<A>>
OptionUnsafe<TryOption<A>> with the predicate f(a) applied
FilterT<A>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Task<TryOption<A>> FilterT<A>(this Task<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Task<TryOption<A>>
Task<TryOption<A>> with the predicate f(a) applied
FilterT<A>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Try<TryOption<A>> FilterT<A>(this Try<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Try<TryOption<A>>
Try<TryOption<A>> with the predicate f(a) applied
FilterT<A>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static TryAsync<TryOption<A>> FilterT<A>(this TryAsync<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
TryAsync<TryOption<A>>
TryAsync<TryOption<A>> with the predicate f(a) applied
FilterT<A>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static TryOption<TryOption<A>> FilterT<A>(this TryOption<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
TryOption<TryOption<A>>
TryOption<TryOption<A>> with the predicate f(a) applied
FilterT<A>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static TryOptionAsync<TryOption<A>> FilterT<A>(this TryOptionAsync<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
TryOptionAsync<TryOption<A>>
TryOptionAsync<TryOption<A>> with the predicate f(a) applied
FilterT<A>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static IEnumerable<TryOption<A>> FilterT<A>(this IEnumerable<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
IEnumerable<TryOption<A>>
IEnumerable<TryOption<A>> with the predicate f(a) applied
FilterT<A>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Seq<TryOption<A>> FilterT<A>(this Seq<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Seq<TryOption<A>>
Seq<TryOption<A>> with the predicate f(a) applied
FilterT<A>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Set<TryOption<A>> FilterT<A>(this Set<TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Set<TryOption<A>>
Set<TryOption<A>> with the predicate f(a) applied
FilterT<FAIL, A>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Validation<FAIL, TryOption<A>> FilterT<FAIL, A>(this Validation<FAIL, TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Validation<FAIL, TryOption<A>>
Validation<FAIL, TryOption<A>> with the predicate f(a) applied
FilterT<L, A>(Either<L, TryOption<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, TryOption<A>>
The Either<L, TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static Either<L, TryOption<A>> FilterT<L, A>(this Either<L, TryOption<A>> ma, Func<A, bool> pred)
RETURNS
Either<L, TryOption<A>>
Either<L, TryOption<A>> with the predicate f(a) applied
FilterT<L, A>(EitherUnsafe<L, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
pred
Func<A, bool>
DECLARATION
[Pure]
public static EitherUnsafe<L, TryOption<A>> FilterT<L, A>(this EitherUnsafe<L, TryOption<A>> ma, Func<A, bool> pred)
RETURNS
EitherUnsafe<L, TryOption<A>>
EitherUnsafe<L, TryOption<A>> with the predicate f(a) applied
FoldBackT<S, A>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<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, A>(this Arr<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<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, A>(this HashSet<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<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, A>(this Lst<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<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, A>(this Option<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<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, A>(this OptionAsync<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<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, A>(this OptionUnsafe<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<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, A>(this Task<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<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, A>(this Try<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<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, A>(this TryAsync<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<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, A>(this TryOption<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<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, A>(this TryOptionAsync<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<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, A>(this IEnumerable<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<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, A>(this Seq<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, A>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<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, A>(this Set<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldBackT<S, FAIL, A>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<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, A>(this Validation<FAIL, TryOption<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, TryOption<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, TryOption<A>>
The Either<L, TryOption<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>(this Either<L, TryOption<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, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<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>(this EitherUnsafe<L, TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<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, A>(this Arr<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<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, A>(this HashSet<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<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, A>(this Lst<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<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, A>(this Option<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<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, A>(this OptionAsync<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<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, A>(this OptionUnsafe<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<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, A>(this Task<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<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, A>(this Try<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<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, A>(this TryAsync<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<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, A>(this TryOption<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<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, A>(this TryOptionAsync<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<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, A>(this IEnumerable<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<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, A>(this Seq<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, A>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<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, A>(this Set<TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
FoldT<S, FAIL, A>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<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, A>(this Validation<FAIL, TryOption<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, TryOption<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, TryOption<A>>
The Either<L, TryOption<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>(this Either<L, TryOption<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, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<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>(this EitherUnsafe<L, TryOption<A>> ma, S state, Func<S, A, S> f)
RETURNS
S
The new aggregate state (which is then returned)
ForAllT<A>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Arr<TryOption<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<A>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this HashSet<TryOption<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<A>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Lst<TryOption<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<A>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Option<TryOption<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<A>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this OptionAsync<TryOption<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<A>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this OptionUnsafe<TryOption<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<A>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Task<TryOption<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<A>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Try<TryOption<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<A>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this TryAsync<TryOption<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<A>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this TryOption<TryOption<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<A>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this TryOptionAsync<TryOption<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<A>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this IEnumerable<TryOption<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<A>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Seq<TryOption<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<A>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<A>(this Set<TryOption<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<FAIL, A>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<FAIL, A>(this Validation<FAIL, TryOption<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, TryOption<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, TryOption<A>>
The Either<L, TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<L, A>(this Either<L, TryOption<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, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
f
Func<A, bool>
The predicate function
DECLARATION
[Pure]
public static bool ForAllT<L, A>(this EitherUnsafe<L, TryOption<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<A>(Arr<TryOption<A>>, Action<A>)
SUMMARY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PARAMETERS
ma
Set<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit IterT<A>(this Set<TryOption<A>> ma, Action<A> f)
IterT<FAIL, A>(Validation<FAIL, TryOption<A>>, Action<A>)
SUMMARY

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

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

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

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

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

PARAMETERS
ma
EitherUnsafe<L, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
f
Action<A>
The action that contains the side-effects
DECLARATION
public static Unit IterT<L, A>(this EitherUnsafe<L, TryOption<A>> ma, Action<A> f)
MapT<A, B>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Arr<TryOption<B>> MapT<A, B>(this Arr<TryOption<A>> ma, Func<A, B> f)
RETURNS
Arr<TryOption<B>>
Arr<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static HashSet<TryOption<B>> MapT<A, B>(this HashSet<TryOption<A>> ma, Func<A, B> f)
RETURNS
HashSet<TryOption<B>>
HashSet<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Lst<TryOption<B>> MapT<A, B>(this Lst<TryOption<A>> ma, Func<A, B> f)
RETURNS
Lst<TryOption<B>>
Lst<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Option<TryOption<B>> MapT<A, B>(this Option<TryOption<A>> ma, Func<A, B> f)
RETURNS
Option<TryOption<B>>
Option<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static OptionAsync<TryOption<B>> MapT<A, B>(this OptionAsync<TryOption<A>> ma, Func<A, B> f)
RETURNS
OptionAsync<TryOption<B>>
OptionAsync<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static OptionUnsafe<TryOption<B>> MapT<A, B>(this OptionUnsafe<TryOption<A>> ma, Func<A, B> f)
RETURNS
OptionUnsafe<TryOption<B>>
OptionUnsafe<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Task<TryOption<B>> MapT<A, B>(this Task<TryOption<A>> ma, Func<A, B> f)
RETURNS
Task<TryOption<B>>
Task<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Try<TryOption<B>> MapT<A, B>(this Try<TryOption<A>> ma, Func<A, B> f)
RETURNS
Try<TryOption<B>>
Try<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryAsync<TryOption<B>> MapT<A, B>(this TryAsync<TryOption<A>> ma, Func<A, B> f)
RETURNS
TryAsync<TryOption<B>>
TryAsync<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryOption<TryOption<B>> MapT<A, B>(this TryOption<TryOption<A>> ma, Func<A, B> f)
RETURNS
TryOption<TryOption<B>>
TryOption<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryOptionAsync<TryOption<B>> MapT<A, B>(this TryOptionAsync<TryOption<A>> ma, Func<A, B> f)
RETURNS
TryOptionAsync<TryOption<B>>
TryOptionAsync<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static IEnumerable<TryOption<B>> MapT<A, B>(this IEnumerable<TryOption<A>> ma, Func<A, B> f)
RETURNS
IEnumerable<TryOption<B>>
IEnumerable<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Seq<TryOption<B>> MapT<A, B>(this Seq<TryOption<A>> ma, Func<A, B> f)
RETURNS
Seq<TryOption<B>>
Seq<TryOption<B>> which is the result of performing f(a)
MapT<A, B>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Set<TryOption<B>> MapT<A, B>(this Set<TryOption<A>> ma, Func<A, B> f)
RETURNS
Set<TryOption<B>>
Set<TryOption<B>> which is the result of performing f(a)
MapT<FAIL, A, B>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Validation<FAIL, TryOption<B>> MapT<FAIL, A, B>(this Validation<FAIL, TryOption<A>> ma, Func<A, B> f)
RETURNS
Validation<FAIL, TryOption<B>>
Validation<FAIL, TryOption<B>> which is the result of performing f(a)
MapT<L, A, B>(Either<L, TryOption<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, TryOption<A>>
The Either<L, TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, TryOption<B>> MapT<L, A, B>(this Either<L, TryOption<A>> ma, Func<A, B> f)
RETURNS
Either<L, TryOption<B>>
Either<L, TryOption<B>> which is the result of performing f(a)
MapT<L, A, B>(EitherUnsafe<L, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, TryOption<B>> MapT<L, A, B>(this EitherUnsafe<L, TryOption<A>> ma, Func<A, B> f)
RETURNS
EitherUnsafe<L, TryOption<B>>
EitherUnsafe<L, TryOption<B>> which is the result of performing f(a)
PlusT<NUM, A>(Arr<TryOption<A>>, Arr<TryOption<A>>)
SUMMARY

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Adds the two inner Num<A> types together

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

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

Finds the product of two inner Num<A> types

PARAMETERS
x
EitherUnsafe<L, TryOption<A>>
The left hand side of the operation
y
EitherUnsafe<L, TryOption<A>>
The right hand side of the operation
DECLARATION
[Pure]
public static EitherUnsafe<L, TryOption<A>> ProductT<NUM, L, A>(this EitherUnsafe<L, TryOption<A>> x, EitherUnsafe<L, TryOption<A>> y)
RETURNS
EitherUnsafe<L, TryOption<A>>
EitherUnsafe<L, TryOption<A>> which is the result of performing x * y
CONSTRAINTS
where NUM : struct Num<A>
Select<A, B>(Arr<TryOption<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<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Arr<TryOption<B>> Select<A, B>(this Arr<TryOption<A>> ma, Func<A, B> f)
RETURNS
Arr<TryOption<B>>
Arr<TryOption<B>> which is the result of performing f(a)
Select<A, B>(HashSet<TryOption<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<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static HashSet<TryOption<B>> Select<A, B>(this HashSet<TryOption<A>> ma, Func<A, B> f)
RETURNS
HashSet<TryOption<B>>
HashSet<TryOption<B>> which is the result of performing f(a)
Select<A, B>(Lst<TryOption<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<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Lst<TryOption<B>> Select<A, B>(this Lst<TryOption<A>> ma, Func<A, B> f)
RETURNS
Lst<TryOption<B>>
Lst<TryOption<B>> which is the result of performing f(a)
Select<A, B>(Option<TryOption<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<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Option<TryOption<B>> Select<A, B>(this Option<TryOption<A>> ma, Func<A, B> f)
RETURNS
Option<TryOption<B>>
Option<TryOption<B>> which is the result of performing f(a)
Select<A, B>(OptionAsync<TryOption<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<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static OptionAsync<TryOption<B>> Select<A, B>(this OptionAsync<TryOption<A>> ma, Func<A, B> f)
RETURNS
OptionAsync<TryOption<B>>
OptionAsync<TryOption<B>> which is the result of performing f(a)
Select<A, B>(OptionUnsafe<TryOption<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<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static OptionUnsafe<TryOption<B>> Select<A, B>(this OptionUnsafe<TryOption<A>> ma, Func<A, B> f)
RETURNS
OptionUnsafe<TryOption<B>>
OptionUnsafe<TryOption<B>> which is the result of performing f(a)
Select<A, B>(Task<TryOption<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<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Task<TryOption<B>> Select<A, B>(this Task<TryOption<A>> ma, Func<A, B> f)
RETURNS
Task<TryOption<B>>
Task<TryOption<B>> which is the result of performing f(a)
Select<A, B>(Try<TryOption<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<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Try<TryOption<B>> Select<A, B>(this Try<TryOption<A>> ma, Func<A, B> f)
RETURNS
Try<TryOption<B>>
Try<TryOption<B>> which is the result of performing f(a)
Select<A, B>(TryAsync<TryOption<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<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryAsync<TryOption<B>> Select<A, B>(this TryAsync<TryOption<A>> ma, Func<A, B> f)
RETURNS
TryAsync<TryOption<B>>
TryAsync<TryOption<B>> which is the result of performing f(a)
Select<A, B>(TryOption<TryOption<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<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryOption<TryOption<B>> Select<A, B>(this TryOption<TryOption<A>> ma, Func<A, B> f)
RETURNS
TryOption<TryOption<B>>
TryOption<TryOption<B>> which is the result of performing f(a)
Select<A, B>(TryOptionAsync<TryOption<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<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static TryOptionAsync<TryOption<B>> Select<A, B>(this TryOptionAsync<TryOption<A>> ma, Func<A, B> f)
RETURNS
TryOptionAsync<TryOption<B>>
TryOptionAsync<TryOption<B>> which is the result of performing f(a)
Select<A, B>(IEnumerable<TryOption<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<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static IEnumerable<TryOption<B>> Select<A, B>(this IEnumerable<TryOption<A>> ma, Func<A, B> f)
RETURNS
IEnumerable<TryOption<B>>
IEnumerable<TryOption<B>> which is the result of performing f(a)
Select<A, B>(Seq<TryOption<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<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Seq<TryOption<B>> Select<A, B>(this Seq<TryOption<A>> ma, Func<A, B> f)
RETURNS
Seq<TryOption<B>>
Seq<TryOption<B>> which is the result of performing f(a)
Select<A, B>(Set<TryOption<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<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Set<TryOption<B>> Select<A, B>(this Set<TryOption<A>> ma, Func<A, B> f)
RETURNS
Set<TryOption<B>>
Set<TryOption<B>> which is the result of performing f(a)
Select<FAIL, A, B>(Validation<FAIL, TryOption<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, TryOption<A>>
The Validation<FAIL, TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Validation<FAIL, TryOption<B>> Select<FAIL, A, B>(this Validation<FAIL, TryOption<A>> ma, Func<A, B> f)
RETURNS
Validation<FAIL, TryOption<B>>
Validation<FAIL, TryOption<B>> which is the result of performing f(a)
Select<L, A, B>(Either<L, TryOption<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, TryOption<A>>
The Either<L, TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static Either<L, TryOption<B>> Select<L, A, B>(this Either<L, TryOption<A>> ma, Func<A, B> f)
RETURNS
Either<L, TryOption<B>>
Either<L, TryOption<B>> which is the result of performing f(a)
Select<L, A, B>(EitherUnsafe<L, TryOption<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, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
f
Func<A, B>
The mapping function to apply
DECLARATION
[Pure]
public static EitherUnsafe<L, TryOption<B>> Select<L, A, B>(this EitherUnsafe<L, TryOption<A>> ma, Func<A, B> f)
RETURNS
EitherUnsafe<L, TryOption<B>>
EitherUnsafe<L, TryOption<B>> which is the result of performing f(a)
SelectMany<A, B, C>(Arr<TryOption<A>>, Func<A, Arr<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Arr<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
bind
Func<A, Arr<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Arr<TryOption<C>> SelectMany<A, B, C>(this Arr<TryOption<A>> ma, Func<A, Arr<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Arr<TryOption<C>>
Arr<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(HashSet<TryOption<A>>, Func<A, HashSet<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
HashSet<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
bind
Func<A, HashSet<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static HashSet<TryOption<C>> SelectMany<A, B, C>(this HashSet<TryOption<A>> ma, Func<A, HashSet<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
HashSet<TryOption<C>>
HashSet<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(Lst<TryOption<A>>, Func<A, Lst<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Lst<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
bind
Func<A, Lst<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Lst<TryOption<C>> SelectMany<A, B, C>(this Lst<TryOption<A>> ma, Func<A, Lst<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Lst<TryOption<C>>
Lst<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(Option<TryOption<A>>, Func<A, Option<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Option<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
bind
Func<A, Option<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Option<TryOption<C>> SelectMany<A, B, C>(this Option<TryOption<A>> ma, Func<A, Option<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Option<TryOption<C>>
Option<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(OptionAsync<TryOption<A>>, Func<A, OptionAsync<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
OptionAsync<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
bind
Func<A, OptionAsync<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static OptionAsync<TryOption<C>> SelectMany<A, B, C>(this OptionAsync<TryOption<A>> ma, Func<A, OptionAsync<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
OptionAsync<TryOption<C>>
OptionAsync<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(OptionUnsafe<TryOption<A>>, Func<A, OptionUnsafe<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
OptionUnsafe<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
bind
Func<A, OptionUnsafe<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static OptionUnsafe<TryOption<C>> SelectMany<A, B, C>(this OptionUnsafe<TryOption<A>> ma, Func<A, OptionUnsafe<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
OptionUnsafe<TryOption<C>>
OptionUnsafe<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(Task<TryOption<A>>, Func<A, Task<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Task<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
bind
Func<A, Task<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Task<TryOption<C>> SelectMany<A, B, C>(this Task<TryOption<A>> ma, Func<A, Task<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Task<TryOption<C>>
Task<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(Try<TryOption<A>>, Func<A, Try<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Try<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
bind
Func<A, Try<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Try<TryOption<C>> SelectMany<A, B, C>(this Try<TryOption<A>> ma, Func<A, Try<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Try<TryOption<C>>
Try<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(TryAsync<TryOption<A>>, Func<A, TryAsync<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
TryAsync<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
bind
Func<A, TryAsync<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static TryAsync<TryOption<C>> SelectMany<A, B, C>(this TryAsync<TryOption<A>> ma, Func<A, TryAsync<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
TryAsync<TryOption<C>>
TryAsync<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(TryOption<TryOption<A>>, Func<A, TryOption<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
TryOption<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
bind
Func<A, TryOption<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static TryOption<TryOption<C>> SelectMany<A, B, C>(this TryOption<TryOption<A>> ma, Func<A, TryOption<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
TryOption<TryOption<C>>
TryOption<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(TryOptionAsync<TryOption<A>>, Func<A, TryOptionAsync<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
TryOptionAsync<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
bind
Func<A, TryOptionAsync<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static TryOptionAsync<TryOption<C>> SelectMany<A, B, C>(this TryOptionAsync<TryOption<A>> ma, Func<A, TryOptionAsync<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
TryOptionAsync<TryOption<C>>
TryOptionAsync<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(IEnumerable<TryOption<A>>, Func<A, IEnumerable<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
IEnumerable<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
bind
Func<A, IEnumerable<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static IEnumerable<TryOption<C>> SelectMany<A, B, C>(this IEnumerable<TryOption<A>> ma, Func<A, IEnumerable<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
IEnumerable<TryOption<C>>
IEnumerable<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(Seq<TryOption<A>>, Func<A, Seq<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Seq<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
bind
Func<A, Seq<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Seq<TryOption<C>> SelectMany<A, B, C>(this Seq<TryOption<A>> ma, Func<A, Seq<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Seq<TryOption<C>>
Seq<TryOption<C>> which is the result of performing bind then project
SelectMany<A, B, C>(Set<TryOption<A>>, Func<A, Set<TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Set<TryOption<A>>
The Set<TryOption<A>> to perform the operation on
bind
Func<A, Set<TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Set<TryOption<C>> SelectMany<A, B, C>(this Set<TryOption<A>> ma, Func<A, Set<TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Set<TryOption<C>>
Set<TryOption<C>> which is the result of performing bind then project
SelectMany<FAIL, A, B, C>(Validation<FAIL, TryOption<A>>, Func<A, Validation<FAIL, TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Validation<FAIL, TryOption<A>>
The Validation<FAIL, TryOption<A>> to perform the operation on
bind
Func<A, Validation<FAIL, TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Validation<FAIL, TryOption<C>> SelectMany<FAIL, A, B, C>(this Validation<FAIL, TryOption<A>> ma, Func<A, Validation<FAIL, TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Validation<FAIL, TryOption<C>>
Validation<FAIL, TryOption<C>> which is the result of performing bind then project
SelectMany<L, A, B, C>(Either<L, TryOption<A>>, Func<A, Either<L, TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
Either<L, TryOption<A>>
The Either<L, TryOption<A>> to perform the operation on
bind
Func<A, Either<L, TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static Either<L, TryOption<C>> SelectMany<L, A, B, C>(this Either<L, TryOption<A>> ma, Func<A, Either<L, TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
Either<L, TryOption<C>>
Either<L, TryOption<C>> which is the result of performing bind then project
SelectMany<L, A, B, C>(EitherUnsafe<L, TryOption<A>>, Func<A, EitherUnsafe<L, TryOption<B>>>, Func<A, B, C>)
SUMMARY

Monadic bind and project operation

PARAMETERS
ma
EitherUnsafe<L, TryOption<A>>
The EitherUnsafe<L, TryOption<A>> to perform the operation on
bind
Func<A, EitherUnsafe<L, TryOption<B>>>
The bind function to apply
project
Func<A, B, C>
The projection function to apply after the bind
DECLARATION
[Pure]
public static EitherUnsafe<L, TryOption<C>> SelectMany<L, A, B, C>(this EitherUnsafe<L, TryOption<A>> ma, Func<A, EitherUnsafe<L, TryOption<B>>> bind, Func<A, B, C> project)
RETURNS
EitherUnsafe<L, TryOption<C>>
EitherUnsafe<L, TryOption<C>> which is the result of performing bind then project
Sequence<A>(Arr<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Arr<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
Arr<TryOption<A>>
The Arr<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<Arr<A>> Sequence<A>(this Arr<TryOption<A>> ma)
RETURNS
TryOption<Arr<A>>
TryOption<Arr<A>>
Sequence<A>(HashSet<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type HashSet<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
HashSet<TryOption<A>>
The HashSet<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<HashSet<A>> Sequence<A>(this HashSet<TryOption<A>> ma)
RETURNS
TryOption<HashSet<A>>
TryOption<HashSet<A>>
Sequence<A>(Lst<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Lst<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
Lst<TryOption<A>>
The Lst<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<Lst<A>> Sequence<A>(this Lst<TryOption<A>> ma)
RETURNS
TryOption<Lst<A>>
TryOption<Lst<A>>
Sequence<A>(Option<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Option<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
Option<TryOption<A>>
The Option<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<Option<A>> Sequence<A>(this Option<TryOption<A>> ma)
RETURNS
TryOption<Option<A>>
TryOption<Option<A>>
Sequence<A>(OptionAsync<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type OptionAsync<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
OptionAsync<TryOption<A>>
The OptionAsync<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<OptionAsync<A>> Sequence<A>(this OptionAsync<TryOption<A>> ma)
RETURNS
TryOption<OptionAsync<A>>
TryOption<OptionAsync<A>>
Sequence<A>(OptionUnsafe<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type OptionUnsafe<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
OptionUnsafe<TryOption<A>>
The OptionUnsafe<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<OptionUnsafe<A>> Sequence<A>(this OptionUnsafe<TryOption<A>> ma)
RETURNS
TryOption<OptionUnsafe<A>>
TryOption<OptionUnsafe<A>>
Sequence<A>(Task<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Task<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
Task<TryOption<A>>
The Task<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<Task<A>> Sequence<A>(this Task<TryOption<A>> ma)
RETURNS
TryOption<Task<A>>
TryOption<Task<A>>
Sequence<A>(Try<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Try<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
Try<TryOption<A>>
The Try<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<Try<A>> Sequence<A>(this Try<TryOption<A>> ma)
RETURNS
TryOption<Try<A>>
TryOption<Try<A>>
Sequence<A>(TryAsync<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type TryAsync<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
TryAsync<TryOption<A>>
The TryAsync<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<TryAsync<A>> Sequence<A>(this TryAsync<TryOption<A>> ma)
RETURNS
TryOption<TryAsync<A>>
TryOption<TryAsync<A>>
Sequence<A>(TryOption<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type TryOption<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
TryOption<TryOption<A>>
The TryOption<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<TryOption<A>> Sequence<A>(this TryOption<TryOption<A>> ma)
RETURNS
TryOption<TryOption<A>>
TryOption<TryOption<A>>
Sequence<A>(TryOptionAsync<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type TryOptionAsync<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
TryOptionAsync<TryOption<A>>
The TryOptionAsync<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<TryOptionAsync<A>> Sequence<A>(this TryOptionAsync<TryOption<A>> ma)
RETURNS
TryOption<TryOptionAsync<A>>
TryOption<TryOptionAsync<A>>
Sequence<A>(IEnumerable<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type IEnumerable<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
IEnumerable<TryOption<A>>
The IEnumerable<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<IEnumerable<A>> Sequence<A>(this IEnumerable<TryOption<A>> ma)
RETURNS
TryOption<IEnumerable<A>>
TryOption<IEnumerable<A>>
Sequence<A>(Seq<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Seq<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma
Seq<TryOption<A>>
The Seq<TryOption<A>> to perform the operation on
DECLARATION
[Pure]
public static TryOption<Seq<A>> Sequence<A>(this Seq<TryOption<A>> ma)
RETURNS
TryOption<Seq<A>>
TryOption<Seq<A>>
Sequence<A>(Set<TryOption<A>>)
SUMMARY

Sequence operation. Takes a value of type Set<TryOption<A>>, traverses the inner values of type A, and returns TryOption<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< A, A>(identity).

PARAMETERS
ma