LanguageExt.Core

LanguageExt.Core ► Class Instances ► Trans

Contents

struct Trans <OuterMonad, OuterType, InnerMonad, InnerType, A> Source #

where OuterMonad : struct, Monad<OuterType, InnerType>
where InnerMonad : struct, Monad<InnerType, A>

Default monad transformer, can nest any two monadic types and provide the correct default behaviour based on their Bind operations.

i.e.

    Trans<MLst<Option<int>>, Lst<Option<int>>, MOption<int>, Option<int>, int>

Fields

field Trans<OuterMonad, OuterType, InnerMonad, InnerType, A> Inst Source #

Methods

method NewOuterType Bind <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewInnerType> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method NewOuterType Bind <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewOuterType> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method NewOuterType BindAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewOuterType> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method NewOuterType Map <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method S Fold <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method S FoldBack <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method int Count (OuterType ma) Source #

method NewOuterType Sequence <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType> (OuterType ma) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, A>

method NewOuterType Traverse <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method OuterType Plus (OuterType ma, OuterType mb) Source #

method OuterType Zero () Source #

struct Trans <OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Source #

where OuterMonad : struct, Monad<OuterType, InnerType>
where InnerMonad : struct, Monad<InnerType, A>
where NumA : struct, Num<A>

Fields

field Trans<OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Inst Source #

Methods

method A Sum (OuterType ma) Source #

struct TransAsync <OuterMonad, OuterType, InnerMonad, InnerType, A> Source #

where OuterMonad : struct, MonadAsync<OuterType, InnerType>
where InnerMonad : struct, MonadAsync<InnerType, A>

Default monad transformer, can nest any two monadic types and provide the correct default behaviour based on their Bind operations.

i.e.

    TransAsync<MTask<TryAsync<int>>, Lst<Task<TryAsync>>, MTryAsync<int>, TryAsync<int>, int>

Fields

field TransAsync<OuterMonad, OuterType, InnerMonad, InnerType, A> Inst Source #

Methods

method NewOuterType Bind <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewInnerType> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType BindAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<NewInnerType>> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType Bind <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewOuterType> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType BindAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<NewOuterType>> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType Map <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType MapAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<B>> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method Task<S> Fold <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method Task<S> FoldBack <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method Task<S> FoldAsync <S> (OuterType ma, S state, Func<S, A, Task<S>> f) Source #

method Task<S> FoldBackAsync <S> (OuterType ma, S state, Func<S, A, Task<S>> f) Source #

method Task<int> CountAsync (OuterType ma) Source #

method NewOuterType Sequence <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType> (OuterType ma) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, A>

method NewOuterType Traverse <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType TraverseAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<B>> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method OuterType Plus (OuterType ma, OuterType mb) Source #

method OuterType Zero () Source #

struct TransAsync <OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Source #

where OuterMonad : struct, MonadAsync<OuterType, InnerType>
where InnerMonad : struct, MonadAsync<InnerType, A>
where NumA : struct, Num<A>

Fields

field TransAsync<OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Inst Source #

Methods

method Task<A> Sum (OuterType ma) Source #

struct TransAsyncSync <OuterMonad, OuterType, InnerMonad, InnerType, A> Source #

where OuterMonad : struct, MonadAsync<OuterType, InnerType>
where InnerMonad : struct, Monad<InnerType, A>

Default monad transformer, can nest any two monadic types and provide the correct default behaviour based on their Bind operations.

i.e.

    TransSyncAsync<MSeq<TryAsync<int>>, Seq<TryAsync<int>>, MTryAsync<int>, TryAsync<int>, int>

Fields

field TransAsyncSync<OuterMonad, OuterType, InnerMonad, InnerType, A> Inst Source #

Methods

method NewOuterC SelectManyAsync <NewOuterMonadB, NewOuterB, NewInnerMonadB, NewInnerB, B, NewOuterMonadC, NewOuterC, NewInnerMonadC, NewInnerC, C> ( OuterType ma, Func<A, NewOuterB> bind, Func<A, B, C> project) Source #

where NewOuterMonadB : struct, MonadAsync<NewOuterB, NewInnerB>
where NewInnerMonadB : struct, Monad<NewInnerB, B>
where NewOuterMonadC : struct, MonadAsync<NewOuterC, NewInnerC>
where NewInnerMonadC : struct, Monad<NewInnerC, C>

method NewOuterType Bind <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewInnerType> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method NewOuterType BindAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewOuterType> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method NewOuterType Map <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method Task<S> Fold <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method Task<S> FoldBack <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method Task<int> Count (OuterType ma) Source #

method OuterType Plus (OuterType ma, OuterType mb) Source #

method OuterType Zero () Source #

struct TransAsyncSync <OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Source #

where OuterMonad : struct, MonadAsync<OuterType, InnerType>
where InnerMonad : struct, Monad<InnerType, A>
where NumA : struct, Num<A>

Fields

field TransAsyncSync<OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Inst Source #

Methods

method Task<A> Sum (OuterType ma) Source #

struct TransSyncAsync <OuterMonad, OuterType, InnerMonad, InnerType, A> Source #

where OuterMonad : struct, Monad<OuterType, InnerType>
where InnerMonad : struct, MonadAsync<InnerType, A>

Default monad transformer, can nest any two monadic types and provide the correct default behaviour based on their Bind operations.

i.e.

    TransSyncAsync<MSeq<TryAsync<int>>, Seq<TryAsync<int>>, MTryAsync<int>, TryAsync<int>, int>

Fields

field TransSyncAsync<OuterMonad, OuterType, InnerMonad, InnerType, A> Inst Source #

Methods

method NewOuterC SelectManyAsync <NewOuterMonadB, NewOuterB, NewInnerMonadB, NewInnerB, B, NewOuterMonadC, NewOuterC, NewInnerMonadC, NewInnerC, C> ( OuterType ma, Func<A, NewInnerB> bind, Func<A, B, C> project) Source #

where NewOuterMonadB : struct, Monad<NewOuterB, NewInnerB>
where NewInnerMonadB : struct, MonadAsync<NewInnerB, B>
where NewOuterMonadC : struct, Monad<NewOuterC, NewInnerC>
where NewInnerMonadC : struct, MonadAsync<NewInnerC, C>

method NewOuterC SelectManyAsync <NewOuterMonadB, NewOuterB, NewInnerMonadB, NewInnerB, B, NewOuterMonadC, NewOuterC, NewInnerMonadC, NewInnerC, C> ( OuterType ma, Func<A, Task<NewInnerB>> bind, Func<A, B, C> project) Source #

where NewOuterMonadB : struct, Monad<NewOuterB, NewInnerB>
where NewInnerMonadB : struct, MonadAsync<NewInnerB, B>
where NewOuterMonadC : struct, Monad<NewOuterC, NewInnerC>
where NewInnerMonadC : struct, MonadAsync<NewInnerC, C>

method NewOuterC SelectManyAsync <NewOuterMonadB, NewOuterB, NewInnerMonadB, NewInnerB, B, NewOuterMonadC, NewOuterC, NewInnerMonadC, NewInnerC, C> ( OuterType ma, Func<A, NewInnerB> bind, Func<A, B, Task<C>> project) Source #

where NewOuterMonadB : struct, Monad<NewOuterB, NewInnerB>
where NewInnerMonadB : struct, MonadAsync<NewInnerB, B>
where NewOuterMonadC : struct, Monad<NewOuterC, NewInnerC>
where NewInnerMonadC : struct, MonadAsync<NewInnerC, C>

method NewOuterC SelectManyAsync <NewOuterMonadB, NewOuterB, NewInnerMonadB, NewInnerB, B, NewOuterMonadC, NewOuterC, NewInnerMonadC, NewInnerC, C> ( OuterType ma, Func<A, Task<NewInnerB>> bind, Func<A, B, Task<C>> project) Source #

where NewOuterMonadB : struct, Monad<NewOuterB, NewInnerB>
where NewInnerMonadB : struct, MonadAsync<NewInnerB, B>
where NewOuterMonadC : struct, Monad<NewOuterC, NewInnerC>
where NewInnerMonadC : struct, MonadAsync<NewInnerC, C>

method NewOuterType Bind <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, NewInnerType> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType BindAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<NewInnerType>> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType Map <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method NewOuterType MapAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<B>> f) Source #

where NewOuterMonad : struct, Monad<NewOuterType, NewInnerType>
where NewInnerMonad : struct, MonadAsync<NewInnerType, B>

method Task<S> Fold <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method Task<S> FoldBack <S> (OuterType ma, S state, Func<S, A, S> f) Source #

method Task<S> FoldAsync <S> (OuterType ma, S state, Func<S, A, Task<S>> f) Source #

method Task<S> FoldBackAsync <S> (OuterType ma, S state, Func<S, A, Task<S>> f) Source #

method Task<int> Count (OuterType ma) Source #

method NewOuterType Sequence <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType> (OuterType ma) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, A>

method NewOuterType Traverse <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, B> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method NewOuterType TraverseAsync <NewOuterMonad, NewOuterType, NewInnerMonad, NewInnerType, B> (OuterType ma, Func<A, Task<B>> f) Source #

where NewOuterMonad : struct, MonadAsync<NewOuterType, NewInnerType>
where NewInnerMonad : struct, Monad<NewInnerType, B>

method OuterType Plus (OuterType ma, OuterType mb) Source #

method OuterType Zero () Source #

struct TransSyncAsync <OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Source #

where OuterMonad : struct, Monad<OuterType, InnerType>
where InnerMonad : struct, MonadAsync<InnerType, A>
where NumA : struct, Num<A>

Fields

field TransSyncAsync<OuterMonad, OuterType, InnerMonad, InnerType, NumA, A> Inst Source #

Methods

method Task<A> Sum (OuterType ma) Source #