Contents
- AffPureT
- SequenceParallel <A> (this Arr<Aff<A>> ta)
- SequenceParallel <A> (this Arr<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this Arr<Aff<A>> ta)
- Sequence <L, A> (this Either<L, Aff<A>> ta)
- Sequence <A> (this Fin<Aff<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Aff<A>> ta)
- Sequence <A> (this Identity<Aff<A>> ta)
- SequenceParallel <A> (this IEnumerable<Aff<A>> ta)
- SequenceParallel <A> (this IEnumerable<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this IEnumerable<Aff<A>> ta)
- SequenceParallel <A> (this Lst<Aff<A>> ta)
- SequenceParallel <A> (this Lst<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this Lst<Aff<A>> ta)
- Sequence <A> (this TryAsync<Aff<A>> ta)
- Sequence <A> (this Option<Aff<A>> ta)
- Sequence <A> (this OptionUnsafe<Aff<A>> ta)
- SequenceParallel <A> (this Que<Aff<A>> ta)
- SequenceParallel <A> (this Que<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this Que<Aff<A>> ta)
- SequenceParallel <A> (this Seq<Aff<A>> ta)
- SequenceParallel <A> (this Seq<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this Seq<Aff<A>> ta)
- SequenceParallel <A> (this Set<Aff<A>> ta)
- SequenceParallel <A> (this Set<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this Set<Aff<A>> ta)
- SequenceParallel <A> (this HashSet<Aff<A>> ta)
- SequenceParallel <A> (this HashSet<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this HashSet<Aff<A>> ta)
- SequenceParallel <A> (this Stck<Aff<A>> ta)
- SequenceParallel <A> (this Stck<Aff<A>> ta, int windowSize)
- SequenceSerial <A> (this Stck<Aff<A>> ta)
- Sequence <A> (this Try<Aff<A>> ta)
- Sequence <A> (this TryOption<Aff<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Aff<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Aff<A>> ta)
- Sequence <A> (this Task<Aff<A>> ta)
- Sequence <A> (this OptionAsync<Aff<A>> ta)
- Sequence <A> (this TryOptionAsync<Aff<A>> ta)
- Sequence <L, A> (this EitherAsync<L, Aff<A>> ta)
- Sequence <A> (this Eff<Aff<A>> ta)
- AffT
- SequenceParallel <RT, A> (this Arr<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Arr<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this Arr<Aff<RT, A>> ta)
- Sequence <RT, L, A> (this Either<L, Aff<RT, A>> ta)
- Sequence <RT, L, A> (this EitherUnsafe<L, Aff<RT, A>> ta)
- Sequence <RT, A> (this Identity<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this IEnumerable<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this IEnumerable<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this IEnumerable<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Lst<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Lst<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this Lst<Aff<RT, A>> ta)
- Sequence <RT, A> (this TryAsync<Aff<RT, A>> ta)
- Sequence <RT, A> (this Fin<Aff<RT, A>> ta)
- Sequence <RT, A> (this Option<Aff<RT, A>> ta)
- Sequence <RT, A> (this OptionUnsafe<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Seq<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Seq<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this Seq<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Set<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Set<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this Set<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this HashSet<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this HashSet<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this HashSet<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Que<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Que<Aff<RT, A>> ta, int windowSize)
- SequenceSerial <RT, A> (this Que<Aff<RT, A>> ta)
- SequenceSerial <RT, A> (this Stck<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Stck<Aff<RT, A>> ta)
- SequenceParallel <RT, A> (this Stck<Aff<RT, A>> ta, int windowSize)
- Sequence <RT, A> (this Try<Aff<RT, A>> ta)
- Sequence <RT, A> (this TryOption<Aff<RT, A>> ta)
- Sequence <RT, FAIL, A> (this Validation<FAIL, Aff<RT, A>> ta)
- Sequence <RT, MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Aff<RT, A>> ta)
- Sequence <RT, A> (this Task<Aff<RT, A>> ta)
- Sequence <RT, A> (this OptionAsync<Aff<RT, A>> ta)
- Sequence <RT, A> (this TryOptionAsync<Aff<RT, A>> ta)
- Sequence <RT, L, A> (this EitherAsync<L, Aff<RT, A>> ta)
- Sequence <RT, A> (this Aff<Aff<RT, A>> ta)
- Sequence <RT, A> (this Eff<Aff<RT, A>> ta)
- Sequence <RT, A> (this Eff<RT, Aff<RT, A>> ta)
- ArrT
- Sequence <A> (this Arr<Arr<A>> ta)
- Sequence <L, A> (this Either<L, Arr<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Arr<A>> ta)
- Sequence <A> (this Identity<Arr<A>> ta)
- Sequence <A> (this IEnumerable<Arr<A>> ta)
- Sequence <A> (this Lst<Arr<A>> ta)
- Sequence <A> (this Fin<Arr<A>> ta)
- Sequence <A> (this Option<Arr<A>> ta)
- Sequence <A> (this OptionUnsafe<Arr<A>> ta)
- Sequence <A> (this Seq<Arr<A>> ta)
- Sequence <A> (this Set<Arr<A>> ta)
- Sequence <A> (this HashSet<Arr<A>> ta)
- Sequence <A> (this Try<Arr<A>> ta)
- Sequence <A> (this TryOption<Arr<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Arr<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Arr<A>> ta)
- Sequence <A> (this Eff<Arr<A>> ta)
- EffPureT
- Sequence <A> (this Arr<Eff<A>> ma)
- Sequence <L, A> (this Either<L, Eff<A>> mma)
- Sequence <L, A> (this EitherUnsafe<L, Eff<A>> mma)
- Sequence <A> (this Identity<Eff<A>> mma)
- Sequence <A> (this IEnumerable<Eff<A>> mma)
- Sequence <A> (this Lst<Eff<A>> mma)
- Sequence <A> (this Fin<Eff<A>> mma)
- Sequence <A> (this Option<Eff<A>> mma)
- Sequence <A> (this OptionUnsafe<Eff<A>> mma)
- Sequence <A> (this Seq<Eff<A>> ma)
- Sequence <A> (this Set<Eff<A>> ma)
- Sequence <A> (this HashSet<Eff<A>> ma)
- Sequence <A> (this Que<Eff<A>> ma)
- Sequence <A> (this Stck<Eff<A>> ma)
- Sequence <A> (this Try<Eff<A>> mma)
- Sequence <A> (this TryOption<Eff<A>> mma)
- Sequence <FAIL, A> (this Validation<FAIL, Eff<A>> mma)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Eff<A>> mma)
- AffT
- Sequence <RT, A> (this Arr<Eff<RT, A>> ma)
- Sequence <RT, L, A> (this Either<L, Eff<RT, A>> mma)
- Sequence <RT, L, A> (this EitherUnsafe<L, Eff<RT, A>> mma)
- Sequence <RT, A> (this Identity<Eff<RT, A>> mma)
- Sequence <RT, A> (this IEnumerable<Eff<RT, A>> ma)
- Sequence <RT, A> (this Lst<Eff<RT, A>> ma)
- Sequence <RT, A> (this Fin<Eff<RT, A>> mma)
- Sequence <RT, A> (this Option<Eff<RT, A>> mma)
- Sequence <RT, A> (this OptionUnsafe<Eff<RT, A>> mma)
- Sequence <RT, A> (this Seq<Eff<RT, A>> ma)
- Sequence <RT, A> (this Set<Eff<RT, A>> ma)
- Sequence <RT, A> (this HashSet<Eff<RT, A>> ma)
- Sequence <RT, A> (this Que<Eff<RT, A>> ma)
- Sequence <RT, A> (this Stck<Eff<RT, A>> ma)
- Sequence <RT, A> (this Try<Eff<RT, A>> mma)
- Sequence <RT, A> (this TryOption<Eff<RT, A>> mma)
- Sequence <RT, FAIL, A> (this Validation<FAIL, Eff<RT, A>> mma)
- Sequence <RT, MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Eff<RT, A>> mma)
- Sequence <RT, A> (this Eff<Eff<RT, A>> mma)
- EitherAsyncT
- Sequence <L, A> (this Arr<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Either<L, EitherAsync<L, A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, EitherAsync<L, A>> ta)
- Sequence <L, A> (this EitherAsync<L, EitherAsync<L, A>> ta)
- Sequence <L, A> (this Identity<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Lst<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Fin<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Option<EitherAsync<L, A>> ta)
- Sequence <L, A> (this OptionUnsafe<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Set<EitherAsync<L, A>> ta)
- Sequence <L, A> (this HashSet<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Try<EitherAsync<L, A>> ta)
- Sequence <L, A> (this TryOption<EitherAsync<L, A>> ta)
- Sequence <FAIL, L, A> (this Validation<FAIL, EitherAsync<L, A>> ta)
- Sequence <L, A> (this TryAsync<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Task<EitherAsync<L, A>> ta)
- Sequence <L, A> (this TryOptionAsync<EitherAsync<L, A>> ta)
- Sequence <L, A> (this OptionAsync<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Aff<EitherAsync<L, A>> ta)
- Sequence <L, A> (this Eff<EitherAsync<L, A>> ta)
- EitherT
- Sequence <L, A> (this Arr<Either<L, A>> ta)
- Sequence <L, A> (this Either<L, Either<L, A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Either<L, A>> ta)
- Sequence <L, A> (this Identity<Either<L, A>> ta)
- Sequence <L, A> (this IEnumerable<Either<L, A>> ta)
- Sequence <L, A> (this Lst<Either<L, A>> ta)
- Sequence <L, A> (this Fin<Either<L, A>> ta)
- Sequence <L, A> (this Option<Either<L, A>> ta)
- Sequence <L, A> (this OptionUnsafe<Either<L, A>> ta)
- Sequence <L, A> (this Seq<Either<L, A>> ta)
- Sequence <L, A> (this Set<Either<L, A>> ta)
- Sequence <L, A> (this HashSet<Either<L, A>> ta)
- Sequence <L, A> (this Try<Either<L, A>> ta)
- Sequence <L, A> (this TryOption<Either<L, A>> ta)
- Sequence <FAIL, L, A> (this Validation<FAIL, Either<L, A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Either<FAIL, A>> ta)
- Sequence <L, A> (this Eff<Either<L, A>> ta)
- EitherUnsafeT
- Sequence <L, A> (this Arr<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Either<L, EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Identity<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this IEnumerable<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Lst<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Fin<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Option<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this OptionUnsafe<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Seq<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Set<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this HashSet<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Try<EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this TryOption<EitherUnsafe<L, A>> ta)
- Sequence <FAIL, L, A> (this Validation<FAIL, EitherUnsafe<L, A>> ta)
- Sequence <L, A> (this Eff<EitherUnsafe<L, A>> ta)
- FinT
- Sequence <A> (this Arr<Fin<A>> ta)
- Sequence <L, A> (this Either<L, Fin<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Fin<A>> ta)
- Sequence <A> (this Identity<Fin<A>> ta)
- Sequence <A> (this IEnumerable<Fin<A>> ta)
- Sequence <A> (this Lst<Fin<A>> ta)
- Sequence <A> (this Fin<Fin<A>> ta)
- Sequence <A> (this Option<Fin<A>> ta)
- Sequence <A> (this OptionUnsafe<Fin<A>> ta)
- Sequence <A> (this Seq<Fin<A>> ta)
- Sequence <A> (this Set<Fin<A>> ta)
- Sequence <A> (this HashSet<Fin<A>> ta)
- Sequence <A> (this Try<Fin<A>> ta)
- Sequence <A> (this TryOption<Fin<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Fin<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Fin<A>> ta)
- Sequence <A> (this Eff<Fin<A>> ta)
- HashSetT
- Sequence <A> (this Arr<HashSet<A>> ta)
- Sequence <L, A> (this Either<L, HashSet<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, HashSet<A>> ta)
- Sequence <A> (this Identity<HashSet<A>> ta)
- Sequence <A> (this IEnumerable<HashSet<A>> ta)
- Sequence <A> (this Lst<HashSet<A>> ta)
- Sequence <A> (this Fin<HashSet<A>> ta)
- Sequence <A> (this Option<HashSet<A>> ta)
- Sequence <A> (this OptionUnsafe<HashSet<A>> ta)
- Sequence <A> (this Seq<HashSet<A>> ta)
- Sequence <A> (this Set<HashSet<A>> ta)
- Sequence <A> (this HashSet<HashSet<A>> ta)
- Sequence <A> (this Try<HashSet<A>> ta)
- Sequence <A> (this TryOption<HashSet<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, HashSet<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, HashSet<A>> ta)
- Sequence <A> (this Eff<HashSet<A>> ta)
- IEnumerableT
- Sequence <A> (this Arr<IEnumerable<A>> ta)
- Sequence <L, A> (this Either<L, IEnumerable<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, IEnumerable<A>> ta)
- Sequence <A> (this HashSet<IEnumerable<A>> ta)
- Sequence <A> (this IEnumerable<IEnumerable<A>> ta)
- Sequence <A> (this Lst<IEnumerable<A>> ta)
- Sequence <A> (this Fin<IEnumerable<A>> ta)
- Sequence <A> (this Option<IEnumerable<A>> ta)
- Sequence <A> (this OptionUnsafe<IEnumerable<A>> ta)
- Sequence <A> (this Que<IEnumerable<A>> ta)
- Sequence <A> (this Seq<IEnumerable<A>> ta)
- Sequence <A> (this Set<IEnumerable<A>> ta)
- Sequence <A> (this Stck<IEnumerable<A>> ta)
- Sequence <A> (this Try<IEnumerable<A>> ta)
- Sequence <A> (this TryOption<IEnumerable<A>> ta)
- Sequence <Fail, A> (this Validation<Fail, IEnumerable<A>> ta)
- Sequence <MonoidFail, Fail, A> (this Validation<MonoidFail, Fail, IEnumerable<A>> ta)
- Sequence <A> (this Eff<IEnumerable<A>> ta)
- LstT
- Sequence <A> (this Arr<Lst<A>> ta)
- Sequence <L, A> (this Either<L, Lst<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Lst<A>> ta)
- Sequence <A> (this Identity<Lst<A>> ta)
- Sequence <A> (this IEnumerable<Lst<A>> ta)
- Sequence <A> (this Lst<Lst<A>> ta)
- Sequence <A> (this Fin<Lst<A>> ta)
- Sequence <A> (this Option<Lst<A>> ta)
- Sequence <A> (this OptionUnsafe<Lst<A>> ta)
- Sequence <A> (this Seq<Lst<A>> ta)
- Sequence <A> (this Set<Lst<A>> ta)
- Sequence <A> (this HashSet<Lst<A>> ta)
- Sequence <A> (this Try<Lst<A>> ta)
- Sequence <A> (this TryOption<Lst<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Lst<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Lst<A>> ta)
- Sequence <A> (this Eff<Lst<A>> ta)
- OptionAsyncT
- Sequence <A> (this Arr<OptionAsync<A>> ta)
- Sequence <L, A> (this Either<L, OptionAsync<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, OptionAsync<A>> ta)
- Sequence <A> (this Identity<OptionAsync<A>> ta)
- Sequence <A> (this Lst<OptionAsync<A>> ta)
- Sequence <A> (this Fin<OptionAsync<A>> ta)
- Sequence <A> (this OptionAsync<OptionAsync<A>> ta)
- Sequence <A> (this Option<OptionAsync<A>> ta)
- Sequence <A> (this OptionUnsafe<OptionAsync<A>> ta)
- Sequence <A> (this Set<OptionAsync<A>> ta)
- Sequence <A> (this HashSet<OptionAsync<A>> ta)
- Sequence <A> (this Try<OptionAsync<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, OptionAsync<A>> ta)
- Sequence <MonoidFail, FAIL, A> ( this Validation<MonoidFail, FAIL, OptionAsync<A>> ta)
- Sequence <A> (this TryAsync<OptionAsync<A>> ta)
- Sequence <A> (this Task<OptionAsync<A>> ta)
- Sequence <A> (this TryOptionAsync<OptionAsync<A>> ta)
- Sequence <A> (this TryOption<OptionAsync<A>> ta)
- Sequence <L, A> (this EitherAsync<L, OptionAsync<A>> ta)
- Sequence <A> (this Aff<OptionAsync<A>> ta)
- Sequence <A> (this Eff<OptionAsync<A>> ta)
- OptionT
- Sequence <A> (this Arr<Option<A>> ta)
- Sequence <L, A> (this Either<L, Option<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Option<A>> ta)
- Sequence <A> (this Identity<Option<A>> ta)
- Sequence <A> (this IEnumerable<Option<A>> ta)
- Sequence <A> (this Lst<Option<A>> ta)
- Sequence <A> (this Fin<Option<A>> ta)
- Sequence <A> (this Option<Option<A>> ta)
- Sequence <A> (this OptionUnsafe<Option<A>> ta)
- Sequence <A> (this Seq<Option<A>> ta)
- Sequence <A> (this Set<Option<A>> ta)
- Sequence <A> (this HashSet<Option<A>> ta)
- Sequence <A> (this Try<Option<A>> ta)
- Sequence <A> (this TryOption<Option<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Option<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Option<A>> ta)
- Sequence <A> (this Eff<Option<A>> ta)
- OptionUnsafeT
- Sequence <A> (this Arr<OptionUnsafe<A>> ta)
- Sequence <L, A> (this Either<L, OptionUnsafe<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, OptionUnsafe<A>> ta)
- Sequence <A> (this Identity<OptionUnsafe<A>> ta)
- Sequence <A> (this IEnumerable<OptionUnsafe<A>> ta)
- Sequence <A> (this Lst<OptionUnsafe<A>> ta)
- Sequence <A> (this Fin<OptionUnsafe<A>> ta)
- Sequence <A> (this Option<OptionUnsafe<A>> ta)
- Sequence <A> (this OptionUnsafe<OptionUnsafe<A>> ta)
- Sequence <A> (this Seq<OptionUnsafe<A>> ta)
- Sequence <A> (this Set<OptionUnsafe<A>> ta)
- Sequence <A> (this HashSet<OptionUnsafe<A>> ta)
- Sequence <A> (this Try<OptionUnsafe<A>> ta)
- Sequence <A> (this TryOption<OptionUnsafe<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, OptionUnsafe<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, OptionUnsafe<A>> ta)
- Sequence <A> (this Eff<OptionUnsafe<A>> ta)
- QueT
- Sequence <A> (this Arr<Que<A>> ta)
- Sequence <L, A> (this Either<L, Que<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Que<A>> ta)
- Sequence <A> (this Identity<Que<A>> ta)
- Sequence <A> (this IEnumerable<Que<A>> ta)
- Sequence <A> (this Fin<Que<A>> ta)
- Sequence <A> (this Option<Que<A>> ta)
- Sequence <A> (this OptionUnsafe<Que<A>> ta)
- Sequence <A> (this Seq<Que<A>> ta)
- Sequence <A> (this Set<Que<A>> ta)
- Sequence <A> (this Try<Que<A>> ta)
- Sequence <A> (this TryOption<Que<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Que<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Que<A>> ta)
- Sequence <A> (this Eff<Que<A>> ta)
- ReaderT
- Sequence <Env, A> (this Seq<Reader<Env, A>> ta)
- Sequence <Env, A> (this Lst<Reader<Env, A>> ta)
- Sequence <Env, A> (this Arr<Reader<Env, A>> ta)
- Sequence <Env, A> (this Reader<Env, A>[] ta)
- Sequence <Env, A> (this Set<Reader<Env, A>> ta)
- Sequence <Env, A> (this HashSet<Reader<Env, A>> ta)
- Sequence <Env, A> (this Stck<Reader<Env, A>> ta)
- Sequence <Env, A> (this IEnumerable<Reader<Env, A>> ta)
- RwsT
- Sequence <MonoidW, R, W, S, A> (this Seq<RWS<MonoidW, R, W, S, A>> ta)
- Sequence <MonoidW, R, W, S, A> (this Lst<RWS<MonoidW, R, W, S, A>> ta)
- Sequence <MonoidW, R, W, S, A> (this Arr<RWS<MonoidW, R, W, S, A>> ta)
- Sequence <MonoidW, R, W, S, A> (this RWS<MonoidW, R, W, S, A>[] ta)
- Sequence <MonoidW, R, W, S, A> (this Set<RWS<MonoidW, R, W, S, A>> ta)
- Sequence <MonoidW, R, W, S, A> (this HashSet<RWS<MonoidW, R, W, S, A>> ta)
- Sequence <MonoidW, R, W, S, A> (this Stck<RWS<MonoidW, R, W, S, A>> ta)
- Sequence <MonoidW, R, W, S, A> (this IEnumerable<RWS<MonoidW, R, W, S, A>> ta)
- SeqT
- Sequence <A> (this Arr<Seq<A>> ta)
- Sequence <L, A> (this Either<L, Seq<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Seq<A>> ta)
- Sequence <A> (this Identity<Seq<A>> ta)
- Sequence <A> (this IEnumerable<Seq<A>> ta)
- Sequence <A> (this Lst<Seq<A>> ta)
- Sequence <A> (this HashSet<Seq<A>> ta)
- Sequence <A> (this Fin<Seq<A>> ta)
- Sequence <A> (this Option<Seq<A>> ta)
- Sequence <A> (this OptionUnsafe<Seq<A>> ta)
- Sequence <A> (this Seq<Seq<A>> ta)
- Sequence <A> (this Set<Seq<A>> ta)
- Sequence <A> (this Try<Seq<A>> ta)
- Sequence <A> (this TryOption<Seq<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Seq<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Seq<A>> ta)
- Sequence <A> (this Eff<Seq<A>> ta)
- SetT
- Sequence <A> (this Arr<Set<A>> ta)
- Sequence <L, A> (this Either<L, Set<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Set<A>> ta)
- Sequence <A> (this Identity<Set<A>> ta)
- Sequence <A> (this IEnumerable<Set<A>> ta)
- Sequence <A> (this Lst<Set<A>> ta)
- Sequence <A> (this Fin<Set<A>> ta)
- Sequence <A> (this Option<Set<A>> ta)
- Sequence <A> (this OptionUnsafe<Set<A>> ta)
- Sequence <A> (this Seq<Set<A>> ta)
- Sequence <A> (this Set<Set<A>> ta)
- Sequence <A> (this HashSet<Set<A>> ta)
- Sequence <A> (this Try<Set<A>> ta)
- Sequence <A> (this TryOption<Set<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Set<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Set<A>> ta)
- Sequence <A> (this Eff<Set<A>> ta)
- StateT
- Sequence <S, A> (this Seq<State<S, A>> ta)
- Sequence <S, A> (this Lst<State<S, A>> ta)
- Sequence <S, A> (this Arr<State<S, A>> ta)
- Sequence <S, A> (this State<S, A>[] ta)
- Sequence <S, A> (this Set<State<S, A>> ta)
- Sequence <S, A> (this HashSet<State<S, A>> ta)
- Sequence <S, A> (this Stck<State<S, A>> ta)
- Sequence <S, A> (this IEnumerable<State<S, A>> ta)
- StckT
- Sequence <A> (this Arr<Stck<A>> ta)
- Sequence <L, A> (this Either<L, Stck<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Stck<A>> ta)
- Sequence <A> (this Identity<Stck<A>> ta)
- Sequence <A> (this IEnumerable<Stck<A>> ta)
- Sequence <A> (this Fin<Stck<A>> ta)
- Sequence <A> (this Option<Stck<A>> ta)
- Sequence <A> (this OptionUnsafe<Stck<A>> ta)
- Sequence <A> (this Seq<Stck<A>> ta)
- Sequence <A> (this Set<Stck<A>> ta)
- Sequence <A> (this Try<Stck<A>> ta)
- Sequence <A> (this TryOption<Stck<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Stck<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Stck<A>> ta)
- Sequence <A> (this Eff<Stck<A>> ta)
- TaskT
- Sequence <A> (this Arr<Task<A>> ta)
- Sequence <L, A> (this Either<L, Task<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Task<A>> ta)
- Sequence <A> (this Identity<Task<A>> ta)
- Sequence <A> (this Task<Task<A>> ta)
- Sequence <A> (this Fin<Task<A>> ta)
- Sequence <A> (this Option<Task<A>> ta)
- Sequence <A> (this OptionUnsafe<Task<A>> ta)
- Sequence <A> (this Set<Task<A>> ta)
- Sequence <A> (this Try<Task<A>> ta)
- Sequence <A> (this TryOption<Task<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Task<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Task<A>> ta)
- Sequence <A> (this TryAsync<Task<A>> ta)
- Sequence <A> (this OptionAsync<Task<A>> ta)
- Sequence <A> (this TryOptionAsync<Task<A>> ta)
- Sequence <L, A> (this EitherAsync<L, Task<A>> ta)
- Sequence <A> (this Aff<Task<A>> ta)
- Sequence <A> (this Eff<Task<A>> ta)
- TryAsyncT
- Sequence <A> (this Arr<TryAsync<A>> ta)
- Sequence <L, A> (this Either<L, TryAsync<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, TryAsync<A>> ta)
- Sequence <A> (this Identity<TryAsync<A>> ta)
- Sequence <A> (this Lst<TryAsync<A>> ta)
- Sequence <A> (this TryAsync<TryAsync<A>> ta)
- Sequence <A> (this Fin<TryAsync<A>> ta)
- Sequence <A> (this Option<TryAsync<A>> ta)
- Sequence <A> (this OptionUnsafe<TryAsync<A>> ta)
- Sequence <A> (this Set<TryAsync<A>> ta)
- Sequence <A> (this HashSet<TryAsync<A>> ta)
- Sequence <A> (this Try<TryAsync<A>> ta)
- Sequence <A> (this TryOption<TryAsync<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, TryAsync<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, TryAsync<A>> ta)
- Sequence <A> (this Task<TryAsync<A>> ta)
- Sequence <A> (this OptionAsync<TryAsync<A>> ta)
- Sequence <A> (this TryOptionAsync<TryAsync<A>> ta)
- Sequence <L, A> (this EitherAsync<L, TryAsync<A>> ta)
- Sequence <A> (this Aff<TryAsync<A>> ta)
- Sequence <A> (this Eff<TryAsync<A>> ta)
- TryOptionAsyncT
- Sequence <A> (this Arr<TryOptionAsync<A>> ta)
- Sequence <L, A> (this Either<L, TryOptionAsync<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, TryOptionAsync<A>> ta)
- Sequence <A> (this Identity<TryOptionAsync<A>> ta)
- Sequence <A> (this Lst<TryOptionAsync<A>> ta)
- Sequence <A> (this TryAsync<TryOptionAsync<A>> ta)
- Sequence <A> (this Fin<TryOptionAsync<A>> ta)
- Sequence <A> (this Option<TryOptionAsync<A>> ta)
- Sequence <A> (this OptionUnsafe<TryOptionAsync<A>> ta)
- Sequence <A> (this Set<TryOptionAsync<A>> ta)
- Sequence <A> (this HashSet<TryOptionAsync<A>> ta)
- Sequence <A> (this Try<TryOptionAsync<A>> ta)
- Sequence <A> (this TryOption<TryOptionAsync<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, TryOptionAsync<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, TryOptionAsync<A>> ta)
- Sequence <A> (this Task<TryOptionAsync<A>> ta)
- Sequence <A> (this OptionAsync<TryOptionAsync<A>> ta)
- Sequence <A> (this TryOptionAsync<TryOptionAsync<A>> ta)
- Sequence <L, A> (this EitherAsync<L, TryOptionAsync<A>> ta)
- Sequence <A> (this Aff<TryOptionAsync<A>> ta)
- Sequence <A> (this Eff<TryOptionAsync<A>> ta)
- TryOptionT
- Sequence <A> (this Arr<TryOption<A>> ta)
- Sequence <L, A> (this Either<L, TryOption<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, TryOption<A>> ta)
- Sequence <A> (this Identity<TryOption<A>> ta)
- Sequence <A> (this IEnumerable<TryOption<A>> ta)
- Sequence <A> (this Lst<TryOption<A>> ta)
- Sequence <A> (this Fin<TryOption<A>> ta)
- Sequence <A> (this Option<TryOption<A>> ta)
- Sequence <A> (this OptionUnsafe<TryOption<A>> ta)
- Sequence <A> (this Seq<TryOption<A>> ta)
- Sequence <A> (this Set<TryOption<A>> ta)
- Sequence <A> (this HashSet<TryOption<A>> ta)
- Sequence <A> (this Try<TryOption<A>> ta)
- Sequence <A> (this TryOption<TryOption<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, TryOption<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, TryOption<A>> ta)
- Sequence <A> (this Eff<TryOption<A>> ta)
- TryT
- Sequence <A> (this Arr<Try<A>> ta)
- Sequence <L, A> (this Either<L, Try<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, Try<A>> ta)
- Sequence <A> (this Identity<Try<A>> ta)
- Sequence <A> (this IEnumerable<Try<A>> ta)
- Sequence <A> (this Lst<Try<A>> ta)
- Sequence <A> (this Fin<Try<A>> ta)
- Sequence <A> (this Option<Try<A>> ta)
- Sequence <A> (this OptionUnsafe<Try<A>> ta)
- Sequence <A> (this Seq<Try<A>> ta)
- Sequence <A> (this Set<Try<A>> ta)
- Sequence <A> (this HashSet<Try<A>> ta)
- Sequence <A> (this Try<Try<A>> ta)
- Sequence <A> (this TryOption<Try<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, Try<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Try<A>> ta)
- Sequence <A> (this Eff<Try<A>> ta)
- ValidationT
- Sequence <Fail, A> (this Arr<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Either<Fail, Validation<Fail, A>> ta)
- Sequence <Fail, A> (this EitherUnsafe<Fail, Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Identity<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this IEnumerable<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Lst<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Fin<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Option<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this OptionUnsafe<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Seq<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Set<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this HashSet<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Try<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this TryOption<Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Validation<Fail, Validation<Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Validation<MonoidFail, Fail, Validation<Fail, A>> ta)
- Sequence <Fail, A> (this Eff<Validation<Fail, A>> ta)
- ValidationT
- Sequence <MonoidFail, Fail, A> (this Arr<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Either<Fail, Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this EitherUnsafe<Fail, Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Identity<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this IEnumerable<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Lst<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Fin<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Option<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this OptionUnsafe<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Seq<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Set<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this HashSet<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Try<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this TryOption<Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Validation<Fail, Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Validation<MonoidFail, Fail, Validation<MonoidFail, Fail, A>> ta)
- Sequence <MonoidFail, Fail, A> (this Eff<Validation<MonoidFail, Fail, A>> ta)
- ValueTaskT
- Sequence <A> (this Arr<ValueTask<A>> ta)
- Sequence <L, A> (this Either<L, ValueTask<A>> ta)
- Sequence <L, A> (this EitherUnsafe<L, ValueTask<A>> ta)
- Sequence <A> (this Identity<ValueTask<A>> ta)
- Sequence <A> (this ValueTask<ValueTask<A>> ta)
- Sequence <A> (this Fin<ValueTask<A>> ta)
- Sequence <A> (this Option<ValueTask<A>> ta)
- Sequence <A> (this OptionUnsafe<ValueTask<A>> ta)
- Sequence <A> (this Set<ValueTask<A>> ta)
- Sequence <A> (this Try<ValueTask<A>> ta)
- Sequence <A> (this TryOption<ValueTask<A>> ta)
- Sequence <FAIL, A> (this Validation<FAIL, ValueTask<A>> ta)
- Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, ValueTask<A>> ta)
- Sequence <A> (this TryAsync<ValueTask<A>> ta)
- Sequence <A> (this OptionAsync<ValueTask<A>> ta)
- Sequence <A> (this TryOptionAsync<ValueTask<A>> ta)
- Sequence <L, A> (this EitherAsync<L, ValueTask<A>> ta)
- Sequence <A> (this Aff<ValueTask<A>> ta)
- Sequence <A> (this Eff<ValueTask<A>> ta)
- WriterT
- Sequence <MonoidW, W, A> (this Seq<Writer<MonoidW, W, A>> ta)
- Sequence <MonoidW, W, A> (this Lst<Writer<MonoidW, W, A>> ta)
- Sequence <MonoidW, W, A> (this Arr<Writer<MonoidW, W, A>> ta)
- Sequence <MonoidW, W, A> (this Writer<MonoidW, W, A>[] ta)
- Sequence <MonoidW, W, A> (this Set<Writer<MonoidW, W, A>> ta)
- Sequence <MonoidW, W, A> (this HashSet<Writer<MonoidW, W, A>> ta)
- Sequence <MonoidW, W, A> (this Stck<Writer<MonoidW, W, A>> ta)
- Sequence <MonoidW, W, A> (this IEnumerable<Writer<MonoidW, W, A>> ta)
Methods
method Aff<Arr<A>> SequenceParallel <A> (this Arr<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Arr<A>> SequenceParallel <A> (this Arr<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Arr<A>> SequenceSerial <A> (this Arr<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Either<L, A>> Sequence <L, A> (this Either<L, Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Fin<A>> Sequence <A> (this Fin<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Identity<A>> Sequence <A> (this Identity<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<IEnumerable<A>> SequenceParallel <A> (this IEnumerable<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<IEnumerable<A>> SequenceSerial <A> (this IEnumerable<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Lst<A>> SequenceParallel <A> (this Lst<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Lst<A>> SequenceParallel <A> (this Lst<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Lst<A>> SequenceSerial <A> (this Lst<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<TryAsync<A>> Sequence <A> (this TryAsync<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Option<A>> Sequence <A> (this Option<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Que<A>> SequenceParallel <A> (this Que<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Que<A>> SequenceParallel <A> (this Que<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Que<A>> SequenceSerial <A> (this Que<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Seq<A>> SequenceParallel <A> (this Seq<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Seq<A>> SequenceParallel <A> (this Seq<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Seq<A>> SequenceSerial <A> (this Seq<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Set<A>> SequenceParallel <A> (this Set<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Set<A>> SequenceParallel <A> (this Set<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Set<A>> SequenceSerial <A> (this Set<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<HashSet<A>> SequenceParallel <A> (this HashSet<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<HashSet<A>> SequenceParallel <A> (this HashSet<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<HashSet<A>> SequenceSerial <A> (this HashSet<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Stck<A>> SequenceParallel <A> (this Stck<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Stck<A>> SequenceParallel <A> (this Stck<Aff<A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Stck<A>> SequenceSerial <A> (this Stck<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Try<A>> Sequence <A> (this Try<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<TryOption<A>> Sequence <A> (this TryOption<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Task<A>> Sequence <A> (this Task<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<OptionAsync<A>> Sequence <A> (this OptionAsync<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<TryOptionAsync<A>> Sequence <A> (this TryOptionAsync<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<Eff<A>> Sequence <A> (this Eff<Aff<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Aff<RT, Arr<A>> SequenceParallel <RT, A> (this Arr<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Arr<A>> SequenceParallel <RT, A> (this Arr<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Arr<A>> SequenceSerial <RT, A> (this Arr<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Either<L, A>> Sequence <RT, L, A> (this Either<L, Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, EitherUnsafe<L, A>> Sequence <RT, L, A> (this EitherUnsafe<L, Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Identity<A>> Sequence <RT, A> (this Identity<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, IEnumerable<A>> SequenceParallel <RT, A> (this IEnumerable<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, IEnumerable<A>> SequenceParallel <RT, A> (this IEnumerable<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, IEnumerable<A>> SequenceSerial <RT, A> (this IEnumerable<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Lst<A>> SequenceParallel <RT, A> (this Lst<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Lst<A>> SequenceParallel <RT, A> (this Lst<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Lst<A>> SequenceSerial <RT, A> (this Lst<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, TryAsync<A>> Sequence <RT, A> (this TryAsync<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Fin<A>> Sequence <RT, A> (this Fin<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Option<A>> Sequence <RT, A> (this Option<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, OptionUnsafe<A>> Sequence <RT, A> (this OptionUnsafe<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Seq<A>> SequenceParallel <RT, A> (this Seq<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Seq<A>> SequenceParallel <RT, A> (this Seq<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Seq<A>> SequenceSerial <RT, A> (this Seq<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Set<A>> SequenceParallel <RT, A> (this Set<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Set<A>> SequenceParallel <RT, A> (this Set<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Set<A>> SequenceSerial <RT, A> (this Set<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, HashSet<A>> SequenceParallel <RT, A> (this HashSet<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, HashSet<A>> SequenceParallel <RT, A> (this HashSet<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, HashSet<A>> SequenceSerial <RT, A> (this HashSet<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Que<A>> SequenceParallel <RT, A> (this Que<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Que<A>> SequenceParallel <RT, A> (this Que<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Que<A>> SequenceSerial <RT, A> (this Que<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Stck<A>> SequenceSerial <RT, A> (this Stck<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Stck<A>> SequenceParallel <RT, A> (this Stck<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Stck<A>> SequenceParallel <RT, A> (this Stck<Aff<RT, A>> ta, int windowSize) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Try<A>> Sequence <RT, A> (this Try<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, TryOption<A>> Sequence <RT, A> (this TryOption<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Validation<FAIL, A>> Sequence <RT, FAIL, A> (this Validation<FAIL, Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Validation<MonoidFail, FAIL, A>> Sequence <RT, MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Task<A>> Sequence <RT, A> (this Task<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, OptionAsync<A>> Sequence <RT, A> (this OptionAsync<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, TryOptionAsync<A>> Sequence <RT, A> (this TryOptionAsync<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, EitherAsync<L, A>> Sequence <RT, L, A> (this EitherAsync<L, Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Aff<A>> Sequence <RT, A> (this Aff<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Eff<A>> Sequence <RT, A> (this Eff<Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Aff<RT, Eff<RT, A>> Sequence <RT, A> (this Eff<RT, Aff<RT, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Arr<Arr<A>> Sequence <A> (this Arr<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Either<L, A>> Sequence <L, A> (this Either<L, Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Identity<A>> Sequence <A> (this Identity<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<IEnumerable<A>> Sequence <A> (this IEnumerable<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Lst<A>> Sequence <A> (this Lst<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Fin<A>> Sequence <A> (this Fin<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Option<A>> Sequence <A> (this Option<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Seq<A>> Sequence <A> (this Seq<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Set<A>> Sequence <A> (this Set<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<HashSet<A>> Sequence <A> (this HashSet<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Try<A>> Sequence <A> (this Try<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<TryOption<A>> Sequence <A> (this TryOption<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Arr<Eff<A>> Sequence <A> (this Eff<Arr<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Eff<Arr<A>> Sequence <A> (this Arr<Eff<A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Either<L, A>> Sequence <L, A> (this Either<L, Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Identity<A>> Sequence <A> (this Identity<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<IEnumerable<A>> Sequence <A> (this IEnumerable<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Lst<A>> Sequence <A> (this Lst<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Fin<A>> Sequence <A> (this Fin<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Option<A>> Sequence <A> (this Option<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Seq<A>> Sequence <A> (this Seq<Eff<A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Set<A>> Sequence <A> (this Set<Eff<A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<HashSet<A>> Sequence <A> (this HashSet<Eff<A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Que<A>> Sequence <A> (this Que<Eff<A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Stck<A>> Sequence <A> (this Stck<Eff<A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Try<A>> Sequence <A> (this Try<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<TryOption<A>> Sequence <A> (this TryOption<Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Eff<A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Eff<RT, Arr<A>> Sequence <RT, A> (this Arr<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Either<L, A>> Sequence <RT, L, A> (this Either<L, Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, EitherUnsafe<L, A>> Sequence <RT, L, A> (this EitherUnsafe<L, Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Identity<A>> Sequence <RT, A> (this Identity<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, IEnumerable<A>> Sequence <RT, A> (this IEnumerable<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Lst<A>> Sequence <RT, A> (this Lst<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Fin<A>> Sequence <RT, A> (this Fin<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Option<A>> Sequence <RT, A> (this Option<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, OptionUnsafe<A>> Sequence <RT, A> (this OptionUnsafe<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Seq<A>> Sequence <RT, A> (this Seq<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Set<A>> Sequence <RT, A> (this Set<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, HashSet<A>> Sequence <RT, A> (this HashSet<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Que<A>> Sequence <RT, A> (this Que<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Stck<A>> Sequence <RT, A> (this Stck<Eff<RT, A>> ma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Try<A>> Sequence <RT, A> (this Try<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, TryOption<A>> Sequence <RT, A> (this TryOption<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Validation<FAIL, A>> Sequence <RT, FAIL, A> (this Validation<FAIL, Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Validation<MonoidFail, FAIL, A>> Sequence <RT, MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Eff<RT, Eff<A>> Sequence <RT, A> (this Eff<Eff<RT, A>> mma) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class EitherAsyncT Source #
Methods
method EitherAsync<L, Arr<A>> Sequence <L, A> (this Arr<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Either<L, A>> Sequence <L, A> (this Either<L, EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Identity<A>> Sequence <L, A> (this Identity<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Lst<A>> Sequence <L, A> (this Lst<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Fin<A>> Sequence <L, A> (this Fin<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Option<A>> Sequence <L, A> (this Option<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, OptionUnsafe<A>> Sequence <L, A> (this OptionUnsafe<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Set<A>> Sequence <L, A> (this Set<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, HashSet<A>> Sequence <L, A> (this HashSet<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Try<A>> Sequence <L, A> (this Try<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, TryOption<A>> Sequence <L, A> (this TryOption<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Validation<FAIL, A>> Sequence <FAIL, L, A> (this Validation<FAIL, EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, TryAsync<A>> Sequence <L, A> (this TryAsync<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Task<A>> Sequence <L, A> (this Task<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, TryOptionAsync<A>> Sequence <L, A> (this TryOptionAsync<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, OptionAsync<A>> Sequence <L, A> (this OptionAsync<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Aff<A>> Sequence <L, A> (this Aff<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherAsync<L, Eff<A>> Sequence <L, A> (this Eff<EitherAsync<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Either<L, Arr<A>> Sequence <L, A> (this Arr<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Either<L, A>> Sequence <L, A> (this Either<L, Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Identity<A>> Sequence <L, A> (this Identity<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, IEnumerable<A>> Sequence <L, A> (this IEnumerable<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Lst<A>> Sequence <L, A> (this Lst<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Fin<A>> Sequence <L, A> (this Fin<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Option<A>> Sequence <L, A> (this Option<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, OptionUnsafe<A>> Sequence <L, A> (this OptionUnsafe<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Seq<A>> Sequence <L, A> (this Seq<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Set<A>> Sequence <L, A> (this Set<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, HashSet<A>> Sequence <L, A> (this HashSet<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Try<A>> Sequence <L, A> (this Try<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, TryOption<A>> Sequence <L, A> (this TryOption<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Validation<FAIL, A>> Sequence <FAIL, L, A> (this Validation<FAIL, Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<FAIL, Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Either<FAIL, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Either<L, Eff<A>> Sequence <L, A> (this Eff<Either<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class EitherUnsafeT Source #
Methods
method EitherUnsafe<L, Arr<A>> Sequence <L, A> (this Arr<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Either<L, A>> Sequence <L, A> (this Either<L, EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Identity<A>> Sequence <L, A> (this Identity<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, IEnumerable<A>> Sequence <L, A> (this IEnumerable<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Lst<A>> Sequence <L, A> (this Lst<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Fin<A>> Sequence <L, A> (this Fin<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Option<A>> Sequence <L, A> (this Option<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, OptionUnsafe<A>> Sequence <L, A> (this OptionUnsafe<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Seq<A>> Sequence <L, A> (this Seq<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Set<A>> Sequence <L, A> (this Set<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, HashSet<A>> Sequence <L, A> (this HashSet<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Try<A>> Sequence <L, A> (this Try<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, TryOption<A>> Sequence <L, A> (this TryOption<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Validation<FAIL, A>> Sequence <FAIL, L, A> (this Validation<FAIL, EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method EitherUnsafe<L, Eff<A>> Sequence <L, A> (this Eff<EitherUnsafe<L, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Fin<Arr<A>> Sequence <A> (this Arr<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Either<L, A>> Sequence <L, A> (this Either<L, Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Identity<A>> Sequence <A> (this Identity<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<IEnumerable<A>> Sequence <A> (this IEnumerable<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Lst<A>> Sequence <A> (this Lst<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Fin<A>> Sequence <A> (this Fin<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Option<A>> Sequence <A> (this Option<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Seq<A>> Sequence <A> (this Seq<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Set<A>> Sequence <A> (this Set<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<HashSet<A>> Sequence <A> (this HashSet<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Try<A>> Sequence <A> (this Try<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<TryOption<A>> Sequence <A> (this TryOption<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Fin<Eff<A>> Sequence <A> (this Eff<Fin<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method HashSet<Arr<A>> Sequence <A> (this Arr<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Either<L, A>> Sequence <L, A> (this Either<L, HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Identity<A>> Sequence <A> (this Identity<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<IEnumerable<A>> Sequence <A> (this IEnumerable<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Lst<A>> Sequence <A> (this Lst<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Fin<A>> Sequence <A> (this Fin<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Option<A>> Sequence <A> (this Option<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Seq<A>> Sequence <A> (this Seq<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Set<A>> Sequence <A> (this Set<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<HashSet<A>> Sequence <A> (this HashSet<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Try<A>> Sequence <A> (this Try<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<TryOption<A>> Sequence <A> (this TryOption<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method HashSet<Eff<A>> Sequence <A> (this Eff<HashSet<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class IEnumerableT Source #
Methods
method IEnumerable<Arr<A>> Sequence <A> (this Arr<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Either<L, A>> Sequence <L, A> (this Either<L, IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<HashSet<A>> Sequence <A> (this HashSet<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<IEnumerable<A>> Sequence <A> (this IEnumerable<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Lst<A>> Sequence <A> (this Lst<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Fin<A>> Sequence <A> (this Fin<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Option<A>> Sequence <A> (this Option<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Que<A>> Sequence <A> (this Que<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Seq<A>> Sequence <A> (this Seq<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Set<A>> Sequence <A> (this Set<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Stck<A>> Sequence <A> (this Stck<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Try<A>> Sequence <A> (this Try<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<TryOption<A>> Sequence <A> (this TryOption<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Validation<Fail, A>> Sequence <Fail, A> (this Validation<Fail, IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Validation<MonoidFail, Fail, A>> Sequence <MonoidFail, Fail, A> (this Validation<MonoidFail, Fail, IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method IEnumerable<Eff<A>> Sequence <A> (this Eff<IEnumerable<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Lst<Arr<A>> Sequence <A> (this Arr<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Either<L, A>> Sequence <L, A> (this Either<L, Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Identity<A>> Sequence <A> (this Identity<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<IEnumerable<A>> Sequence <A> (this IEnumerable<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Lst<A>> Sequence <A> (this Lst<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Fin<A>> Sequence <A> (this Fin<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Option<A>> Sequence <A> (this Option<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Seq<A>> Sequence <A> (this Seq<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Set<A>> Sequence <A> (this Set<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<HashSet<A>> Sequence <A> (this HashSet<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Try<A>> Sequence <A> (this Try<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<TryOption<A>> Sequence <A> (this TryOption<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Lst<Eff<A>> Sequence <A> (this Eff<Lst<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class OptionAsyncT Source #
Methods
method OptionAsync<Arr<A>> Sequence <A> (this Arr<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Either<L, A>> Sequence <L, A> (this Either<L, OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Identity<A>> Sequence <A> (this Identity<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Lst<A>> Sequence <A> (this Lst<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Fin<A>> Sequence <A> (this Fin<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<OptionAsync<A>> Sequence <A> (this OptionAsync<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Option<A>> Sequence <A> (this Option<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Set<A>> Sequence <A> (this Set<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<HashSet<A>> Sequence <A> (this HashSet<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Try<A>> Sequence <A> (this Try<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> ( this Validation<MonoidFail, FAIL, OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<TryAsync<A>> Sequence <A> (this TryAsync<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Task<A>> Sequence <A> (this Task<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<TryOptionAsync<A>> Sequence <A> (this TryOptionAsync<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<TryOption<A>> Sequence <A> (this TryOption<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Aff<A>> Sequence <A> (this Aff<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionAsync<Eff<A>> Sequence <A> (this Eff<OptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Option<Arr<A>> Sequence <A> (this Arr<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Either<L, A>> Sequence <L, A> (this Either<L, Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Identity<A>> Sequence <A> (this Identity<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<IEnumerable<A>> Sequence <A> (this IEnumerable<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Lst<A>> Sequence <A> (this Lst<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Fin<A>> Sequence <A> (this Fin<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Option<A>> Sequence <A> (this Option<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Seq<A>> Sequence <A> (this Seq<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Set<A>> Sequence <A> (this Set<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<HashSet<A>> Sequence <A> (this HashSet<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Try<A>> Sequence <A> (this Try<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<TryOption<A>> Sequence <A> (this TryOption<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Option<Eff<A>> Sequence <A> (this Eff<Option<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class OptionUnsafeT Source #
Methods
method OptionUnsafe<Arr<A>> Sequence <A> (this Arr<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Either<L, A>> Sequence <L, A> (this Either<L, OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Identity<A>> Sequence <A> (this Identity<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<IEnumerable<A>> Sequence <A> (this IEnumerable<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Lst<A>> Sequence <A> (this Lst<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Fin<A>> Sequence <A> (this Fin<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Option<A>> Sequence <A> (this Option<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Seq<A>> Sequence <A> (this Seq<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Set<A>> Sequence <A> (this Set<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<HashSet<A>> Sequence <A> (this HashSet<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Try<A>> Sequence <A> (this Try<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<TryOption<A>> Sequence <A> (this TryOption<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method OptionUnsafe<Eff<A>> Sequence <A> (this Eff<OptionUnsafe<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Que<Arr<A>> Sequence <A> (this Arr<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Either<L, A>> Sequence <L, A> (this Either<L, Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Identity<A>> Sequence <A> (this Identity<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<IEnumerable<A>> Sequence <A> (this IEnumerable<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Fin<A>> Sequence <A> (this Fin<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Option<A>> Sequence <A> (this Option<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Seq<A>> Sequence <A> (this Seq<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Set<A>> Sequence <A> (this Set<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Try<A>> Sequence <A> (this Try<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<TryOption<A>> Sequence <A> (this TryOption<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Que<Eff<A>> Sequence <A> (this Eff<Que<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Reader<Env, Seq<A>> Sequence <Env, A> (this Seq<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, Lst<A>> Sequence <Env, A> (this Lst<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, Arr<A>> Sequence <Env, A> (this Arr<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, A[]> Sequence <Env, A> (this Reader<Env, A>[] ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, Set<A>> Sequence <Env, A> (this Set<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, HashSet<A>> Sequence <Env, A> (this HashSet<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, Stck<A>> Sequence <Env, A> (this Stck<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Reader<Env, IEnumerable<A>> Sequence <Env, A> (this IEnumerable<Reader<Env, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method RWS<MonoidW, R, W, S, Seq<A>> Sequence <MonoidW, R, W, S, A> (this Seq<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, Lst<A>> Sequence <MonoidW, R, W, S, A> (this Lst<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, Arr<A>> Sequence <MonoidW, R, W, S, A> (this Arr<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, A[]> Sequence <MonoidW, R, W, S, A> (this RWS<MonoidW, R, W, S, A>[] ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, Set<A>> Sequence <MonoidW, R, W, S, A> (this Set<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, HashSet<A>> Sequence <MonoidW, R, W, S, A> (this HashSet<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, Stck<A>> Sequence <MonoidW, R, W, S, A> (this Stck<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method RWS<MonoidW, R, W, S, IEnumerable<A>> Sequence <MonoidW, R, W, S, A> (this IEnumerable<RWS<MonoidW, R, W, S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Seq<Arr<A>> Sequence <A> (this Arr<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Either<L, A>> Sequence <L, A> (this Either<L, Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Identity<A>> Sequence <A> (this Identity<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<IEnumerable<A>> Sequence <A> (this IEnumerable<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Lst<A>> Sequence <A> (this Lst<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<HashSet<A>> Sequence <A> (this HashSet<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Fin<A>> Sequence <A> (this Fin<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Option<A>> Sequence <A> (this Option<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Seq<A>> Sequence <A> (this Seq<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Set<A>> Sequence <A> (this Set<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Try<A>> Sequence <A> (this Try<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<TryOption<A>> Sequence <A> (this TryOption<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Seq<Eff<A>> Sequence <A> (this Eff<Seq<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Set<Arr<A>> Sequence <A> (this Arr<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Either<L, A>> Sequence <L, A> (this Either<L, Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Identity<A>> Sequence <A> (this Identity<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<IEnumerable<A>> Sequence <A> (this IEnumerable<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Lst<A>> Sequence <A> (this Lst<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Fin<A>> Sequence <A> (this Fin<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Option<A>> Sequence <A> (this Option<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Seq<A>> Sequence <A> (this Seq<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Set<A>> Sequence <A> (this Set<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<HashSet<A>> Sequence <A> (this HashSet<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Try<A>> Sequence <A> (this Try<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<TryOption<A>> Sequence <A> (this TryOption<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Set<Eff<A>> Sequence <A> (this Eff<Set<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method State<S, Seq<A>> Sequence <S, A> (this Seq<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, Lst<A>> Sequence <S, A> (this Lst<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, Arr<A>> Sequence <S, A> (this Arr<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, A[]> Sequence <S, A> (this State<S, A>[] ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, Set<A>> Sequence <S, A> (this Set<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, HashSet<A>> Sequence <S, A> (this HashSet<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, Stck<A>> Sequence <S, A> (this Stck<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method State<S, IEnumerable<A>> Sequence <S, A> (this IEnumerable<State<S, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Stck<Arr<A>> Sequence <A> (this Arr<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Either<L, A>> Sequence <L, A> (this Either<L, Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Identity<A>> Sequence <A> (this Identity<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<IEnumerable<A>> Sequence <A> (this IEnumerable<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Fin<A>> Sequence <A> (this Fin<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Option<A>> Sequence <A> (this Option<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Seq<A>> Sequence <A> (this Seq<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Set<A>> Sequence <A> (this Set<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Try<A>> Sequence <A> (this Try<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<TryOption<A>> Sequence <A> (this TryOption<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Stck<Eff<A>> Sequence <A> (this Eff<Stck<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Task<Arr<A>> Sequence <A> (this Arr<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Either<L, A>> Sequence <L, A> (this Either<L, Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Identity<A>> Sequence <A> (this Identity<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Task<A>> Sequence <A> (this Task<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Fin<A>> Sequence <A> (this Fin<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Option<A>> Sequence <A> (this Option<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Set<A>> Sequence <A> (this Set<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Try<A>> Sequence <A> (this Try<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<TryOption<A>> Sequence <A> (this TryOption<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<TryAsync<A>> Sequence <A> (this TryAsync<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<OptionAsync<A>> Sequence <A> (this OptionAsync<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<TryOptionAsync<A>> Sequence <A> (this TryOptionAsync<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Aff<A>> Sequence <A> (this Aff<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Task<Eff<A>> Sequence <A> (this Eff<Task<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method TryAsync<Arr<A>> Sequence <A> (this Arr<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Either<L, A>> Sequence <L, A> (this Either<L, TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Identity<A>> Sequence <A> (this Identity<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Lst<A>> Sequence <A> (this Lst<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<TryAsync<A>> Sequence <A> (this TryAsync<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Fin<A>> Sequence <A> (this Fin<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Option<A>> Sequence <A> (this Option<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Set<A>> Sequence <A> (this Set<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<HashSet<A>> Sequence <A> (this HashSet<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Try<A>> Sequence <A> (this Try<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<TryOption<A>> Sequence <A> (this TryOption<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Task<A>> Sequence <A> (this Task<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<OptionAsync<A>> Sequence <A> (this OptionAsync<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<TryOptionAsync<A>> Sequence <A> (this TryOptionAsync<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Aff<A>> Sequence <A> (this Aff<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryAsync<Eff<A>> Sequence <A> (this Eff<TryAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class TryOptionAsyncT Source #
Methods
method TryOptionAsync<Arr<A>> Sequence <A> (this Arr<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Either<L, A>> Sequence <L, A> (this Either<L, TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Identity<A>> Sequence <A> (this Identity<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Lst<A>> Sequence <A> (this Lst<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<TryAsync<A>> Sequence <A> (this TryAsync<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Fin<A>> Sequence <A> (this Fin<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Option<A>> Sequence <A> (this Option<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Set<A>> Sequence <A> (this Set<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<HashSet<A>> Sequence <A> (this HashSet<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Try<A>> Sequence <A> (this Try<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<TryOption<A>> Sequence <A> (this TryOption<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Task<A>> Sequence <A> (this Task<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<OptionAsync<A>> Sequence <A> (this OptionAsync<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<TryOptionAsync<A>> Sequence <A> (this TryOptionAsync<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Aff<A>> Sequence <A> (this Aff<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOptionAsync<Eff<A>> Sequence <A> (this Eff<TryOptionAsync<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class TryOptionT Source #
Methods
method TryOption<Arr<A>> Sequence <A> (this Arr<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Either<L, A>> Sequence <L, A> (this Either<L, TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Identity<A>> Sequence <A> (this Identity<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<IEnumerable<A>> Sequence <A> (this IEnumerable<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Lst<A>> Sequence <A> (this Lst<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Fin<A>> Sequence <A> (this Fin<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Option<A>> Sequence <A> (this Option<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Seq<A>> Sequence <A> (this Seq<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Set<A>> Sequence <A> (this Set<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<HashSet<A>> Sequence <A> (this HashSet<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Try<A>> Sequence <A> (this Try<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<TryOption<A>> Sequence <A> (this TryOption<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method TryOption<Eff<A>> Sequence <A> (this Eff<TryOption<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Try<Arr<A>> Sequence <A> (this Arr<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Either<L, A>> Sequence <L, A> (this Either<L, Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Identity<A>> Sequence <A> (this Identity<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<IEnumerable<A>> Sequence <A> (this IEnumerable<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Lst<A>> Sequence <A> (this Lst<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Fin<A>> Sequence <A> (this Fin<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Option<A>> Sequence <A> (this Option<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Seq<A>> Sequence <A> (this Seq<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Set<A>> Sequence <A> (this Set<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<HashSet<A>> Sequence <A> (this HashSet<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Try<A>> Sequence <A> (this Try<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<TryOption<A>> Sequence <A> (this TryOption<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Try<Eff<A>> Sequence <A> (this Eff<Try<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class ValidationT Source #
Methods
method Validation<Fail, Arr<A>> Sequence <Fail, A> (this Arr<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Either<Fail, A>> Sequence <Fail, A> (this Either<Fail, Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, EitherUnsafe<Fail, A>> Sequence <Fail, A> (this EitherUnsafe<Fail, Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Identity<A>> Sequence <Fail, A> (this Identity<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, IEnumerable<A>> Sequence <Fail, A> (this IEnumerable<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Lst<A>> Sequence <Fail, A> (this Lst<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Fin<A>> Sequence <Fail, A> (this Fin<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Option<A>> Sequence <Fail, A> (this Option<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, OptionUnsafe<A>> Sequence <Fail, A> (this OptionUnsafe<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Seq<A>> Sequence <Fail, A> (this Seq<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Set<A>> Sequence <Fail, A> (this Set<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, HashSet<A>> Sequence <Fail, A> (this HashSet<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Try<A>> Sequence <Fail, A> (this Try<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, TryOption<A>> Sequence <Fail, A> (this TryOption<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Validation<Fail, A>> Sequence <Fail, A> (this Validation<Fail, Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Validation<MonoidFail, Fail, A>> Sequence <MonoidFail, Fail, A> (this Validation<MonoidFail, Fail, Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<Fail, Eff<A>> Sequence <Fail, A> (this Eff<Validation<Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class ValidationT Source #
Methods
method Validation<MonoidFail, Fail, Arr<A>> Sequence <MonoidFail, Fail, A> (this Arr<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Either<Fail, A>> Sequence <MonoidFail, Fail, A> (this Either<Fail, Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, EitherUnsafe<Fail, A>> Sequence <MonoidFail, Fail, A> (this EitherUnsafe<Fail, Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Identity<A>> Sequence <MonoidFail, Fail, A> (this Identity<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, IEnumerable<A>> Sequence <MonoidFail, Fail, A> (this IEnumerable<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Lst<A>> Sequence <MonoidFail, Fail, A> (this Lst<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Fin<A>> Sequence <MonoidFail, Fail, A> (this Fin<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Option<A>> Sequence <MonoidFail, Fail, A> (this Option<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, OptionUnsafe<A>> Sequence <MonoidFail, Fail, A> (this OptionUnsafe<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Seq<A>> Sequence <MonoidFail, Fail, A> (this Seq<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Set<A>> Sequence <MonoidFail, Fail, A> (this Set<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, HashSet<A>> Sequence <MonoidFail, Fail, A> (this HashSet<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Try<A>> Sequence <MonoidFail, Fail, A> (this Try<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, TryOption<A>> Sequence <MonoidFail, Fail, A> (this TryOption<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Validation<Fail, A>> Sequence <MonoidFail, Fail, A> (this Validation<Fail, Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Validation<MonoidFail, Fail, A>> Sequence <MonoidFail, Fail, A> (this Validation<MonoidFail, Fail, Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Validation<MonoidFail, Fail, Eff<A>> Sequence <MonoidFail, Fail, A> (this Eff<Validation<MonoidFail, Fail, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
class ValueTaskT Source #
Methods
method ValueTask<Arr<A>> Sequence <A> (this Arr<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Either<L, A>> Sequence <L, A> (this Either<L, ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<EitherUnsafe<L, A>> Sequence <L, A> (this EitherUnsafe<L, ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Identity<A>> Sequence <A> (this Identity<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<ValueTask<A>> Sequence <A> (this ValueTask<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Fin<A>> Sequence <A> (this Fin<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Option<A>> Sequence <A> (this Option<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<OptionUnsafe<A>> Sequence <A> (this OptionUnsafe<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Set<A>> Sequence <A> (this Set<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Try<A>> Sequence <A> (this Try<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<TryOption<A>> Sequence <A> (this TryOption<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Validation<FAIL, A>> Sequence <FAIL, A> (this Validation<FAIL, ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Validation<MonoidFail, FAIL, A>> Sequence <MonoidFail, FAIL, A> (this Validation<MonoidFail, FAIL, ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<TryAsync<A>> Sequence <A> (this TryAsync<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<OptionAsync<A>> Sequence <A> (this OptionAsync<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<TryOptionAsync<A>> Sequence <A> (this TryOptionAsync<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<EitherAsync<L, A>> Sequence <L, A> (this EitherAsync<L, ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Aff<A>> Sequence <A> (this Aff<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method ValueTask<Eff<A>> Sequence <A> (this Eff<ValueTask<A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
Methods
method Writer<MonoidW, W, Seq<A>> Sequence <MonoidW, W, A> (this Seq<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, Lst<A>> Sequence <MonoidW, W, A> (this Lst<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, Arr<A>> Sequence <MonoidW, W, A> (this Arr<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, A[]> Sequence <MonoidW, W, A> (this Writer<MonoidW, W, A>[] ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, Set<A>> Sequence <MonoidW, W, A> (this Set<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, HashSet<A>> Sequence <MonoidW, W, A> (this HashSet<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, Stck<A>> Sequence <MonoidW, W, A> (this Stck<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |
method Writer<MonoidW, W, IEnumerable<A>> Sequence <MonoidW, W, A> (this IEnumerable<Writer<MonoidW, W, A>> ta) Source #
Traverses each value in the ta nested monad, Then applies the monadic rules of the return type
(which is the input nested monad, flipped: so M<N<A>> becomes N<M<A>>).
Parameters
| type | A | Bound value type |
| param | ta | The subject traversable |
| returns | Mapped monad | |