arrow-core / arrow.core / kotlin.sequences.Sequence

Extensions for kotlin.sequences.Sequence

align Combines two structures by taking the union of their shapes and combining the elements with the given function.fun <A, B, C> Sequence<A>.align(b: Sequence<B>, fa: (Ior<A, B>) -> C): Sequence<C>
Combines two structures by taking the union of their shapes and using Ior to hold the elements.fun <A, B> Sequence<A>.align(b: Sequence<B>): Sequence<Ior<A, B>>
combineAll fun <A> Sequence<A>.combineAll(MA: Monoid<A>): A
crosswalk fun <A, B> Sequence<A>.crosswalk(f: (A) -> Sequence<B>): Sequence<Sequence<B>>
crosswalkMap fun <A, K, V> Sequence<A>.crosswalkMap(f: (A) -> Map<K, V>): Map<K, Sequence<V>>
crosswalkNull fun <A, B> Sequence<A>.crosswalkNull(f: (A) -> B?): Sequence<B>?
flatten fun <A> Sequence<Sequence<A>>.flatten(): Sequence<A>
fold fun <A> Sequence<A>.fold(MA: Monoid<A>): A
foldMap fun <A, B> Sequence<A>.foldMap(MB: Monoid<B>, f: (A) -> B): B
foldRight fun <A, B> Sequence<A>.~~foldRight~~(lb: Eval<B>, f: (A, Eval<B>) -> Eval<B>): Eval<B>
ifThen Logical conditional. The equivalent of Prolog’s soft-cut. If its first argument succeeds at all, then the results will be fed into the success branch. Otherwise, the failure branch is taken.fun <A, B> Sequence<A>.ifThen(fb: Sequence<B>, ffa: (A) -> Sequence<B>): Sequence<B>
interleave interleave both computations in a fair way.fun <A> Sequence<A>.interleave(other: Sequence<A>): Sequence<A>
leftPadZip Returns a Sequence containing the result of applying some transformation (A?, B) -> C on a zip, excluding all cases where the right value is null.fun <A, B, C> Sequence<A>.leftPadZip(other: Sequence<B>, fab: (A?, B) -> C): Sequence<C>
Returns a SequencePairA?,B containing the zipped values of the two sequences with null for padding on the left.fun <A, B> Sequence<A>.leftPadZip(other: Sequence<B>): Sequence<Pair<A?, B>>
many fun <A> Sequence<A>.many(): Sequence<Sequence<A>>
once fun <A> Sequence<A>.once(): Sequence<A>
padZip Returns a SequencePairA?,B? containing the zipped values of the two sequences with null for padding.fun <A, B> Sequence<A>.padZip(other: Sequence<B>): Sequence<Pair<A?, B?>>
Returns a Sequence containing the result of applying some transformation (A?, B?) -> C on a zip.fun <A, B, C> Sequence<A>.padZip(other: Sequence<B>, fa: (A?, B?) -> C): Sequence<C>
reduceRightEvalOrNull fun <A, B> Sequence<A>.~~reduceRightEvalOrNull~~(initial: (A) -> B, operation: (A, acc: Eval<B>) -> Eval<B>): Eval<B?>
replicate fun <A> Sequence<A>.replicate(n: Int): Sequence<Sequence<A>>
fun <A> Sequence<A>.replicate(n: Int, MA: Monoid<A>): Sequence<A>
rightPadZip Returns a Sequence containing the result of applying some transformation (A, B?) -> C on a zip, excluding all cases where the left value is null.fun <A, B, C> Sequence<A>.rightPadZip(other: Sequence<B>, fa: (A, B?) -> C): Sequence<C>
Returns a SequencePairA,B? containing the zipped values of the two sequences with null for padding on the right.fun <A, B> Sequence<A>.rightPadZip(other: Sequence<B>): Sequence<Pair<A, B?>>
salign aligns two structures and combine them with the given Semigroup.combinefun <A> Sequence<A>.salign(SG: Semigroup<A>, other: Sequence<A>): Sequence<A>
separateEither Separate the inner Either values into the Either.Left and Either.Right.fun <A, B> Sequence<Either<A, B>>.separateEither(): Pair<Sequence<A>, Sequence<B>>
separateValidated Separate the inner Validated values into the Validated.Invalid and Validated.Valid.fun <A, B> Sequence<Validated<A, B>>.separateValidated(): Pair<Sequence<A>, Sequence<B>>
sequenceEither fun <E, A> Sequence<Either<E, A>>.sequenceEither(): Either<E, Sequence<A>>
sequenceValidated fun <E, A> Sequence<Validated<E, A>>.sequenceValidated(semigroup: Semigroup<E>): Validated<E, Sequence<A>>
some fun <A> Sequence<A>.some(): Sequence<Sequence<A>>
split attempt to split the computation, giving access to the first result.fun <A> Sequence<A>.split(): Pair<Sequence<A>, A>?
tail fun <A> Sequence<A>.tail(): Sequence<A>
traverseEither fun <E, A, B> Sequence<A>.traverseEither(f: (A) -> Either<E, B>): Either<E, Sequence<B>>
traverseValidated fun <E, A, B> Sequence<A>.traverseValidated(semigroup: Semigroup<E>, f: (A) -> Validated<E, B>): Validated<E, Sequence<B>>
unalign splits an union into its component parts.fun <A, B> Sequence<Ior<A, B>>.unalign(): Pair<Sequence<A>, Sequence<B>>
after applying the given function, splits the resulting union shaped structure into its components partsfun <A, B, C> Sequence<C>.unalign(fa: (C) -> Ior<A, B>): Pair<Sequence<A>, Sequence<B>>
uniteEither fun <A, B> Sequence<Either<A, B>>.uniteEither(): Sequence<B>
uniteValidated fun <A, B> Sequence<Validated<A, B>>.uniteValidated(): Sequence<B>
unweave Fair conjunction. Similarly to interleavefun <A, B> Sequence<A>.unweave(ffa: (A) -> Sequence<B>): Sequence<B>
unzip unzips the structure holding the resulting elements in an Pairfun <A, B> Sequence<Pair<A, B>>.unzip(): Pair<Sequence<A>, Sequence<B>>
after applying the given function unzip the resulting structure into its elements.fun <A, B, C> Sequence<C>.unzip(fc: (C) -> Pair<A, B>): Pair<Sequence<A>, Sequence<B>>
void fun <A> Sequence<A>.void(): Sequence<Unit>
widen Given A is a sub type of B, re-type this value from Sequence to Sequencefun <B, A : B> Sequence<A>.widen(): Sequence<B>
zip fun <B, C, D, E> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, map: (B, C, D) -> E): Sequence<E>
fun <B, C, D, E, F> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, map: (B, C, D, E) -> F): Sequence<F>
fun <B, C, D, E, F, G> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, f: Sequence<F>, map: (B, C, D, E, F) -> G): Sequence<G>
fun <B, C, D, E, F, G, H> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, f: Sequence<F>, g: Sequence<G>, map: (B, C, D, E, F, G) -> H): Sequence<H>
fun <B, C, D, E, F, G, H, I> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, f: Sequence<F>, g: Sequence<G>, h: Sequence<H>, map: (B, C, D, E, F, G, H) -> I): Sequence<I>
fun <B, C, D, E, F, G, H, I, J> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, f: Sequence<F>, g: Sequence<G>, h: Sequence<H>, i: Sequence<I>, map: (B, C, D, E, F, G, H, I) -> J): Sequence<J>
fun <B, C, D, E, F, G, H, I, J, K> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, f: Sequence<F>, g: Sequence<G>, h: Sequence<H>, i: Sequence<I>, j: Sequence<J>, map: (B, C, D, E, F, G, H, I, J) -> K): Sequence<K>
fun <B, C, D, E, F, G, H, I, J, K, L> Sequence<B>.zip(c: Sequence<C>, d: Sequence<D>, e: Sequence<E>, f: Sequence<F>, g: Sequence<G>, h: Sequence<H>, i: Sequence<I>, j: Sequence<J>, k: Sequence<K>, map: (B, C, D, E, F, G, H, I, J, K) -> L): Sequence<L>

Do you like Arrow?

Arrow Org
<