Λrrow Core

arrow-core-data / 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>`
k	`fun <A>` `Sequence<A>.~~k~~():` `SequenceK<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.combine`fun <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>`
toMap	`fun <K, V>` `Sequence<Tuple2<K, V>>.~~toMap~~():` `Map<K, V>`
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 parts`fun <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 interleave`fun <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 Sequence`fun <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>`