Returns a list of pairs, where each value corresponds to all possible pairings with values from other. this: A, B, C other: 1, 2 this.cartesianProduct(other) = A to 1, A to 2, B to 1, B to 2, C to 1, C to 2

chunkedAverage

fun Collection<Float>.chunkedAverage(chunkSize: Int): List<Double>

fun Sequence<Float>.chunkedAverage(chunkSize: Int): Sequence<Double>

Will first put this's elements into chunks of size chunkSize, then calculate an average of each of the chunks.

coerceIn

infix fun <T : Comparable<T>> ClosedRange<T>.coerceIn(other: ClosedRange<T>): ClosedRange<T>

Produces a range that is fully contained within other range.

component1

operator fun <T : Comparable<T>> ClosedRange<T>.component1(): T

Get ClosedRange.start

component2

operator fun <T : Comparable<T>> ClosedRange<T>.component2(): T

Get ClosedRange.endInclusive

contains

infix operator fun <T : Comparable<T>> ClosedRange<T>.contains(other: ClosedRange<T>): Boolean

Returns true if this range is fully contained within the other range

copies

fun <T> T.copies(count: Int): List<T>

Fills the list with shallow copies of the receiver

expand

fun <T : Comparable<T>> ClosedRange<T>.expand(other: ClosedRange<T>): ClosedRange<T>

Produces a range where min value is the minimum between other.start and ClosedRange.start and max value is maximum between other.endInclusive and ClosedRange.endInclusive

expandBy

fun ClosedFloatingPointRange<Double>.expandBy(delta: Double): ClosedFloatingPointRange<Double>

fun ClosedFloatingPointRange<Float>.expandBy(delta: Float): ClosedFloatingPointRange<Float>

fun ClosedFloatingPointRange<Int>.expandBy(delta: Int): IntRange

fun ClosedFloatingPointRange<Long>.expandBy(delta: Long): LongRange

Expand the range left and right by delta and return the resulting range

fastLazy

fun <T> fastLazy(initializer: () -> T): Lazy<T>

Uses LazyThreadSafetyMode.NONE to provide values quicker.

filterBySubstring

fun Iterable<String>.filterBySubstring(substring: String?, ignoreCase: Boolean = false): List<String>

Filter this by searching for elements that contain substring, or if string is not String.isValid, the list itself

filterNotNullValues

fun <K, V> Map<K, V?>.filterNotNullValues(): Map<K, V & Any>

Filters the values in this map, leaving only non-null entries

format

fun Float.format(digits: Int, locale: Locale? = null): String

Formats this Float to string using specified number of digits and a given locale

indexOfFirstOrNull

inline fun <T> Iterable<T>.indexOfFirstOrNull(predicate: (T) -> Boolean): Int?

Like indexOfFirst but returns null instead of -1. If the not found.

isValid

inline fun String?.isValid(): Boolean

mapNotNull

fun <T, R> List<T>.mapNotNull(transform: (prev: R?, value: T) -> R?): List<R>

The same as a regular mapNotNull, but transform block contains the previous value of the list.

minus

operator fun ClosedRange<Double>.minus(value: Double): ClosedFloatingPointRange<Double>

operator fun ClosedRange<Float>.minus(value: Float): ClosedFloatingPointRange<Float>

operator fun ClosedRange<Int>.minus(value: Int): IntRange

operator fun ClosedRange<Long>.minus(value: Long): LongRange

Subtract value from both start and end of the range

plus

operator fun ClosedRange<Double>.plus(value: Double): ClosedFloatingPointRange<Double>

operator fun ClosedRange<Float>.plus(value: Float): ClosedFloatingPointRange<Float>

operator fun ClosedRange<Int>.plus(value: Int): IntRange

operator fun ClosedRange<Long>.plus(value: Long): LongRange

Add value to both start and end of the range

randomElements

fun <T> Iterable<T>.randomElements(count: Int): List<T>

Returns count number elements from this

randomIndex

fun <T> Collection<T>.randomIndex(): Int

Returns a random index of this collection

reorderBy

inline fun <T, R> Iterable<T>.reorderBy(order: List<R>, crossinline selector: (T) -> R): List<T>

replace

inline fun <T> Iterable<T>.replace(item: T, replacement: T.() -> T): List<T>

Creates a copy of this with item replaced with whatever is returned by replacement.

replaceIf

inline fun <T> Iterable<T>.replaceIf(with: T, predicate: (T) -> Boolean): List<T>

inline fun <T> Iterable<T>.replaceIf(apply: T.() -> T, predicate: (T) -> Boolean): List<T>

replaceWith

fun <T> MutableCollection<T>.replaceWith(src: Collection<T>)

Replaces all values of this with values from src

requireNotNull

fun <T> T?.requireNotNull(): T & Any

inline fun <T> T?.requireNotNull(lazyMessage: () -> Unit): T & Any

Calls requireNotNull on this value and returns it

rethrowErrors

@JvmName(name = "rethrowErrorsNotNull")

fun Throwable.rethrowErrors(): Exception

fun Throwable?.rethrowErrors(): Exception?

If this is an Error, throws it, otherwise returns this as an Exception

shrinkBy

fun ClosedFloatingPointRange<Double>.shrinkBy(delta: Double): ClosedFloatingPointRange<Double>

fun ClosedFloatingPointRange<Float>.shrinkBy(delta: Float): ClosedFloatingPointRange<Float>

fun ClosedFloatingPointRange<Int>.shrinkBy(delta: Int): IntRange

fun ClosedFloatingPointRange<Long>.shrinkBy(delta: Long): LongRange

Shrink the range left and right by delta and return the resulting range

singleOrNullIfEmpty

fun <T> Iterable<T>.singleOrNullIfEmpty(): T?

spans

infix fun String.spans(range: IntRange): Boolean

Check if this String has length in range

sumOf

inline fun <T> Collection<T>.sumOf(selector: (T) -> Float): Float

A sumOf variation that returns a float instead of Double

swap

fun <T> MutableList<T>.swap(index1: Int, index2: Int): MutableList<T>

Swaps values index1 with index2 in place. Throws IndexOutOfBoundsException when one or both indices are not present in the collection

swapped

fun <T> List<T>.swapped(index1: Int, index2: Int): List<T>

Returns a shallow copy of this list with the items at index1 and index2 swapped. Throws IndexOutOfBoundsException when one or both indices are not present in the collection

swappedOrDefault

fun <T : Any> List<T>.swappedOrDefault(index1: Int, index2: Int): List<T>

Returns a shallow copy of this list with the items at index1 and index2 swapped. Returns the original collection if either index1 or index2 are not resent

take