LanguageExt.Core ► Class Instances ► Monad

Contents

• MArr <A>
• Inst = default(MArr<A>)
• Append (Arr<A> x, Arr<A> y)
• Bind <MONADB, MB, B> (Arr<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Arr<A> ma, Func<A, MB> f)
• Count (Arr<A> fa)
• Empty ()
• Equals (Arr<A> x, Arr<A> y)
• Compare (Arr<A> x, Arr<A> y)
• Fail (object err = null)
• Fold <S> (Arr<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Arr<A> fa, S state, Func<S, A, S> f)
• Plus (Arr<A> ma, Arr<A> mb)
• Return (Func<Unit, A> f)
• Return (A x)
• Zero ()
• GetHashCode (Arr<A> x)
• Run (Func<Unit, Arr<A>> f)
• BindReturn (Unit _, Arr<A> fmb)
• Apply (Func<A, A, A> f, Arr<A> fa, Arr<A> fb)
• EqualsAsync (Arr<A> x, Arr<A> y)
• GetHashCodeAsync (Arr<A> x)
• CompareAsync (Arr<A> x, Arr<A> y)
• MArray <A>
• Inst = default(MArray<A>)
• Append (A[] x, A[] y)
• Bind <MONADB, MB, B> (A[] ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (A[] ma, Func<A, MB> f)
• Count (A[] fa)
• Subtract (A[] x, A[] y)
• Empty ()
• Equals (A[] x, A[] y)
• Compare (A[] x, A[] y)
• Fail (object err = null)
• Fold <S> (A[] fa, S state, Func<S, A, S> f)
• FoldBack <S> (A[] fa, S state, Func<S, A, S> f)
• Plus (A[] ma, A[] mb)
• Return (Func<Unit, A> x)
• Return (A x)
• Zero ()
• GetHashCode (A[] x)
• Run (Func<Unit, A[]> ma)
• BindReturn (Unit _, A[] mb)
• Apply (Func<A, A, A> f, A[] fa, A[] fb)
• EqualsAsync (A[] x, A[] y)
• GetHashCodeAsync (A[] x)
• CompareAsync (A[] x, A[] y)
• MEither <L, R>
• Inst = default(MEither<L, R>)
• Bind <MONADB, MB, B> (Either<L, R> ma, Func<R, MB> f)
• BindAsync <MONADB, MB, B> (Either<L, R> ma, Func<R, MB> f)
• Fail (object err = null)
• Plus (Either<L, R> ma, Either<L, R> mb)
• Return (Func<Unit, R> f)
• Zero ()
• IsNone (Either<L, R> opt)
• IsSome (Either<L, R> opt)
• Match <R2> (Either<L, R> opt, Func<R, R2> Some, Func<R2> None)
• MatchUnsafe <R2> (Either<L, R> opt, Func<R, R2> Some, R2 None)
• Match <R2> (Either<L, R> opt, Func<R, R2> Some, R2 None)
• Match (Either<L, R> opt, Action<R> Some, Action None)
• MatchUnsafe <R2> (Either<L, R> opt, Func<R, R2> Some, Func<R2> None)
• Fold <S> (Either<L, R> foldable, S state, Func<S, R, S> f)
• FoldBack <S> (Either<L, R> foldable, S state, Func<S, R, S> f)
• BiFold <S> (Either<L, R> foldable, S state, Func<S, L, S> fa, Func<S, R, S> fb)
• BiFoldBack <S> (Either<L, R> foldable, S state, Func<S, L, S> fa, Func<S, R, S> fb)
• Count (Either<L, R> ma)
• None
• Some (R value)
• Optional (R value)
• Run (Func<Unit, Either<L, R>> ma)
• BindReturn (Unit _, Either<L, R> mb)
• Return (R x)
• Empty ()
• Append (Either<L, R> x, Either<L, R> y)
• IsLeft (Either<L, R> choice)
• IsRight (Either<L, R> choice)
• IsBottom (Either<L, R> choice)
• Match <C> (Either<L, R> choice, Func<L, C> Left, Func<R, C> Right, Func<C> Bottom = null)
• Match (Either<L, R> choice, Action<L> Left, Action<R> Right, Action Bottom = null)
• MatchUnsafe <C> (Either<L, R> choice, Func<L, C> Left, Func<R, C> Right, Func<C> Bottom = null)
• Apply (Func<R, R, R> f, Either<L, R> fa, Either<L, R> fb)
• ToAsync (Either<L, R> sa)
• MEitherAsync <L, R>
• None
• Append (EitherAsync<L, R> ma, EitherAsync<L, R> mb)
• Apply (Func<R, R, R> f, EitherAsync<L, R> ma, EitherAsync<L, R> mb)
• BiFold <S> (EitherAsync<L, R> ma, S state, Func<S, L, S> fa, Func<S, R, S> fb)
• BiFoldAsync <S> (EitherAsync<L, R> ma, S state, Func<S, L, Task<S>> fa, Func<S, R, S> fb)
• BiFoldAsync <S> (EitherAsync<L, R> ma, S state, Func<S, L, S> fa, Func<S, R, Task<S>> fb)
• BiFoldAsync <S> (EitherAsync<L, R> ma, S state, Func<S, L, Task<S>> fa, Func<S, R, Task<S>> fb)
• BiFoldBack <S> (EitherAsync<L, R> ma, S state, Func<S, L, S> fa, Func<S, R, S> fb)
• BiFoldBackAsync <S> (EitherAsync<L, R> ma, S state, Func<S, L, Task<S>> fa, Func<S, R, S> fb)
• BiFoldBackAsync <S> (EitherAsync<L, R> ma, S state, Func<S, L, S> fa, Func<S, R, Task<S>> fb)
• BiFoldBackAsync <S> (EitherAsync<L, R> ma, S state, Func<S, L, Task<S>> fa, Func<S, R, Task<S>> fb)
• Bind <MONADB, MB, B> (EitherAsync<L, R> ma, Func<R, MB> f)
• BindAsync <MONADB, MB, B> (EitherAsync<L, R> ma, Func<R, Task<MB>> f)
• BindReturn (Unit outputma, EitherAsync<L, R> mb)
• Count (EitherAsync<L, R> fa)
• Empty ()
• Fail (object err = null)
• Fold <S> (EitherAsync<L, R> fa, S state, Func<S, R, S> f)
• FoldAsync <S> (EitherAsync<L, R> fa, S state, Func<S, R, Task<S>> f)
• FoldAsync <S> (EitherAsync<L, R> fa, S state, Func<S, L, S> f)
• FoldAsync <S> (EitherAsync<L, R> fa, S state, Func<S, L, Task<S>> f)
• FoldBack <S> (EitherAsync<L, R> fa, S state, Func<S, R, S> f)
• FoldBackAsync <S> (EitherAsync<L, R> fa, S state, Func<S, R, Task<S>> f)
• FoldBackAsync <S> (EitherAsync<L, R> fa, S state, Func<S, L, S> f)
• FoldBackAsync <S> (EitherAsync<L, R> fa, S state, Func<S, L, Task<S>> f)
• IsNone (EitherAsync<L, R> ma)
• IsSome (EitherAsync<L, R> ma)
• Match <B> (EitherAsync<L, R> ma, Func<R, B> Some, Func<B> None)
• MatchAsync <B> (EitherAsync<L, R> ma, Func<R, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (EitherAsync<L, R> ma, Func<R, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (EitherAsync<L, R> ma, Func<R, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (EitherAsync<L, R> ma, Action<R> Some, Action None)
• MatchAsync (EitherAsync<L, R> ma, Func<R, Task> SomeAsync, Action None)
• MatchAsync (EitherAsync<L, R> ma, Action<R> Some, Func<Task> NoneAsync)
• MatchAsync (EitherAsync<L, R> ma, Func<R, Task> SomeAsync, Func<Task> NoneAsync)
• MatchUnsafe <B> (EitherAsync<L, R> ma, Func<R, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (EitherAsync<L, R> ma, Func<R, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (EitherAsync<L, R> ma, Func<R, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (EitherAsync<L, R> ma, Func<R, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Optional (R value)
• OptionalAsync (Task<R> value)
• Plus (EitherAsync<L, R> ma, EitherAsync<L, R> mb)
• ReturnAsync (Task<R> x)
• ReturnAsync (Func<Unit, Task<R>> f)
• RunAsync (Func<Unit, Task<EitherAsync<L, R>>> ma)
• Some (R value)
• SomeAsync (Task<R> value)
• Zero ()
• IsLeft (EitherAsync<L, R> choice)
• IsRight (EitherAsync<L, R> choice)
• IsBottom (EitherAsync<L, R> choice)
• Match <C> (EitherAsync<L, R> choice, Func<L, C> Left, Func<R, C> Right, Func<C> Bottom = null)
• MatchAsync <C> (EitherAsync<L, R> choice, Func<L, Task<C>> LeftAsync, Func<R, C> Right, Func<C> Bottom = null)
• MatchAsync <C> (EitherAsync<L, R> choice, Func<L, C> Left, Func<R, Task<C>> RightAsync, Func<C> Bottom = null)
• MatchAsync <C> (EitherAsync<L, R> choice, Func<L, Task<C>> LeftAsync, Func<R, Task<C>> RightAsync, Func<C> Bottom = null)
• Match (EitherAsync<L, R> choice, Action<L> Left, Action<R> Right, Action Bottom = null)
• MatchAsync (EitherAsync<L, R> choice, Func<L, Task> LeftAsync, Action<R> Right, Action Bottom = null)
• MatchAsync (EitherAsync<L, R> choice, Action<L> Left, Func<R, Task> RightAsync, Action Bottom = null)
• MatchAsync (EitherAsync<L, R> choice, Func<L, Task> LeftAsync, Func<R, Task> RightAsync, Action Bottom = null)
• MatchUnsafe <C> (EitherAsync<L, R> choice, Func<L, C> Left, Func<R, C> Right, Func<C> Bottom = null)
• MatchUnsafeAsync <C> (EitherAsync<L, R> choice, Func<L, Task<C>> LeftAsync, Func<R, C> Right, Func<C> Bottom = null)
• MatchUnsafeAsync <C> (EitherAsync<L, R> choice, Func<L, C> Left, Func<R, Task<C>> RightAsync, Func<C> Bottom = null)
• MatchUnsafeAsync <C> (EitherAsync<L, R> choice, Func<L, Task<C>> LeftAsync, Func<R, Task<C>> RightAsync, Func<C> Bottom = null)
• MEitherUnsafe <L, R>
• Inst = default(MEitherUnsafe<L, R>)
• Bind <MONADB, MB, B> (EitherUnsafe<L, R> ma, Func<R, MB> f)
• BindAsync <MONADB, MB, B> (EitherUnsafe<L, R> ma, Func<R, MB> f)
• Fail (object err = null)
• Plus (EitherUnsafe<L, R> ma, EitherUnsafe<L, R> mb)
• Return (Func<Unit, R> f)
• Zero ()
• IsNone (EitherUnsafe<L, R> opt)
• IsSome (EitherUnsafe<L, R> opt)
• MatchUnsafe <R2> (EitherUnsafe<L, R> opt, Func<R, R2> Some, Func<R2> None)
• MatchUnsafe <R2> (EitherUnsafe<L, R> opt, Func<R, R2> Some, R2 None)
• Match (EitherUnsafe<L, R> choice, Action<R> Right, Action Left)
• Fold <S> (EitherUnsafe<L, R> foldable, S state, Func<S, R, S> f)
• FoldBack <S> (EitherUnsafe<L, R> foldable, S state, Func<S, R, S> f)
• BiFold <S> (EitherUnsafe<L, R> foldable, S state, Func<S, L, S> fa, Func<S, R, S> fb)
• BiFoldBack <S> (EitherUnsafe<L, R> foldable, S state, Func<S, L, S> fa, Func<S, R, S> fb)
• Count (EitherUnsafe<L, R> ma)
• Some (R value)
• Optional (R value)
• None
• Run (Func<Unit, EitherUnsafe<L, R>> ma)
• BindReturn (Unit _, EitherUnsafe<L, R> mb)
• Return (R x)
• Empty ()
• Append (EitherUnsafe<L, R> x, EitherUnsafe<L, R> y)
• IsLeft (EitherUnsafe<L, R> choice)
• IsRight (EitherUnsafe<L, R> choice)
• IsBottom (EitherUnsafe<L, R> choice)
• MatchUnsafe <C> (EitherUnsafe<L, R> choice, Func<L, C> Left, Func<R, C> Right, Func<C> Bottom = null)
• Match (EitherUnsafe<L, R> choice, Action<L> Left, Action<R> Right, Action Bottom = null)
• Apply (Func<R, R, R> f, EitherUnsafe<L, R> fa, EitherUnsafe<L, R> fb)
• MEnumerable <A>
• Inst = default(MEnumerable<A>)
• Append (IEnumerable<A> x, IEnumerable<A> y)
• Bind <MONADB, MB, B> (IEnumerable<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (IEnumerable<A> ma, Func<A, MB> f)
• Count (IEnumerable<A> fa)
• Subtract (IEnumerable<A> x, IEnumerable<A> y)
• Empty ()
• Equals (IEnumerable<A> x, IEnumerable<A> y)
• Compare (IEnumerable<A> x, IEnumerable<A> y)
• Fail (object err = null)
• Fold <S> (IEnumerable<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (IEnumerable<A> fa, S state, Func<S, A, S> f)
• Plus (IEnumerable<A> ma, IEnumerable<A> mb)
• Zero ()
• Return (Func<Unit, A> f)
• GetHashCode (IEnumerable<A> x)
• Run (Func<Unit, IEnumerable<A>> ma)
• BindReturn (Unit maOutput, IEnumerable<A> mb)
• Return (A x)
• Apply <MonadB, MB, B> (Func<A, A, B> faab, IEnumerable<A> fa, IEnumerable<A> fb)
• Apply (Func<A, A, A> f, IEnumerable<A> fa, IEnumerable<A> fb)
• EqualsAsync (IEnumerable<A> x, IEnumerable<A> y)
• GetHashCodeAsync (IEnumerable<A> x)
• CompareAsync (IEnumerable<A> x, IEnumerable<A> y)
• MFin <A>
• Inst = default(MFin<A>)
• None
• Bind <MonadB, MB, B> (Fin<A> ma, Func<A, MB> f)
• BindAsync <MonadB, MB, B> (Fin<A> ma, Func<A, MB> f)
• Fail (object err = null)
• Plus (Fin<A> a, Fin<A> b)
• Return (Func<Unit, A> f)
• Zero ()
• Fold <S> (Fin<A> ma, S state, Func<S, A, S> f)
• FoldBack <S> (Fin<A> ma, S state, Func<S, A, S> f)
• BiFold <S> (Fin<A> ma, S state, Func<S, A, S> fa, Func<S, Error, S> fb)
• BiFoldBack <S> (Fin<A> ma, S state, Func<S, A, S> fa, Func<S, Error, S> fb)
• Count (Fin<A> ma)
• Run (Func<Unit, Fin<A>> ma)
• BindReturn (Unit _, Fin<A> mb)
• Return (A x)
• Empty ()
• Append (Fin<A> x, Fin<A> y)
• Equals (Fin<A> x, Fin<A> y)
• GetHashCode (Fin<A> x)
• Apply (Func<A, A, A> f, Fin<A> fa, Fin<A> fb)
• EqualsAsync (Fin<A> x, Fin<A> y)
• GetHashCodeAsync (Fin<A> x)
• Compare (Fin<A> x, Fin<A> y)
• CompareAsync (Fin<A> x, Fin<A> y)
• MHashSet <A>
• Inst = default(MHashSet<A>)
• Append (HashSet<A> x, HashSet<A> y)
• Bind <MONADB, MB, B> (HashSet<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (HashSet<A> ma, Func<A, MB> f)
• Count (HashSet<A> fa)
• Subtract (HashSet<A> x, HashSet<A> y)
• Empty ()
• Equals (HashSet<A> x, HashSet<A> y)
• Fail (object err = null)
• Fold <S> (HashSet<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (HashSet<A> fa, S state, Func<S, A, S> f)
• Plus (HashSet<A> ma, HashSet<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• GetHashCode (HashSet<A> x)
• Run (Func<Unit, HashSet<A>> ma)
• BindReturn (Unit maOutput, HashSet<A> mb)
• Return (A x)
• Apply (Func<A, A, A> f, HashSet<A> fa, HashSet<A> fb)
• EqualsAsync (HashSet<A> x, HashSet<A> y)
• GetHashCodeAsync (HashSet<A> x)
• MIdentity <A>
• Inst = new MIdentity<A>()
• Bind <MONADB, MB, B> (Identity<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Identity<A> ma, Func<A, MB> f)
• BindReturn (Unit maOutput, Identity<A> mb)
• Count (Identity<A> fa)
• Fail (object err = null)
• Fold <S> (Identity<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Identity<A> fa, S state, Func<S, A, S> f)
• Run (Func<Unit, Identity<A>> ma)
• Plus (Identity<A> a, Identity<A> b)
• Return (Func<Unit, A> f)
• Zero ()
• Return (A x)
• Apply (Func<A, A, A> f, Identity<A> fa, Identity<A> fb)
• ToAsync (Identity<A> sa)
• MLst <A>
• Inst = default(MLst<A>)
• Append (Lst<A> x, Lst<A> y)
• Bind <MONADB, MB, B> (Lst<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Lst<A> ma, Func<A, MB> f)
• Count (Lst<A> fa)
• Subtract (Lst<A> x, Lst<A> y)
• Empty ()
• Equals (Lst<A> x, Lst<A> y)
• Compare (Lst<A> x, Lst<A> y)
• Fail (object err = null)
• Fold <S> (Lst<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Lst<A> fa, S state, Func<S, A, S> f)
• Plus (Lst<A> ma, Lst<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• GetHashCode (Lst<A> x)
• Run (Func<Unit, Lst<A>> ma)
• BindReturn (Unit maOutput, Lst<A> mb)
• Return (A x)
• Apply (Func<A, A, A> f, Lst<A> fa, Lst<A> fb)
• EqualsAsync (Lst<A> x, Lst<A> y)
• GetHashCodeAsync (Lst<A> x)
• CompareAsync (Lst<A> x, Lst<A> y)
• MNullable <A>
• Inst = default(MNullable<A>)
• None
• Bind <MONADB, MB, B> (A? ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (A? ma, Func<A, MB> f)
• Fail (object err = null)
• Plus (A? a, A? b)
• Return (Func<Unit, A> f)
• Zero ()
• IsNone (A? ma)
• IsSome (A? ma)
• Match (A? ma, Action<A> Some, Action None)
• Match <B> (A? ma, Func<A, B> Some, Func<B> None)
• Match <B> (A? ma, Func<A, B> Some, B None)
• MatchUnsafe <B> (A? ma, Func<A, B> Some, Func<B> None)
• MatchUnsafe <B> (A? ma, Func<A, B> Some, B None)
• Fold <S> (A? ma, S state, Func<S, A, S> f)
• FoldBack <S> (A? ma, S state, Func<S, A, S> f)
• BiFold <S> (A? ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldBack <S> (A? ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• Count (A? ma)
• Some (A value)
• Optional (A value)
• Run (Func<Unit, A?> ma)
• BindReturn (Unit _, A? mb)
• Return (A x)
• Apply (Func<A, A, A> f, A? fa, A? fb)
• Compare (A? x, A? y)
• Equals (A? x, A? y)
• GetHashCode (A? x)
• EqualsAsync (A? x, A? y)
• GetHashCodeAsync (A? x)
• CompareAsync (A? x, A? y)
• MOption <A>
• Inst = default(MOption<A>)
• None
• Bind <MonadB, MB, B> (Option<A> ma, Func<A, MB> f)
• BindAsync <MonadB, MB, B> (Option<A> ma, Func<A, MB> f)
• Fail (object err = null)
• Plus (Option<A> a, Option<A> b)
• Return (Func<Unit, A> f)
• Zero ()
• IsNone (Option<A> opt)
• IsSome (Option<A> opt)
• Match <B> (Option<A> opt, Func<A, B> Some, Func<B> None)
• Match <B> (Option<A> opt, Func<A, B> Some, B None)
• Match (Option<A> opt, Action<A> Some, Action None)
• MatchUnsafe <B> (Option<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafe <B> (Option<A> opt, Func<A, B> Some, B None)
• Fold <S> (Option<A> ma, S state, Func<S, A, S> f)
• FoldBack <S> (Option<A> ma, S state, Func<S, A, S> f)
• BiFold <S> (Option<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldBack <S> (Option<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• Count (Option<A> ma)
• Some (A x)
• Optional (A x)
• Run (Func<Unit, Option<A>> ma)
• BindReturn (Unit _, Option<A> mb)
• Return (A x)
• Empty ()
• Append (Option<A> x, Option<A> y)
• Equals (Option<A> x, Option<A> y)
• GetHashCode (Option<A> x)
• Apply (Func<A, A, A> f, Option<A> fa, Option<A> fb)
• Compare (Option<A> x, Option<A> y)
• ToAsync (Option<A> sa)
• EqualsAsync (Option<A> x, Option<A> y)
• GetHashCodeAsync (Option<A> x)
• CompareAsync (Option<A> x, Option<A> y)
• MOptionAsync <A>
• Inst = default(MOptionAsync<A>)
• None
• Bind <MonadB, MB, B> (OptionAsync<A> ma, Func<A, MB> f)
• BindAsync <MonadB, MB, B> (OptionAsync<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (OptionAsync<A> a, OptionAsync<A> b)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• IsNone (OptionAsync<A> opt)
• IsSome (OptionAsync<A> opt)
• Match <B> (OptionAsync<A> opt, Func<A, B> Some, Func<B> None)
• MatchAsync <B> (OptionAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (OptionAsync<A> opt, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (OptionAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (OptionAsync<A> opt, Action<A> Some, Action None)
• MatchAsync (OptionAsync<A> opt, Func<A, Task> SomeAsync, Action None)
• MatchAsync (OptionAsync<A> opt, Action<A> Some, Func<Task> NoneAsync)
• MatchAsync (OptionAsync<A> opt, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• MatchUnsafe <B> (OptionAsync<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (OptionAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (OptionAsync<A> opt, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (OptionAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Some (A value)
• SomeAsync (Task<A> taskA)
• Optional (A value)
• OptionalAsync (Task<A> taskA)
• BindReturn (Unit _, OptionAsync<A> mb)
• ReturnAsync (Task<A> x)
• RunAsync (Func<Unit, Task<OptionAsync<A>>> ma)
• Empty ()
• Append (OptionAsync<A> x, OptionAsync<A> y)
• Fold <S> (OptionAsync<A> ma, S state, Func<S, A, S> f)
• FoldAsync <S> (OptionAsync<A> ma, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (OptionAsync<A> ma, S state, Func<S, A, S> f)
• FoldBackAsync <S> (OptionAsync<A> ma, S state, Func<S, A, Task<S>> f)
• Count (OptionAsync<A> ma)
• BiFold <S> (OptionAsync<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldAsync <S> (OptionAsync<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, Task<S>> fb)
• BiFoldAsync <S> (OptionAsync<A> ma, S state, Func<S, A, Task<S>> fa, Func<S, Unit, S> fb)
• BiFoldAsync <S> (OptionAsync<A> ma, S state, Func<S, A, Task<S>> fa, Func<S, Unit, Task<S>> fb)
• BiFoldBack <S> (OptionAsync<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldBackAsync <S> (OptionAsync<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, Task<S>> fb)
• BiFoldBackAsync <S> (OptionAsync<A> ma, S state, Func<S, A, Task<S>> fa, Func<S, Unit, S> fb)
• BiFoldBackAsync <S> (OptionAsync<A> ma, S state, Func<S, A, Task<S>> fa, Func<S, Unit, Task<S>> fb)
• Apply (Func<A, A, A> f, OptionAsync<A> fa, OptionAsync<A> fb)
• MOptionUnsafe <A>
• Inst = default(MOptionUnsafe<A>)
• None
• Bind <MONADB, MB, B> (OptionUnsafe<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (OptionUnsafe<A> ma, Func<A, MB> f)
• Fail (object err = null)
• Plus (OptionUnsafe<A> a, OptionUnsafe<A> b)
• Return (Func<Unit, A> f)
• Zero ()
• IsNone (OptionUnsafe<A> opt)
• IsSome (OptionUnsafe<A> opt)
• MatchUnsafe <B> (OptionUnsafe<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafe <B> (OptionUnsafe<A> opt, Func<A, B> Some, B None)
• Match (OptionUnsafe<A> opt, Action<A> Some, Action None)
• Fold <S> (OptionUnsafe<A> ma, S state, Func<S, A, S> f)
• FoldBack <S> (OptionUnsafe<A> ma, S state, Func<S, A, S> f)
• BiFold <S> (OptionUnsafe<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldBack <S> (OptionUnsafe<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• Count (OptionUnsafe<A> ma)
• Some (A x)
• Optional (A x)
• Run (Func<Unit, OptionUnsafe<A>> ma)
• BindReturn (Unit _, OptionUnsafe<A> mb)
• Return (A x)
• Empty ()
• Append (OptionUnsafe<A> x, OptionUnsafe<A> y)
• Equals (OptionUnsafe<A> x, OptionUnsafe<A> y)
• GetHashCode (OptionUnsafe<A> x)
• Apply (Func<A, A, A> f, OptionUnsafe<A> fa, OptionUnsafe<A> fb)
• EqualsAsync (OptionUnsafe<A> x, OptionUnsafe<A> y)
• GetHashCodeAsync (OptionUnsafe<A> x)
• MQue <A>
• Inst = default(MQue<A>)
• Append (Que<A> x, Que<A> y)
• Bind <MONADB, MB, B> (Que<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Que<A> ma, Func<A, MB> f)
• Count (Que<A> fa)
• Subtract (Que<A> x, Que<A> y)
• Empty ()
• Equals (Que<A> x, Que<A> y)
• Fail (object err = null)
• Fold <S> (Que<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Que<A> fa, S state, Func<S, A, S> f)
• Plus (Que<A> ma, Que<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• GetHashCode (Que<A> x)
• Run (Func<Unit, Que<A>> ma)
• BindReturn (Unit _, Que<A> mb)
• Return (A x)
• Apply (Func<A, A, A> f, Que<A> fa, Que<A> fb)
• EqualsAsync (Que<A> x, Que<A> y)
• GetHashCodeAsync (Que<A> x)
• MReader <Env, A>
• Inst = new MReader<Env, A>()
• Bind <MONADB, MB, B> (Reader<Env, A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Reader<Env, A> ma, Func<A, MB> f)
• Fail (object err = null)
• Reader (Func<Env, A> f)
• Ask ()
• Local (Reader<Env, A> ma, Func<Env, Env> f)
• Return (Func<Env, A> f)
• Run (Func<Env, Reader<Env, A>> f)
• Plus (Reader<Env, A> ma, Reader<Env, A> mb)
• Zero ()
• Fold <S> (Reader<Env, A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Reader<Env, A> fa, S state, Func<S, A, S> f)
• Count (Reader<Env, A> fa)
• BindReturn (Unit _, Reader<Env, A> mb)
• Apply (Func<A, A, A> f, Reader<Env, A> fa, Reader<Env, A> fb)
• MRWS <MonoidW, R, W, S, A>
• Apply (Func<A, A, A> f, RWS<MonoidW, R, W, S, A> fa, RWS<MonoidW, R, W, S, A> fb)
• Ask ()
• Bind <MONADB, MB, B> (RWS<MonoidW, R, W, S, A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (RWS<MonoidW, R, W, S, A> ma, Func<A, MB> f)
• BindReturn (RWSState<W, S> previous, RWS<MonoidW, R, W, S, A> mb)
• Count (RWS<MonoidW, R, W, S, A> fa)
• Fail (object err = null)
• Fold <S1> (RWS<MonoidW, R, W, S, A> fa, S1 initialValue, Func<S1, A, S1> f)
• FoldBack <S1> (RWS<MonoidW, R, W, S, A> fa, S1 state, Func<S1, A, S1> f)
• Run (Func<(R Env, S State), RWS<MonoidW, R, W, S, A>> ma)
• Local (RWS<MonoidW, R, W, S, A> ma, Func<R, R> f)
• Plus (RWS<MonoidW, R, W, S, A> ma, RWS<MonoidW, R, W, S, A> mb)
• Return (Func<(R Env, S State), A> f)
• Zero ()
• Get ()
• Put (S state)
• Tell (W what)
• Listen <B> (RWS<MonoidW, R, W, S, A> ma, Func<W, B> f)
• MSeq <A>
• Inst = default(MSeq<A>)
• Append (Seq<A> x, Seq<A> y)
• Bind <MONADB, MB, B> (Seq<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Seq<A> ma, Func<A, MB> f)
• Count (Seq<A> fa)
• Subtract (Seq<A> x, Seq<A> y)
• Empty ()
• Equals (Seq<A> x, Seq<A> y)
• Fail (object err = null)
• Fold <S> (Seq<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Seq<A> fa, S state, Func<S, A, S> f)
• Plus (Seq<A> ma, Seq<A> mb)
• Zero ()
• Return (Func<Unit, A> f)
• GetHashCode (Seq<A> x)
• Run (Func<Unit, Seq<A>> ma)
• BindReturn (Unit maOutput, Seq<A> mb)
• Return (A x)
• Apply (Func<A, A, A> f, Seq<A> fa, Seq<A> fb)
• EqualsAsync (Seq<A> x, Seq<A> y)
• GetHashCodeAsync (Seq<A> x)
• MSet <A>
• Inst = default(MSet<A>)
• Append (Set<A> x, Set<A> y)
• Bind <MONADB, MB, B> (Set<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Set<A> ma, Func<A, MB> f)
• Count (Set<A> fa)
• Subtract (Set<A> x, Set<A> y)
• Empty ()
• Equals (Set<A> x, Set<A> y)
• Fail (object err = null)
• Fold <S> (Set<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Set<A> fa, S state, Func<S, A, S> f)
• Plus (Set<A> ma, Set<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• GetHashCode (Set<A> x)
• Return (A x)
• Run (Func<Unit, Set<A>> ma)
• BindReturn (Unit _, Set<A> mb)
• Apply (Func<A, A, A> f, Set<A> fa, Set<A> fb)
• EqualsAsync (Set<A> x, Set<A> y)
• GetHashCodeAsync (Set<A> x)
• MState <S, A>
• Bind <MONADB, MB, B> (State<S, A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (State<S, A> ma, Func<A, MB> f)
• BindReturn ((S State, bool IsFaulted) output, State<S, A> mb)
• Fail (object err = null)
• Get ()
• Put (S state)
• Return (Func<S, A> f)
• Plus (State<S, A> ma, State<S, A> mb)
• Zero ()
• Fold <FoldState> (State<S, A> fa, FoldState initialState, Func<FoldState, A, FoldState> f)
• FoldBack <FoldState> (State<S, A> fa, FoldState state, Func<FoldState, A, FoldState> f)
• Count (State<S, A> fa)
• Run (Func<S, State<S, A>> ma)
• State (Func<S, A> f)
• Apply (Func<A, A, A> f, State<S, A> fa, State<S, A> fb)
• MStck <A>
• Inst = default(MStck<A>)
• Append (Stck<A> x, Stck<A> y)
• Bind <MONADB, MB, B> (Stck<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Stck<A> ma, Func<A, MB> f)
• Count (Stck<A> fa)
• Subtract (Stck<A> x, Stck<A> y)
• Empty ()
• Equals (Stck<A> x, Stck<A> y)
• Fail (object err = null)
• Fold <S> (Stck<A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Stck<A> fa, S state, Func<S, A, S> f)
• Plus (Stck<A> ma, Stck<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• GetHashCode (Stck<A> x)
• Run (Func<Unit, Stck<A>> ma)
• BindReturn (Unit _, Stck<A> mb)
• Return (A x)
• Apply (Func<A, A, A> f, Stck<A> fa, Stck<A> fb)
• EqualsAsync (Stck<A> x, Stck<A> y)
• GetHashCodeAsync (Stck<A> x)
• MTask <A>
• Inst = default(MTask<A>)
• None
• Bind <MONADB, MB, B> (Task<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Task<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (Task<A> ma, Task<A> mb)
• ReturnAsync (Task<A> x)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• IsNone (Task<A> ma)
• IsSome (Task<A> ma)
• Match <B> (Task<A> ma, Func<A, B> Some, Func<B> None)
• Some (A value)
• Optional (A value)
• BindReturn (Unit _, Task<A> mb)
• RunAsync (Func<Unit, Task<Task<A>>> ma)
• Fold <S> (Task<A> fa, S state, Func<S, A, S> f)
• FoldAsync <S> (Task<A> fa, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (Task<A> fa, S state, Func<S, A, S> f)
• FoldBackAsync <S> (Task<A> fa, S state, Func<S, A, Task<S>> f)
• Count (Task<A> fa)
• Apply (Func<A, A, A> f, Task<A> fa, Task<A> fb)
• MatchAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (Task<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• MatchUnsafe <B> (Task<A> ma, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (Task<A> ma, Action<A> Some, Action None)
• MatchAsync (Task<A> ma, Func<A, Task> SomeAsync, Action None)
• MatchAsync (Task<A> ma, Action<A> SomeAsync, Func<Task> NoneAsync)
• MatchAsync (Task<A> ma, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• SomeAsync (Task<A> value)
• OptionalAsync (Task<A> value)
• BiFold <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBack <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• MTaskFirst <A>
• Inst = default(MTaskFirst<A>)
• None
• Bind <MONADB, MB, B> (Task<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Task<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (Task<A> ma, Task<A> mb)
• ReturnAsync (Task<A> x)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• IsNone (Task<A> ma)
• IsSome (Task<A> ma)
• Match <B> (Task<A> ma, Func<A, B> Some, Func<B> None)
• Some (A value)
• Optional (A value)
• BindReturn (Unit _, Task<A> mb)
• RunAsync (Func<Unit, Task<Task<A>>> ma)
• Fold <S> (Task<A> fa, S state, Func<S, A, S> f)
• FoldAsync <S> (Task<A> fa, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (Task<A> fa, S state, Func<S, A, S> f)
• FoldBackAsync <S> (Task<A> fa, S state, Func<S, A, Task<S>> f)
• Count (Task<A> fa)
• Apply (Func<A, A, A> f, Task<A> fa, Task<A> fb)
• MatchAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (Task<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (Task<A> ma, Action<A> Some, Action None)
• MatchAsync (Task<A> ma, Func<A, Task> SomeAsync, Action None)
• MatchAsync (Task<A> ma, Action<A> Some, Func<Task> None)
• MatchAsync (Task<A> ma, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• SomeAsync (Task<A> value)
• OptionalAsync (Task<A> value)
• BiFold <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBack <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• MatchUnsafe <B> (Task<A> ma, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• MTaskSerial <A>
• Inst = default
• None
• Bind <MONADB, MB, B> (Task<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Task<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (Task<A> ma, Task<A> mb)
• ReturnAsync (Task<A> x)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• IsNone (Task<A> ma)
• IsSome (Task<A> ma)
• Match <B> (Task<A> ma, Func<A, B> Some, Func<B> None)
• Some (A value)
• Optional (A value)
• BindReturn (Unit _, Task<A> mb)
• RunAsync (Func<Unit, Task<Task<A>>> ma)
• Fold <S> (Task<A> fa, S state, Func<S, A, S> f)
• FoldAsync <S> (Task<A> fa, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (Task<A> fa, S state, Func<S, A, S> f)
• FoldBackAsync <S> (Task<A> fa, S state, Func<S, A, Task<S>> f)
• Count (Task<A> fa)
• Apply (Func<A, A, A> f, Task<A> fa, Task<A> fb)
• MatchAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (Task<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• MatchUnsafe <B> (Task<A> ma, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (Task<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (Task<A> ma, Action<A> Some, Action None)
• MatchAsync (Task<A> ma, Func<A, Task> SomeAsync, Action None)
• MatchAsync (Task<A> ma, Action<A> SomeAsync, Func<Task> NoneAsync)
• MatchAsync (Task<A> ma, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• SomeAsync (Task<A> value)
• OptionalAsync (Task<A> value)
• BiFold <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBack <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBackAsync <S> (Task<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• MTry <A>
• Inst = default(MTry<A>)
• None
• Bind <MONADB, MB, B> (Try<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Try<A> ma, Func<A, MB> f)
• Fail (object err = null)
• Plus (Try<A> ma, Try<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• IsNone (Try<A> opt)
• IsSome (Try<A> opt)
• Match <B> (Try<A> opt, Func<A, B> Some, Func<B> None)
• Match <B> (Try<A> opt, Func<A, B> Some, B None)
• Match (Try<A> opt, Action<A> Some, Action None)
• MatchUnsafe <B> (Try<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafe <B> (Try<A> opt, Func<A, B> Some, B None)
• Fold <S> (Try<A> ma, S state, Func<S, A, S> f)
• FoldBack <S> (Try<A> ma, S state, Func<S, A, S> f)
• BiFold <S> (Try<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldBack <S> (Try<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• Count (Try<A> ma)
• Some (A value)
• Optional (A value)
• Run (Func<Unit, Try<A>> ma)
• BindReturn (Unit _, Try<A> mb)
• Return (A x)
• Empty ()
• Append (Try<A> x, Try<A> y)
• Apply (Func<A, A, A> f, Try<A> fa, Try<A> fb)
• ToAsync (Try<A> sa)
• IsLeft (Try<A> choice)
• IsRight (Try<A> choice)
• IsBottom (Try<A> choice)
• Match <C> (Try<A> choice, Func<Exception, C> Left, Func<A, C> Right, Func<C> Bottom = null)
• Match (Try<A> choice, Action<Exception> Left, Action<A> Right, Action Bottom = null)
• MTryAsync <A>
• Inst = default(MTryAsync<A>)
• None
• Bind <MONADB, MB, B> (TryAsync<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (TryAsync<A> ma, Func<A, Task<MB>> f)
• RunAsync (Func<Unit, Task<TryAsync<A>>> ma)
• BindReturn (Unit _, TryAsync<A> mb)
• Fail (object err = null)
• Plus (TryAsync<A> ma, TryAsync<A> mb)
• ReturnAsync (Func<Unit, Task<A>> f)
• ReturnAsync (Task<A> x)
• Zero ()
• Match <B> (TryAsync<A> opt, Func<A, B> Some, Func<B> None)
• MatchAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (TryAsync<A> opt, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (TryAsync<A> opt, Action<A> Some, Action None)
• MatchAsync (TryAsync<A> opt, Func<A, Task> SomeAsync, Action None)
• MatchAsync (TryAsync<A> opt, Action<A> Some, Func<Task> NoneAsync)
• MatchAsync (TryAsync<A> opt, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• MatchUnsafe <B> (TryAsync<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (TryAsync<A> opt, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Fold <S> (TryAsync<A> ma, S state, Func<S, A, S> f)
• FoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (TryAsync<A> ma, S state, Func<S, A, S> f)
• FoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> f)
• Count (TryAsync<A> ma)
• IsNone (TryAsync<A> opt)
• IsSome (TryAsync<A> opt)
• Some (A value)
• SomeAsync (Task<A> value)
• Optional (A value)
• OptionalAsync (Task<A> value)
• Empty ()
• Append (TryAsync<A> x, TryAsync<A> y)
• BiFold <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBack <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• Apply (Func<A, A, A> f, TryAsync<A> fa, TryAsync<A> fb)
• MTryFirstAsync <A>
• Inst = default(MTryFirstAsync<A>)
• None
• Bind <MONADB, MB, B> (TryAsync<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (TryAsync<A> ma, Func<A, Task<MB>> f)
• RunAsync (Func<Unit, Task<TryAsync<A>>> ma)
• BindReturn (Unit _, TryAsync<A> mb)
• Fail (object err = null)
• Plus (TryAsync<A> ma, TryAsync<A> mb)
• ReturnAsync (Func<Unit, Task<A>> f)
• ReturnAsync (Task<A> x)
• Zero ()
• Match <B> (TryAsync<A> opt, Func<A, B> Some, Func<B> None)
• MatchAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (TryAsync<A> opt, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (TryAsync<A> opt, Action<A> Some, Action None)
• MatchAsync (TryAsync<A> opt, Func<A, Task> SomeAsync, Action None)
• MatchAsync (TryAsync<A> opt, Action<A> Some, Func<Task> NoneAsync)
• MatchAsync (TryAsync<A> opt, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• MatchUnsafe <B> (TryAsync<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (TryAsync<A> opt, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (TryAsync<A> opt, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Fold <S> (TryAsync<A> ma, S state, Func<S, A, S> f)
• FoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (TryAsync<A> ma, S state, Func<S, A, S> f)
• FoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> f)
• Count (TryAsync<A> ma)
• IsNone (TryAsync<A> opt)
• IsSome (TryAsync<A> opt)
• Some (A value)
• SomeAsync (Task<A> value)
• Optional (A value)
• OptionalAsync (Task<A> value)
• Empty ()
• Append (TryAsync<A> x, TryAsync<A> y)
• BiFold <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBack <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBackAsync <S> (TryAsync<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• Apply (Func<A, A, A> f, TryAsync<A> fa, TryAsync<A> fb)
• MTryOption <A>
• Inst = default(MTryOption<A>)
• None
• Bind <MONADB, MB, B> (TryOption<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (TryOption<A> ma, Func<A, MB> f)
• Fail (object err = null)
• Plus (TryOption<A> ma, TryOption<A> mb)
• Return (Func<Unit, A> f)
• Zero ()
• IsNone (TryOption<A> opt)
• IsSome (TryOption<A> opt)
• Match <B> (TryOption<A> opt, Func<A, B> Some, Func<B> None)
• Match <B> (TryOption<A> opt, Func<A, B> Some, B None)
• Match (TryOption<A> opt, Action<A> Some, Action None)
• MatchUnsafe <B> (TryOption<A> opt, Func<A, B> Some, Func<B> None)
• MatchUnsafe <B> (TryOption<A> opt, Func<A, B> Some, B None)
• Fold <S> (TryOption<A> ma, S state, Func<S, A, S> f)
• FoldBack <S> (TryOption<A> ma, S state, Func<S, A, S> f)
• BiFold <S> (TryOption<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• BiFoldBack <S> (TryOption<A> ma, S state, Func<S, A, S> fa, Func<S, Unit, S> fb)
• Count (TryOption<A> ma)
• Some (A value)
• Optional (A value)
• Run (Func<Unit, TryOption<A>> ma)
• BindReturn (Unit _, TryOption<A> mb)
• Return (A x)
• Empty ()
• Append (TryOption<A> x, TryOption<A> y)
• Apply (Func<A, A, A> f, TryOption<A> fa, TryOption<A> fb)
• ToAsync (TryOption<A> sa)
• MTryOptionAsync <A>
• Inst = default(MTryOptionAsync<A>)
• None
• Bind <MONADB, MB, B> (TryOptionAsync<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (TryOptionAsync<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (TryOptionAsync<A> ma, TryOptionAsync<A> mb)
• ReturnAsync (Task<A> x)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• RunAsync (Func<Unit, Task<TryOptionAsync<A>>> ma)
• BindReturn (Unit _, TryOptionAsync<A> mb)
• Fold <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> f)
• FoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> f)
• FoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> f)
• Count (TryOptionAsync<A> ma)
• Empty ()
• Append (TryOptionAsync<A> x, TryOptionAsync<A> y)
• BiFold <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, S> Fail)
• BiFoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, S> Fail)
• BiFoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, Task<S>> FailAsync)
• BiFoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, Task<S>> FailAsync)
• BiFoldBack <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, S> Fail)
• BiFoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, S> Fail)
• BiFoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, Task<S>> FailAsync)
• BiFoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, Task<S>> FailAsync)
• IsSome (TryOptionAsync<A> opt)
• IsNone (TryOptionAsync<A> opt)
• Match <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<B> Fail)
• MatchAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<B> Fail)
• MatchAsync <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<Task<B>> FailAsync)
• MatchAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<Task<B>> FailAsync)
• MatchUnsafe <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<B> Fail)
• MatchUnsafeAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<B> Fail)
• MatchUnsafeAsync <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<Task<B>> FailAsync)
• MatchUnsafeAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<Task<B>> FailAsync)
• Match (TryOptionAsync<A> opt, Action<A> Succ, Action Fail)
• MatchAsync (TryOptionAsync<A> opt, Func<A, Task> SuccAsync, Action Fail)
• MatchAsync (TryOptionAsync<A> opt, Action<A> Succ, Func<Task> FailAsync)
• MatchAsync (TryOptionAsync<A> opt, Func<A, Task> SuccAsync, Func<Task> FailAsync)
• SomeAsync (Task<A> value)
• OptionalAsync (Task<A> value)
• Some (A value)
• Optional (A value)
• Apply (Func<A, A, A> f, TryOptionAsync<A> fa, TryOptionAsync<A> fb)
• MTryOptionFirstAsync <A>
• Inst = default(MTryOptionFirstAsync<A>)
• None
• Bind <MONADB, MB, B> (TryOptionAsync<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (TryOptionAsync<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (TryOptionAsync<A> ma, TryOptionAsync<A> mb)
• ReturnAsync (Task<A> x)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• RunAsync (Func<Unit, Task<TryOptionAsync<A>>> ma)
• BindReturn (Unit _, TryOptionAsync<A> mb)
• Fold <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> f)
• FoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> f)
• FoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> f)
• Count (TryOptionAsync<A> ma)
• Empty ()
• Append (TryOptionAsync<A> x, TryOptionAsync<A> y)
• BiFold <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, S> Fail)
• BiFoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, S> Fail)
• BiFoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, Task<S>> FailAsync)
• BiFoldAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, Task<S>> FailAsync)
• BiFoldBack <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, S> Fail)
• BiFoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, S> Fail)
• BiFoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, S> Succ, Func<S, Unit, Task<S>> FailAsync)
• BiFoldBackAsync <S> (TryOptionAsync<A> ma, S state, Func<S, A, Task<S>> SuccAsync, Func<S, Unit, Task<S>> FailAsync)
• IsSome (TryOptionAsync<A> opt)
• IsNone (TryOptionAsync<A> opt)
• Match <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<B> Fail)
• MatchAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<B> Fail)
• MatchAsync <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<Task<B>> FailAsync)
• MatchAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<Task<B>> FailAsync)
• MatchUnsafe <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<B> Fail)
• MatchUnsafeAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<B> Fail)
• MatchUnsafeAsync <B> (TryOptionAsync<A> opt, Func<A, B> Succ, Func<Task<B>> FailAsync)
• MatchUnsafeAsync <B> (TryOptionAsync<A> opt, Func<A, Task<B>> SuccAsync, Func<Task<B>> FailAsync)
• Match (TryOptionAsync<A> opt, Action<A> Succ, Action Fail)
• MatchAsync (TryOptionAsync<A> opt, Func<A, Task> SuccAsync, Action Fail)
• MatchAsync (TryOptionAsync<A> opt, Action<A> Succ, Func<Task> FailAsync)
• MatchAsync (TryOptionAsync<A> opt, Func<A, Task> SuccAsync, Func<Task> FailAsync)
• SomeAsync (Task<A> value)
• OptionalAsync (Task<A> value)
• Some (A value)
• Optional (A value)
• Apply (Func<A, A, A> f, TryOptionAsync<A> fa, TryOptionAsync<A> fb)
• MValidation <MonoidFail, FAIL, SUCCESS>
• Inst = default(MValidation<MonoidFail, FAIL, SUCCESS>)
• Append (Validation<MonoidFail, FAIL, SUCCESS> x, Validation<MonoidFail, FAIL, SUCCESS> y)
• BiFold <S> (Validation<MonoidFail, FAIL, SUCCESS> foldable, S state, Func<S, FAIL, S> fa, Func<S, SUCCESS, S> fb)
• BiFoldBack <S> (Validation<MonoidFail, FAIL, SUCCESS> foldable, S state, Func<S, FAIL, S> fa, Func<S, SUCCESS, S> fb)
• Count (Validation<MonoidFail, FAIL, SUCCESS> fa)
• Empty ()
• Fold <S> (Validation<MonoidFail, FAIL, SUCCESS> fa, S state, Func<S, SUCCESS, S> f)
• FoldBack <S> (Validation<MonoidFail, FAIL, SUCCESS> fa, S state, Func<S, SUCCESS, S> f)
• IsBottom (Validation<MonoidFail, FAIL, SUCCESS> choice)
• IsLeft (Validation<MonoidFail, FAIL, SUCCESS> choice)
• IsRight (Validation<MonoidFail, FAIL, SUCCESS> choice)
• Match <C> (Validation<MonoidFail, FAIL, SUCCESS> choice, Func<FAIL, C> Left, Func<SUCCESS, C> Right, Func<C> Bottom = null)
• Match (Validation<MonoidFail, FAIL, SUCCESS> choice, Action<FAIL> Left, Action<SUCCESS> Right, Action Bottom = null)
• MatchUnsafe <C> (Validation<MonoidFail, FAIL, SUCCESS> choice, Func<FAIL, C> Left, Func<SUCCESS, C> Right, Func<C> Bottom = null)
• Bind <MONADB, MB, B> (Validation<MonoidFail, FAIL, SUCCESS> ma, Func<SUCCESS, MB> f)
• BindAsync <MONADB, MB, B> (Validation<MonoidFail, FAIL, SUCCESS> ma, Func<SUCCESS, MB> f)
• BindReturn (Unit outputma, Validation<MonoidFail, FAIL, SUCCESS> mb)
• Fail (object err = null)
• Run (Func<Unit, Validation<MonoidFail, FAIL, SUCCESS>> ma)
• Plus (Validation<MonoidFail, FAIL, SUCCESS> a, Validation<MonoidFail, FAIL, SUCCESS> b)
• Return (SUCCESS x)
• Return (Func<Unit, SUCCESS> f)
• Zero ()
• Apply (Func<SUCCESS, SUCCESS, SUCCESS> f, Validation<MonoidFail, FAIL, SUCCESS> fa, Validation<MonoidFail, FAIL, SUCCESS> fb)
• MValidation <FAIL, SUCCESS>
• Inst = default(MValidation<FAIL, SUCCESS>)
• Append (Validation<FAIL, SUCCESS> x, Validation<FAIL, SUCCESS> y)
• BiFold <S> (Validation<FAIL, SUCCESS> foldable, S state, Func<S, FAIL, S> fa, Func<S, SUCCESS, S> fb)
• BiFoldBack <S> (Validation<FAIL, SUCCESS> foldable, S state, Func<S, FAIL, S> fa, Func<S, SUCCESS, S> fb)
• Count (Validation<FAIL, SUCCESS> fa)
• Empty ()
• Fold <S> (Validation<FAIL, SUCCESS> fa, S state, Func<S, SUCCESS, S> f)
• FoldBack <S> (Validation<FAIL, SUCCESS> fa, S state, Func<S, SUCCESS, S> f)
• IsBottom (Validation<FAIL, SUCCESS> choice)
• IsLeft (Validation<FAIL, SUCCESS> choice)
• IsRight (Validation<FAIL, SUCCESS> choice)
• Match <C> (Validation<FAIL, SUCCESS> choice, Func<Seq<FAIL>, C> Left, Func<SUCCESS, C> Right, Func<C> Bottom = null)
• Match (Validation<FAIL, SUCCESS> choice, Action<Seq<FAIL>> Left, Action<SUCCESS> Right, Action Bottom = null)
• MatchUnsafe <C> (Validation<FAIL, SUCCESS> choice, Func<Seq<FAIL>, C> Left, Func<SUCCESS, C> Right, Func<C> Bottom = null)
• Bind <MONADB, MB, B> (Validation<FAIL, SUCCESS> ma, Func<SUCCESS, MB> f)
• BindAsync <MONADB, MB, B> (Validation<FAIL, SUCCESS> ma, Func<SUCCESS, MB> f)
• BindReturn (Unit outputma, Validation<FAIL, SUCCESS> mb)
• Fail (Seq<FAIL> err)
• Fail (object err = null)
• Run (Func<Unit, Validation<FAIL, SUCCESS>> ma)
• Plus (Validation<FAIL, SUCCESS> a, Validation<FAIL, SUCCESS> b)
• Return (SUCCESS x)
• Return (Func<Unit, SUCCESS> f)
• Zero ()
• Apply (Func<SUCCESS, SUCCESS, SUCCESS> f, Validation<FAIL, SUCCESS> fa, Validation<FAIL, SUCCESS> fb)
• MValueTask <A>
• Inst = default(MValueTask<A>)
• None
• Bind <MONADB, MB, B> (ValueTask<A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (ValueTask<A> ma, Func<A, Task<MB>> f)
• Fail (object err = null)
• Plus (ValueTask<A> ma, ValueTask<A> mb)
• ReturnAsync (Task<A> x)
• ReturnAsync (Func<Unit, Task<A>> f)
• Zero ()
• IsNone (ValueTask<A> ma)
• IsSome (ValueTask<A> ma)
• Match <B> (ValueTask<A> ma, Func<A, B> Some, Func<B> None)
• Some (A value)
• Optional (A value)
• BindReturn (Unit _, ValueTask<A> mb)
• RunAsync (Func<Unit, Task<ValueTask<A>>> ma)
• Fold <S> (ValueTask<A> fa, S state, Func<S, A, S> f)
• FoldAsync <S> (ValueTask<A> fa, S state, Func<S, A, Task<S>> f)
• FoldBack <S> (ValueTask<A> fa, S state, Func<S, A, S> f)
• FoldBackAsync <S> (ValueTask<A> fa, S state, Func<S, A, Task<S>> f)
• Count (ValueTask<A> fa)
• Apply (Func<A, A, A> f, ValueTask<A> fa, ValueTask<A> fb)
• MatchAsync <B> (ValueTask<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchAsync <B> (ValueTask<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchAsync <B> (ValueTask<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• Match (ValueTask<A> ma, Action<A> Some, Action None)
• MatchAsync (ValueTask<A> ma, Func<A, Task> SomeAsync, Action None)
• MatchAsync (ValueTask<A> ma, Action<A> Some, Func<Task> None)
• MatchAsync (ValueTask<A> ma, Func<A, Task> SomeAsync, Func<Task> NoneAsync)
• SomeAsync (Task<A> value)
• OptionalAsync (Task<A> value)
• BiFold <S> (ValueTask<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldAsync <S> (ValueTask<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldAsync <S> (ValueTask<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldAsync <S> (ValueTask<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBack <S> (ValueTask<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (ValueTask<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, S> None)
• BiFoldBackAsync <S> (ValueTask<A> ma, S state, Func<S, A, S> Some, Func<S, Unit, Task<S>> NoneAsync)
• BiFoldBackAsync <S> (ValueTask<A> ma, S state, Func<S, A, Task<S>> SomeAsync, Func<S, Unit, Task<S>> NoneAsync)
• MatchUnsafe <B> (ValueTask<A> ma, Func<A, B> Some, Func<B> None)
• MatchUnsafeAsync <B> (ValueTask<A> ma, Func<A, Task<B>> SomeAsync, Func<B> None)
• MatchUnsafeAsync <B> (ValueTask<A> ma, Func<A, B> Some, Func<Task<B>> NoneAsync)
• MatchUnsafeAsync <B> (ValueTask<A> ma, Func<A, Task<B>> SomeAsync, Func<Task<B>> NoneAsync)
• MWriter <MonoidW, W, A>
• Bind <MONADB, MB, B> (Writer<MonoidW, W, A> ma, Func<A, MB> f)
• BindAsync <MONADB, MB, B> (Writer<MonoidW, W, A> ma, Func<A, MB> f)
• BindReturn ((W, bool) output, Writer<MonoidW, W, A> mb)
• Fail (object err = null)
• Writer (A value, W output)
• Run (Func<Unit, Writer<MonoidW, W, A>> f)
• Return (Func<Unit, A> f)
• Tell (W what)
• Listen <B> (Writer<MonoidW, W, A> ma, Func<W, B> f)
• Plus (Writer<MonoidW, W, A> ma, Writer<MonoidW, W, A> mb)
• Zero ()
• Fold <S> (Writer<MonoidW, W, A> fa, S state, Func<S, A, S> f)
• FoldBack <S> (Writer<MonoidW, W, A> fa, S state, Func<S, A, S> f)
• Count (Writer<MonoidW, W, A> fa)
• Apply (Func<A, A, A> f, Writer<MonoidW, W, A> fa, Writer<MonoidW, W, A> fb)