LanguageExt.Core

LanguageExt.Core Transformer Traverse

Contents

class AffPureT Source #

Methods

method Aff<Arr<B>> TraverseParallel <A, B> (this Arr<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Arr<B>> TraverseParallel <A, B> (this Arr<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<Arr<B>> TraverseSerial <A, B> (this Arr<Aff<A>> ma, Func<A, B> f) Source #

method Aff<HashSet<B>> TraverseParallel <A, B> (this HashSet<Aff<A>> ma, Func<A, B> f) Source #

method Aff<HashSet<B>> TraverseParallel <A, B> (this HashSet<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<HashSet<B>> TraverseSerial <A, B> (this HashSet<Aff<A>> ma, Func<A, B> f) Source #

method Aff<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<IEnumerable<B>> TraverseSerial <A, B> (this IEnumerable<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Lst<B>> TraverseParallel <A, B> (this Lst<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Lst<B>> TraverseParallel <A, B> (this Lst<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<Lst<B>> TraverseSerial <A, B> (this Lst<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Que<B>> TraverseParallel <A, B> (this Que<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Que<B>> TraverseParallel <A, B> (this Que<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<Que<B>> TraverseSerial <A, B> (this Que<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Seq<B>> TraverseParallel <A, B> (this Seq<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Seq<B>> TraverseParallel <A, B> (this Seq<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<Seq<B>> TraverseSerial <A, B> (this Seq<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Set<B>> TraverseParallel <A, B> (this Set<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Set<B>> TraverseParallel <A, B> (this Set<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<Set<B>> TraverseSerial <A, B> (this Set<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Stck<B>> TraverseParallel <A, B> (this Stck<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Stck<B>> TraverseParallel <A, B> (this Stck<Aff<A>> ma, Func<A, B> f, int windowSize) Source #

method Aff<Stck<B>> TraverseSerial <A, B> (this Stck<Aff<A>> ma, Func<A, B> f) Source #

method Aff<EitherAsync<L, B>> Traverse <L, A, B> (this EitherAsync<L, Aff<A>> ma, Func<A, B> f) Source #

method Aff<OptionAsync<B>> Traverse <A, B> (this OptionAsync<Aff<A>> ma, Func<A, B> f) Source #

method Aff<TryAsync<B>> Traverse <A, B> (this TryAsync<Aff<A>> ma, Func<A, B> f) Source #

method Aff<TryOptionAsync<B>> Traverse <A, B> (this TryOptionAsync<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Task<B>> Traverse <A, B> (this Task<Aff<A>> ma, Func<A, B> f) Source #

method Aff<ValueTask<B>> Traverse <A, B> (this ValueTask<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Aff<B>> Traverse <A, B> (this Aff<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Either<L, B>> Traverse <L, A, B> (this Either<L, Aff<A>> ma, Func<A, B> f) Source #

method Aff<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Aff<A>> ma, Func<A, B> f) Source #

method Aff<Identity<B>> Traverse <A, B> (this Identity<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Fin<B>> Traverse <A, B> (this Fin<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Option<B>> Traverse <A, B> (this Option<Aff<A>> ma, Func<A, B> f) Source #

method Aff<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Try<B>> Traverse <A, B> (this Try<Aff<A>> ma, Func<A, B> f) Source #

method Aff<TryOption<B>> Traverse <A, B> (this TryOption<Aff<A>> ma, Func<A, B> f) Source #

method Aff<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Aff<A>> ma, Func<A, B> f) Source #

method Aff<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Aff<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Aff<Eff<B>> Traverse <A, B> (this Eff<Aff<A>> ma, Func<A, B> f) Source #

class AffT Source #

Methods

method Aff<RT, Arr<B>> TraverseParallel <RT, A, B> (this Arr<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Arr<B>> TraverseParallel <RT, A, B> (this Arr<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Arr<B>> TraverseSerial <RT, A, B> (this Arr<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, HashSet<B>> TraverseParallel <RT, A, B> (this HashSet<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, HashSet<B>> TraverseParallel <RT, A, B> (this HashSet<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, HashSet<B>> TraverseSerial <RT, A, B> (this HashSet<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, IEnumerable<B>> TraverseParallel <RT, A, B> (this IEnumerable<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, IEnumerable<B>> TraverseParallel <RT, A, B> (this IEnumerable<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, IEnumerable<B>> TraverseSerial <RT, A, B> (this IEnumerable<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Lst<B>> TraverseParallel <RT, A, B> (this Lst<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Lst<B>> TraverseParallel <RT, A, B> (this Lst<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Lst<B>> TraverseSerial <RT, A, B> (this Lst<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Que<B>> TraverseParallel <RT, A, B> (this Que<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Que<B>> TraverseParallel <RT, A, B> (this Que<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Que<B>> TraverseSerial <RT, A, B> (this Que<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Seq<B>> TraverseParallel <RT, A, B> (this Seq<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Seq<B>> TraverseParallel <RT, A, B> (this Seq<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Seq<B>> TraverseSerial <RT, A, B> (this Seq<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Set<B>> TraverseParallel <RT, A, B> (this Set<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Set<B>> TraverseParallel <RT, A, B> (this Set<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Set<B>> TraverseSerial <RT, A, B> (this Set<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Stck<B>> TraverseParallel <RT, A, B> (this Stck<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Stck<B>> TraverseParallel <RT, A, B> (this Stck<Aff<RT, A>> ma, Func<A, B> f, int windowSize) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Stck<B>> TraverseSerial <RT, A, B> (this Stck<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, EitherAsync<L, B>> Traverse <RT, L, A, B> (this EitherAsync<L, Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, OptionAsync<B>> Traverse <RT, A, B> (this OptionAsync<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, TryAsync<B>> Traverse <RT, A, B> (this TryAsync<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, TryOptionAsync<B>> Traverse <RT, A, B> (this TryOptionAsync<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Task<B>> Traverse <RT, A, B> (this Task<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, ValueTask<B>> Traverse <RT, A, B> (this ValueTask<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Aff<B>> Traverse <RT, A, B> (this Aff<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Either<L, B>> Traverse <RT, L, A, B> (this Either<L, Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, EitherUnsafe<L, B>> Traverse <RT, L, A, B> (this EitherUnsafe<L, Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Identity<B>> Traverse <RT, A, B> (this Identity<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Fin<B>> Traverse <RT, A, B> (this Fin<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Option<B>> Traverse <RT, A, B> (this Option<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, OptionUnsafe<B>> Traverse <RT, A, B> (this OptionUnsafe<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Try<B>> Traverse <RT, A, B> (this Try<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, TryOption<B>> Traverse <RT, A, B> (this TryOption<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Validation<Fail, B>> Traverse <RT, Fail, A, B> (this Validation<Fail, Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Validation<MonoidFail, Fail, B>> Traverse <RT, MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>
where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Aff<RT, Eff<RT, B>> Traverse <RT, A, B> (this Eff<RT, Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

method Aff<RT, Eff<B>> Traverse <RT, A, B> (this Eff<Aff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct, HasCancel<RT>

class ArrT Source #

Methods

method Arr<Arr<B>> Traverse <A, B> (this Arr<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<Either<L, B>> Traverse <L, A, B> (this Either<L, Arr<A>> ma, Func<A, B> f) Source #

method Arr<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Arr<A>> ma, Func<A, B> f) Source #

method Arr<HashSet<B>> Traverse <A, B> (this HashSet<Arr<A>> ma, Func<A, B> f) Source #

method Arr<Identity<B>> Traverse <A, B> (this Identity<Arr<A>> ma, Func<A, B> f) Source #

method Arr<Lst<B>> Traverse <A, B> (this Lst<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<Fin<B>> Traverse <A, B> (this Fin<Arr<A>> ma, Func<A, B> f) Source #

method Arr<Option<B>> Traverse <A, B> (this Option<Arr<A>> ma, Func<A, B> f) Source #

method Arr<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Arr<A>> ma, Func<A, B> f) Source #

method Arr<Que<B>> Traverse <A, B> (this Que<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<Seq<B>> Traverse <A, B> (this Seq<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<Set<B>> Traverse <A, B> (this Set<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<Stck<B>> Traverse <A, B> (this Stck<Arr<A>> xxs, Func<A, B> f) Source #

method Arr<Try<B>> Traverse <A, B> (this Try<Arr<A>> ma, Func<A, B> f) Source #

method Arr<TryOption<B>> Traverse <A, B> (this TryOption<Arr<A>> ma, Func<A, B> f) Source #

method Arr<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Arr<A>> ma, Func<A, B> f) Source #

method Arr<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Arr<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Arr<Eff<B>> Traverse <A, B> (this Eff<Arr<A>> ma, Func<A, B> f) Source #

class EffPureT Source #

Methods

method Eff<Arr<B>> Traverse <A, B> (this Arr<Eff<A>> ma, Func<A, B> f) Source #

method Eff<HashSet<B>> Traverse <A, B> (this HashSet<Eff<A>> ma, Func<A, B> f) Source #

method Eff<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Lst<B>> Traverse <A, B> (this Lst<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Que<B>> Traverse <A, B> (this Que<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Seq<B>> Traverse <A, B> (this Seq<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Set<B>> Traverse <A, B> (this Set<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Stck<B>> Traverse <A, B> (this Stck<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Either<L, B>> Traverse <L, A, B> (this Either<L, Eff<A>> ma, Func<A, B> f) Source #

method Eff<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Eff<A>> ma, Func<A, B> f) Source #

method Eff<Identity<B>> Traverse <A, B> (this Identity<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Fin<B>> Traverse <A, B> (this Fin<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Option<B>> Traverse <A, B> (this Option<Eff<A>> ma, Func<A, B> f) Source #

method Eff<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Try<B>> Traverse <A, B> (this Try<Eff<A>> ma, Func<A, B> f) Source #

method Eff<TryOption<B>> Traverse <A, B> (this TryOption<Eff<A>> ma, Func<A, B> f) Source #

method Eff<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Eff<A>> ma, Func<A, B> f) Source #

method Eff<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Eff<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

class EffT Source #

Methods

method Eff<RT, Arr<B>> Traverse <RT, A, B> (this Arr<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, HashSet<B>> Traverse <RT, A, B> (this HashSet<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, IEnumerable<B>> Traverse <RT, A, B> (this IEnumerable<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Lst<B>> Traverse <RT, A, B> (this Lst<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Que<B>> Traverse <RT, A, B> (this Que<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Seq<B>> Traverse <RT, A, B> (this Seq<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Set<B>> Traverse <RT, A, B> (this Set<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Stck<B>> Traverse <RT, A, B> (this Stck<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Either<L, B>> Traverse <RT, L, A, B> (this Either<L, Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, EitherUnsafe<L, B>> Traverse <RT, L, A, B> (this EitherUnsafe<L, Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Identity<B>> Traverse <RT, A, B> (this Identity<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Fin<B>> Traverse <RT, A, B> (this Fin<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Option<B>> Traverse <RT, A, B> (this Option<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, OptionUnsafe<B>> Traverse <RT, A, B> (this OptionUnsafe<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Try<B>> Traverse <RT, A, B> (this Try<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, TryOption<B>> Traverse <RT, A, B> (this TryOption<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Validation<Fail, B>> Traverse <RT, Fail, A, B> (this Validation<Fail, Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

method Eff<RT, Validation<MonoidFail, Fail, B>> Traverse <RT, MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct
where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Eff<RT, Eff<B>> Traverse <RT, A, B> (this Eff<Eff<RT, A>> ma, Func<A, B> f) Source #

where RT : struct

class EitherAsyncT Source #

Methods

method EitherAsync<L, Arr<B>> Traverse <L, A, B> (this Arr<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, HashSet<B>> Traverse <L, A, B> (this HashSet<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, IEnumerable<B>> Traverse <L, A, B> (this IEnumerable<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, IEnumerable<B>> TraverseSerial <L, A, B> (this IEnumerable<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, IEnumerable<B>> TraverseParallel <L, A, B> (this IEnumerable<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, IEnumerable<B>> TraverseParallel <L, A, B> (this IEnumerable<EitherAsync<L, A>> ma, int windowSize, Func<A, B> f) Source #

method EitherAsync<L, IEnumerable<A>> Sequence <L, A> (this IEnumerable<EitherAsync<L, A>> ma) Source #

method EitherAsync<L, IEnumerable<A>> SequenceSerial <L, A> (this IEnumerable<EitherAsync<L, A>> ma) Source #

method EitherAsync<L, IEnumerable<A>> SequenceParallel <L, A> (this IEnumerable<EitherAsync<L, A>> ma) Source #

method EitherAsync<L, IEnumerable<A>> SequenceParallel <L, A> (this IEnumerable<EitherAsync<L, A>> ma, int windowSize) Source #

method EitherAsync<L, Lst<B>> Traverse <L, A, B> (this Lst<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Que<B>> Traverse <L, A, B> (this Que<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Seq<B>> Traverse <L, A, B> (this Seq<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Seq<B>> TraverseSerial <L, A, B> (this Seq<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Seq<B>> TraverseParallel <L, A, B> (this Seq<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Seq<B>> TraverseParallel <L, A, B> (this Seq<EitherAsync<L, A>> ma, int windowSize, Func<A, B> f) Source #

method EitherAsync<L, Seq<A>> Sequence <L, A> (this Seq<EitherAsync<L, A>> ma) Source #

method EitherAsync<L, Seq<A>> SequenceSerial <L, A> (this Seq<EitherAsync<L, A>> ma) Source #

method EitherAsync<L, Seq<A>> SequenceParallel <L, A> (this Seq<EitherAsync<L, A>> ma) Source #

method EitherAsync<L, Seq<A>> SequenceParallel <L, A> (this Seq<EitherAsync<L, A>> ma, int windowSize) Source #

method EitherAsync<L, Set<B>> Traverse <L, A, B> (this Set<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Stck<B>> Traverse <L, A, B> (this Stck<EitherAsync<L, A>> ma, Func<A, B> f) Source #

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

method EitherAsync<L, OptionAsync<B>> Traverse <L, A, B> (this OptionAsync<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, TryAsync<B>> Traverse <L, A, B> (this TryAsync<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, TryOptionAsync<B>> Traverse <L, A, B> (this TryOptionAsync<EitherAsync<L, A>> ma, Func<A, B> f) Source #

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

method EitherAsync<L, ValueTask<B>> Traverse <L, A, B> (this ValueTask<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Aff<B>> Traverse <L, A, B> (this Aff<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Either<L, B>> Traverse <L, A, B> (this Either<L, EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Identity<B>> Traverse <L, A, B> (this Identity<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Fin<B>> Traverse <L, A, B> (this Fin<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Option<B>> Traverse <L, A, B> (this Option<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, OptionUnsafe<B>> Traverse <L, A, B> (this OptionUnsafe<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Try<B>> Traverse <L, A, B> (this Try<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, TryOption<B>> Traverse <L, A, B> (this TryOption<EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Validation<L, B>> Traverse <L, A, B> (this Validation<L, EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<L, Validation<Fail, B>> Traverse <Fail, L, A, B> (this Validation<Fail, EitherAsync<L, A>> ma, Func<A, B> f) Source #

method EitherAsync<Fail, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, EitherAsync<Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method EitherAsync<L, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, L, A, B> (this Validation<MonoidFail, Fail, EitherAsync<L, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method EitherAsync<L, Eff<B>> Traverse <L, A, B> (this Eff<EitherAsync<L, A>> ma, Func<A, B> f) Source #

class EitherT Source #

Methods

method Either<L, Arr<B>> Traverse <L, A, B> (this Arr<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, HashSet<B>> Traverse <L, A, B> (this HashSet<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Lst<B>> Traverse <L, A, B> (this Lst<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Que<B>> Traverse <L, A, B> (this Que<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Seq<B>> Traverse <L, A, B> (this Seq<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, IEnumerable<B>> Traverse <L, A, B> (this IEnumerable<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Set<B>> Traverse <L, A, B> (this Set<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Stck<B>> Traverse <L, A, B> (this Stck<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Either<L, B>> Traverse <L, A, B> (this Either<L, Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Identity<B>> Traverse <L, A, B> (this Identity<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Fin<B>> Traverse <L, A, B> (this Fin<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Option<B>> Traverse <L, A, B> (this Option<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, OptionUnsafe<B>> Traverse <L, A, B> (this OptionUnsafe<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, Try<B>> Traverse <L, A, B> (this Try<Either<L, A>> ma, Func<A, B> f) Source #

method Either<L, TryOption<B>> Traverse <L, A, B> (this TryOption<Either<L, A>> ma, Func<A, B> f) Source #

method Either<Fail, Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Either<Fail, A>> ma, Func<A, B> f) Source #

method Either<Fail, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Either<Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Either<L, Validation<Fail, B>> Traverse <Fail, L, A, B> (this Validation<Fail, Either<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, L, A, B> (this Validation<MonoidFail, Fail, EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Either<L, Eff<B>> Traverse <L, A, B> (this Eff<Either<L, A>> ma, Func<A, B> f) Source #

class EitherUnsafeT Source #

Methods

method EitherUnsafe<L, Arr<B>> Traverse <L, A, B> (this Arr<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Either<L, B>> Traverse <L, A, B> (this Either<L, EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, HashSet<B>> Traverse <L, A, B> (this HashSet<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Identity<B>> Traverse <L, A, B> (this Identity<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Lst<B>> Traverse <L, A, B> (this Lst<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Fin<B>> Traverse <L, A, B> (this Fin<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Option<B>> Traverse <L, A, B> (this Option<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, OptionUnsafe<B>> Traverse <L, A, B> (this OptionUnsafe<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Que<B>> Traverse <L, A, B> (this Que<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Seq<B>> Traverse <L, A, B> (this Seq<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, IEnumerable<B>> Traverse <L, A, B> (this IEnumerable<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Set<B>> Traverse <L, A, B> (this Set<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Stck<B>> Traverse <L, A, B> (this Stck<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Try<B>> Traverse <L, A, B> (this Try<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, TryOption<B>> Traverse <L, A, B> (this TryOption<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<Fail, Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, EitherUnsafe<Fail, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<Fail, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, EitherUnsafe<Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method EitherUnsafe<L, Validation<Fail, B>> Traverse <Fail, L, A, B> (this Validation<Fail, EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

method EitherUnsafe<L, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, L, A, B> (this Validation<MonoidFail, Fail, EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method EitherUnsafe<L, Eff<B>> Traverse <L, A, B> (this Eff<EitherUnsafe<L, A>> ma, Func<A, B> f) Source #

class FinT Source #

Methods

method Fin<Arr<B>> Traverse <A, B> (this Arr<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Either<L, B>> Traverse <L, A, B> (this Either<L, Fin<A>> ma, Func<A, B> f) Source #

method Fin<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Fin<A>> ma, Func<A, B> f) Source #

method Fin<HashSet<B>> Traverse <A, B> (this HashSet<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Identity<B>> Traverse <A, B> (this Identity<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Lst<B>> Traverse <A, B> (this Lst<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Option<B>> Traverse <A, B> (this Option<Fin<A>> ma, Func<A, B> f) Source #

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

method Fin<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Que<B>> Traverse <A, B> (this Que<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Seq<B>> Traverse <A, B> (this Seq<Fin<A>> ma, Func<A, B> f) Source #

method Fin<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Set<B>> Traverse <A, B> (this Set<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Stck<B>> Traverse <A, B> (this Stck<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Try<B>> Traverse <A, B> (this Try<Fin<A>> ma, Func<A, B> f) Source #

method Fin<TryOption<B>> Traverse <A, B> (this TryOption<Fin<A>> ma, Func<A, B> f) Source #

method Fin<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Fin<A>> ma, Func<A, B> f) Source #

method Fin<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> ( this Validation<MonoidFail, Fail, Fin<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Fin<Eff<B>> Traverse <A, B> (this Eff<Fin<A>> ma, Func<A, B> f) Source #

class HashSetT Source #

Methods

method HashSet<Arr<B>> Traverse <A, B> (this Arr<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Either<L, B>> Traverse <L, A, B> (this Either<L, HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, HashSet<A>> ma, Func<A, B> f) Source #

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

method HashSet<Identity<B>> Traverse <A, B> (this Identity<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Lst<B>> Traverse <A, B> (this Lst<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Fin<B>> Traverse <A, B> (this Fin<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Option<B>> Traverse <A, B> (this Option<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Que<B>> Traverse <A, B> (this Que<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Seq<B>> Traverse <A, B> (this Seq<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<IEnumerable<B>> Traverse <A, B> (this IEnumerable<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Set<B>> Traverse <A, B> (this Set<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Stck<B>> Traverse <A, B> (this Stck<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Try<B>> Traverse <A, B> (this Try<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<TryOption<B>> Traverse <A, B> (this TryOption<HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, HashSet<A>> ma, Func<A, B> f) Source #

method HashSet<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, HashSet<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method HashSet<Eff<B>> Traverse <A, B> (this Eff<HashSet<A>> ma, Func<A, B> f) Source #

class IdentityT Source #

Methods

method Identity<Arr<B>> Traverse <A, B> (this Arr<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Either<L, B>> Traverse <L, A, B> (this Either<L, Identity<A>> ma, Func<A, B> f) Source #

method Identity<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Identity<A>> ma, Func<A, B> f) Source #

method Identity<HashSet<B>> Traverse <A, B> (this HashSet<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Identity<B>> Traverse <A, B> (this Identity<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Lst<B>> Traverse <A, B> (this Lst<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Fin<B>> Traverse <A, B> (this Fin<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Option<B>> Traverse <A, B> (this Option<Identity<A>> ma, Func<A, B> f) Source #

method Identity<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Que<B>> Traverse <A, B> (this Que<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Seq<B>> Traverse <A, B> (this Seq<Identity<A>> ma, Func<A, B> f) Source #

method Identity<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Set<B>> Traverse <A, B> (this Set<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Stck<B>> Traverse <A, B> (this Stck<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Try<B>> Traverse <A, B> (this Try<Identity<A>> ma, Func<A, B> f) Source #

method Identity<TryOption<B>> Traverse <A, B> (this TryOption<Identity<A>> ma, Func<A, B> f) Source #

method Identity<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Identity<A>> ma, Func<A, B> f) Source #

method Identity<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Identity<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Identity<Eff<B>> Traverse <A, B> (this Eff<Identity<A>> ma, Func<A, B> f) Source #

class IEnumerableT Source #

Methods

method IEnumerable<Arr<B>> Traverse <A, B> (this Arr<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Either<L, B>> Traverse <L, A, B> (this Either<L, IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<HashSet<B>> Traverse <A, B> (this HashSet<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Identity<B>> Traverse <A, B> (this Identity<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Lst<B>> Traverse <A, B> (this Lst<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Fin<B>> Traverse <A, B> (this Fin<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Option<B>> Traverse <A, B> (this Option<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Que<B>> Traverse <A, B> (this Que<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Seq<B>> Traverse <A, B> (this Seq<IEnumerable<A>> ma, Func<A, B> f) Source #

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

method IEnumerable<Set<B>> Traverse <A, B> (this Set<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Stck<B>> Traverse <A, B> (this Stck<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Try<B>> Traverse <A, B> (this Try<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<TryOption<B>> Traverse <A, B> (this TryOption<IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, IEnumerable<A>> ma, Func<A, B> f) Source #

method IEnumerable<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, IEnumerable<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method IEnumerable<Eff<B>> Traverse <A, B> (this Eff<IEnumerable<A>> ma, Func<A, B> f) Source #

class LstT Source #

Methods

method Lst<Arr<B>> Traverse <A, B> (this Arr<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Either<L, B>> Traverse <L, A, B> (this Either<L, Lst<A>> ma, Func<A, B> f) Source #

method Lst<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Lst<A>> ma, Func<A, B> f) Source #

method Lst<HashSet<B>> Traverse <A, B> (this HashSet<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Identity<B>> Traverse <A, B> (this Identity<Lst<A>> ma, Func<A, B> f) Source #

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

method Lst<Fin<B>> Traverse <A, B> (this Fin<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Option<B>> Traverse <A, B> (this Option<Lst<A>> ma, Func<A, B> f) Source #

method Lst<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Que<B>> Traverse <A, B> (this Que<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Seq<B>> Traverse <A, B> (this Seq<Lst<A>> ma, Func<A, B> f) Source #

method Lst<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Set<B>> Traverse <A, B> (this Set<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Stck<B>> Traverse <A, B> (this Stck<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Try<B>> Traverse <A, B> (this Try<Lst<A>> ma, Func<A, B> f) Source #

method Lst<TryOption<B>> Traverse <A, B> (this TryOption<Lst<A>> ma, Func<A, B> f) Source #

method Lst<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Lst<A>> ma, Func<A, B> f) Source #

method Lst<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Lst<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Lst<Eff<B>> Traverse <A, B> (this Eff<Lst<A>> ma, Func<A, B> f) Source #

class OptionAsyncT Source #

Methods

method OptionAsync<Arr<B>> Traverse <A, B> (this Arr<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<HashSet<B>> Traverse <A, B> (this HashSet<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<IEnumerable<B>> Traverse <A, B> (this IEnumerable<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<IEnumerable<B>> TraverseSerial <A, B> (this IEnumerable<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<OptionAsync<A>> ma, int windowSize, Func<A, B> f) Source #

method OptionAsync<IEnumerable<A>> Sequence <A> (this IEnumerable<OptionAsync<A>> ma) Source #

method OptionAsync<IEnumerable<A>> SequenceSerial <A> (this IEnumerable<OptionAsync<A>> ma) Source #

method OptionAsync<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<OptionAsync<A>> ma) Source #

method OptionAsync<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<OptionAsync<A>> ma, int windowSize) Source #

method OptionAsync<Lst<B>> Traverse <A, B> (this Lst<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Que<B>> Traverse <A, B> (this Que<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Seq<B>> Traverse <A, B> (this Seq<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Seq<B>> TraverseSerial <A, B> (this Seq<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Seq<B>> TraverseParallel <A, B> (this Seq<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Seq<B>> TraverseParallel <A, B> (this Seq<OptionAsync<A>> ma, int windowSize, Func<A, B> f) Source #

method OptionAsync<Seq<A>> Sequence <A> (this Seq<OptionAsync<A>> ma) Source #

method OptionAsync<Seq<A>> SequenceSerial <A> (this Seq<OptionAsync<A>> ma) Source #

method OptionAsync<Seq<A>> SequenceParallel <A> (this Seq<OptionAsync<A>> ma) Source #

method OptionAsync<Seq<A>> SequenceParallel <A> (this Seq<OptionAsync<A>> ma, int windowSize) Source #

method OptionAsync<Set<B>> Traverse <A, B> (this Set<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Stck<B>> Traverse <A, B> (this Stck<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<EitherAsync<L, B>> Traverse <L, A, B> (this EitherAsync<L, OptionAsync<A>> ma, Func<A, B> f) Source #

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

method OptionAsync<TryAsync<B>> Traverse <A, B> (this TryAsync<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<TryOptionAsync<B>> Traverse <A, B> (this TryOptionAsync<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Task<B>> Traverse <A, B> (this Task<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<ValueTask<B>> Traverse <A, B> (this ValueTask<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Aff<B>> Traverse <A, B> (this Aff<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Either<L, B>> Traverse <L, A, B> (this Either<L, OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Identity<B>> Traverse <A, B> (this Identity<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Fin<B>> Traverse <A, B> (this Fin<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Option<B>> Traverse <A, B> (this Option<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Try<B>> Traverse <A, B> (this Try<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<TryOption<B>> Traverse <A, B> (this TryOption<OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, OptionAsync<A>> ma, Func<A, B> f) Source #

method OptionAsync<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, OptionAsync<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method OptionAsync<Eff<B>> Traverse <A, B> (this Eff<OptionAsync<A>> ma, Func<A, B> f) Source #

class OptionT Source #

Methods

method Option<Arr<B>> Traverse <A, B> (this Arr<Option<A>> ma, Func<A, B> f) Source #

method Option<Either<L, B>> Traverse <L, A, B> (this Either<L, Option<A>> ma, Func<A, B> f) Source #

method Option<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Option<A>> ma, Func<A, B> f) Source #

method Option<HashSet<B>> Traverse <A, B> (this HashSet<Option<A>> ma, Func<A, B> f) Source #

method Option<Identity<B>> Traverse <A, B> (this Identity<Option<A>> ma, Func<A, B> f) Source #

method Option<Lst<B>> Traverse <A, B> (this Lst<Option<A>> ma, Func<A, B> f) Source #

method Option<Fin<B>> Traverse <A, B> (this Fin<Option<A>> ma, Func<A, B> f) Source #

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

method Option<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Option<A>> ma, Func<A, B> f) Source #

method Option<Que<B>> Traverse <A, B> (this Que<Option<A>> ma, Func<A, B> f) Source #

method Option<Seq<B>> Traverse <A, B> (this Seq<Option<A>> ma, Func<A, B> f) Source #

method Option<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Option<A>> ma, Func<A, B> f) Source #

method Option<Set<B>> Traverse <A, B> (this Set<Option<A>> ma, Func<A, B> f) Source #

method Option<Stck<B>> Traverse <A, B> (this Stck<Option<A>> ma, Func<A, B> f) Source #

method Option<Try<B>> Traverse <A, B> (this Try<Option<A>> ma, Func<A, B> f) Source #

method Option<TryOption<B>> Traverse <A, B> (this TryOption<Option<A>> ma, Func<A, B> f) Source #

method Option<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Option<A>> ma, Func<A, B> f) Source #

method Option<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> ( this Validation<MonoidFail, Fail, Option<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Option<Eff<B>> Traverse <A, B> (this Eff<Option<A>> ma, Func<A, B> f) Source #

class OptionUnsafeT Source #

Methods

method OptionUnsafe<Arr<B>> Traverse <A, B> (this Arr<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Either<L, B>> Traverse <L, A, B> (this Either<L, OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<HashSet<B>> Traverse <A, B> (this HashSet<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Identity<B>> Traverse <A, B> (this Identity<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Lst<B>> Traverse <A, B> (this Lst<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Fin<B>> Traverse <A, B> (this Fin<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Option<B>> Traverse <A, B> (this Option<OptionUnsafe<A>> ma, Func<A, B> f) Source #

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

method OptionUnsafe<Que<B>> Traverse <A, B> (this Que<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Seq<B>> Traverse <A, B> (this Seq<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<IEnumerable<B>> Traverse <A, B> (this IEnumerable<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Set<B>> Traverse <A, B> (this Set<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Stck<B>> Traverse <A, B> (this Stck<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Try<B>> Traverse <A, B> (this Try<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<TryOption<B>> Traverse <A, B> (this TryOption<OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, OptionUnsafe<A>> ma, Func<A, B> f) Source #

method OptionUnsafe<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> ( this Validation<MonoidFail, Fail, OptionUnsafe<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method OptionUnsafe<Eff<B>> Traverse <A, B> (this Eff<OptionUnsafe<A>> ma, Func<A, B> f) Source #

class QueT Source #

Methods

method Que<Arr<B>> Traverse <A, B> (this Arr<Que<A>> ma, Func<A, B> f) Source #

method Que<Either<L, B>> Traverse <L, A, B> (this Either<L, Que<A>> ma, Func<A, B> f) Source #

method Que<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Que<A>> ma, Func<A, B> f) Source #

method Que<HashSet<B>> Traverse <A, B> (this HashSet<Que<A>> ma, Func<A, B> f) Source #

method Que<Identity<B>> Traverse <A, B> (this Identity<Que<A>> ma, Func<A, B> f) Source #

method Que<Lst<B>> Traverse <A, B> (this Lst<Que<A>> ma, Func<A, B> f) Source #

method Que<Fin<B>> Traverse <A, B> (this Fin<Que<A>> ma, Func<A, B> f) Source #

method Que<Option<B>> Traverse <A, B> (this Option<Que<A>> ma, Func<A, B> f) Source #

method Que<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Que<A>> ma, Func<A, B> f) Source #

method Que<Que<B>> Traverse <A, B> (this Que<Que<A>> ma, Func<A, B> f) Source #

method Que<Seq<B>> Traverse <A, B> (this Seq<Que<A>> ma, Func<A, B> f) Source #

method Que<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Que<A>> ma, Func<A, B> f) Source #

method Que<Set<B>> Traverse <A, B> (this Set<Que<A>> ma, Func<A, B> f) Source #

method Que<Stck<B>> Traverse <A, B> (this Stck<Que<A>> ma, Func<A, B> f) Source #

method Que<Try<B>> Traverse <A, B> (this Try<Que<A>> ma, Func<A, B> f) Source #

method Que<TryOption<B>> Traverse <A, B> (this TryOption<Que<A>> ma, Func<A, B> f) Source #

method Que<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Que<A>> ma, Func<A, B> f) Source #

method Que<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Que<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Que<Eff<B>> Traverse <A, B> (this Eff<Que<A>> ma, Func<A, B> f) Source #

class ReaderT Source #

Methods

method Reader<Env, Seq<B>> Traverse <Env, A, B> (this Seq<Reader<Env, A>> ma, Func<A, B> f) Source #

method Reader<Env, Lst<B>> Traverse <Env, A, B> (this Lst<Reader<Env, A>> ma, Func<A, B> f) Source #

method Reader<Env, Arr<B>> Traverse <Env, A, B> (this Arr<Reader<Env, A>> ma, Func<A, B> f) Source #

method Reader<Env, B[]> Traverse <Env, A, B> (this Reader<Env, A>[] ma, Func<A, B> f) Source #

method Reader<Env, Set<B>> Traverse <Env, A, B> (this Set<Reader<Env, A>> ma, Func<A, B> f) Source #

method Reader<Env, HashSet<B>> Traverse <Env, A, B> (this HashSet<Reader<Env, A>> ma, Func<A, B> f) Source #

method Reader<Env, Stck<B>> Traverse <Env, A, B> (this Stck<Reader<Env, A>> ma, Func<A, B> f) Source #

method Reader<Env, IEnumerable<B>> Traverse <Env, A, B> (this IEnumerable<Reader<Env, A>> ma, Func<A, B> f) Source #

class RwsT Source #

Methods

method RWS<MonoidW, R, W, S, Seq<B>> Traverse <MonoidW, R, W, S, A, B> (this Seq<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, Lst<B>> Traverse <MonoidW, R, W, S, A, B> (this Lst<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, Arr<B>> Traverse <MonoidW, R, W, S, A, B> (this Arr<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, B[]> Traverse <MonoidW, R, W, S, A, B> (this RWS<MonoidW, R, W, S, A>[] ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, Set<B>> Traverse <MonoidW, R, W, S, A, B> (this Set<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, HashSet<B>> Traverse <MonoidW, R, W, S, A, B> (this HashSet<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, Stck<B>> Traverse <MonoidW, R, W, S, A, B> (this Stck<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method RWS<MonoidW, R, W, S, IEnumerable<B>> Traverse <MonoidW, R, W, S, A, B> (this IEnumerable<RWS<MonoidW, R, W, S, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

class SeqT Source #

Methods

method Seq<Arr<B>> Traverse <A, B> (this Arr<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Either<L, B>> Traverse <L, A, B> (this Either<L, Seq<A>> ma, Func<A, B> f) Source #

method Seq<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Seq<A>> ma, Func<A, B> f) Source #

method Seq<HashSet<B>> Traverse <A, B> (this HashSet<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Identity<B>> Traverse <A, B> (this Identity<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Lst<B>> Traverse <A, B> (this Lst<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Fin<B>> Traverse <A, B> (this Fin<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Option<B>> Traverse <A, B> (this Option<Seq<A>> ma, Func<A, B> f) Source #

method Seq<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Que<B>> Traverse <A, B> (this Que<Seq<A>> ma, Func<A, B> f) Source #

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

method Seq<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Set<B>> Traverse <A, B> (this Set<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Stck<B>> Traverse <A, B> (this Stck<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Try<B>> Traverse <A, B> (this Try<Seq<A>> ma, Func<A, B> f) Source #

method Seq<TryOption<B>> Traverse <A, B> (this TryOption<Seq<A>> ma, Func<A, B> f) Source #

method Seq<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Seq<A>> ma, Func<A, B> f) Source #

method Seq<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Seq<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Seq<Eff<B>> Traverse <A, B> (this Eff<Seq<A>> ma, Func<A, B> f) Source #

class SetT Source #

Methods

method Set<Arr<B>> Traverse <A, B> (this Arr<Set<A>> ma, Func<A, B> f) Source #

method Set<Either<L, B>> Traverse <L, A, B> (this Either<L, Set<A>> ma, Func<A, B> f) Source #

method Set<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Set<A>> ma, Func<A, B> f) Source #

method Set<HashSet<B>> Traverse <A, B> (this HashSet<Set<A>> ma, Func<A, B> f) Source #

method Set<Identity<B>> Traverse <A, B> (this Identity<Set<A>> ma, Func<A, B> f) Source #

method Set<Lst<B>> Traverse <A, B> (this Lst<Set<A>> ma, Func<A, B> f) Source #

method Set<Fin<B>> Traverse <A, B> (this Fin<Set<A>> ma, Func<A, B> f) Source #

method Set<Option<B>> Traverse <A, B> (this Option<Set<A>> ma, Func<A, B> f) Source #

method Set<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Set<A>> ma, Func<A, B> f) Source #

method Set<Que<B>> Traverse <A, B> (this Que<Set<A>> ma, Func<A, B> f) Source #

method Set<Seq<B>> Traverse <A, B> (this Seq<Set<A>> ma, Func<A, B> f) Source #

method Set<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Set<A>> ma, Func<A, B> f) Source #

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

method Set<Stck<B>> Traverse <A, B> (this Stck<Set<A>> ma, Func<A, B> f) Source #

method Set<Try<B>> Traverse <A, B> (this Try<Set<A>> ma, Func<A, B> f) Source #

method Set<TryOption<B>> Traverse <A, B> (this TryOption<Set<A>> ma, Func<A, B> f) Source #

method Set<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Set<A>> ma, Func<A, B> f) Source #

method Set<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Set<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Set<Eff<B>> Traverse <A, B> (this Eff<Set<A>> ma, Func<A, B> f) Source #

class StateT Source #

Methods

method State<S, Seq<B>> Traverse <S, A, B> (this Seq<State<S, A>> ma, Func<A, B> f) Source #

method State<S, Lst<B>> Traverse <S, A, B> (this Lst<State<S, A>> ma, Func<A, B> f) Source #

method State<S, Arr<B>> Traverse <S, A, B> (this Arr<State<S, A>> ma, Func<A, B> f) Source #

method State<S, B[]> Traverse <S, A, B> (this State<S, A>[] ma, Func<A, B> f) Source #

method State<S, Set<B>> Traverse <S, A, B> (this Set<State<S, A>> ma, Func<A, B> f) Source #

method State<S, HashSet<B>> Traverse <S, A, B> (this HashSet<State<S, A>> ma, Func<A, B> f) Source #

method State<S, Stck<B>> Traverse <S, A, B> (this Stck<State<S, A>> ma, Func<A, B> f) Source #

method State<S, IEnumerable<B>> Traverse <S, A, B> (this IEnumerable<State<S, A>> ma, Func<A, B> f) Source #

class StckT Source #

Methods

method Stck<Arr<B>> Traverse <A, B> (this Arr<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Either<L, B>> Traverse <L, A, B> (this Either<L, Stck<A>> ma, Func<A, B> f) Source #

method Stck<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Stck<A>> ma, Func<A, B> f) Source #

method Stck<HashSet<B>> Traverse <A, B> (this HashSet<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Identity<B>> Traverse <A, B> (this Identity<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Lst<B>> Traverse <A, B> (this Lst<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Fin<B>> Traverse <A, B> (this Fin<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Option<B>> Traverse <A, B> (this Option<Stck<A>> ma, Func<A, B> f) Source #

method Stck<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Que<B>> Traverse <A, B> (this Que<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Seq<B>> Traverse <A, B> (this Seq<Stck<A>> ma, Func<A, B> f) Source #

method Stck<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Set<B>> Traverse <A, B> (this Set<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Stck<B>> Traverse <A, B> (this Stck<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Try<B>> Traverse <A, B> (this Try<Stck<A>> ma, Func<A, B> f) Source #

method Stck<TryOption<B>> Traverse <A, B> (this TryOption<Stck<A>> ma, Func<A, B> f) Source #

method Stck<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Stck<A>> ma, Func<A, B> f) Source #

method Stck<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Stck<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Stck<Eff<B>> Traverse <A, B> (this Eff<Stck<A>> ma, Func<A, B> f) Source #

class TaskT Source #

Methods

method Task<Arr<B>> Traverse <A, B> (this Arr<Task<A>> ma, Func<A, B> f) Source #

method Task<HashSet<B>> Traverse <A, B> (this HashSet<Task<A>> ma, Func<A, B> f) Source #

method Task<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Task<A>> ma, Func<A, B> f) Source #

method Task<IEnumerable<B>> TraverseSerial <A, B> (this IEnumerable<Task<A>> ma, Func<A, B> f) Source #

method Task<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<Task<A>> ma, int windowSize, Func<A, B> f) Source #

method Task<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<Task<A>> ma, Func<A, B> f) Source #

method Task<IEnumerable<A>> Sequence <A> (this IEnumerable<Task<A>> ma) Source #

method Task<IEnumerable<A>> SequenceSerial <A> (this IEnumerable<Task<A>> ma) Source #

method Task<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<Task<A>> ma) Source #

method Task<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<Task<A>> ma, int windowSize) Source #

method Task<Lst<B>> Traverse <A, B> (this Lst<Task<A>> ma, Func<A, B> f) Source #

method Task<Lst<A>> Sequence <A> (this Lst<Task<A>> ma) Source #

method Task<Que<B>> Traverse <A, B> (this Que<Task<A>> ma, Func<A, B> f) Source #

method Task<Que<A>> Sequence <A> (this Que<Task<A>> ma) Source #

method Task<Seq<B>> Traverse <A, B> (this Seq<Task<A>> ma, Func<A, B> f) Source #

method Task<Seq<B>> TraverseSerial <A, B> (this Seq<Task<A>> ma, Func<A, B> f) Source #

method Task<Seq<B>> TraverseParallel <A, B> (this Seq<Task<A>> ma, int windowSize, Func<A, B> f) Source #

method Task<Seq<B>> TraverseParallel <A, B> (this Seq<Task<A>> ma, Func<A, B> f) Source #

method Task<Seq<A>> Sequence <A> (this Seq<Task<A>> ma) Source #

method Task<Seq<A>> SequenceSerial <A> (this Seq<Task<A>> ma) Source #

method Task<Seq<A>> SequenceParallel <A> (this Seq<Task<A>> ma) Source #

method Task<Seq<A>> SequenceParallel <A> (this Seq<Task<A>> ma, int windowSize) Source #

method Task<Set<B>> Traverse <A, B> (this Set<Task<A>> ma, Func<A, B> f) Source #

method Task<Stck<B>> Traverse <A, B> (this Stck<Task<A>> ma, Func<A, B> f) Source #

method Task<Stck<A>> Sequence <A> (this Stck<Task<A>> ma) Source #

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

method Task<OptionAsync<B>> Traverse <A, B> (this OptionAsync<Task<A>> ma, Func<A, B> f) Source #

method Task<TryAsync<B>> Traverse <A, B> (this TryAsync<Task<A>> ma, Func<A, B> f) Source #

method Task<TryOptionAsync<B>> Traverse <A, B> (this TryOptionAsync<Task<A>> ma, Func<A, B> f) Source #

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

method Task<ValueTask<B>> Traverse <A, B> (this ValueTask<Task<A>> ma, Func<A, B> f) Source #

method Task<Aff<B>> Traverse <A, B> (this Aff<Task<A>> ma, Func<A, B> f) Source #

method Task<Either<L, B>> Traverse <L, A, B> (this Either<L, Task<A>> ma, Func<A, B> f) Source #

method Task<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Task<A>> ma, Func<A, B> f) Source #

method Task<Identity<B>> Traverse <A, B> (this Identity<Task<A>> ma, Func<A, B> f) Source #

method Task<Fin<B>> Traverse <A, B> (this Fin<Task<A>> ma, Func<A, B> f) Source #

method Task<Option<B>> Traverse <A, B> (this Option<Task<A>> ma, Func<A, B> f) Source #

method Task<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Task<A>> ma, Func<A, B> f) Source #

method Task<Try<B>> Traverse <A, B> (this Try<Task<A>> ma, Func<A, B> f) Source #

method Task<TryOption<B>> Traverse <A, B> (this TryOption<Task<A>> ma, Func<A, B> f) Source #

method Task<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Task<A>> ma, Func<A, B> f) Source #

method Task<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Task<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Task<Eff<B>> Traverse <A, B> (this Eff<Task<A>> ma, Func<A, B> f) Source #

class TryAsyncT Source #

Methods

method TryAsync<Arr<B>> Traverse <A, B> (this Arr<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<HashSet<B>> Traverse <A, B> (this HashSet<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<IEnumerable<B>> Traverse <A, B> (this IEnumerable<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<IEnumerable<B>> TraverseSerial <A, B> (this IEnumerable<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<TryAsync<A>> ma, int windowSize, Func<A, B> f) Source #

method TryAsync<IEnumerable<A>> Sequence <A> (this IEnumerable<TryAsync<A>> ma) Source #

method TryAsync<IEnumerable<A>> SequenceSerial <A> (this IEnumerable<TryAsync<A>> ma) Source #

method TryAsync<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<TryAsync<A>> ma) Source #

method TryAsync<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<TryAsync<A>> ma, int windowSize) Source #

method TryAsync<Lst<B>> Traverse <A, B> (this Lst<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Que<B>> Traverse <A, B> (this Que<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Seq<B>> Traverse <A, B> (this Seq<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Seq<B>> TraverseSerial <A, B> (this Seq<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Seq<B>> TraverseParallel <A, B> (this Seq<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Seq<B>> TraverseParallel <A, B> (this Seq<TryAsync<A>> ma, int windowSize, Func<A, B> f) Source #

method TryAsync<Seq<A>> Sequence <A> (this Seq<TryAsync<A>> ma) Source #

method TryAsync<Seq<A>> SequenceSerial <A> (this Seq<TryAsync<A>> ma) Source #

method TryAsync<Seq<A>> SequenceParallel <A> (this Seq<TryAsync<A>> ma) Source #

method TryAsync<Seq<A>> SequenceParallel <A> (this Seq<TryAsync<A>> ma, int windowSize) Source #

method TryAsync<Set<B>> Traverse <A, B> (this Set<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Stck<B>> Traverse <A, B> (this Stck<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<EitherAsync<L, B>> Traverse <L, A, B> (this EitherAsync<L, TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<OptionAsync<B>> Traverse <A, B> (this OptionAsync<TryAsync<A>> ma, Func<A, B> f) Source #

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

method TryAsync<TryOptionAsync<B>> Traverse <A, B> (this TryOptionAsync<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Task<B>> Traverse <A, B> (this Task<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<ValueTask<B>> Traverse <A, B> (this ValueTask<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Aff<B>> Traverse <A, B> (this Aff<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Either<L, B>> Traverse <L, A, B> (this Either<L, TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Identity<B>> Traverse <A, B> (this Identity<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Fin<B>> Traverse <A, B> (this Fin<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Option<B>> Traverse <A, B> (this Option<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Try<B>> Traverse <A, B> (this Try<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<TryOption<B>> Traverse <A, B> (this TryOption<TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, TryAsync<A>> ma, Func<A, B> f) Source #

method TryAsync<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, TryAsync<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method TryAsync<Eff<B>> Traverse <A, B> (this Eff<TryAsync<A>> ma, Func<A, B> f) Source #

class TryOptionAsyncT Source #

Methods

method TryOptionAsync<Arr<B>> Traverse <A, B> (this Arr<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<HashSet<B>> Traverse <A, B> (this HashSet<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<IEnumerable<B>> Traverse <A, B> (this IEnumerable<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<IEnumerable<B>> TraverseSerial <A, B> (this IEnumerable<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<TryOptionAsync<A>> ma, int windowSize, Func<A, B> f) Source #

method TryOptionAsync<IEnumerable<A>> Sequence <A> (this IEnumerable<TryOptionAsync<A>> ma) Source #

method TryOptionAsync<IEnumerable<A>> SequenceSerial <A> (this IEnumerable<TryOptionAsync<A>> ma) Source #

method TryOptionAsync<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<TryOptionAsync<A>> ma) Source #

method TryOptionAsync<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<TryOptionAsync<A>> ma, int windowSize) Source #

method TryOptionAsync<Lst<B>> Traverse <A, B> (this Lst<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Que<B>> Traverse <A, B> (this Que<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Seq<B>> Traverse <A, B> (this Seq<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Seq<B>> TraverseSerial <A, B> (this Seq<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Seq<B>> TraverseParallel <A, B> (this Seq<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Seq<B>> TraverseParallel <A, B> (this Seq<TryOptionAsync<A>> ma, int windowSize, Func<A, B> f) Source #

method TryOptionAsync<Seq<A>> Sequence <A> (this Seq<TryOptionAsync<A>> ma) Source #

method TryOptionAsync<Seq<A>> SequenceSerial <A> (this Seq<TryOptionAsync<A>> ma) Source #

method TryOptionAsync<Seq<A>> SequenceParallel <A> (this Seq<TryOptionAsync<A>> ma) Source #

method TryOptionAsync<Seq<A>> SequenceParallel <A> (this Seq<TryOptionAsync<A>> ma, int windowSize) Source #

method TryOptionAsync<Set<B>> Traverse <A, B> (this Set<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Stck<B>> Traverse <A, B> (this Stck<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<EitherAsync<L, B>> Traverse <L, A, B> (this EitherAsync<L, TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<OptionAsync<B>> Traverse <A, B> (this OptionAsync<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<TryAsync<B>> Traverse <A, B> (this TryAsync<TryOptionAsync<A>> ma, Func<A, B> f) Source #

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

method TryOptionAsync<Task<B>> Traverse <A, B> (this Task<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<ValueTask<B>> Traverse <A, B> (this ValueTask<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Aff<B>> Traverse <A, B> (this Aff<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Either<L, B>> Traverse <L, A, B> (this Either<L, TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Identity<B>> Traverse <A, B> (this Identity<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Fin<B>> Traverse <A, B> (this Fin<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Option<B>> Traverse <A, B> (this Option<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Try<B>> Traverse <A, B> (this Try<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<TryOption<B>> Traverse <A, B> (this TryOption<TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, TryOptionAsync<A>> ma, Func<A, B> f) Source #

method TryOptionAsync<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, TryOptionAsync<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method TryOptionAsync<Eff<B>> Traverse <A, B> (this Eff<TryOptionAsync<A>> ma, Func<A, B> f) Source #

class TryOptionT Source #

Methods

method TryOption<Arr<B>> Traverse <A, B> (this Arr<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Either<L, B>> Traverse <L, A, B> (this Either<L, TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<HashSet<B>> Traverse <A, B> (this HashSet<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Identity<B>> Traverse <A, B> (this Identity<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Lst<B>> Traverse <A, B> (this Lst<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Fin<B>> Traverse <A, B> (this Fin<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Option<B>> Traverse <A, B> (this Option<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Que<B>> Traverse <A, B> (this Que<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Seq<B>> Traverse <A, B> (this Seq<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<IEnumerable<B>> Traverse <A, B> (this IEnumerable<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Set<B>> Traverse <A, B> (this Set<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Stck<B>> Traverse <A, B> (this Stck<TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Try<B>> Traverse <A, B> (this Try<TryOption<A>> ma, Func<A, B> f) Source #

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

method TryOption<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, TryOption<A>> ma, Func<A, B> f) Source #

method TryOption<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> ( this Validation<MonoidFail, Fail, TryOption<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method TryOption<Eff<B>> Traverse <A, B> (this Eff<TryOption<A>> ma, Func<A, B> f) Source #

class TryT Source #

Methods

method Try<Arr<B>> Traverse <A, B> (this Arr<Try<A>> ma, Func<A, B> f) Source #

method Try<Either<L, B>> Traverse <L, A, B> (this Either<L, Try<A>> ma, Func<A, B> f) Source #

method Try<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, Try<A>> ma, Func<A, B> f) Source #

method Try<HashSet<B>> Traverse <A, B> (this HashSet<Try<A>> ma, Func<A, B> f) Source #

method Try<Identity<B>> Traverse <A, B> (this Identity<Try<A>> ma, Func<A, B> f) Source #

method Try<Lst<B>> Traverse <A, B> (this Lst<Try<A>> ma, Func<A, B> f) Source #

method Try<Fin<B>> Traverse <A, B> (this Fin<Try<A>> ma, Func<A, B> f) Source #

method Try<Option<B>> Traverse <A, B> (this Option<Try<A>> ma, Func<A, B> f) Source #

method Try<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<Try<A>> ma, Func<A, B> f) Source #

method Try<Que<B>> Traverse <A, B> (this Que<Try<A>> ma, Func<A, B> f) Source #

method Try<Seq<B>> Traverse <A, B> (this Seq<Try<A>> ma, Func<A, B> f) Source #

method Try<IEnumerable<B>> Traverse <A, B> (this IEnumerable<Try<A>> ma, Func<A, B> f) Source #

method Try<Set<B>> Traverse <A, B> (this Set<Try<A>> ma, Func<A, B> f) Source #

method Try<Stck<B>> Traverse <A, B> (this Stck<Try<A>> ma, Func<A, B> f) Source #

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

method Try<TryOption<B>> Traverse <A, B> (this TryOption<Try<A>> ma, Func<A, B> f) Source #

method Try<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Try<A>> ma, Func<A, B> f) Source #

method Try<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> ( this Validation<MonoidFail, Fail, Try<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Try<Eff<B>> Traverse <A, B> (this Eff<Try<A>> ma, Func<A, B> f) Source #

class ValidationT Source #

Methods

method Validation<Fail, Arr<B>> Traverse <Fail, A, B> (this Arr<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Either<L, B>> Traverse <L, Fail, A, B> (this Either<L, Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, EitherUnsafe<L, B>> Traverse <L, Fail, A, B> (this EitherUnsafe<L, Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, HashSet<B>> Traverse <Fail, A, B> (this HashSet<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Identity<B>> Traverse <Fail, A, B> (this Identity<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Lst<B>> Traverse <Fail, A, B> (this Lst<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Fin<B>> Traverse <Fail, A, B> (this Fin<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Option<B>> Traverse <Fail, A, B> (this Option<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, OptionUnsafe<B>> Traverse <Fail, A, B> (this OptionUnsafe<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Que<B>> Traverse <Fail, A, B> (this Que<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Seq<B>> Traverse <Fail, A, B> (this Seq<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, IEnumerable<B>> Traverse <Fail, A, B> (this IEnumerable<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Set<B>> Traverse <Fail, A, B> (this Set<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Stck<B>> Traverse <Fail, A, B> (this Stck<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Try<B>> Traverse <Fail, A, B> (this Try<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, TryOption<B>> Traverse <Fail, A, B> (this TryOption<Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, Validation<Fail, A>> ma, Func<A, B> f) Source #

method Validation<Fail, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Validation<Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<Fail, Eff<B>> Traverse <Fail, A, B> (this Eff<Validation<Fail, A>> ma, Func<A, B> f) Source #

class ValidationT Source #

Methods

method Validation<MonoidFail, Fail, Arr<B>> Traverse <MonoidFail, Fail, A, B> (this Arr<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Either<Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Either<Fail, Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, EitherUnsafe<Fail, B>> Traverse <MonoidFail, Fail, A, B> (this EitherUnsafe<Fail, Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, HashSet<B>> Traverse <MonoidFail, Fail, A, B> (this HashSet<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Identity<B>> Traverse <MonoidFail, Fail, A, B> (this Identity<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Lst<B>> Traverse <MonoidFail, Fail, A, B> (this Lst<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Fin<B>> Traverse <MonoidFail, Fail, A, B> (this Fin<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Option<B>> Traverse <MonoidFail, Fail, A, B> (this Option<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, OptionUnsafe<B>> Traverse <MonoidFail, Fail, A, B> (this OptionUnsafe<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Que<B>> Traverse <MonoidFail, Fail, A, B> (this Que<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Seq<B>> Traverse <MonoidFail, Fail, A, B> (this Seq<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, IEnumerable<B>> Traverse <MonoidFail, Fail, A, B> (this IEnumerable<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Set<B>> Traverse <MonoidFail, Fail, A, B> (this Set<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Stck<B>> Traverse <MonoidFail, Fail, A, B> (this Stck<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Try<B>> Traverse <MonoidFail, Fail, A, B> (this Try<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, TryOption<B>> Traverse <MonoidFail, Fail, A, B> (this TryOption<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Validation<Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<Fail, Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method Validation<MonoidFail, Fail, Eff<B>> Traverse <MonoidFail, Fail, A, B> (this Eff<Validation<MonoidFail, Fail, A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

class ValueTaskT Source #

Methods

method ValueTask<Arr<B>> Traverse <A, B> (this Arr<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<HashSet<B>> Traverse <A, B> (this HashSet<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<IEnumerable<B>> Traverse <A, B> (this IEnumerable<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<IEnumerable<B>> TraverseSerial <A, B> (this IEnumerable<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<ValueTask<A>> ma, int windowSize, Func<A, B> f) Source #

method ValueTask<IEnumerable<B>> TraverseParallel <A, B> (this IEnumerable<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<IEnumerable<A>> Sequence <A> (this IEnumerable<ValueTask<A>> ma) Source #

method ValueTask<IEnumerable<A>> SequenceSerial <A> (this IEnumerable<ValueTask<A>> ma) Source #

method ValueTask<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<ValueTask<A>> ma) Source #

method ValueTask<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<ValueTask<A>> ma, int windowSize) Source #

method ValueTask<Lst<B>> Traverse <A, B> (this Lst<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Que<B>> Traverse <A, B> (this Que<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Seq<B>> Traverse <A, B> (this Seq<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Seq<B>> TraverseSerial <A, B> (this Seq<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Seq<B>> TraverseParallel <A, B> (this Seq<ValueTask<A>> ma, int windowSize, Func<A, B> f) Source #

method ValueTask<Seq<B>> TraverseParallel <A, B> (this Seq<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Seq<A>> Sequence <A> (this Seq<ValueTask<A>> ma) Source #

method ValueTask<Seq<A>> SequenceSerial <A> (this Seq<ValueTask<A>> ma) Source #

method ValueTask<Seq<A>> SequenceParallel <A> (this Seq<ValueTask<A>> ma) Source #

method ValueTask<Seq<A>> SequenceParallel <A> (this Seq<ValueTask<A>> ma, int windowSize) Source #

method ValueTask<Set<B>> Traverse <A, B> (this Set<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Stck<B>> Traverse <A, B> (this Stck<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<EitherAsync<L, B>> Traverse <L, A, B> (this EitherAsync<L, ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<OptionAsync<B>> Traverse <A, B> (this OptionAsync<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<TryAsync<B>> Traverse <A, B> (this TryAsync<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<TryOptionAsync<B>> Traverse <A, B> (this TryOptionAsync<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Task<B>> Traverse <A, B> (this Task<ValueTask<A>> ma, Func<A, B> f) Source #

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

method ValueTask<Aff<B>> Traverse <A, B> (this Aff<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Either<L, B>> Traverse <L, A, B> (this Either<L, ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<EitherUnsafe<L, B>> Traverse <L, A, B> (this EitherUnsafe<L, ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Identity<B>> Traverse <A, B> (this Identity<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Fin<B>> Traverse <A, B> (this Fin<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Option<B>> Traverse <A, B> (this Option<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<OptionUnsafe<B>> Traverse <A, B> (this OptionUnsafe<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Try<B>> Traverse <A, B> (this Try<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<TryOption<B>> Traverse <A, B> (this TryOption<ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Validation<Fail, B>> Traverse <Fail, A, B> (this Validation<Fail, ValueTask<A>> ma, Func<A, B> f) Source #

method ValueTask<Validation<MonoidFail, Fail, B>> Traverse <MonoidFail, Fail, A, B> (this Validation<MonoidFail, Fail, ValueTask<A>> ma, Func<A, B> f) Source #

where MonoidFail : struct, Monoid<Fail>, Eq<Fail>

method ValueTask<Eff<B>> Traverse <A, B> (this Eff<ValueTask<A>> ma, Func<A, B> f) Source #

class WriterT Source #

Methods

method Writer<MonoidW, W, Seq<B>> Traverse <MonoidW, W, A, B> (this Seq<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, Lst<B>> Traverse <MonoidW, W, A, B> (this Lst<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, Arr<B>> Traverse <MonoidW, W, A, B> (this Arr<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, B[]> Traverse <MonoidW, W, A, B> (this Writer<MonoidW, W, A>[] ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, Set<B>> Traverse <MonoidW, W, A, B> (this Set<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, HashSet<B>> Traverse <MonoidW, W, A, B> (this HashSet<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, Stck<B>> Traverse <MonoidW, W, A, B> (this Stck<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>

method Writer<MonoidW, W, IEnumerable<B>> Traverse <MonoidW, W, A, B> (this IEnumerable<Writer<MonoidW, W, A>> ma, Func<A, B> f) Source #

where MonoidW : struct, Monoid<W>