arrow-analysis-laws/arrow.analysis.laws.kotlin/ArrayLaws

ArrayLaws

object ArrayLaws

Functions

inline fun <E> Array<E>.component1Law(): E

inline fun <E> Array<E>.component2Law(): E

inline fun <E> Array<E>.component3Law(): E

inline fun <E> Array<E>.component4Law(): E

inline fun <E> Array<E>.component5Law(): E

inline fun <E : Any> constructorLaw(size: Int, noinline init: (Int) -> E): Array<E>

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

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

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

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

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

elementAtOrNullLaw

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

inline fun <E : Any> emptyArrayLaw(): Array<E>

filterIndexedLaw

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

filterIsInstanceLaw

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

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

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

filterNotNullLaw

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

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

firstLawWithPredicate

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

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

inline fun <E> Array<E>.getLaw(index: Int): E

indexOfFirstLaw

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

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

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

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

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

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

isNullOrEmptyLaw

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

inline fun <E> Array<E>.lastIndexLaw(): Int

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

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

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

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

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

mapIndexedNotNullLaw

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

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

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

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

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

randomOrNullLaw

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

inline fun <E> Array<E>.setLaw(index: Int, value: E)

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

singleOrNullLaw

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

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

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

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