Flatten an Iterable of Either. Alias for mapOrAccumulate over an Iterable of computed Either. Either returns a List containing all Either.Right values, or Either.Left values accumulated using combine.

@JvmName(name = "flattenNelOrAccumulate")

fun <Error, A> Iterable<EitherNel<Error, A>>.flattenOrAccumulate(combine: (Error, Error) -> Error): Either<Error, List<A>>

Flatten an Iterable of Either. Alias for mapOrAccumulate over an Iterable of computed Either. Either returns a List containing all Either.Right values, or EitherNel values accumulated using combine.

hashCode

open override fun hashCode(): Int

interleave

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

Interleaves the elements of this Iterable with those of other. Elements of this and other are taken in turn, and the resulting list is the concatenation of the interleaved elements. If one Iterable is longer than the other, the remaining elements are appended to the end.

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): Iterator<E>

lastOrNone

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

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

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

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

lastOrNull

open override fun lastOrNull(): E

leftPadZip

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.

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.

map

open override fun <T> map(transform: (E) -> T): NonEmptyList<T>

mapIndexed

open override fun <T> mapIndexed(transform: (index: Int, E) -> T): NonEmptyList<T>

mapOrAccumulate

inline fun <Error, E, T> NonEmptySet<E>.mapOrAccumulate(transform: RaiseAccumulate<Error>.(E) -> T): Either<NonEmptyList<Error>, NonEmptySet<T>>

inline fun <Error, E, T> NonEmptySet<E>.mapOrAccumulate(combine: (Error, Error) -> Error, transform: RaiseAccumulate<Error>.(E) -> T): Either<Error, NonEmptySet<T>>

inline fun <Error, A, B> Iterable<A>.mapOrAccumulate(transform: RaiseAccumulate<Error>.(A) -> B): Either<NonEmptyList<Error>, List>

Returns Either a List containing the results of applying the given transform function to each element in the original collection, or accumulate all the logical errors into a NonEmptyList that were raised while applying the transform function.

inline fun <Error, A, B> Iterable<A>.mapOrAccumulate(combine: (Error, Error) -> Error, transform: RaiseAccumulate<Error>.(A) -> B): Either<Error, List>

Returns Either a List containing the results of applying the given transform function to each element in the original collection, or accumulate all the logical errors that were raised while transforming the collection using the combine function is used to accumulate all the logical errors.

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.

inline fun <A, B, C> Iterable<A>.padZip(other: Iterable, left: (A) -> C, right: (B) -> C, both: (A, B) -> C): List<C>

plus

open operator override fun plus(element: E): NonEmptySet<E>

open operator override fun plus(elements: Iterable<E>): NonEmptySet<E>

reduceOrNull

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

rightPadZip

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.

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.

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.

inline fun <T, A, B> Iterable<T>.separateEither(f: (T) -> Either<A, B>): Pair<List<A>, List>

Applies a function f to each element and returns a pair of arrays: the first one made of those values returned by f that were wrapped in Either.Left, and the second one made of those wrapped in Either.Right.

separateIor

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

splits a union into its component parts.

singleOrNone

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

Returns single element as Some, 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 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 Iterable into the tail and the first element. Returns null if the Iterable is empty, otherwise returns a Pair of the tail and the first element.

tail

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

Alias for drop(1)

toNonEmptyList

open fun toNonEmptyList(): NonEmptyList<E>

toNonEmptyListOrNone

@JvmName(name = "toNonEmptyListOrNone")

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

toNonEmptyListOrNull

@JvmName(name = "toNonEmptyListOrNull")

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

toNonEmptySet

open fun toNonEmptySet(): NonEmptySet<E>

toNonEmptySetOrNone

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

toNonEmptySetOrNull

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

toString

open override fun toString(): String

unalign

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

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

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

unweave

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

interleaves the elements produced by applying ffa to every element of this Iterable.

zip

open override fun <T> zip(other: NonEmptyCollection<T>): NonEmptyList<Pair<E, T>>

zip

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>