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

Do you like Arrow?

<