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.

interleave

fun <A> Iterable<A>.interleave(other: Iterable<A>): List<A>

interleave both computations in a fair way.

lastOrNone

fun <T> Iterable<T>.lastOrNone(): Option<T>

Returns the last element as Some(element), or None if the iterable is empty.

inline fun <T> Iterable<T>.lastOrNone(predicate: (T) -> Boolean): Option<T>

Returns the last element as Some(element) matching the given predicate, or None if no such element was found.

leftPadZip

inline fun <A, B, C> Iterable<A>.leftPadZip(other: Iterable, fab: (A?, B) -> C): List<C>

Returns a List 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> Iterable<A>.leftPadZip(other: Iterable): List<Pair<A?, B>>

Returns a List> containing the zipped values of the two lists with null for padding on the left.

padZip

fun <A, B> Iterable<A>.padZip(other: Iterable): List<Pair<A?, B?>>

Returns a List> containing the zipped values of the two lists with null for padding.

inline fun <A, B, C> Iterable<A>.padZip(other: Iterable, fa: (A?, B?) -> C): List<C>

Returns a List containing the result of applying some transformation (A?, B?) -> C on a zip.

reduceOrNull

fun <A, B> Iterable<A>.reduceOrNull(initial: (A) -> B, operation: (acc: B, A) -> B): B?

replicate

fun <A> Iterable<A>.replicate(n: Int): List<List<A>>

fun <A> Iterable<A>.replicate(n: Int, MA: Monoid<A>): List<A>

rightPadZip

inline fun <A, B, C> Iterable<A>.rightPadZip(other: Iterable, fa: (A, B?) -> C): List<C>

Returns a List 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> Iterable<A>.rightPadZip(other: Iterable): List<Pair<A, B?>>

Returns a List> containing the zipped values of the two lists with null for padding on the right.

salign

fun <A> Iterable<A>.salign(SG: Semigroup<A>, other: Iterable<A>): Iterable<A>

aligns two structures and combine them with the given Semigroup.combine

separateEither

fun <A, B> Iterable<Either<A, B>>.separateEither(): Pair<List<A>, List>

Separate the inner Either values into the Either.Left and Either.Right.

separateValidated

fun <A, B> Iterable<Validated<A, B>>.separateValidated(): Pair<List<A>, List>

Separate the inner Validated values into the Validated.Invalid and Validated.Valid.

sequence

fun <E, A> Iterable<Either<E, A>>.sequence(): Either<E, List<A>>

fun <A> Iterable<Result<A>>.sequence(): Result<List<A>>

fun <E, A> Iterable<Validated<E, A>>.sequence(semigroup: Semigroup<E>): Validated<E, List<A>>

fun <E, A> Iterable<ValidatedNel<E, A>>.sequence(): ValidatedNel<E, List<A>>

fun <A> Iterable<Option<A>>.sequence(): Option<List<A>>

fun <A> Iterable<A?>.sequence(): List<A>?

sequenceEither

fun <E, A> Iterable<Either<E, A>>.~~sequenceEither~~(): Either<E, List<A>>

sequenceNullable

fun <A> Iterable<A?>.~~sequenceNullable~~(): List<A>?

sequenceOption

fun <A> Iterable<Option<A>>.~~sequenceOption~~(): Option<List<A>>

sequenceResult

fun <A> Iterable<Result<A>>.~~sequenceResult~~(): Result<List<A>>

sequenceValidated

fun <E, A> Iterable<Validated<E, A>>.~~sequenceValidated~~(semigroup: Semigroup<E>): Validated<E, List<A>>

fun <E, A> Iterable<ValidatedNel<E, A>>.~~sequenceValidated~~(): ValidatedNel<E, List<A>>

singleOrNone

fun <T> Iterable<T>.singleOrNone(): Option<T>

Returns single element as Some(element), or None if the iterable is empty or has more than one element.

inline fun <T> Iterable<T>.singleOrNone(predicate: (T) -> Boolean): Option<T>

Returns the single element as Some(element) matching the given predicate, or None if element was not found or more than one element was found.

split

fun <A> Iterable<A>.split(): Pair<List<A>, A>?

attempt to split the computation, giving access to the first result.

tail

fun <A> Iterable<A>.tail(): List<A>

toNonEmptyListOrNone

fun <A> Iterable<A>.toNonEmptyListOrNone(): Option<NonEmptyList<A>>

toNonEmptyListOrNull

fun <A> Iterable<A>.toNonEmptyListOrNull(): NonEmptyList<A>?

toNonEmptySetOrNone

fun <T> Collection<T>.toNonEmptySetOrNone(): Option<NonEmptySet<T>>

toNonEmptySetOrNull

fun <T> Collection<T>.toNonEmptySetOrNull(): NonEmptySet<T>?

traverse

inline fun <E, A, B> Iterable<A>.traverse(f: (A) -> Either<E, B>): Either<E, List>

inline fun <A, B> Iterable<A>.traverse(f: (A) -> Result): Result<List>

inline fun <E, A, B> Iterable<A>.traverse(semigroup: Semigroup<E>, f: (A) -> Validated<E, B>): Validated<E, List>

inline fun <E, A, B> Iterable<A>.traverse(f: (A) -> ValidatedNel<E, B>): ValidatedNel<E, List>

inline fun <A, B> Iterable<A>.traverse(f: (A) -> Option): Option<List>

inline fun <A, B> Iterable<A>.traverse(f: (A) -> B?): List?

traverseEither

inline fun <E, A, B> Iterable<A>.~~traverseEither~~(f: (A) -> Either<E, B>): Either<E, List>

traverseNullable

inline fun <A, B> Iterable<A>.~~traverseNullable~~(f: (A) -> B?): List?

traverseOption

inline fun <A, B> Iterable<A>.~~traverseOption~~(f: (A) -> Option): Option<List>

traverseResult

inline fun <A, B> Iterable<A>.~~traverseResult~~(f: (A) -> Result): Result<List>

traverseValidated

inline fun <E, A, B> Iterable<A>.~~traverseValidated~~(semigroup: Semigroup<E>, f: (A) -> Validated<E, B>): Validated<E, List>

inline fun <E, A, B> Iterable<A>.~~traverseValidated~~(f: (A) -> ValidatedNel<E, B>): ValidatedNel<E, List>

unalign

fun <A, B> Iterable<Ior<A, B>>.unalign(): Pair<List<A>, List>

splits a union into its component parts.

inline fun <A, B, C> Iterable<C>.unalign(fa: (C) -> Ior<A, B>): Pair<List<A>, List>

after applying the given function, splits the resulting union shaped structure into its components parts

uniteEither

fun <A, B> Iterable<Either<A, B>>.~~uniteEither~~(): List

uniteValidated

fun <A, B> Iterable<Validated<A, B>>.~~uniteValidated~~(): List

unweave

fun <A, B> Iterable<A>.unweave(ffa: (A) -> Iterable): List

Fair conjunction. Similarly to interleave

unzip

fun <A, B> Iterable<Pair<A, B>>.unzip(): Pair<List<A>, List>

unzips the structure holding the resulting elements in an Pair

inline fun <A, B, C> Iterable<C>.unzip(fc: (C) -> Pair<A, B>): Pair<List<A>, List>

after applying the given function unzip the resulting structure into its elements.

void

fun <A> Iterable<A>.void(): List<Unit>

widen

fun <B, A : B> Iterable<A>.widen(): Iterable

Given A is a sub type of B, re-type this value from Iterable to Iterable

zip

Link copied to clipboard

inline fun <B, C, D, E> Iterable.zip(c: Iterable<C>, d: Iterable<D>, transform: (B, C, D) -> E): List<E>
inline fun <B, C, D, E, F> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, transform: (B, C, D, E) -> F): List<F>
inline fun <B, C, D, E, F, G> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, f: Iterable<F>, transform: (B, C, D, E, F) -> G): List<G>
inline fun <B, C, D, E, F, G, H> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, f: Iterable<F>, g: Iterable<G>, transform: (B, C, D, E, F, G) -> H): List<H>
inline fun <B, C, D, E, F, G, H, I> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, f: Iterable<F>, g: Iterable<G>, h: Iterable<H>, transform: (B, C, D, E, F, G, H) -> I): List
inline fun <B, C, D, E, F, G, H, I, J> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, f: Iterable<F>, g: Iterable<G>, h: Iterable<H>, i: Iterable, transform: (B, C, D, E, F, G, H, I) -> J): List<J>
inline fun <B, C, D, E, F, G, H, I, J, K> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, f: Iterable<F>, g: Iterable<G>, h: Iterable<H>, i: Iterable, j: Iterable<J>, transform: (B, C, D, E, F, G, H, I, J) -> K): List<K>
inline fun <B, C, D, E, F, G, H, I, J, K, L> Iterable.zip(c: Iterable<C>, d: Iterable<D>, e: Iterable<E>, f: Iterable<F>, g: Iterable<G>, h: Iterable<H>, i: Iterable, j: Iterable<J>, k: Iterable<K>, transform: (B, C, D, E, F, G, H, I, J, K) -> L): List<L>