LanguageExt.Core ► Class Instances ► Applicative

Contents

ApplArr <A, B>

Inst = default(ApplArr<A, B>)
Action (Arr<A> fa, Arr fb)
Apply (Arr<Func<A, B>> fab, Arr<A> fa)
Map (Arr<A> ma, Func<A, B> f)
Pure (A x)

ApplArr <A, B, C>

Inst = default(ApplArr<A, B, C>)
Apply (Arr<Func<A, Func<B, C>>> fabc, Arr<A> fa)
Apply (Arr<Func<A, Func<B, C>>> fabc, Arr<A> fa, Arr fb)
Pure (A x)

ApplArr <A>

Inst = default(ApplArr<A>)
Action (Arr<A> fa, Arr<A> fb)
Apply (Arr<Func<A, A>> fab, Arr<A> fa)
Apply (Arr<Func<A, Func<A, A>>> fabc, Arr<A> fa)
Apply (Arr<Func<A, Func<A, A>>> fabc, Arr<A> fa, Arr<A> fb)
Pure (A x)

ApplArray <A, B>

Inst = default(ApplArray<A, B>)
Action (A[] fa, B[] fb)
Apply (Func<A, B>[] fab, A[] fa)
Map (A[] ma, Func<A, B> f)
Pure (A x)

ApplArray <A, B, C>

Inst = default(ApplArray<A, B, C>)
Apply (Func<A, Func<B, C>>[] fabc, A[] fa)
Apply (Func<A, Func<B, C>>[] fabc, A[] fa, B[] fb)
Pure (A x)

ApplArray <A>

Inst = default(ApplArray<A>)
Action (A[] fa, A[] fb)
Apply (Func<A, A>[] fab, A[] fa)
Apply (Func<A, Func<A, A>>[] fabc, A[] fa)
Apply (Func<A, Func<A, A>>[] fabc, A[] fa, A[] fb)
Pure (A x)

ApplEither <L, R, R2>

Inst = default(ApplEither<L, R, R2>)
BiMap (Either<L, R> ma, Func<L, R2> fa, Func<R, R2> fb)
Map (Either<L, R> ma, Func<R, R2> f)
Apply (Either<L, Func<R, R2>> fab, Either<L, R> fa)
Action (Either<L, R> fa, Either<L, R2> fb)
Pure (R x)

ApplEitherBi <L, R, L2, R2>

Inst = default(ApplEitherBi<L, R, L2, R2>)
BiMap (Either<L, R> ma, Func<L, L2> fa, Func<R, R2> fb)
Apply (Either<L, Func<R, R2>> fab, Either<L, R> fa)
Action (Either<L, R> fa, Either<L, R2> fb)
Pure (R x)

ApplEither <L, A, B, C>

Inst = default(ApplEither<L, A, B, C>)
Apply (Either<L, Func<A, Func<B, C>>> fab, Either<L, A> fa)
Apply (Either<L, Func<A, Func<B, C>>> fab, Either<L, A> fa, Either<L, B> fb)
Pure (A x)

ApplEitherAsync <L, A, B>

Inst = default(ApplEitherAsync<L, A, B>)
Action (EitherAsync<L, A> fa, EitherAsync<L, B> fb)
Apply (EitherAsync<L, Func<A, B>> fab, EitherAsync<L, A> fa)
Map (EitherAsync<L, A> ma, Func<A, B> f)
MapAsync (EitherAsync<L, A> ma, Func<A, Task> f)
PureAsync (Task<A> x)

ApplEitherAsync <L, A, B, C>

Inst = default(ApplEitherAsync<L, A, B, C>)
Apply (EitherAsync<L, Func<A, Func<B, C>>> fabc, EitherAsync<L, A> fa)
Apply (EitherAsync<L, Func<A, Func<B, C>>> fabc, EitherAsync<L, A> fa, EitherAsync<L, B> fb)
PureAsync (Task<A> x)

ApplEitherUnsafe <L, R, R2>

Inst = default(ApplEitherUnsafe<L, R, R2>)
BiMap (EitherUnsafe<L, R> ma, Func<L, R2> fa, Func<R, R2> fb)
Map (EitherUnsafe<L, R> ma, Func<R, R2> f)
Apply (EitherUnsafe<L, Func<R, R2>> fab, EitherUnsafe<L, R> fa)
Action (EitherUnsafe<L, R> fa, EitherUnsafe<L, R2> fb)
Pure (R x)

ApplEitherUnsafeBi <L, R, L2, R2>

Inst = default(ApplEitherUnsafeBi<L, R, L2, R2>)
BiMap (EitherUnsafe<L, R> ma, Func<L, L2> fa, Func<R, R2> fb)
Apply (EitherUnsafe<L, Func<R, R2>> fab, EitherUnsafe<L, R> fa)
Action (EitherUnsafe<L, R> fa, EitherUnsafe<L, R2> fb)
Pure (R x)

ApplEitherUnsafe <L, A, B, C>

Inst = default(ApplEitherUnsafe<L, A, B, C>)
Apply (EitherUnsafe<L, Func<A, Func<B, C>>> fab, EitherUnsafe<L, A> fa)
Apply (EitherUnsafe<L, Func<A, Func<B, C>>> fab, EitherUnsafe<L, A> fa, EitherUnsafe<L, B> fb)
Pure (A x)

ApplEnumerable <A, B>

Inst = default(ApplEnumerable<A, B>)
Action (IEnumerable<A> fa, IEnumerable fb)
Apply (IEnumerable<Func<A, B>> fab, IEnumerable<A> fa)
Map (IEnumerable<A> ma, Func<A, B> f)
Pure (A x)

ApplEnumerable <A, B, C>

Inst = default(ApplEnumerable<A, B, C>)
Apply (IEnumerable<Func<A, Func<B, C>>> fabc, IEnumerable<A> fa)
Apply (IEnumerable<Func<A, Func<B, C>>> fabc, IEnumerable<A> fa, IEnumerable fb)
Pure (A x)

ApplEnumerable <A>

Inst = default(ApplEnumerable<A>)
Action (IEnumerable<A> fa, IEnumerable<A> fb)
Apply (IEnumerable<Func<A, A>> fab, IEnumerable<A> fa)
Apply (IEnumerable<Func<A, Func<A, A>>> fabc, IEnumerable<A> fa)
Apply (IEnumerable<Func<A, Func<A, A>>> fabc, IEnumerable<A> fa, IEnumerable<A> fb)
Pure (A x)

ApplFin <A, B>

Inst = default(ApplFin<A, B>)
BiMap (Fin<A> ma, Func<A, B> fa, Func<Error, B> fb)
Map (Fin<A> ma, Func<A, B> f)
Apply (Fin<Func<A, B>> fab, Fin<A> fa)
Pure (A x)
Action (Fin<A> fa, Fin fb)

ApplFin <A, B, C>

Inst = default(ApplFin<A, B, C>)
Apply (Fin<Func<A, Func<B, C>>> fabc, Fin<A> fa)
Apply (Fin<Func<A, Func<B, C>>> fabc, Fin<A> fa, Fin fb)
Pure (A x)

ApplFin <A>

Inst = default(ApplFin<A>)
BiMap (Fin<A> ma, Func<A, A> fa, Func<Error, A> fb)
Map (Fin<A> ma, Func<A, A> f)
Apply (Fin<Func<A, A>> fab, Fin<A> fa)
Pure (A x)
Action (Fin<A> fa, Fin<A> fb)
Apply (Fin<Func<A, Func<A, A>>> fabc, Fin<A> fa)
Apply (Fin<Func<A, Func<A, A>>> fabc, Fin<A> fa, Fin<A> fb)

ApplHashSet <A, B>

Inst = default(ApplHashSet<A, B>)
Action (HashSet<A> fa, HashSet fb)
Apply (HashSet<Func<A, B>> fab, HashSet<A> fa)
Map (HashSet<A> ma, Func<A, B> f)
Pure (A x)

ApplHashSet <A, B, C>

Inst = default(ApplHashSet<A, B, C>)
Apply (HashSet<Func<A, Func<B, C>>> fabc, HashSet<A> fa)
Apply (HashSet<Func<A, Func<B, C>>> fabc, HashSet<A> fa, HashSet fb)
Pure (A x)

ApplHashSet <A>

Inst = default(ApplHashSet<A>)
Action (HashSet<A> fa, HashSet<A> fb)
Apply (HashSet<Func<A, A>> fab, HashSet<A> fa)
Apply (HashSet<Func<A, Func<A, A>>> fabc, HashSet<A> fa)
Apply (HashSet<Func<A, Func<A, A>>> fabc, HashSet<A> fa, HashSet<A> fb)
Pure (A x)

ApplHashSet <OrdFAB, OrdA, OrdB, A, B>

Inst = default(ApplHashSet<OrdFAB, OrdA, OrdB, A, B>)
Action (HashSet<OrdA, A> fa, HashSet<OrdB, B> fb)
Apply (HashSet<OrdFAB, Func<A, B>> fab, HashSet<OrdA, A> fa)
Map (HashSet<OrdA, A> ma, Func<A, B> f)
Pure (A x)

ApplHashSet <OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C>

Inst = default(ApplHashSet<OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C>)
Apply (HashSet<OrdFABC, Func<A, Func<B, C>>> fabc, HashSet<OrdA, A> fa)
Apply (HashSet<OrdFABC, Func<A, Func<B, C>>> fabc, HashSet<OrdA, A> fa, HashSet<OrdB, B> fb)
Pure (A x)

ApplHashSet <OrdFAAA, OrdFAA, OrdA, A>

Inst = default(ApplHashSet<A>)
Action (HashSet<OrdA, A> fa, HashSet<OrdA, A> fb)
Apply (HashSet<OrdFAA, Func<A, A>> fab, HashSet<OrdA, A> fa)
Apply (HashSet<OrdFAAA, Func<A, Func<A, A>>> fabc, HashSet<OrdA, A> fa)
Apply (HashSet<OrdFAAA, Func<A, Func<A, A>>> fabc, HashSet<OrdA, A> fa, HashSet<OrdA, A> fb)
Pure (A x)

ApplLst <A, B>

Inst = default(ApplLst<A, B>)
Action (Lst<A> fa, Lst fb)
Apply (Lst<Func<A, B>> fab, Lst<A> fa)
Map (Lst<A> ma, Func<A, B> f)
Pure (A x)

ApplLst <A, B, C>

Inst = default(ApplLst<A, B, C>)
Apply (Lst<Func<A, Func<B, C>>> fabc, Lst<A> fa)
Apply (Lst<Func<A, Func<B, C>>> fabc, Lst<A> fa, Lst fb)
Pure (A x)

ApplLst <A>

Inst = default(ApplLst<A>)
Action (Lst<A> fa, Lst<A> fb)
Apply (Lst<Func<A, A>> fab, Lst<A> fa)
Apply (Lst<Func<A, Func<A, A>>> fabc, Lst<A> fa)
Apply (Lst<Func<A, Func<A, A>>> fabc, Lst<A> fa, Lst<A> fb)
Pure (A x)

ApplOption <A, B>

Inst = default(ApplOption<A, B>)
BiMap (Option<A> ma, Func<A, B> fa, Func<Unit, B> fb)
Map (Option<A> ma, Func<A, B> f)
Apply (Option<Func<A, B>> fab, Option<A> fa)
Pure (A x)
Action (Option<A> fa, Option fb)

ApplOption <A, B, C>

Inst = default(ApplOption<A, B, C>)
Apply (Option<Func<A, Func<B, C>>> fab, Option<A> fa)
Apply (Option<Func<A, Func<B, C>>> fab, Option<A> fa, Option fb)
Pure (A x)

ApplOptional <OptionalA, OptionalB, OA, OB, A, B>

Inst = default(ApplOptional<OptionalA, OptionalB, OA, OB, A, B>)
BiMap (OA ma, Func<A, B> fa, Func<Unit, B> fb)
Map (OA ma, Func<A, B> f)

ApplOptional <OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B>

Inst = default(ApplOptional<OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B>)
Action (FA fa, FB fb)
Apply (FAB fab, FA fa)
Pure (A x)

ApplOptional <OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C>

Inst = default(ApplOptional<OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C>)
Apply (FABC fabc, FA fa)
Apply (FABC fabc, FA fa, FB fb)
Pure (A x)

ApplOptionalUnsafe <OptionalA, OptionalB, OA, OB, A, B>

Inst = default(ApplOptionalUnsafe<OptionalA, OptionalB, OA, OB, A, B>)
BiMap (OA ma, Func<A, B> fa, Func<Unit, B> fb)
Map (OA ma, Func<A, B> f)

ApplOptionalUnsafe <OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B>

Inst = default(ApplOptionalUnsafe<OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B>)
Action (FA fa, FB fb)
Apply (FAB fab, FA fa)
Pure (A x)

ApplOptionalUnsafe <OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C>

Inst = default(ApplOptionalUnsafe<OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C>)
Apply (FABC fabc, FA fa)
Apply (FABC fabc, FA fa, FB fb)
Pure (A x)

ApplOptionAsync <A, B>

Inst = default(ApplOptionAsync<A, B>)
Map (OptionAsync<A> ma, Func<A, B> f)
MapAsync (OptionAsync<A> ma, Func<A, Task> f)
Apply (OptionAsync<Func<A, B>> fab, OptionAsync<A> fa)
Apply (Func<A, B> fab, OptionAsync<A> fa)
Apply (Func<A, A, B> fab, OptionAsync<A> fa, OptionAsync<A> fb)
PureAsync (Task<A> x)
Action (OptionAsync<A> fa, OptionAsync fb)

ApplOptionAsync <A, B, C>

Inst = default(ApplOptionAsync<A, B, C>)
Apply (OptionAsync<Func<A, Func<B, C>>> fab, OptionAsync<A> fa)
Apply (OptionAsync<Func<A, Func<B, C>>> fab, OptionAsync<A> fa, OptionAsync fb)
Apply (Func<A, Func<B, C>> fab, OptionAsync<A> fa)
Apply (Func<A, Func<B, C>> fab, OptionAsync<A> fa, OptionAsync fb)
PureAsync (Task<A> x)

ApplOptionUnsafe <A, B>

Inst = default(ApplOptionUnsafe<A, B>)
BiMap (OptionUnsafe<A> ma, Func<A, B> fa, Func<Unit, B> fb)
Map (OptionUnsafe<A> ma, Func<A, B> f)
Apply (OptionUnsafe<Func<A, B>> fab, OptionUnsafe<A> fa)
Pure (A x)
Action (OptionUnsafe<A> fa, OptionUnsafe fb)

ApplOptionUnsafe <A, B, C>

Inst = default(ApplOptionUnsafe<A, B, C>)
Apply (OptionUnsafe<Func<A, Func<B, C>>> fab, OptionUnsafe<A> fa)
Apply (OptionUnsafe<Func<A, Func<B, C>>> fab, OptionUnsafe<A> fa, OptionUnsafe fb)
Pure (A x)

ApplSeq <A, B>

Inst = default(ApplSeq<A, B>)
Action (Seq<A> fa, Seq fb)
Apply (Seq<Func<A, B>> fab, Seq<A> fa)
Map (Seq<A> ma, Func<A, B> f)
Pure (A x)

ApplSeq <A, B, C>

Inst = default(ApplSeq<A, B, C>)
Apply (Seq<Func<A, Func<B, C>>> fabc, Seq<A> fa)
Apply (Seq<Func<A, Func<B, C>>> fabc, Seq<A> fa, Seq fb)
Pure (A x)

ApplSeq <A>

Inst = default(ApplSeq<A>)
Action (Seq<A> fa, Seq<A> fb)
Apply (Seq<Func<A, A>> fab, Seq<A> fa)
Apply (Seq<Func<A, Func<A, A>>> fabc, Seq<A> fa)
Apply (Seq<Func<A, Func<A, A>>> fabc, Seq<A> fa, Seq<A> fb)
Pure (A x)

ApplSet <A, B>

Inst = default(ApplSet<A, B>)
Action (Set<A> fa, Set fb)
Apply (Set<Func<A, B>> fab, Set<A> fa)
Map (Set<A> ma, Func<A, B> f)
Pure (A x)

ApplSet <A, B, C>

Inst = default(ApplSet<A, B, C>)
Apply (Set<Func<A, Func<B, C>>> fabc, Set<A> fa)
Apply (Set<Func<A, Func<B, C>>> fabc, Set<A> fa, Set fb)
Pure (A x)

ApplSet <A>

Inst = default(ApplSet<A>)
Action (Set<A> fa, Set<A> fb)
Apply (Set<Func<A, A>> fab, Set<A> fa)
Apply (Set<Func<A, Func<A, A>>> fabc, Set<A> fa)
Apply (Set<Func<A, Func<A, A>>> fabc, Set<A> fa, Set<A> fb)
Pure (A x)

ApplSet <OrdFAB, OrdA, OrdB, A, B>

Inst = default(ApplSet<OrdFAB, OrdA, OrdB, A, B>)
Action (Set<OrdA, A> fa, Set<OrdB, B> fb)
Apply (Set<OrdFAB, Func<A, B>> fab, Set<OrdA, A> fa)
Map (Set<OrdA, A> ma, Func<A, B> f)
Pure (A x)

ApplSet <OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C>

Inst = default(ApplSet<OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C>)
Apply (Set<OrdFABC, Func<A, Func<B, C>>> fabc, Set<OrdA, A> fa)
Apply (Set<OrdFABC, Func<A, Func<B, C>>> fabc, Set<OrdA, A> fa, Set<OrdB, B> fb)
Pure (A x)

ApplSet <OrdFAAA, OrdFAA, OrdA, A>

Inst = default(ApplSet<A>)
Action (Set<OrdA, A> fa, Set<OrdA, A> fb)
Apply (Set<OrdFAA, Func<A, A>> fab, Set<OrdA, A> fa)
Apply (Set<OrdFAAA, Func<A, Func<A, A>>> fabc, Set<OrdA, A> fa)
Apply (Set<OrdFAAA, Func<A, Func<A, A>>> fabc, Set<OrdA, A> fa, Set<OrdA, A> fb)
Pure (A x)

ApplTask <A, B>

Inst = default(ApplTask<A, B>)
Map (Task<A> ma, Func<A, B> f)
MapAsync (Task<A> ma, Func<A, Task> f)
Apply (Task<Func<A, B>> fab, Task<A> fa)
Apply (Task<Func<A, A, B>> fab, Task<A> fa, Task<A> fb)
Apply (Func<A, A, B> fab, Task<A> fa, Task<A> fb)
PureAsync (Task<A> x)
Action (Task<A> fa, Task fb)

ApplTask <A, B, C>

Inst = default(ApplTask<A, B, C>)
Apply (Task<Func<A, Func<B, C>>> fabc, Task<A> fa)
Apply (Task<Func<A, Func<B, C>>> fabc, Task<A> fa, Task fb)
PureAsync (Task<A> x)

ApplTask <A>

Inst = default(ApplTask<A>)
Map (Task<A> ma, Func<A, A> f)
MapAsync (Task<A> ma, Func<A, Task<A>> f)
Apply (Task<Func<A, A>> fab, Task<A> fa)
PureAsync (Task<A> x)
Action (Task<A> fa, Task<A> fb)
Apply (Task<Func<A, Func<A, A>>> fabc, Task<A> fa)
Apply (Task<Func<A, Func<A, A>>> fabc, Task<A> fa, Task<A> fb)

ApplTry <A, B>

Inst = default(ApplTry<A, B>)
BiMap (Try<A> ma, Func<A, B> fa, Func<Unit, B> fb)
Map (Try<A> ma, Func<A, B> f)
Apply (Try<Func<A, B>> fab, Try<A> fa)
Pure (A x)
Action (Try<A> fa, Try fb)

ApplTry <A, B, C>

Inst = default(ApplTry<A, B, C>)
Apply (Try<Func<A, Func<B, C>>> fabc, Try<A> fa)
Apply (Try<Func<A, Func<B, C>>> fabc, Try<A> fa, Try fb)
Pure (A x)

ApplTry <A>

Inst = default(ApplTry<A>)
BiMap (Try<A> ma, Func<A, A> fa, Func<Unit, A> fb)
Map (Try<A> ma, Func<A, A> f)
Apply (Try<Func<A, A>> fab, Try<A> fa)
Pure (A x)
Action (Try<A> fa, Try<A> fb)
Apply (Try<Func<A, Func<A, A>>> fabc, Try<A> fa)
Apply (Try<Func<A, Func<A, A>>> fabc, Try<A> fa, Try<A> fb)

ApplTryAsync <A, B>

Inst = default(ApplTryAsync<A, B>)
Map (TryAsync<A> ma, Func<A, B> f)
MapAsync (TryAsync<A> ma, Func<A, Task> f)
Apply (TryAsync<Func<A, B>> fab, TryAsync<A> fa)
PureAsync (Task<A> x)
Action (TryAsync<A> fa, TryAsync fb)

ApplTryAsync <A, B, C>

Inst = default(ApplTryAsync<A, B, C>)
Apply (TryAsync<Func<A, Func<B, C>>> fabc, TryAsync<A> fa)
Apply (TryAsync<Func<A, Func<B, C>>> fabc, TryAsync<A> fa, TryAsync fb)
PureAsync (Task<A> x)

ApplTryAsync <A>

Inst = default(ApplTryAsync<A>)
Map (TryAsync<A> ma, Func<A, A> f)
MapAsync (TryAsync<A> ma, Func<A, Task<A>> f)
Apply (TryAsync<Func<A, A>> fab, TryAsync<A> fa)
PureAsync (Task<A> x)
Action (TryAsync<A> fa, TryAsync<A> fb)
Apply (TryAsync<Func<A, Func<A, A>>> fabc, TryAsync<A> fa)
Apply (TryAsync<Func<A, Func<A, A>>> fabc, TryAsync<A> fa, TryAsync<A> fb)

ApplTryOption <A, B>

Inst = default(ApplTryOption<A, B>)
BiMap (TryOption<A> ma, Func<A, B> fa, Func<Unit, B> fb)
Map (TryOption<A> ma, Func<A, B> f)
Apply (TryOption<Func<A, B>> fab, TryOption<A> fa)
Pure (A x)
Action (TryOption<A> fa, TryOption fb)

ApplTryOption <A, B, C>

Inst = default(ApplTryOption<A, B, C>)
Apply (TryOption<Func<A, Func<B, C>>> fabc, TryOption<A> fa)
Apply (TryOption<Func<A, Func<B, C>>> fabc, TryOption<A> fa, TryOption fb)
Pure (A x)

ApplTryOption <A>

Inst = default(ApplTryOption<A>)
BiMap (TryOption<A> ma, Func<A, A> fa, Func<Unit, A> fb)
Map (TryOption<A> ma, Func<A, A> f)
Apply (TryOption<Func<A, A>> fab, TryOption<A> fa)
Pure (A x)
Action (TryOption<A> fa, TryOption<A> fb)
Apply (TryOption<Func<A, Func<A, A>>> fabc, TryOption<A> fa)
Apply (TryOption<Func<A, Func<A, A>>> fabc, TryOption<A> fa, TryOption<A> fb)

ApplTryOptionAsync <A, B>

Inst = default(ApplTryOptionAsync<A, B>)
Map (TryOptionAsync<A> ma, Func<A, B> f)
MapAsync (TryOptionAsync<A> ma, Func<A, Task> f)
Apply (TryOptionAsync<Func<A, B>> fab, TryOptionAsync<A> fa)
Apply (Func<A, B> fab, TryOptionAsync<A> fa)
Apply (TryOptionAsync<Func<A, A, B>> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb)
Apply (Func<A, A, B> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb)
ApplyOption (Func<Option<A>, Option<A>, B> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb)
ApplyOption (TryOptionAsync<Func<Option<A>, Option<A>, B>> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb)
PureAsync (Task<A> x)
Action (TryOptionAsync<A> fa, TryOptionAsync fb)

ApplTryOptionAsync <A, B, C>

Inst = default(ApplTryOptionAsync<A, B, C>)
Apply (TryOptionAsync<Func<A, Func<B, C>>> fabc, TryOptionAsync<A> fa)
Apply (TryOptionAsync<Func<A, Func<B, C>>> fabc, TryOptionAsync<A> fa, TryOptionAsync fb)
PureAsync (Task<A> x)

ApplTryOptionAsync <A>

Inst = default(ApplTryOptionAsync<A>)
Map (TryOptionAsync<A> ma, Func<A, A> f)
MapAsync (TryOptionAsync<A> ma, Func<A, Task<A>> f)
Apply (TryOptionAsync<Func<A, A>> fab, TryOptionAsync<A> fa)
PureAsync (Task<A> x)
Action (TryOptionAsync<A> fa, TryOptionAsync<A> fb)
Apply (TryOptionAsync<Func<A, Func<A, A>>> fabc, TryOptionAsync<A> fa)
Apply (TryOptionAsync<Func<A, Func<A, A>>> fabc, TryOptionAsync<A> fa, TryOptionAsync<A> fb)

ApplValidation <FAIL, SUCCESS, SUCCESS2>

Inst = default(ApplValidation<FAIL, SUCCESS, SUCCESS2>)
BiMap (Validation<FAIL, SUCCESS> ma, Func<Seq<FAIL>, SUCCESS2> fa, Func<SUCCESS, SUCCESS2> fb)
Map (Validation<FAIL, SUCCESS> ma, Func<SUCCESS, SUCCESS2> f)
Apply (Validation<FAIL, Func<SUCCESS, SUCCESS2>> fab, Validation<FAIL, SUCCESS> fa)
Action (Validation<FAIL, SUCCESS> fa, Validation<FAIL, SUCCESS2> fb)
Pure (SUCCESS x)

ApplValidationBi <FAIL, SUCCESS, FAIL2, SUCCESS2>

Inst = default(ApplValidationBi<FAIL, SUCCESS, FAIL2, SUCCESS2>)
BiMap (Validation<FAIL, SUCCESS> ma, Func<FAIL, FAIL2> fa, Func<SUCCESS, SUCCESS2> fb)
Apply (Validation<FAIL, Func<SUCCESS, SUCCESS2>> fab, Validation<FAIL, SUCCESS> fa)
Action (Validation<FAIL, SUCCESS> fa, Validation<FAIL, SUCCESS2> fb)
Pure (SUCCESS x)

ApplValidation <FAIL, A, B, C>

Inst = default(ApplValidation<FAIL, A, B, C>)
Apply (Validation<FAIL, Func<A, Func<B, C>>> fab, Validation<FAIL, A> fa)
Apply (Validation<FAIL, Func<A, Func<B, C>>> fab, Validation<FAIL, A> fa, Validation<FAIL, B> fb)
Pure (A x)

ApplValueTask <A, B>

Inst = default(ApplValueTask<A, B>)
Map (ValueTask<A> ma, Func<A, B> f)
MapAsync (ValueTask<A> ma, Func<A, Task> f)
Apply (ValueTask<Func<A, B>> fab, ValueTask<A> fa)
Apply (ValueTask<Func<A, A, B>> fab, ValueTask<A> fa, ValueTask<A> fb)
Apply (Func<A, A, B> fab, ValueTask<A> fa, ValueTask<A> fb)
PureAsync (Task<A> x)
Action (ValueTask<A> fa, ValueTask fb)

ApplValueTask <A, B, C>

Inst = default(ApplValueTask<A, B, C>)
Apply (ValueTask<Func<A, Func<B, C>>> fabc, ValueTask<A> fa)
Apply (ValueTask<Func<A, Func<B, C>>> fabc, ValueTask<A> fa, ValueTask fb)
PureAsync (Task<A> x)

ApplValueTask <A>

Inst = default(ApplValueTask<A>)
Map (ValueTask<A> ma, Func<A, A> f)
MapAsync (ValueTask<A> ma, Func<A, Task<A>> f)
Apply (ValueTask<Func<A, A>> fab, ValueTask<A> fa)
PureAsync (Task<A> x)
Action (ValueTask<A> fa, ValueTask<A> fb)
Apply (ValueTask<Func<A, Func<A, A>>> fabc, ValueTask<A> fa)
Apply (ValueTask<Func<A, Func<A, A>>> fabc, ValueTask<A> fa, ValueTask<A> fb)

struct ApplArr <A, B> Source #

Fields

field ApplArr<A, B> Inst = default(ApplArr<A, B>) Source #

Methods

method Arr Action (Arr<A> fa, Arr fb) Source #

method Arr Apply (Arr<Func<A, B>> fab, Arr<A> fa) Source #

method Arr Map (Arr<A> ma, Func<A, B> f) Source #

method Arr<A> Pure (A x) Source #

struct ApplArr <A, B, C> Source #

Fields

field ApplArr<A, B, C> Inst = default(ApplArr<A, B, C>) Source #

Methods

method Arr<Func<B, C>> Apply (Arr<Func<A, Func<B, C>>> fabc, Arr<A> fa) Source #

method Arr<C> Apply (Arr<Func<A, Func<B, C>>> fabc, Arr<A> fa, Arr fb) Source #

method Arr<A> Pure (A x) Source #

struct ApplArr <A> Source #

Fields

field ApplArr<A> Inst = default(ApplArr<A>) Source #

Methods

method Arr<A> Action (Arr<A> fa, Arr<A> fb) Source #

method Arr<A> Apply (Arr<Func<A, A>> fab, Arr<A> fa) Source #

method Arr<Func<A, A>> Apply (Arr<Func<A, Func<A, A>>> fabc, Arr<A> fa) Source #

method Arr<A> Apply (Arr<Func<A, Func<A, A>>> fabc, Arr<A> fa, Arr<A> fb) Source #

method Arr<A> Pure (A x) Source #

struct ApplArray <A, B> Source #

Fields

field ApplArray<A, B> Inst = default(ApplArray<A, B>) Source #

Methods

method B[] Action (A[] fa, B[] fb) Source #

method B[] Apply (Func<A, B>[] fab, A[] fa) Source #

method B[] Map (A[] ma, Func<A, B> f) Source #

method A[] Pure (A x) Source #

struct ApplArray <A, B, C> Source #

Fields

field ApplArray<A, B, C> Inst = default(ApplArray<A, B, C>) Source #

Methods

method Func<B, C>[] Apply (Func<A, Func<B, C>>[] fabc, A[] fa) Source #

method C[] Apply (Func<A, Func<B, C>>[] fabc, A[] fa, B[] fb) Source #

method A[] Pure (A x) Source #

struct ApplArray <A> Source #

Fields

field ApplArray<A> Inst = default(ApplArray<A>) Source #

Methods

method A[] Action (A[] fa, A[] fb) Source #

method A[] Apply (Func<A, A>[] fab, A[] fa) Source #

method Func<A, A>[] Apply (Func<A, Func<A, A>>[] fabc, A[] fa) Source #

method A[] Apply (Func<A, Func<A, A>>[] fabc, A[] fa, A[] fb) Source #

method A[] Pure (A x) Source #

struct ApplEither <L, R, R2> Source #

Fields

field ApplEither<L, R, R2> Inst = default(ApplEither<L, R, R2>) Source #

Methods

method Either<L, R2> BiMap (Either<L, R> ma, Func<L, R2> fa, Func<R, R2> fb) Source #

method Either<L, R2> Map (Either<L, R> ma, Func<R, R2> f) Source #

method Either<L, R2> Apply (Either<L, Func<R, R2>> fab, Either<L, R> fa) Source #

method Either<L, R2> Action (Either<L, R> fa, Either<L, R2> fb) Source #

method Either<L, R> Pure (R x) Source #

struct ApplEitherBi <L, R, L2, R2> Source #

Fields

field ApplEitherBi<L, R, L2, R2> Inst = default(ApplEitherBi<L, R, L2, R2>) Source #

Methods

method Either<L2, R2> BiMap (Either<L, R> ma, Func<L, L2> fa, Func<R, R2> fb) Source #

method Either<L, R2> Apply (Either<L, Func<R, R2>> fab, Either<L, R> fa) Source #

method Either<L, R2> Action (Either<L, R> fa, Either<L, R2> fb) Source #

method Either<L, R> Pure (R x) Source #

struct ApplEither <L, A, B, C> Source #

Fields

field ApplEither<L, A, B, C> Inst = default(ApplEither<L, A, B, C>) Source #

Methods

method Either<L, Func<B, C>> Apply (Either<L, Func<A, Func<B, C>>> fab, Either<L, A> fa) Source #

method Either<L, C> Apply (Either<L, Func<A, Func<B, C>>> fab, Either<L, A> fa, Either<L, B> fb) Source #

method Either<L, A> Pure (A x) Source #

struct ApplEitherAsync <L, A, B> Source #

Fields

field ApplEitherAsync<L, A, B> Inst = default(ApplEitherAsync<L, A, B>) Source #

Methods

method EitherAsync<L, B> Action (EitherAsync<L, A> fa, EitherAsync<L, B> fb) Source #

method EitherAsync<L, B> Apply (EitherAsync<L, Func<A, B>> fab, EitherAsync<L, A> fa) Source #

method EitherAsync<L, B> Map (EitherAsync<L, A> ma, Func<A, B> f) Source #

method EitherAsync<L, B> MapAsync (EitherAsync<L, A> ma, Func<A, Task> f) Source #

method EitherAsync<L, A> PureAsync (Task<A> x) Source #

struct ApplEitherAsync <L, A, B, C> Source #

Fields

field ApplEitherAsync<L, A, B, C> Inst = default(ApplEitherAsync<L, A, B, C>) Source #

Methods

method EitherAsync<L, Func<B, C>> Apply (EitherAsync<L, Func<A, Func<B, C>>> fabc, EitherAsync<L, A> fa) Source #

method EitherAsync<L, C> Apply (EitherAsync<L, Func<A, Func<B, C>>> fabc, EitherAsync<L, A> fa, EitherAsync<L, B> fb) Source #

method EitherAsync<L, A> PureAsync (Task<A> x) Source #

struct ApplEitherUnsafe <L, R, R2> Source #

Fields

field ApplEitherUnsafe<L, R, R2> Inst = default(ApplEitherUnsafe<L, R, R2>) Source #

Methods

method EitherUnsafe<L, R2> BiMap (EitherUnsafe<L, R> ma, Func<L, R2> fa, Func<R, R2> fb) Source #

method EitherUnsafe<L, R2> Map (EitherUnsafe<L, R> ma, Func<R, R2> f) Source #

method EitherUnsafe<L, R2> Apply (EitherUnsafe<L, Func<R, R2>> fab, EitherUnsafe<L, R> fa) Source #

method EitherUnsafe<L, R2> Action (EitherUnsafe<L, R> fa, EitherUnsafe<L, R2> fb) Source #

method EitherUnsafe<L, R> Pure (R x) Source #

struct ApplEitherUnsafeBi <L, R, L2, R2> Source #

Fields

field ApplEitherUnsafeBi<L, R, L2, R2> Inst = default(ApplEitherUnsafeBi<L, R, L2, R2>) Source #

Methods

method EitherUnsafe<L2, R2> BiMap (EitherUnsafe<L, R> ma, Func<L, L2> fa, Func<R, R2> fb) Source #

method EitherUnsafe<L, R2> Apply (EitherUnsafe<L, Func<R, R2>> fab, EitherUnsafe<L, R> fa) Source #

method EitherUnsafe<L, R2> Action (EitherUnsafe<L, R> fa, EitherUnsafe<L, R2> fb) Source #

method EitherUnsafe<L, R> Pure (R x) Source #

struct ApplEitherUnsafe <L, A, B, C> Source #

Fields

field ApplEitherUnsafe<L, A, B, C> Inst = default(ApplEitherUnsafe<L, A, B, C>) Source #

Methods

method EitherUnsafe<L, Func<B, C>> Apply (EitherUnsafe<L, Func<A, Func<B, C>>> fab, EitherUnsafe<L, A> fa) Source #

method EitherUnsafe<L, C> Apply (EitherUnsafe<L, Func<A, Func<B, C>>> fab, EitherUnsafe<L, A> fa, EitherUnsafe<L, B> fb) Source #

method EitherUnsafe<L, A> Pure (A x) Source #

struct ApplEnumerable <A, B> Source #

Fields

field ApplEnumerable<A, B> Inst = default(ApplEnumerable<A, B>) Source #

Methods

method IEnumerable Action (IEnumerable<A> fa, IEnumerable fb) Source #

method IEnumerable Apply (IEnumerable<Func<A, B>> fab, IEnumerable<A> fa) Source #

method IEnumerable Map (IEnumerable<A> ma, Func<A, B> f) Source #

method IEnumerable<A> Pure (A x) Source #

struct ApplEnumerable <A, B, C> Source #

Fields

field ApplEnumerable<A, B, C> Inst = default(ApplEnumerable<A, B, C>) Source #

Methods

method IEnumerable<Func<B, C>> Apply (IEnumerable<Func<A, Func<B, C>>> fabc, IEnumerable<A> fa) Source #

method IEnumerable<C> Apply (IEnumerable<Func<A, Func<B, C>>> fabc, IEnumerable<A> fa, IEnumerable fb) Source #

method IEnumerable<A> Pure (A x) Source #

struct ApplEnumerable <A> Source #

Fields

field ApplEnumerable<A> Inst = default(ApplEnumerable<A>) Source #

Methods

method IEnumerable<A> Action (IEnumerable<A> fa, IEnumerable<A> fb) Source #

method IEnumerable<A> Apply (IEnumerable<Func<A, A>> fab, IEnumerable<A> fa) Source #

method IEnumerable<Func<A, A>> Apply (IEnumerable<Func<A, Func<A, A>>> fabc, IEnumerable<A> fa) Source #

method IEnumerable<A> Apply (IEnumerable<Func<A, Func<A, A>>> fabc, IEnumerable<A> fa, IEnumerable<A> fb) Source #

method IEnumerable<A> Pure (A x) Source #

struct ApplFin <A, B> Source #

Fields

field ApplFin<A, B> Inst = default(ApplFin<A, B>) Source #

Methods

method Fin BiMap (Fin<A> ma, Func<A, B> fa, Func<Error, B> fb) Source #

method Fin Map (Fin<A> ma, Func<A, B> f) Source #

method Fin Apply (Fin<Func<A, B>> fab, Fin<A> fa) Source #

method Fin<A> Pure (A x) Source #

method Fin Action (Fin<A> fa, Fin fb) Source #

struct ApplFin <A, B, C> Source #

Fields

field ApplFin<A, B, C> Inst = default(ApplFin<A, B, C>) Source #

Methods

method Fin<Func<B, C>> Apply (Fin<Func<A, Func<B, C>>> fabc, Fin<A> fa) Source #

method Fin<C> Apply (Fin<Func<A, Func<B, C>>> fabc, Fin<A> fa, Fin fb) Source #

method Fin<A> Pure (A x) Source #

struct ApplFin <A> Source #

Fields

field ApplFin<A> Inst = default(ApplFin<A>) Source #

Methods

method Fin<A> BiMap (Fin<A> ma, Func<A, A> fa, Func<Error, A> fb) Source #

method Fin<A> Map (Fin<A> ma, Func<A, A> f) Source #

method Fin<A> Apply (Fin<Func<A, A>> fab, Fin<A> fa) Source #

method Fin<A> Pure (A x) Source #

method Fin<A> Action (Fin<A> fa, Fin<A> fb) Source #

method Fin<Func<A, A>> Apply (Fin<Func<A, Func<A, A>>> fabc, Fin<A> fa) Source #

method Fin<A> Apply (Fin<Func<A, Func<A, A>>> fabc, Fin<A> fa, Fin<A> fb) Source #

struct ApplHashSet <A, B> Source #

Fields

field ApplHashSet<A, B> Inst = default(ApplHashSet<A, B>) Source #

Methods

method HashSet Action (HashSet<A> fa, HashSet fb) Source #

method HashSet Apply (HashSet<Func<A, B>> fab, HashSet<A> fa) Source #

method HashSet Map (HashSet<A> ma, Func<A, B> f) Source #

method HashSet<A> Pure (A x) Source #

struct ApplHashSet <A, B, C> Source #

Fields

field ApplHashSet<A, B, C> Inst = default(ApplHashSet<A, B, C>) Source #

Methods

method HashSet<Func<B, C>> Apply (HashSet<Func<A, Func<B, C>>> fabc, HashSet<A> fa) Source #

method HashSet<C> Apply (HashSet<Func<A, Func<B, C>>> fabc, HashSet<A> fa, HashSet fb) Source #

method HashSet<A> Pure (A x) Source #

struct ApplHashSet <A> Source #

Fields

field ApplHashSet<A> Inst = default(ApplHashSet<A>) Source #

Methods

method HashSet<A> Action (HashSet<A> fa, HashSet<A> fb) Source #

method HashSet<A> Apply (HashSet<Func<A, A>> fab, HashSet<A> fa) Source #

method HashSet<Func<A, A>> Apply (HashSet<Func<A, Func<A, A>>> fabc, HashSet<A> fa) Source #

method HashSet<A> Apply (HashSet<Func<A, Func<A, A>>> fabc, HashSet<A> fa, HashSet<A> fb) Source #

method HashSet<A> Pure (A x) Source #

struct ApplHashSet <OrdFAB, OrdA, OrdB, A, B> Source #

where OrdA : struct, Ord<A>

where OrdB : struct, Ord

where OrdFAB : struct, Ord<Func<A, B>>

Fields

field ApplHashSet<OrdFAB, OrdA, OrdB, A, B> Inst = default(ApplHashSet<OrdFAB, OrdA, OrdB, A, B>) Source #

Methods

method HashSet<OrdB, B> Action (HashSet<OrdA, A> fa, HashSet<OrdB, B> fb) Source #

method HashSet<OrdB, B> Apply (HashSet<OrdFAB, Func<A, B>> fab, HashSet<OrdA, A> fa) Source #

method HashSet<OrdB, B> Map (HashSet<OrdA, A> ma, Func<A, B> f) Source #

method HashSet<OrdA, A> Pure (A x) Source #

struct ApplHashSet <OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C> Source #

where OrdA : struct, Ord<A>

where OrdB : struct, Ord

where OrdC : struct, Ord<C>

where OrdFABC : struct, Ord<Func<A, Func<B, C>>>

where OrdFBC : struct, Ord<Func<B, C>>

Fields

field ApplHashSet<OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C> Inst = default(ApplHashSet<OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C>) Source #

Methods

method HashSet<OrdFBC, Func<B, C>> Apply (HashSet<OrdFABC, Func<A, Func<B, C>>> fabc, HashSet<OrdA, A> fa) Source #

method HashSet<OrdC, C> Apply (HashSet<OrdFABC, Func<A, Func<B, C>>> fabc, HashSet<OrdA, A> fa, HashSet<OrdB, B> fb) Source #

method HashSet<OrdA, A> Pure (A x) Source #

struct ApplHashSet <OrdFAAA, OrdFAA, OrdA, A> Source #

where OrdA : struct, Ord<A>

where OrdFAAA : struct, Ord<Func<A, Func<A, A>>>

where OrdFAA : struct, Ord<Func<A, A>>

Fields

field ApplHashSet<A> Inst = default(ApplHashSet<A>) Source #

Methods

method HashSet<OrdA, A> Action (HashSet<OrdA, A> fa, HashSet<OrdA, A> fb) Source #

method HashSet<OrdA, A> Apply (HashSet<OrdFAA, Func<A, A>> fab, HashSet<OrdA, A> fa) Source #

method HashSet<OrdFAA, Func<A, A>> Apply (HashSet<OrdFAAA, Func<A, Func<A, A>>> fabc, HashSet<OrdA, A> fa) Source #

method HashSet<OrdA, A> Apply (HashSet<OrdFAAA, Func<A, Func<A, A>>> fabc, HashSet<OrdA, A> fa, HashSet<OrdA, A> fb) Source #

method HashSet<OrdA, A> Pure (A x) Source #

struct ApplLst <A, B> Source #

Fields

field ApplLst<A, B> Inst = default(ApplLst<A, B>) Source #

Methods

method Lst Action (Lst<A> fa, Lst fb) Source #

method Lst Apply (Lst<Func<A, B>> fab, Lst<A> fa) Source #

method Lst Map (Lst<A> ma, Func<A, B> f) Source #

method Lst<A> Pure (A x) Source #

struct ApplLst <A, B, C> Source #

Fields

field ApplLst<A, B, C> Inst = default(ApplLst<A, B, C>) Source #

Methods

method Lst<Func<B, C>> Apply (Lst<Func<A, Func<B, C>>> fabc, Lst<A> fa) Source #

method Lst<C> Apply (Lst<Func<A, Func<B, C>>> fabc, Lst<A> fa, Lst fb) Source #

method Lst<A> Pure (A x) Source #

struct ApplLst <A> Source #

Fields

field ApplLst<A> Inst = default(ApplLst<A>) Source #

Methods

method Lst<A> Action (Lst<A> fa, Lst<A> fb) Source #

method Lst<A> Apply (Lst<Func<A, A>> fab, Lst<A> fa) Source #

method Lst<Func<A, A>> Apply (Lst<Func<A, Func<A, A>>> fabc, Lst<A> fa) Source #

method Lst<A> Apply (Lst<Func<A, Func<A, A>>> fabc, Lst<A> fa, Lst<A> fb) Source #

method Lst<A> Pure (A x) Source #

struct ApplOption <A, B> Source #

Fields

field ApplOption<A, B> Inst = default(ApplOption<A, B>) Source #

Methods

method Option BiMap (Option<A> ma, Func<A, B> fa, Func<Unit, B> fb) Source #

method Option Map (Option<A> ma, Func<A, B> f) Source #

method Option Apply (Option<Func<A, B>> fab, Option<A> fa) Source #

method Option<A> Pure (A x) Source #

method Option Action (Option<A> fa, Option fb) Source #

struct ApplOption <A, B, C> Source #

Fields

field ApplOption<A, B, C> Inst = default(ApplOption<A, B, C>) Source #

Methods

method Option<Func<B, C>> Apply (Option<Func<A, Func<B, C>>> fab, Option<A> fa) Source #

method Option<C> Apply (Option<Func<A, Func<B, C>>> fab, Option<A> fa, Option fb) Source #

method Option<A> Pure (A x) Source #

struct ApplOptional <OptionalA, OptionalB, OA, OB, A, B> Source #

where OptionalA : struct, Optional<OA, A>

where OptionalB : struct, Optional<OB, B>

Fields

field ApplOptional<OptionalA, OptionalB, OA, OB, A, B> Inst = default(ApplOptional<OptionalA, OptionalB, OA, OB, A, B>) Source #

Methods

method OB BiMap (OA ma, Func<A, B> fa, Func<Unit, B> fb) Source #

method OB Map (OA ma, Func<A, B> f) Source #

struct ApplOptional <OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B> Source #

where OptionFAB : struct, Optional<FAB, Func<A, B>>

where OptionFA : struct, Optional<FA, A>

where OptionFB : struct, Optional<FB, B>

Fields

field ApplOptional<OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B> Inst = default(ApplOptional<OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B>) Source #

Methods

method FB Action (FA fa, FB fb) Source #

method FB Apply (FAB fab, FA fa) Source #

method FA Pure (A x) Source #

struct ApplOptional <OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C> Source #

where OptionFABC : struct, Optional<FABC, Func<A, Func<B, C>>>

where OptionFBC : struct, Optional<FBC, Func<B, C>>

where OptionFA : struct, Optional<FA, A>

where OptionFB : struct, Optional<FB, B>

where OptionFC : struct, Optional<FC, C>

Fields

field ApplOptional<OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C> Inst = default(ApplOptional<OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C>) Source #

Methods

method FBC Apply (FABC fabc, FA fa) Source #

method FC Apply (FABC fabc, FA fa, FB fb) Source #

method FA Pure (A x) Source #

struct ApplOptionalUnsafe <OptionalA, OptionalB, OA, OB, A, B> Source #

where OptionalA : struct, OptionalUnsafe<OA, A>

where OptionalB : struct, OptionalUnsafe<OB, B>

Fields

field ApplOptionalUnsafe<OptionalA, OptionalB, OA, OB, A, B> Inst = default(ApplOptionalUnsafe<OptionalA, OptionalB, OA, OB, A, B>) Source #

Methods

method OB BiMap (OA ma, Func<A, B> fa, Func<Unit, B> fb) Source #

method OB Map (OA ma, Func<A, B> f) Source #

struct ApplOptionalUnsafe <OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B> Source #

where OptionFAB : struct, OptionalUnsafe<FAB, Func<A, B>>

where OptionFA : struct, OptionalUnsafe<FA, A>

where OptionFB : struct, OptionalUnsafe<FB, B>

Fields

field ApplOptionalUnsafe<OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B> Inst = default(ApplOptionalUnsafe<OptionFAB, OptionFA, OptionFB, FAB, FA, FB, A, B>) Source #

Methods

method FB Action (FA fa, FB fb) Source #

method FB Apply (FAB fab, FA fa) Source #

method FA Pure (A x) Source #

struct ApplOptionalUnsafe <OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C> Source #

where OptionFABC : struct, OptionalUnsafe<FABC, Func<A, Func<B, C>>>

where OptionFBC : struct, OptionalUnsafe<FBC, Func<B, C>>

where OptionFA : struct, OptionalUnsafe<FA, A>

where OptionFB : struct, OptionalUnsafe<FB, B>

where OptionFC : struct, OptionalUnsafe<FC, C>

Fields

field ApplOptionalUnsafe<OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C> Inst = default(ApplOptionalUnsafe<OptionFABC, OptionFBC, OptionFA, OptionFB, OptionFC, FABC, FBC, FA, FB, FC, A, B, C>) Source #

Methods

method FBC Apply (FABC fabc, FA fa) Source #

method FC Apply (FABC fabc, FA fa, FB fb) Source #

method FA Pure (A x) Source #

struct ApplOptionAsync <A, B> Source #

Fields

field ApplOptionAsync<A, B> Inst = default(ApplOptionAsync<A, B>) Source #

Methods

method OptionAsync Map (OptionAsync<A> ma, Func<A, B> f) Source #

method OptionAsync MapAsync (OptionAsync<A> ma, Func<A, Task> f) Source #

method OptionAsync Apply (OptionAsync<Func<A, B>> fab, OptionAsync<A> fa) Source #

method OptionAsync Apply (Func<A, B> fab, OptionAsync<A> fa) Source #

method OptionAsync Apply (Func<A, A, B> fab, OptionAsync<A> fa, OptionAsync<A> fb) Source #

method OptionAsync<A> PureAsync (Task<A> x) Source #

method OptionAsync Action (OptionAsync<A> fa, OptionAsync fb) Source #

struct ApplOptionAsync <A, B, C> Source #

Fields

field ApplOptionAsync<A, B, C> Inst = default(ApplOptionAsync<A, B, C>) Source #

Methods

method OptionAsync<Func<B, C>> Apply (OptionAsync<Func<A, Func<B, C>>> fab, OptionAsync<A> fa) Source #

method OptionAsync<C> Apply (OptionAsync<Func<A, Func<B, C>>> fab, OptionAsync<A> fa, OptionAsync fb) Source #

method OptionAsync<Func<B, C>> Apply (Func<A, Func<B, C>> fab, OptionAsync<A> fa) Source #

method OptionAsync<C> Apply (Func<A, Func<B, C>> fab, OptionAsync<A> fa, OptionAsync fb) Source #

method OptionAsync<A> PureAsync (Task<A> x) Source #

struct ApplOptionUnsafe <A, B> Source #

Fields

field ApplOptionUnsafe<A, B> Inst = default(ApplOptionUnsafe<A, B>) Source #

Methods

method OptionUnsafe BiMap (OptionUnsafe<A> ma, Func<A, B> fa, Func<Unit, B> fb) Source #

method OptionUnsafe Map (OptionUnsafe<A> ma, Func<A, B> f) Source #

method OptionUnsafe Apply (OptionUnsafe<Func<A, B>> fab, OptionUnsafe<A> fa) Source #

method OptionUnsafe<A> Pure (A x) Source #

method OptionUnsafe Action (OptionUnsafe<A> fa, OptionUnsafe fb) Source #

struct ApplOptionUnsafe <A, B, C> Source #

Fields

field ApplOptionUnsafe<A, B, C> Inst = default(ApplOptionUnsafe<A, B, C>) Source #

Methods

method OptionUnsafe<Func<B, C>> Apply (OptionUnsafe<Func<A, Func<B, C>>> fab, OptionUnsafe<A> fa) Source #

method OptionUnsafe<C> Apply (OptionUnsafe<Func<A, Func<B, C>>> fab, OptionUnsafe<A> fa, OptionUnsafe fb) Source #

method OptionUnsafe<A> Pure (A x) Source #

struct ApplSeq <A, B> Source #

Fields

field ApplSeq<A, B> Inst = default(ApplSeq<A, B>) Source #

Methods

method Seq Action (Seq<A> fa, Seq fb) Source #

method Seq Apply (Seq<Func<A, B>> fab, Seq<A> fa) Source #

method Seq Map (Seq<A> ma, Func<A, B> f) Source #

method Seq<A> Pure (A x) Source #

struct ApplSeq <A, B, C> Source #

Fields

field ApplSeq<A, B, C> Inst = default(ApplSeq<A, B, C>) Source #

Methods

method Seq<Func<B, C>> Apply (Seq<Func<A, Func<B, C>>> fabc, Seq<A> fa) Source #

method Seq<C> Apply (Seq<Func<A, Func<B, C>>> fabc, Seq<A> fa, Seq fb) Source #

method Seq<A> Pure (A x) Source #

struct ApplSeq <A> Source #

Fields

field ApplSeq<A> Inst = default(ApplSeq<A>) Source #

Methods

method Seq<A> Action (Seq<A> fa, Seq<A> fb) Source #

method Seq<A> Apply (Seq<Func<A, A>> fab, Seq<A> fa) Source #

method Seq<Func<A, A>> Apply (Seq<Func<A, Func<A, A>>> fabc, Seq<A> fa) Source #

method Seq<A> Apply (Seq<Func<A, Func<A, A>>> fabc, Seq<A> fa, Seq<A> fb) Source #

method Seq<A> Pure (A x) Source #

struct ApplSet <A, B> Source #

Fields

field ApplSet<A, B> Inst = default(ApplSet<A, B>) Source #

Methods

method Set Action (Set<A> fa, Set fb) Source #

method Set Apply (Set<Func<A, B>> fab, Set<A> fa) Source #

method Set Map (Set<A> ma, Func<A, B> f) Source #

method Set<A> Pure (A x) Source #

struct ApplSet <A, B, C> Source #

Fields

field ApplSet<A, B, C> Inst = default(ApplSet<A, B, C>) Source #

Methods

method Set<Func<B, C>> Apply (Set<Func<A, Func<B, C>>> fabc, Set<A> fa) Source #

method Set<C> Apply (Set<Func<A, Func<B, C>>> fabc, Set<A> fa, Set fb) Source #

method Set<A> Pure (A x) Source #

struct ApplSet <A> Source #

Fields

field ApplSet<A> Inst = default(ApplSet<A>) Source #

Methods

method Set<A> Action (Set<A> fa, Set<A> fb) Source #

method Set<A> Apply (Set<Func<A, A>> fab, Set<A> fa) Source #

method Set<Func<A, A>> Apply (Set<Func<A, Func<A, A>>> fabc, Set<A> fa) Source #

method Set<A> Apply (Set<Func<A, Func<A, A>>> fabc, Set<A> fa, Set<A> fb) Source #

method Set<A> Pure (A x) Source #

struct ApplSet <OrdFAB, OrdA, OrdB, A, B> Source #

where OrdA : struct, Ord<A>

where OrdB : struct, Ord

where OrdFAB : struct, Ord<Func<A,B>>

Fields

field ApplSet<OrdFAB, OrdA, OrdB, A, B> Inst = default(ApplSet<OrdFAB, OrdA, OrdB, A, B>) Source #

Methods

method Set<OrdB, B> Action (Set<OrdA, A> fa, Set<OrdB, B> fb) Source #

method Set<OrdB, B> Apply (Set<OrdFAB, Func<A, B>> fab, Set<OrdA, A> fa) Source #

method Set<OrdB, B> Map (Set<OrdA, A> ma, Func<A, B> f) Source #

method Set<OrdA, A> Pure (A x) Source #

struct ApplSet <OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C> Source #

where OrdA : struct, Ord<A>

where OrdB : struct, Ord

where OrdC : struct, Ord<C>

where OrdFABC : struct, Ord<Func<A, Func<B, C>>>

where OrdFBC : struct, Ord<Func<B, C>>

Fields

field ApplSet<OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C> Inst = default(ApplSet<OrdFABC, OrdFBC, OrdA, OrdB, OrdC, A, B, C>) Source #

Methods

method Set<OrdFBC, Func<B, C>> Apply (Set<OrdFABC, Func<A, Func<B, C>>> fabc, Set<OrdA, A> fa) Source #

method Set<OrdC, C> Apply (Set<OrdFABC, Func<A, Func<B, C>>> fabc, Set<OrdA, A> fa, Set<OrdB, B> fb) Source #

method Set<OrdA, A> Pure (A x) Source #

struct ApplSet <OrdFAAA, OrdFAA, OrdA, A> Source #

where OrdA : struct, Ord<A>

where OrdFAAA : struct, Ord<Func<A, Func<A, A>>>

where OrdFAA : struct, Ord<Func<A, A>>

Fields

field ApplSet<A> Inst = default(ApplSet<A>) Source #

Methods

method Set<OrdA, A> Action (Set<OrdA, A> fa, Set<OrdA, A> fb) Source #

method Set<OrdA, A> Apply (Set<OrdFAA, Func<A, A>> fab, Set<OrdA, A> fa) Source #

method Set<OrdFAA, Func<A, A>> Apply (Set<OrdFAAA, Func<A, Func<A, A>>> fabc, Set<OrdA, A> fa) Source #

method Set<OrdA, A> Apply (Set<OrdFAAA, Func<A, Func<A, A>>> fabc, Set<OrdA, A> fa, Set<OrdA, A> fb) Source #

method Set<OrdA, A> Pure (A x) Source #

struct ApplTask <A, B> Source #

Fields

field ApplTask<A, B> Inst = default(ApplTask<A, B>) Source #

Methods

method Task Map (Task<A> ma, Func<A, B> f) Source #

method Task MapAsync (Task<A> ma, Func<A, Task> f) Source #

method Task Apply (Task<Func<A, B>> fab, Task<A> fa) Source #

method Task Apply (Task<Func<A, A, B>> fab, Task<A> fa, Task<A> fb) Source #

method Task Apply (Func<A, A, B> fab, Task<A> fa, Task<A> fb) Source #

method Task<A> PureAsync (Task<A> x) Source #

method Task Action (Task<A> fa, Task fb) Source #

struct ApplTask <A, B, C> Source #

Fields

field ApplTask<A, B, C> Inst = default(ApplTask<A, B, C>) Source #

Methods

method Task<Func<B, C>> Apply (Task<Func<A, Func<B, C>>> fabc, Task<A> fa) Source #

method Task<C> Apply (Task<Func<A, Func<B, C>>> fabc, Task<A> fa, Task fb) Source #

method Task<A> PureAsync (Task<A> x) Source #

struct ApplTask <A> Source #

Fields

field ApplTask<A> Inst = default(ApplTask<A>) Source #

Methods

method Task<A> Map (Task<A> ma, Func<A, A> f) Source #

method Task<A> MapAsync (Task<A> ma, Func<A, Task<A>> f) Source #

method Task<A> Apply (Task<Func<A, A>> fab, Task<A> fa) Source #

method Task<A> PureAsync (Task<A> x) Source #

method Task<A> Action (Task<A> fa, Task<A> fb) Source #

method Task<Func<A, A>> Apply (Task<Func<A, Func<A, A>>> fabc, Task<A> fa) Source #

method Task<A> Apply (Task<Func<A, Func<A, A>>> fabc, Task<A> fa, Task<A> fb) Source #

struct ApplTry <A, B> Source #

Fields

field ApplTry<A, B> Inst = default(ApplTry<A, B>) Source #

Methods

method Try BiMap (Try<A> ma, Func<A, B> fa, Func<Unit, B> fb) Source #

method Try Map (Try<A> ma, Func<A, B> f) Source #

method Try Apply (Try<Func<A, B>> fab, Try<A> fa) Source #

method Try<A> Pure (A x) Source #

method Try Action (Try<A> fa, Try fb) Source #

struct ApplTry <A, B, C> Source #

Fields

field ApplTry<A, B, C> Inst = default(ApplTry<A, B, C>) Source #

Methods

method Try<Func<B, C>> Apply (Try<Func<A, Func<B, C>>> fabc, Try<A> fa) Source #

method Try<C> Apply (Try<Func<A, Func<B, C>>> fabc, Try<A> fa, Try fb) Source #

method Try<A> Pure (A x) Source #

struct ApplTry <A> Source #

Fields

field ApplTry<A> Inst = default(ApplTry<A>) Source #

Methods

method Try<A> BiMap (Try<A> ma, Func<A, A> fa, Func<Unit, A> fb) Source #

method Try<A> Map (Try<A> ma, Func<A, A> f) Source #

method Try<A> Apply (Try<Func<A, A>> fab, Try<A> fa) Source #

method Try<A> Pure (A x) Source #

method Try<A> Action (Try<A> fa, Try<A> fb) Source #

method Try<Func<A, A>> Apply (Try<Func<A, Func<A, A>>> fabc, Try<A> fa) Source #

method Try<A> Apply (Try<Func<A, Func<A, A>>> fabc, Try<A> fa, Try<A> fb) Source #

struct ApplTryAsync <A, B> Source #

Fields

field ApplTryAsync<A, B> Inst = default(ApplTryAsync<A, B>) Source #

Methods

method TryAsync Map (TryAsync<A> ma, Func<A, B> f) Source #

method TryAsync MapAsync (TryAsync<A> ma, Func<A, Task> f) Source #

method TryAsync Apply (TryAsync<Func<A, B>> fab, TryAsync<A> fa) Source #

method TryAsync<A> PureAsync (Task<A> x) Source #

method TryAsync Action (TryAsync<A> fa, TryAsync fb) Source #

struct ApplTryAsync <A, B, C> Source #

Fields

field ApplTryAsync<A, B, C> Inst = default(ApplTryAsync<A, B, C>) Source #

Methods

method TryAsync<Func<B, C>> Apply (TryAsync<Func<A, Func<B, C>>> fabc, TryAsync<A> fa) Source #

method TryAsync<C> Apply (TryAsync<Func<A, Func<B, C>>> fabc, TryAsync<A> fa, TryAsync fb) Source #

method TryAsync<A> PureAsync (Task<A> x) Source #

struct ApplTryAsync <A> Source #

Fields

field ApplTryAsync<A> Inst = default(ApplTryAsync<A>) Source #

Methods

method TryAsync<A> Map (TryAsync<A> ma, Func<A, A> f) Source #

method TryAsync<A> MapAsync (TryAsync<A> ma, Func<A, Task<A>> f) Source #

method TryAsync<A> Apply (TryAsync<Func<A, A>> fab, TryAsync<A> fa) Source #

method TryAsync<A> PureAsync (Task<A> x) Source #

method TryAsync<A> Action (TryAsync<A> fa, TryAsync<A> fb) Source #

method TryAsync<Func<A, A>> Apply (TryAsync<Func<A, Func<A, A>>> fabc, TryAsync<A> fa) Source #

method TryAsync<A> Apply (TryAsync<Func<A, Func<A, A>>> fabc, TryAsync<A> fa, TryAsync<A> fb) Source #

struct ApplTryOption <A, B> Source #

Fields

field ApplTryOption<A, B> Inst = default(ApplTryOption<A, B>) Source #

Methods

method TryOption BiMap (TryOption<A> ma, Func<A, B> fa, Func<Unit, B> fb) Source #

method TryOption Map (TryOption<A> ma, Func<A, B> f) Source #

method TryOption Apply (TryOption<Func<A, B>> fab, TryOption<A> fa) Source #

method TryOption<A> Pure (A x) Source #

method TryOption Action (TryOption<A> fa, TryOption fb) Source #

struct ApplTryOption <A, B, C> Source #

Fields

field ApplTryOption<A, B, C> Inst = default(ApplTryOption<A, B, C>) Source #

Methods

method TryOption<Func<B, C>> Apply (TryOption<Func<A, Func<B, C>>> fabc, TryOption<A> fa) Source #

method TryOption<C> Apply (TryOption<Func<A, Func<B, C>>> fabc, TryOption<A> fa, TryOption fb) Source #

method TryOption<A> Pure (A x) Source #

struct ApplTryOption <A> Source #

Fields

field ApplTryOption<A> Inst = default(ApplTryOption<A>) Source #

Methods

method TryOption<A> BiMap (TryOption<A> ma, Func<A, A> fa, Func<Unit, A> fb) Source #

method TryOption<A> Map (TryOption<A> ma, Func<A, A> f) Source #

method TryOption<A> Apply (TryOption<Func<A, A>> fab, TryOption<A> fa) Source #

method TryOption<A> Pure (A x) Source #

method TryOption<A> Action (TryOption<A> fa, TryOption<A> fb) Source #

method TryOption<Func<A, A>> Apply (TryOption<Func<A, Func<A, A>>> fabc, TryOption<A> fa) Source #

method TryOption<A> Apply (TryOption<Func<A, Func<A, A>>> fabc, TryOption<A> fa, TryOption<A> fb) Source #

struct ApplTryOptionAsync <A, B> Source #

Fields

field ApplTryOptionAsync<A, B> Inst = default(ApplTryOptionAsync<A, B>) Source #

Methods

method TryOptionAsync Map (TryOptionAsync<A> ma, Func<A, B> f) Source #

method TryOptionAsync MapAsync (TryOptionAsync<A> ma, Func<A, Task> f) Source #

method TryOptionAsync Apply (TryOptionAsync<Func<A, B>> fab, TryOptionAsync<A> fa) Source #

method TryOptionAsync Apply (Func<A, B> fab, TryOptionAsync<A> fa) Source #

method TryOptionAsync Apply (TryOptionAsync<Func<A, A, B>> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb) Source #

method TryOptionAsync Apply (Func<A, A, B> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb) Source #

method TryOptionAsync ApplyOption (Func<Option<A>, Option<A>, B> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb) Source #

method TryOptionAsync ApplyOption (TryOptionAsync<Func<Option<A>, Option<A>, B>> fab, TryOptionAsync<A> fa, TryOptionAsync<A> fb) Source #

method TryOptionAsync<A> PureAsync (Task<A> x) Source #

method TryOptionAsync Action (TryOptionAsync<A> fa, TryOptionAsync fb) Source #

struct ApplTryOptionAsync <A, B, C> Source #

Fields

field ApplTryOptionAsync<A, B, C> Inst = default(ApplTryOptionAsync<A, B, C>) Source #

Methods

method TryOptionAsync<Func<B, C>> Apply (TryOptionAsync<Func<A, Func<B, C>>> fabc, TryOptionAsync<A> fa) Source #

method TryOptionAsync<C> Apply (TryOptionAsync<Func<A, Func<B, C>>> fabc, TryOptionAsync<A> fa, TryOptionAsync fb) Source #

method TryOptionAsync<A> PureAsync (Task<A> x) Source #

struct ApplTryOptionAsync <A> Source #

Fields

field ApplTryOptionAsync<A> Inst = default(ApplTryOptionAsync<A>) Source #

Methods

method TryOptionAsync<A> Map (TryOptionAsync<A> ma, Func<A, A> f) Source #

method TryOptionAsync<A> MapAsync (TryOptionAsync<A> ma, Func<A, Task<A>> f) Source #

method TryOptionAsync<A> Apply (TryOptionAsync<Func<A, A>> fab, TryOptionAsync<A> fa) Source #

method TryOptionAsync<A> PureAsync (Task<A> x) Source #

method TryOptionAsync<A> Action (TryOptionAsync<A> fa, TryOptionAsync<A> fb) Source #

method TryOptionAsync<Func<A, A>> Apply (TryOptionAsync<Func<A, Func<A, A>>> fabc, TryOptionAsync<A> fa) Source #

method TryOptionAsync<A> Apply (TryOptionAsync<Func<A, Func<A, A>>> fabc, TryOptionAsync<A> fa, TryOptionAsync<A> fb) Source #

struct ApplValidation <FAIL, SUCCESS, SUCCESS2> Source #

Fields

field ApplValidation<FAIL, SUCCESS, SUCCESS2> Inst = default(ApplValidation<FAIL, SUCCESS, SUCCESS2>) Source #

Methods

method Validation<FAIL, SUCCESS2> BiMap (Validation<FAIL, SUCCESS> ma, Func<Seq<FAIL>, SUCCESS2> fa, Func<SUCCESS, SUCCESS2> fb) Source #

method Validation<FAIL, SUCCESS2> Map (Validation<FAIL, SUCCESS> ma, Func<SUCCESS, SUCCESS2> f) Source #

method Validation<FAIL, SUCCESS2> Apply (Validation<FAIL, Func<SUCCESS, SUCCESS2>> fab, Validation<FAIL, SUCCESS> fa) Source #

method Validation<FAIL, SUCCESS2> Action (Validation<FAIL, SUCCESS> fa, Validation<FAIL, SUCCESS2> fb) Source #

method Validation<FAIL, SUCCESS> Pure (SUCCESS x) Source #

struct ApplValidationBi <FAIL, SUCCESS, FAIL2, SUCCESS2> Source #

Fields

field ApplValidationBi<FAIL, SUCCESS, FAIL2, SUCCESS2> Inst = default(ApplValidationBi<FAIL, SUCCESS, FAIL2, SUCCESS2>) Source #

Methods

method Validation<FAIL2, SUCCESS2> BiMap (Validation<FAIL, SUCCESS> ma, Func<FAIL, FAIL2> fa, Func<SUCCESS, SUCCESS2> fb) Source #

method Validation<FAIL, SUCCESS2> Apply (Validation<FAIL, Func<SUCCESS, SUCCESS2>> fab, Validation<FAIL, SUCCESS> fa) Source #

method Validation<FAIL, SUCCESS2> Action (Validation<FAIL, SUCCESS> fa, Validation<FAIL, SUCCESS2> fb) Source #

method Validation<FAIL, SUCCESS> Pure (SUCCESS x) Source #

struct ApplValidation <FAIL, A, B, C> Source #

Fields

field ApplValidation<FAIL, A, B, C> Inst = default(ApplValidation<FAIL, A, B, C>) Source #

Methods

method Validation<FAIL, Func<B, C>> Apply (Validation<FAIL, Func<A, Func<B, C>>> fab, Validation<FAIL, A> fa) Source #

method Validation<FAIL, C> Apply (Validation<FAIL, Func<A, Func<B, C>>> fab, Validation<FAIL, A> fa, Validation<FAIL, B> fb) Source #

method Validation<FAIL, A> Pure (A x) Source #

struct ApplValueTask <A, B> Source #

Fields

field ApplValueTask<A, B> Inst = default(ApplValueTask<A, B>) Source #

Methods

method ValueTask Map (ValueTask<A> ma, Func<A, B> f) Source #

method ValueTask MapAsync (ValueTask<A> ma, Func<A, Task> f) Source #

method ValueTask Apply (ValueTask<Func<A, B>> fab, ValueTask<A> fa) Source #

method ValueTask Apply (ValueTask<Func<A, A, B>> fab, ValueTask<A> fa, ValueTask<A> fb) Source #

method ValueTask Apply (Func<A, A, B> fab, ValueTask<A> fa, ValueTask<A> fb) Source #

method ValueTask<A> PureAsync (Task<A> x) Source #

method ValueTask Action (ValueTask<A> fa, ValueTask fb) Source #

struct ApplValueTask <A, B, C> Source #

Fields

field ApplValueTask<A, B, C> Inst = default(ApplValueTask<A, B, C>) Source #

Methods

method ValueTask<Func<B, C>> Apply (ValueTask<Func<A, Func<B, C>>> fabc, ValueTask<A> fa) Source #

method ValueTask<C> Apply (ValueTask<Func<A, Func<B, C>>> fabc, ValueTask<A> fa, ValueTask fb) Source #

method ValueTask<A> PureAsync (Task<A> x) Source #

struct ApplValueTask <A> Source #

Fields

field ApplValueTask<A> Inst = default(ApplValueTask<A>) Source #

Methods

method ValueTask<A> Map (ValueTask<A> ma, Func<A, A> f) Source #

method ValueTask<A> MapAsync (ValueTask<A> ma, Func<A, Task<A>> f) Source #

method ValueTask<A> Apply (ValueTask<Func<A, A>> fab, ValueTask<A> fa) Source #

method ValueTask<A> PureAsync (Task<A> x) Source #

method ValueTask<A> Action (ValueTask<A> fa, ValueTask<A> fb) Source #

method ValueTask<Func<A, A>> Apply (ValueTask<Func<A, Func<A, A>>> fabc, ValueTask<A> fa) Source #

method ValueTask<A> Apply (ValueTask<Func<A, Func<A, A>>> fabc, ValueTask<A> fa, ValueTask<A> fb) Source #