arrow-analysis-laws/arrow.analysis.laws.kotlin/CollectionLaws

CollectionLaws

object CollectionLaws

Functions

inline fun <T> Collection<T>.allLaw(predicate: (T) -> Boolean): Boolean

inline fun <T> Collection<T>.anyLaw(): Boolean

inline fun <T> Collection<T>.anyLaw(predicate: (T) -> Boolean): Boolean

inline fun <E> Collection<E>.countLaw(): Int

inline fun <E> Collection<E>.countLaw(predicate: (E) -> Boolean): Int

inline fun <T, K> Collection<T>.distinctByLaw(selector: (T) -> K): List<T>

inline fun <E> Collection<E>.distinctLaw(): List<E>

inline fun <E> Collection<E>.dropLaw(n: Int): List<E>

inline fun <E> Collection<E>.dropWhileLaw(predicate: (E) -> Boolean): List<E>

inline fun <E> Collection<E>.elementAtLaw(index: Int): E

elementAtOrNullLaw

inline fun <E> Collection<E>.elementAtOrNullLaw(index: Int): E?

filterIndexedLaw

inline fun <E> Collection<E>.filterIndexedLaw(predicate: (Int, E) -> Boolean): List<E>

filterIsInstanceLaw

inline fun <R> Collection<*>.filterIsInstanceLaw(): List<R>

inline fun <E> Collection<E>.filterLaw(predicate: (E) -> Boolean): List<E>

inline fun <E> Collection<E>.filterNotLaw(predicate: (E) -> Boolean): List<E>

filterNotNullLaw

inline fun <E> Collection<E?>.filterNotNullLaw(): List<E>

inline fun <E> Collection<E>.firstLaw(): E

firstLawWithPredicate

inline fun <E> Collection<E>.firstLawWithPredicate(predicate: (E) -> Boolean): E

inline fun <E> Collection<E>.firstOrNullLaw(): E?

flatMapIndexedLaw

inline fun <A, B> Collection<A>.flatMapIndexedLaw(transform: (index: Int, A) -> Iterable<B>): List<B>

inline fun <A, B> Collection<A>.flatMapLaw(transform: (A) -> Iterable<B>): List<B>

inline fun <A> Collection<Collection<A>>.flattenLaw(): List<A>

forEachIndexedLaw

inline fun <A> Collection<A>.forEachIndexedLaw(action: (Int, A) -> Unit)

inline fun <A> Collection<A>.forEachLaw(action: (A) -> Unit)

indexOfFirstLaw

inline fun <E> Collection<E>.indexOfFirstLaw(predicate: (E) -> Boolean): Int

inline fun <E> Collection<E>.indexOfLastLaw(predicate: (E) -> Boolean): Int

inline fun <E> Collection<E>.indexOfLaw(element: E): Int

inline fun <T> Collection<T>.intersectLaw(other: Collection<T>): Set<T>

inline fun <E> Collection<E>.isEmptyLaw(): Boolean

inline fun <E> Collection<E>.isNotEmptyLaw(): Boolean

isNullOrEmptyLaw

inline fun <E> Collection<E>?.isNullOrEmptyLaw(): Boolean

inline fun <E> Collection<E>.lastIndexOfLaw(element: E): Int

inline fun <E> Collection<E>.lastLaw(): E

inline fun <E> Collection<E>.lastLaw(predicate: (E) -> Boolean): E

inline fun <E> Collection<E>.lastOrNullLaw(): E?

inline fun <A, B> Collection<A>.mapIndexedLaw(transform: (Int, A) -> B): List<B>

mapIndexedNotNullLaw

inline fun <A, B> Collection<A>.mapIndexedNotNullLaw(transform: (Int, A) -> B?): List<B>

inline fun <A, B> Collection<A>.mapLaw(transform: (A) -> B): List<B>

inline fun <A, B> Collection<A>.mapNotNullLaw(transform: (A) -> B?): List<B>

inline fun <E> Collection<E>.minusLaw(element: E): List<E>

minusLawWithElements

inline fun <E> Collection<E>.minusLawWithElements(elements: Collection<E>): List<E>

inline fun <E> Collection<E>.noneLaw(): Boolean

onEachIndexedLaw

inline fun <A, C : Collection<A>> C.onEachIndexedLaw(action: (Int, A) -> Unit): C

inline fun <A, C : Collection<A>> C.onEachLaw(action: (A) -> Unit): C

inline fun <E> Collection<E>?.orEmptyLaw(): Collection<E>

inline fun <E> Collection<E>.plusLaw(element: E): List<E>

plusLawWithElements

inline fun <E> Collection<E>.plusLawWithElements(elements: Collection<E>): List<E>

inline fun <T> Collection<T>.randomLaw(): T

randomOrNullLaw

inline fun <T> Collection<T>.randomOrNullLaw(): T?

inline fun <E> Collection<E>.reversedLaw(): List<E>

inline fun <T> Collection<T>.shuffledLaw(): List<T>

inline fun <E> Collection<E>.singleLaw(): E

singleOrNullLaw

inline fun <E> Collection<E>.singleOrNullLaw(): E?

inline fun <E> Collection<E>.sizeLaw(): Int

sortedByDescendingLaw

inline fun <T, R : Comparable<R>> Collection<T>.sortedByDescendingLaw(crossinline selector: (T) -> R?): List<T>

inline fun <T, R : Comparable<R>> Collection<T>.sortedByLaw(crossinline selector: (T) -> R?): List<T>

sortedDescendingLaw

inline fun <E : Comparable<E>> Collection<E>.sortedDescendingLaw(): List<E>

inline fun <E : Comparable<E>> Collection<E>.sortedLaw(): List<E>

inline fun <T> Collection<T>.sortedWithLaw(comparator: Comparator<in T>): List<T>

inline fun <T> Collection<T>.subtractLaw(other: Collection<T>): Set<T>

inline fun <E> Collection<E>.takeLaw(n: Int): List<E>

inline fun <E> Collection<E>.takeWhileLaw(predicate: (E) -> Boolean): List<E>

inline fun <T> Collection<T>.unionLaw(other: Collection<T>): Set<T>

inline fun <T, R> Collection<Pair<T, R>>.unzipLaw(): Pair<List<T>, List<R>>

inline fun <T, R> Collection<T>.zipLaw(other: Collection<R>): List<Pair<T, R>>

inline fun <T, R, V> Collection<T>.zipLaw(other: Collection<R>, transform: (T, R) -> V): List<V>

inline fun <T> Collection<T>.zipWithNextLaw(): List<Pair<T, T>>

inline fun <T, V> Collection<T>.zipWithNextLaw(transform: (T, T) -> V): List<V>