Package-level declarations

Collection types, such as Iterable, Collection, List, Set, Map and related top-level and extension functions.

Collection types, such as Iterable, Collection, List, Set, Map and related top-level and extension functions.

Types

Link copied to clipboard
abstract class AbstractCollection<out E> : Collection<E>

Provides a skeletal implementation of the read-only Collection interface.

Since Kotlin 1.1
abstract class AbstractCollection<out E> : Collection<E>

Provides a skeletal implementation of the read-only Collection interface.

Since Kotlin 1.1
Link copied to clipboard
abstract class AbstractIterator<T> : Iterator<T>

A base class to simplify implementing iterators so that implementations only have to implement computeNext to implement the iterator, calling done when the iteration is complete.

Since Kotlin 1.1
abstract class AbstractIterator<T> : Iterator<T>

A base class to simplify implementing iterators so that implementations only have to implement computeNext to implement the iterator, calling done when the iteration is complete.

Since Kotlin 1.0
Link copied to clipboard
abstract class AbstractList<out E> : AbstractCollection<E> , List<E>

Provides a skeletal implementation of the read-only List interface.

Since Kotlin 1.1
abstract class AbstractList<out E> : AbstractCollection<E> , List<E>

Provides a skeletal implementation of the read-only List interface.

Since Kotlin 1.1
Link copied to clipboard
abstract class AbstractMap<K, out V> : Map<K, V>

Provides a skeletal implementation of the read-only Map interface.

Since Kotlin 1.1
abstract class AbstractMap<K, out V> : Map<K, V>

Provides a skeletal implementation of the read-only Map interface.

Since Kotlin 1.1
Link copied to clipboard
expect abstract class AbstractMutableList<E> : AbstractList<E> , MutableList<E>

Provides a skeletal implementation of the MutableList interface.

Since Kotlin 1.1
Link copied to clipboard
abstract class AbstractSet<out E> : AbstractCollection<E> , Set<E>

Provides a skeletal implementation of the read-only Set interface.

Since Kotlin 1.1
abstract class AbstractSet<out E> : AbstractCollection<E> , Set<E>

Provides a skeletal implementation of the read-only Set interface.

Since Kotlin 1.1
Link copied to clipboard
actual typealias ArrayList<E> = java.util.ArrayList<E>
Since Kotlin 1.1
Link copied to clipboard
abstract class BooleanIterator : Iterator<Boolean>

An iterator over a sequence of values of type Boolean.

Since Kotlin 1.1
abstract class BooleanIterator : Iterator<Boolean>

An iterator over a sequence of values of type Boolean.

Since Kotlin 1.0
Link copied to clipboard
abstract class ByteIterator : Iterator<Byte>

An iterator over a sequence of values of type Byte.

Since Kotlin 1.1
abstract class ByteIterator : Iterator<Byte>

An iterator over a sequence of values of type Byte.

Since Kotlin 1.0
Link copied to clipboard
abstract class CharIterator : Iterator<Char>

An iterator over a sequence of values of type Char.

Since Kotlin 1.1
abstract class CharIterator : Iterator<Char>

An iterator over a sequence of values of type Char.

Since Kotlin 1.0
Link copied to clipboard
interface Collection<out E> : Iterable<E>

A generic collection of elements. Methods in this interface support only read-only access to the collection; read/write access is supported through the MutableCollection interface.

Since Kotlin 1.1
interface Collection<out E> : Iterable<E>

A generic collection of elements. Methods in this interface support only read-only access to the collection; read/write access is supported through the MutableCollection interface.

Since Kotlin 1.0
Link copied to clipboard
abstract class DoubleIterator : Iterator<Double>

An iterator over a sequence of values of type Double.

Since Kotlin 1.1
abstract class DoubleIterator : Iterator<Double>

An iterator over a sequence of values of type Double.

Since Kotlin 1.0
Link copied to clipboard
abstract class FloatIterator : Iterator<Float>

An iterator over a sequence of values of type Float.

Since Kotlin 1.1
abstract class FloatIterator : Iterator<Float>

An iterator over a sequence of values of type Float.

Since Kotlin 1.0
Link copied to clipboard
interface Grouping<T, out K>

Represents a source of elements with a keyOf function, which can be applied to each element to get its key.

Since Kotlin 1.1
interface Grouping<T, out K>

Represents a source of elements with a keyOf function, which can be applied to each element to get its key.

Since Kotlin 1.1
Link copied to clipboard
actual typealias HashMap<K, V> = java.util.HashMap<K, V>
Since Kotlin 1.1
Link copied to clipboard
actual typealias HashSet<E> = java.util.HashSet<E>
Since Kotlin 1.1
Link copied to clipboard
data class IndexedValue<out T>(val index: Int, val value: T)

Data class representing a value from a collection or sequence, along with its index in that collection or sequence.

Since Kotlin 1.1
data class IndexedValue<out T>(val index: Int, val value: T)

Data class representing a value from a collection or sequence, along with its index in that collection or sequence.

Since Kotlin 1.0
Link copied to clipboard
abstract class IntIterator : Iterator<Int>

An iterator over a sequence of values of type Int.

Since Kotlin 1.1
abstract class IntIterator : Iterator<Int>

An iterator over a sequence of values of type Int.

Since Kotlin 1.0
Link copied to clipboard
interface Iterable<out T>

Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over.

Since Kotlin 1.1
interface Iterable<out T>

Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over.

Since Kotlin 1.0
Link copied to clipboard
interface Iterator<out T>

An iterator over a collection or another entity that can be represented as a sequence of elements. Allows to sequentially access the elements.

Since Kotlin 1.1
interface Iterator<out T>

An iterator over a collection or another entity that can be represented as a sequence of elements. Allows to sequentially access the elements.

Since Kotlin 1.0
Link copied to clipboard
actual typealias LinkedHashMap<K, V> = java.util.LinkedHashMap<K, V>
Since Kotlin 1.1
Link copied to clipboard
Since Kotlin 1.1
Link copied to clipboard
interface List<out E> : Collection<E>

A generic ordered collection of elements. Methods in this interface support only read-only access to the list; read/write access is supported through the MutableList interface.

Since Kotlin 1.1
interface List<out E> : Collection<E>

A generic ordered collection of elements. Methods in this interface support only read-only access to the list; read/write access is supported through the MutableList interface.

Since Kotlin 1.0
Link copied to clipboard
interface ListIterator<out T> : Iterator<T>

An iterator over a collection that supports indexed access.

Since Kotlin 1.1
interface ListIterator<out T> : Iterator<T>

An iterator over a collection that supports indexed access.

Since Kotlin 1.0
Link copied to clipboard
abstract class LongIterator : Iterator<Long>

An iterator over a sequence of values of type Long.

Since Kotlin 1.1
abstract class LongIterator : Iterator<Long>

An iterator over a sequence of values of type Long.

Since Kotlin 1.0
Link copied to clipboard
interface Map<K, out V>

A collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key. Methods in this interface support only read-only access to the map; read-write access is supported through the MutableMap interface.

Since Kotlin 1.1
interface Map<K, out V>

A collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key. Methods in this interface support only read-only access to the map; read-write access is supported through the MutableMap interface.

Since Kotlin 1.0
Link copied to clipboard

A generic collection of elements that supports adding and removing elements.

Since Kotlin 1.1

A generic collection of elements that supports adding and removing elements.

Since Kotlin 1.0
Link copied to clipboard
interface MutableIterable<out T> : Iterable<T>

Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over and that supports removing elements during iteration.

Since Kotlin 1.1
interface MutableIterable<out T> : Iterable<T>

Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over and that supports removing elements during iteration.

Since Kotlin 1.0
Link copied to clipboard
interface MutableIterator<out T> : Iterator<T>

An iterator over a mutable collection. Provides the ability to remove elements while iterating.

Since Kotlin 1.1
interface MutableIterator<out T> : Iterator<T>

An iterator over a mutable collection. Provides the ability to remove elements while iterating.

Since Kotlin 1.0
Link copied to clipboard

A generic ordered collection of elements that supports adding and removing elements.

Since Kotlin 1.1

A generic ordered collection of elements that supports adding and removing elements.

Since Kotlin 1.0
Link copied to clipboard

An iterator over a mutable collection that supports indexed access. Provides the ability to add, modify and remove elements while iterating.

Since Kotlin 1.1

An iterator over a mutable collection that supports indexed access. Provides the ability to add, modify and remove elements while iterating.

Since Kotlin 1.0
Link copied to clipboard
interface MutableMap<K, V> : Map<K, V>

A modifiable collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key.

Since Kotlin 1.1
interface MutableMap<K, V> : Map<K, V>

A modifiable collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key.

Since Kotlin 1.0
Link copied to clipboard
interface MutableSet<E> : Set<E> , MutableCollection<E>

A generic unordered collection of elements that does not support duplicate elements, and supports adding and removing elements.

Since Kotlin 1.1
interface MutableSet<E> : Set<E> , MutableCollection<E>

A generic unordered collection of elements that does not support duplicate elements, and supports adding and removing elements.

Since Kotlin 1.0
Link copied to clipboard
Since Kotlin 1.1
Link copied to clipboard
interface Set<out E> : Collection<E>

A generic unordered collection of elements that does not support duplicate elements. Methods in this interface support only read-only access to the set; read/write access is supported through the MutableSet interface.

Since Kotlin 1.1
interface Set<out E> : Collection<E>

A generic unordered collection of elements that does not support duplicate elements. Methods in this interface support only read-only access to the set; read/write access is supported through the MutableSet interface.

Since Kotlin 1.0
Link copied to clipboard
abstract class ShortIterator : Iterator<Short>

An iterator over a sequence of values of type Short.

Since Kotlin 1.1
abstract class ShortIterator : Iterator<Short>

An iterator over a sequence of values of type Short.

Since Kotlin 1.0

Properties

Link copied to clipboard

Returns an IntRange of the valid indices for this collection.

Since Kotlin 1.1
val <T> Array<out T>.indices: IntRange

Returns the range of valid indices for the array.

Since Kotlin 1.0

Returns an IntRange of the valid indices for this collection.

Since Kotlin 1.0
Link copied to clipboard
val <T> List<T>.lastIndex: Int

Returns the index of the last item in the list or -1 if the list is empty.

Since Kotlin 1.1
val <T> Array<out T>.lastIndex: Int

Returns the last valid index for the array.

Since Kotlin 1.0
val <T> List<T>.lastIndex: Int

Returns the index of the last item in the list or -1 if the list is empty.

Since Kotlin 1.0

Functions

Link copied to clipboard
fun <T> MutableCollection<in T>.addAll(elements: Array<out T>): Boolean

Adds all elements of the given elements array to this MutableCollection.

Since Kotlin 1.1
fun <T> MutableCollection<in T>.addAll(elements: Iterable<T>): Boolean

Adds all elements of the given elements collection to this MutableCollection.

Since Kotlin 1.1
fun <T> MutableCollection<in T>.addAll(elements: Sequence<T>): Boolean

Adds all elements of the given elements sequence to this MutableCollection.

Since Kotlin 1.1
fun <T> MutableCollection<in T>.addAll(elements: Array<out T>): Boolean

Adds all elements of the given elements array to this MutableCollection.

Since Kotlin 1.0
fun <T> MutableCollection<in T>.addAll(elements: Iterable<T>): Boolean

Adds all elements of the given elements collection to this MutableCollection.

Since Kotlin 1.0
fun <T> MutableCollection<in T>.addAll(elements: Sequence<T>): Boolean

Adds all elements of the given elements sequence to this MutableCollection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, R> Grouping<T, K>.aggregate(operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): Map<K, R>

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map.

Since Kotlin 1.1
inline fun <T, K, R> Grouping<T, K>.aggregate(operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): Map<K, R>

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.aggregateTo(destination: M, operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): M

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map.

Since Kotlin 1.1
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.aggregateTo(destination: M, operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): M

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> Array<out T>.all(predicate: (T) -> Boolean): Boolean
inline fun BooleanArray.all(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.all(predicate: (Byte) -> Boolean): Boolean
inline fun CharArray.all(predicate: (Char) -> Boolean): Boolean
inline fun DoubleArray.all(predicate: (Double) -> Boolean): Boolean
inline fun FloatArray.all(predicate: (Float) -> Boolean): Boolean
inline fun IntArray.all(predicate: (Int) -> Boolean): Boolean
inline fun LongArray.all(predicate: (Long) -> Boolean): Boolean
inline fun ShortArray.all(predicate: (Short) -> Boolean): Boolean
inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

Returns true if all elements match the given predicate.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.all(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

Returns true if all entries match the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.any(): Boolean

Returns true if array has at least one element.

Since Kotlin 1.0
fun <T> Iterable<T>.any(): Boolean

Returns true if collection has at least one element.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.any(): Boolean

Returns true if map has at least one entry.

Since Kotlin 1.0
inline fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean
inline fun BooleanArray.any(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.any(predicate: (Byte) -> Boolean): Boolean
inline fun CharArray.any(predicate: (Char) -> Boolean): Boolean
inline fun DoubleArray.any(predicate: (Double) -> Boolean): Boolean
inline fun FloatArray.any(predicate: (Float) -> Boolean): Boolean
inline fun IntArray.any(predicate: (Int) -> Boolean): Boolean
inline fun LongArray.any(predicate: (Long) -> Boolean): Boolean
inline fun ShortArray.any(predicate: (Short) -> Boolean): Boolean
inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

Returns true if at least one element matches the given predicate.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.any(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

Returns true if at least one entry matches the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> arrayListOf(): ArrayList<T>

Returns an empty new ArrayList.

Since Kotlin 1.1
fun <T> arrayListOf(vararg elements: T): ArrayList<T>

Returns a new ArrayList with the given elements.

Since Kotlin 1.1
inline fun <T> arrayListOf(): ArrayList<T>

Returns an empty new ArrayList.

Since Kotlin 1.1
fun <T> arrayListOf(vararg elements: T): ArrayList<T>

Returns a new ArrayList with the given elements.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.asIterable(): Iterable<T>

Creates an Iterable instance that wraps the original array returning its elements when being iterated.

Since Kotlin 1.0
inline fun <T> Iterable<T>.asIterable(): Iterable<T>

Returns this collection as an Iterable.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.asIterable(): Iterable<Map.Entry<K, V>>

Creates an Iterable instance that wraps the original map returning its entries when being iterated.

Since Kotlin 1.0
Link copied to clipboard
expect fun <T> Array<out T>.asList(): List<T>
expect fun ByteArray.asList(): List<Byte>
expect fun CharArray.asList(): List<Char>
expect fun DoubleArray.asList(): List<Double>
expect fun FloatArray.asList(): List<Float>
expect fun IntArray.asList(): List<Int>
expect fun LongArray.asList(): List<Long>
expect fun ShortArray.asList(): List<Short>

Returns a List that wraps the original array.

Since Kotlin 1.0
Link copied to clipboard
fun <T> List<T>.asReversed(): List<T>

Returns a reversed read-only view of the original List. All changes made in the original list will be reflected in the reversed one.

Since Kotlin 1.1

Returns a reversed mutable view of the original mutable List. All changes made in the original list will be reflected in the reversed one and vice versa.

Since Kotlin 1.1
fun <T> List<T>.asReversed(): List<T>

Returns a reversed read-only view of the original List. All changes made in the original list will be reflected in the reversed one.

Since Kotlin 1.0
@JvmName(name = "asReversedMutable")
fun <T> MutableList<T>.asReversed(): MutableList<T>

Returns a reversed mutable view of the original mutable List. All changes made in the original list will be reflected in the reversed one and vice versa.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.asSequence(): Sequence<T>

Creates a Sequence instance that wraps the original array returning its elements when being iterated.

Since Kotlin 1.0

Creates a Sequence instance that wraps the original collection returning its elements when being iterated.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.asSequence(): Sequence<Map.Entry<K, V>>

Creates a Sequence instance that wraps the original map returning its entries when being iterated.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, V> Array<out T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>
inline fun <K, V> BooleanArray.associate(transform: (Boolean) -> Pair<K, V>): Map<K, V>
inline fun <K, V> ByteArray.associate(transform: (Byte) -> Pair<K, V>): Map<K, V>
inline fun <K, V> CharArray.associate(transform: (Char) -> Pair<K, V>): Map<K, V>
inline fun <K, V> DoubleArray.associate(transform: (Double) -> Pair<K, V>): Map<K, V>
inline fun <K, V> FloatArray.associate(transform: (Float) -> Pair<K, V>): Map<K, V>
inline fun <K, V> IntArray.associate(transform: (Int) -> Pair<K, V>): Map<K, V>
inline fun <K, V> LongArray.associate(transform: (Long) -> Pair<K, V>): Map<K, V>
inline fun <K, V> ShortArray.associate(transform: (Short) -> Pair<K, V>): Map<K, V>

Returns a Map containing key-value pairs provided by transform function applied to elements of the given array.

Since Kotlin 1.0
inline fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>

Returns a Map containing key-value pairs provided by transform function applied to elements of the given collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K> Array<out T>.associateBy(keySelector: (T) -> K): Map<K, T>
inline fun <K> BooleanArray.associateBy(keySelector: (Boolean) -> K): Map<K, Boolean>
inline fun <K> ByteArray.associateBy(keySelector: (Byte) -> K): Map<K, Byte>
inline fun <K> CharArray.associateBy(keySelector: (Char) -> K): Map<K, Char>
inline fun <K> DoubleArray.associateBy(keySelector: (Double) -> K): Map<K, Double>
inline fun <K> FloatArray.associateBy(keySelector: (Float) -> K): Map<K, Float>
inline fun <K> IntArray.associateBy(keySelector: (Int) -> K): Map<K, Int>
inline fun <K> LongArray.associateBy(keySelector: (Long) -> K): Map<K, Long>
inline fun <K> ShortArray.associateBy(keySelector: (Short) -> K): Map<K, Short>

Returns a Map containing the elements from the given array indexed by the key returned from keySelector function applied to each element.

Since Kotlin 1.0
inline fun <T, K> Iterable<T>.associateBy(keySelector: (T) -> K): Map<K, T>

Returns a Map containing the elements from the given collection indexed by the key returned from keySelector function applied to each element.

Since Kotlin 1.0
inline fun <T, K, V> Array<out T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>
inline fun <K, V> BooleanArray.associateBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, V>
inline fun <K, V> ByteArray.associateBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, V>
inline fun <K, V> CharArray.associateBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, V>
inline fun <K, V> DoubleArray.associateBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, V>
inline fun <K, V> FloatArray.associateBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, V>
inline fun <K, V> IntArray.associateBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, V>
inline fun <K, V> LongArray.associateBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, V>
inline fun <K, V> ShortArray.associateBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, V>

Returns a Map containing the values provided by valueTransform and indexed by keySelector functions applied to elements of the given array.

Since Kotlin 1.0
inline fun <T, K, V> Iterable<T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>

Returns a Map containing the values provided by valueTransform and indexed by keySelector functions applied to elements of the given collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, M : MutableMap<in K, in T>> Array<out T>.associateByTo(destination: M, keySelector: (T) -> K): M
inline fun <K, M : MutableMap<in K, in Boolean>> BooleanArray.associateByTo(destination: M, keySelector: (Boolean) -> K): M
inline fun <K, M : MutableMap<in K, in Byte>> ByteArray.associateByTo(destination: M, keySelector: (Byte) -> K): M
inline fun <K, M : MutableMap<in K, in Char>> CharArray.associateByTo(destination: M, keySelector: (Char) -> K): M
inline fun <K, M : MutableMap<in K, in Double>> DoubleArray.associateByTo(destination: M, keySelector: (Double) -> K): M
inline fun <K, M : MutableMap<in K, in Float>> FloatArray.associateByTo(destination: M, keySelector: (Float) -> K): M
inline fun <K, M : MutableMap<in K, in Int>> IntArray.associateByTo(destination: M, keySelector: (Int) -> K): M
inline fun <K, M : MutableMap<in K, in Long>> LongArray.associateByTo(destination: M, keySelector: (Long) -> K): M
inline fun <K, M : MutableMap<in K, in Short>> ShortArray.associateByTo(destination: M, keySelector: (Short) -> K): M

Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each element of the given array and value is the element itself.

Since Kotlin 1.0
inline fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K): M

Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each element of the given collection and value is the element itself.

Since Kotlin 1.0
inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateByTo(destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateByTo(destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateByTo(destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateByTo(destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateByTo(destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateByTo(destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateByTo(destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateByTo(destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V): M

Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to elements of the given array.

Since Kotlin 1.0
inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to elements of the given collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateTo(destination: M, transform: (Boolean) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateTo(destination: M, transform: (Byte) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateTo(destination: M, transform: (Char) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateTo(destination: M, transform: (Double) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateTo(destination: M, transform: (Float) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateTo(destination: M, transform: (Int) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateTo(destination: M, transform: (Long) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateTo(destination: M, transform: (Short) -> Pair<K, V>): M

Populates and returns the destination mutable map with key-value pairs provided by transform function applied to each element of the given array.

Since Kotlin 1.0
inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M

Populates and returns the destination mutable map with key-value pairs provided by transform function applied to each element of the given collection.

Since Kotlin 1.0
Link copied to clipboard
@JvmName(name = "averageOfByte")
fun ByteArray.average(): Double
@JvmName(name = "averageOfDouble")
fun DoubleArray.average(): Double
@JvmName(name = "averageOfFloat")
fun FloatArray.average(): Double
@JvmName(name = "averageOfInt")
fun IntArray.average(): Double
@JvmName(name = "averageOfLong")
fun LongArray.average(): Double
@JvmName(name = "averageOfShort")
fun ShortArray.average(): Double

Returns an average value of elements in the array.

Since Kotlin 1.0
@JvmName(name = "averageOfByte")
fun Iterable<Byte>.average(): Double
@JvmName(name = "averageOfDouble")
fun Iterable<Double>.average(): Double
@JvmName(name = "averageOfFloat")
fun Iterable<Float>.average(): Double
@JvmName(name = "averageOfInt")
fun Iterable<Int>.average(): Double
@JvmName(name = "averageOfLong")
fun Iterable<Long>.average(): Double
@JvmName(name = "averageOfShort")
fun Iterable<Short>.average(): Double

Returns an average value of elements in the collection.

Since Kotlin 1.0
Link copied to clipboard
fun <T> List<T>.binarySearch(fromIndex: Int = 0, toIndex: Int = size, comparison: (T) -> Int): Int

Searches this list or its range for an element for which the given comparison function returns zero using the binary search algorithm.

Since Kotlin 1.1
fun <T : Comparable<T>> List<T?>.binarySearch(element: T?, fromIndex: Int = 0, toIndex: Int = size): Int

Searches this list or its range for the provided element using the binary search algorithm. The list is expected to be sorted into ascending order according to the Comparable natural ordering of its elements, otherwise the result is undefined.

Since Kotlin 1.1
fun <T> List<T>.binarySearch(element: T, comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size): Int

Searches this list or its range for the provided element using the binary search algorithm. The list is expected to be sorted into ascending order according to the specified comparator, otherwise the result is undefined.

Since Kotlin 1.1
fun <T> Array<out T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size): Int
fun ByteArray.binarySearch(element: Byte, fromIndex: Int = 0, toIndex: Int = size): Int
fun CharArray.binarySearch(element: Char, fromIndex: Int = 0, toIndex: Int = size): Int
fun DoubleArray.binarySearch(element: Double, fromIndex: Int = 0, toIndex: Int = size): Int
fun FloatArray.binarySearch(element: Float, fromIndex: Int = 0, toIndex: Int = size): Int
fun IntArray.binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size): Int
fun LongArray.binarySearch(element: Long, fromIndex: Int = 0, toIndex: Int = size): Int
fun ShortArray.binarySearch(element: Short, fromIndex: Int = 0, toIndex: Int = size): Int

Searches the array or the range of the array for the provided element using the binary search algorithm. The array is expected to be sorted, otherwise the result is undefined.

Since Kotlin 1.0
fun <T> List<T>.binarySearch(fromIndex: Int = 0, toIndex: Int = size, comparison: (T) -> Int): Int

Searches this list or its range for an element for which the given comparison function returns zero using the binary search algorithm.

Since Kotlin 1.0
fun <T : Comparable<T>> List<T?>.binarySearch(element: T?, fromIndex: Int = 0, toIndex: Int = size): Int

Searches this list or its range for the provided element using the binary search algorithm. The list is expected to be sorted into ascending order according to the Comparable natural ordering of its elements, otherwise the result is undefined.

Since Kotlin 1.0
fun <T> Array<out T>.binarySearch(element: T, comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size): Int

Searches the array or the range of the array for the provided element using the binary search algorithm. The array is expected to be sorted according to the specified comparator, otherwise the result is undefined.

Since Kotlin 1.0
fun <T> List<T>.binarySearch(element: T, comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size): Int

Searches this list or its range for the provided element using the binary search algorithm. The list is expected to be sorted into ascending order according to the specified comparator, otherwise the result is undefined.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K : Comparable<K>> List<T>.binarySearchBy(key: K?, fromIndex: Int = 0, toIndex: Int = size, crossinline selector: (T) -> K?): Int

Searches this list or its range for an element having the key returned by the specified selector function equal to the provided key value using the binary search algorithm. The list is expected to be sorted into ascending order according to the Comparable natural ordering of keys of its elements. otherwise the result is undefined.

Since Kotlin 1.1
inline fun <T, K : Comparable<K>> List<T>.binarySearchBy(key: K?, fromIndex: Int = 0, toIndex: Int = size, crossinline selector: (T) -> K?): Int

Searches this list or its range for an element having the key returned by the specified selector function equal to the provided key value using the binary search algorithm. The list is expected to be sorted into ascending order according to the Comparable natural ordering of keys of its elements. otherwise the result is undefined.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <K, V> Map.Entry<K, V>.component1(): K

Returns the key component of the map entry.

Since Kotlin 1.1
inline operator fun <T> Array<out T>.component1(): T
inline operator fun BooleanArray.component1(): Boolean
inline operator fun ByteArray.component1(): Byte
inline operator fun CharArray.component1(): Char
inline operator fun DoubleArray.component1(): Double
inline operator fun FloatArray.component1(): Float
inline operator fun IntArray.component1(): Int
inline operator fun LongArray.component1(): Long
inline operator fun ShortArray.component1(): Short

Returns 1st element from the array.

Since Kotlin 1.0
inline operator fun <T> List<T>.component1(): T

Returns 1st element from the list.

Since Kotlin 1.0
inline operator fun <K, V> Map.Entry<K, V>.component1(): K

Returns the key component of the map entry.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <K, V> Map.Entry<K, V>.component2(): V

Returns the value component of the map entry.

Since Kotlin 1.1
inline operator fun <T> Array<out T>.component2(): T
inline operator fun BooleanArray.component2(): Boolean
inline operator fun ByteArray.component2(): Byte
inline operator fun CharArray.component2(): Char
inline operator fun DoubleArray.component2(): Double
inline operator fun FloatArray.component2(): Float
inline operator fun IntArray.component2(): Int
inline operator fun LongArray.component2(): Long
inline operator fun ShortArray.component2(): Short

Returns 2nd element from the array.

Since Kotlin 1.0
inline operator fun <T> List<T>.component2(): T

Returns 2nd element from the list.

Since Kotlin 1.0
inline operator fun <K, V> Map.Entry<K, V>.component2(): V

Returns the value component of the map entry.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <T> Array<out T>.component3(): T
inline operator fun BooleanArray.component3(): Boolean
inline operator fun ByteArray.component3(): Byte
inline operator fun CharArray.component3(): Char
inline operator fun DoubleArray.component3(): Double
inline operator fun FloatArray.component3(): Float
inline operator fun IntArray.component3(): Int
inline operator fun LongArray.component3(): Long
inline operator fun ShortArray.component3(): Short

Returns 3rd element from the array.

Since Kotlin 1.0
inline operator fun <T> List<T>.component3(): T

Returns 3rd element from the list.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <T> Array<out T>.component4(): T
inline operator fun BooleanArray.component4(): Boolean
inline operator fun ByteArray.component4(): Byte
inline operator fun CharArray.component4(): Char
inline operator fun DoubleArray.component4(): Double
inline operator fun FloatArray.component4(): Float
inline operator fun IntArray.component4(): Int
inline operator fun LongArray.component4(): Long
inline operator fun ShortArray.component4(): Short

Returns 4th element from the array.

Since Kotlin 1.0
inline operator fun <T> List<T>.component4(): T

Returns 4th element from the list.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <T> Array<out T>.component5(): T
inline operator fun BooleanArray.component5(): Boolean
inline operator fun ByteArray.component5(): Byte
inline operator fun CharArray.component5(): Char
inline operator fun DoubleArray.component5(): Double
inline operator fun FloatArray.component5(): Float
inline operator fun IntArray.component5(): Int
inline operator fun LongArray.component5(): Long
inline operator fun ShortArray.component5(): Short

Returns 5th element from the array.

Since Kotlin 1.0
inline operator fun <T> List<T>.component5(): T

Returns 5th element from the list.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <K, V> Map<out K, V>.contains(key: K): Boolean

Checks if the map contains the given key.

Since Kotlin 1.1
operator fun <T> Array<out T>.contains(element: T): Boolean
operator fun BooleanArray.contains(element: Boolean): Boolean
operator fun ByteArray.contains(element: Byte): Boolean
operator fun CharArray.contains(element: Char): Boolean
operator fun DoubleArray.contains(element: Double): Boolean
operator fun FloatArray.contains(element: Float): Boolean
operator fun IntArray.contains(element: Int): Boolean
operator fun LongArray.contains(element: Long): Boolean
operator fun ShortArray.contains(element: Short): Boolean

Returns true if element is found in the array.

Since Kotlin 1.0
operator fun <T> Iterable<T>.contains(element: T): Boolean

Returns true if element is found in the collection.

Since Kotlin 1.0
inline operator fun <K, V> Map<out K, V>.contains(key: K): Boolean

Checks if the map contains the given key.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Collection<T>.containsAll(elements: Collection<T>): Boolean

Checks if all elements in the specified collection are contained in this collection.

Since Kotlin 1.1
inline fun <T> Collection<T>.containsAll(elements: Collection<T>): Boolean

Checks if all elements in the specified collection are contained in this collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K> Map<out K, *>.containsKey(key: K): Boolean

Returns true if the map contains the specified key.

Since Kotlin 1.1
inline fun <K> Map<out K, *>.containsKey(key: K): Boolean

Returns true if the map contains the specified key.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<K, V>.containsValue(value: V): Boolean

Returns true if the map maps one or more keys to the specified value.

Since Kotlin 1.1
inline fun <K, V> Map<K, V>.containsValue(value: V): Boolean

Returns true if the map maps one or more keys to the specified value.

Since Kotlin 1.0
Link copied to clipboard
@JvmName(name = "contentDeepEqualsInline")
expect infix inline fun <T> Array<out T>.contentDeepEquals(other: Array<out T>): Boolean

Returns true if the two specified arrays are deeply equal to one another, i.e. contain the same number of the same elements in the same order.

Since Kotlin 1.1
Link copied to clipboard
@JvmName(name = "contentDeepHashCodeInline")
expect inline fun <T> Array<out T>.contentDeepHashCode(): Int

Returns a hash code based on the contents of this array as if it is List. Nested arrays are treated as lists too.

Since Kotlin 1.1
Link copied to clipboard
@JvmName(name = "contentDeepToStringInline")
expect inline fun <T> Array<out T>.contentDeepToString(): String

Returns a string representation of the contents of this array as if it is a List. Nested arrays are treated as lists too.

Since Kotlin 1.1
Link copied to clipboard
expect infix inline fun <T> Array<out T>.contentEquals(other: Array<out T>): Boolean
expect infix inline fun BooleanArray.contentEquals(other: BooleanArray): Boolean
expect infix inline fun ByteArray.contentEquals(other: ByteArray): Boolean
expect infix inline fun CharArray.contentEquals(other: CharArray): Boolean
expect infix inline fun DoubleArray.contentEquals(other: DoubleArray): Boolean
expect infix inline fun FloatArray.contentEquals(other: FloatArray): Boolean
expect infix inline fun IntArray.contentEquals(other: IntArray): Boolean
expect infix inline fun LongArray.contentEquals(other: LongArray): Boolean
expect infix inline fun ShortArray.contentEquals(other: ShortArray): Boolean

Returns true if the two specified arrays are structurally equal to one another, i.e. contain the same number of the same elements in the same order.

Since Kotlin 1.1
Link copied to clipboard
expect inline fun <T> Array<out T>.contentHashCode(): Int
expect inline fun BooleanArray.contentHashCode(): Int
expect inline fun ByteArray.contentHashCode(): Int
expect inline fun CharArray.contentHashCode(): Int
expect inline fun DoubleArray.contentHashCode(): Int
expect inline fun FloatArray.contentHashCode(): Int
expect inline fun IntArray.contentHashCode(): Int
expect inline fun LongArray.contentHashCode(): Int
expect inline fun ShortArray.contentHashCode(): Int

Returns a hash code based on the contents of this array as if it is List.

Since Kotlin 1.1
Link copied to clipboard
expect inline fun <T> Array<out T>.contentToString(): String
expect inline fun BooleanArray.contentToString(): String
expect inline fun ByteArray.contentToString(): String
expect inline fun CharArray.contentToString(): String
expect inline fun DoubleArray.contentToString(): String
expect inline fun FloatArray.contentToString(): String
expect inline fun IntArray.contentToString(): String
expect inline fun LongArray.contentToString(): String
expect inline fun ShortArray.contentToString(): String

Returns a string representation of the contents of the specified array as if it is List.

Since Kotlin 1.1
Link copied to clipboard
expect inline fun <T> Array<T>.copyOf(): Array<T>
expect inline fun BooleanArray.copyOf(): BooleanArray
expect inline fun ByteArray.copyOf(): ByteArray
expect inline fun CharArray.copyOf(): CharArray
expect inline fun DoubleArray.copyOf(): DoubleArray
expect inline fun FloatArray.copyOf(): FloatArray
expect inline fun IntArray.copyOf(): IntArray
expect inline fun LongArray.copyOf(): LongArray
expect inline fun ShortArray.copyOf(): ShortArray

Returns new array which is a copy of the original array.

Since Kotlin 1.0
expect inline fun <T> Array<T>.copyOf(newSize: Int): Array<T?>

Returns new array which is a copy of the original array, resized to the given newSize. The copy is either truncated or padded at the end with null values if necessary.

Since Kotlin 1.0
expect inline fun BooleanArray.copyOf(newSize: Int): BooleanArray

Returns new array which is a copy of the original array, resized to the given newSize. The copy is either truncated or padded at the end with false values if necessary.

Since Kotlin 1.0
expect inline fun ByteArray.copyOf(newSize: Int): ByteArray
expect inline fun DoubleArray.copyOf(newSize: Int): DoubleArray
expect inline fun FloatArray.copyOf(newSize: Int): FloatArray
expect inline fun IntArray.copyOf(newSize: Int): IntArray
expect inline fun LongArray.copyOf(newSize: Int): LongArray
expect inline fun ShortArray.copyOf(newSize: Int): ShortArray

Returns new array which is a copy of the original array, resized to the given newSize. The copy is either truncated or padded at the end with zero values if necessary.

Since Kotlin 1.0
expect inline fun CharArray.copyOf(newSize: Int): CharArray

Returns new array which is a copy of the original array, resized to the given newSize. The copy is either truncated or padded at the end with null char (\u0000) values if necessary.

Since Kotlin 1.0
Link copied to clipboard
@JvmName(name = "copyOfRangeInline")
expect inline fun <T> Array<T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T>
@JvmName(name = "copyOfRangeInline")
expect inline fun BooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): BooleanArray
@JvmName(name = "copyOfRangeInline")
expect inline fun ByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ByteArray
@JvmName(name = "copyOfRangeInline")
expect inline fun CharArray.copyOfRange(fromIndex: Int, toIndex: Int): CharArray
@JvmName(name = "copyOfRangeInline")
expect inline fun DoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): DoubleArray
@JvmName(name = "copyOfRangeInline")
expect inline fun FloatArray.copyOfRange(fromIndex: Int, toIndex: Int): FloatArray
@JvmName(name = "copyOfRangeInline")
expect inline fun IntArray.copyOfRange(fromIndex: Int, toIndex: Int): IntArray
@JvmName(name = "copyOfRangeInline")
expect inline fun LongArray.copyOfRange(fromIndex: Int, toIndex: Int): LongArray
@JvmName(name = "copyOfRangeInline")
expect inline fun ShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ShortArray

Returns a new array which is a copy of the specified range of the original array.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.count(): Int
inline fun BooleanArray.count(): Int
inline fun ByteArray.count(): Int
inline fun CharArray.count(): Int
inline fun DoubleArray.count(): Int
inline fun FloatArray.count(): Int
inline fun IntArray.count(): Int
inline fun LongArray.count(): Int
inline fun ShortArray.count(): Int

Returns the number of elements in this array.

Since Kotlin 1.0
inline fun <T> Collection<T>.count(): Int
fun <T> Iterable<T>.count(): Int

Returns the number of elements in this collection.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.count(): Int

Returns the number of entries in this map.

Since Kotlin 1.0
inline fun <T> Array<out T>.count(predicate: (T) -> Boolean): Int
inline fun BooleanArray.count(predicate: (Boolean) -> Boolean): Int
inline fun ByteArray.count(predicate: (Byte) -> Boolean): Int
inline fun CharArray.count(predicate: (Char) -> Boolean): Int
inline fun DoubleArray.count(predicate: (Double) -> Boolean): Int
inline fun FloatArray.count(predicate: (Float) -> Boolean): Int
inline fun IntArray.count(predicate: (Int) -> Boolean): Int
inline fun LongArray.count(predicate: (Long) -> Boolean): Int
inline fun ShortArray.count(predicate: (Short) -> Boolean): Int
inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int

Returns the number of elements matching the given predicate.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.count(predicate: (Map.Entry<K, V>) -> Boolean): Int

Returns the number of entries matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.distinct(): List<T>

Returns a list containing only distinct elements from the given array.

Since Kotlin 1.0
fun <T> Iterable<T>.distinct(): List<T>

Returns a list containing only distinct elements from the given collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K> Array<out T>.distinctBy(selector: (T) -> K): List<T>
inline fun <K> BooleanArray.distinctBy(selector: (Boolean) -> K): List<Boolean>
inline fun <K> ByteArray.distinctBy(selector: (Byte) -> K): List<Byte>
inline fun <K> CharArray.distinctBy(selector: (Char) -> K): List<Char>
inline fun <K> DoubleArray.distinctBy(selector: (Double) -> K): List<Double>
inline fun <K> FloatArray.distinctBy(selector: (Float) -> K): List<Float>
inline fun <K> IntArray.distinctBy(selector: (Int) -> K): List<Int>
inline fun <K> LongArray.distinctBy(selector: (Long) -> K): List<Long>
inline fun <K> ShortArray.distinctBy(selector: (Short) -> K): List<Short>

Returns a list containing only elements from the given array having distinct keys returned by the given selector function.

Since Kotlin 1.0
inline fun <T, K> Iterable<T>.distinctBy(selector: (T) -> K): List<T>

Returns a list containing only elements from the given collection having distinct keys returned by the given selector function.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.drop(n: Int): List<T>
fun <T> Iterable<T>.drop(n: Int): List<T>

Returns a list containing all elements except first n elements.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.dropLast(n: Int): List<T>
fun <T> List<T>.dropLast(n: Int): List<T>

Returns a list containing all elements except last n elements.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.dropLastWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.dropLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.dropLastWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.dropLastWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.dropLastWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.dropLastWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.dropLastWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.dropLastWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.dropLastWhile(predicate: (Short) -> Boolean): List<Short>
inline fun <T> List<T>.dropLastWhile(predicate: (T) -> Boolean): List<T>

Returns a list containing all elements except last elements that satisfy the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.dropWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.dropWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.dropWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.dropWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.dropWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.dropWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.dropWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.dropWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.dropWhile(predicate: (Short) -> Boolean): List<Short>
inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T>

Returns a list containing all elements except first elements that satisfy the given predicate.

Since Kotlin 1.0
Link copied to clipboard
expect fun <T, K> Grouping<T, K>.eachCount(): Map<K, Int>

Groups elements from the Grouping source by key and counts elements in each group.

Since Kotlin 1.1
Link copied to clipboard
fun <T, K, M : MutableMap<in K, Int>> Grouping<T, K>.eachCountTo(destination: M): M

Groups elements from the Grouping source by key and counts elements in each group to the given destination map.

Since Kotlin 1.1
fun <T, K, M : MutableMap<in K, Int>> Grouping<T, K>.eachCountTo(destination: M): M

Groups elements from the Grouping source by key and counts elements in each group to the given destination map.

Since Kotlin 1.1
Link copied to clipboard
expect inline fun <T> Array<out T>.elementAt(index: Int): T
expect inline fun BooleanArray.elementAt(index: Int): Boolean
expect inline fun ByteArray.elementAt(index: Int): Byte
expect inline fun CharArray.elementAt(index: Int): Char
expect inline fun DoubleArray.elementAt(index: Int): Double
expect inline fun FloatArray.elementAt(index: Int): Float
expect inline fun IntArray.elementAt(index: Int): Int
expect inline fun LongArray.elementAt(index: Int): Long
expect inline fun ShortArray.elementAt(index: Int): Short

Returns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this array.

Since Kotlin 1.0
fun <T> Iterable<T>.elementAt(index: Int): T

Returns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this collection.

Since Kotlin 1.0
inline fun <T> List<T>.elementAt(index: Int): T

Returns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this list.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
inline fun BooleanArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean
inline fun ByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Byte): Byte
inline fun CharArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Char): Char
inline fun DoubleArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Double): Double
inline fun FloatArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Float): Float
inline fun IntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Int): Int
inline fun LongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Long): Long
inline fun ShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Short): Short

Returns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this array.

Since Kotlin 1.0
fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

Returns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this collection.

Since Kotlin 1.0
inline fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

Returns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this list.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.elementAtOrNull(index: Int): T?
inline fun ByteArray.elementAtOrNull(index: Int): Byte?
inline fun CharArray.elementAtOrNull(index: Int): Char?
inline fun DoubleArray.elementAtOrNull(index: Int): Double?
inline fun FloatArray.elementAtOrNull(index: Int): Float?
inline fun IntArray.elementAtOrNull(index: Int): Int?
inline fun LongArray.elementAtOrNull(index: Int): Long?
inline fun ShortArray.elementAtOrNull(index: Int): Short?

Returns an element at the given index or null if the index is out of bounds of this array.

Since Kotlin 1.0
fun <T> Iterable<T>.elementAtOrNull(index: Int): T?

Returns an element at the given index or null if the index is out of bounds of this collection.

Since Kotlin 1.0
inline fun <T> List<T>.elementAtOrNull(index: Int): T?

Returns an element at the given index or null if the index is out of bounds of this list.

Since Kotlin 1.0
Link copied to clipboard
fun <T> emptyList(): List<T>

Returns an empty read-only list. The returned list is serializable (JVM).

Since Kotlin 1.1
fun <T> emptyList(): List<T>

Returns an empty read-only list. The returned list is serializable (JVM).

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> emptyMap(): Map<K, V>

Returns an empty read-only map of specified type.

Since Kotlin 1.1
fun <K, V> emptyMap(): Map<K, V>

Returns an empty read-only map of specified type.

Since Kotlin 1.0
Link copied to clipboard
fun <T> emptySet(): Set<T>

Returns an empty read-only set. The returned set is serializable (JVM).

Since Kotlin 1.1
fun <T> emptySet(): Set<T>

Returns an empty read-only set. The returned set is serializable (JVM).

Since Kotlin 1.0
Link copied to clipboard
expect fun <T> Array<T>.fill(element: T, fromIndex: Int = 0, toIndex: Int = size)
expect fun BooleanArray.fill(element: Boolean, fromIndex: Int = 0, toIndex: Int = size)
expect fun ByteArray.fill(element: Byte, fromIndex: Int = 0, toIndex: Int = size)
expect fun CharArray.fill(element: Char, fromIndex: Int = 0, toIndex: Int = size)
expect fun DoubleArray.fill(element: Double, fromIndex: Int = 0, toIndex: Int = size)
expect fun FloatArray.fill(element: Float, fromIndex: Int = 0, toIndex: Int = size)
expect fun IntArray.fill(element: Int, fromIndex: Int = 0, toIndex: Int = size)
expect fun LongArray.fill(element: Long, fromIndex: Int = 0, toIndex: Int = size)
expect fun ShortArray.fill(element: Short, fromIndex: Int = 0, toIndex: Int = size)

Fills this array or its subrange with the specified element value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

Returns a new map containing all key-value pairs matching the given predicate.

Since Kotlin 1.1
inline fun <T> Array<out T>.filter(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.filter(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.filter(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.filter(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.filter(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.filter(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.filter(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.filter(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.filter(predicate: (Short) -> Boolean): List<Short>
inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

Returns a list containing only elements matching the given predicate.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

Returns a new map containing all key-value pairs matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
inline fun BooleanArray.filterIndexed(predicate: (index: Int, Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.filterIndexed(predicate: (index: Int, Byte) -> Boolean): List<Byte>
inline fun CharArray.filterIndexed(predicate: (index: Int, Char) -> Boolean): List<Char>
inline fun DoubleArray.filterIndexed(predicate: (index: Int, Double) -> Boolean): List<Double>
inline fun FloatArray.filterIndexed(predicate: (index: Int, Float) -> Boolean): List<Float>
inline fun IntArray.filterIndexed(predicate: (index: Int, Int) -> Boolean): List<Int>
inline fun LongArray.filterIndexed(predicate: (index: Int, Long) -> Boolean): List<Long>
inline fun ShortArray.filterIndexed(predicate: (index: Int, Short) -> Boolean): List<Short>
inline fun <T> Iterable<T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>

Returns a list containing only elements matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo(destination: C, predicate: (index: Int, Boolean) -> Boolean): C
inline fun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo(destination: C, predicate: (index: Int, Byte) -> Boolean): C
inline fun <C : MutableCollection<in Char>> CharArray.filterIndexedTo(destination: C, predicate: (index: Int, Char) -> Boolean): C
inline fun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo(destination: C, predicate: (index: Int, Double) -> Boolean): C
inline fun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo(destination: C, predicate: (index: Int, Float) -> Boolean): C
inline fun <C : MutableCollection<in Int>> IntArray.filterIndexedTo(destination: C, predicate: (index: Int, Int) -> Boolean): C
inline fun <C : MutableCollection<in Long>> LongArray.filterIndexedTo(destination: C, predicate: (index: Int, Long) -> Boolean): C
inline fun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo(destination: C, predicate: (index: Int, Short) -> Boolean): C
inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C

Appends all elements matching the given predicate to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <R> Array<*>.filterIsInstance(): List<R>
inline fun <R> Iterable<*>.filterIsInstance(): List<R>

Returns a list containing all elements that are instances of specified type parameter R.

Since Kotlin 1.0
fun <R> Array<*>.filterIsInstance(klass: Class<R>): List<R>
fun <R> Iterable<*>.filterIsInstance(klass: Class<R>): List<R>

Returns a list containing all elements that are instances of specified class.

Since Kotlin 1.0
Link copied to clipboard
inline fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(destination: C): C
inline fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C

Appends all elements that are instances of specified type parameter R to the given destination.

Since Kotlin 1.0
fun <C : MutableCollection<in R>, R> Array<*>.filterIsInstanceTo(destination: C, klass: Class<R>): C
fun <C : MutableCollection<in R>, R> Iterable<*>.filterIsInstanceTo(destination: C, klass: Class<R>): C

Appends all elements that are instances of specified class to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V>

Returns a map containing all key-value pairs with keys matching the given predicate.

Since Kotlin 1.1
inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V>

Returns a map containing all key-value pairs with keys matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

Returns a new map containing all key-value pairs not matching the given predicate.

Since Kotlin 1.1
inline fun <T> Array<out T>.filterNot(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.filterNot(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.filterNot(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.filterNot(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.filterNot(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.filterNot(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.filterNot(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.filterNot(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.filterNot(predicate: (Short) -> Boolean): List<Short>
inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T>

Returns a list containing all elements not matching the given predicate.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

Returns a new map containing all key-value pairs not matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T : Any> Array<out T?>.filterNotNull(): List<T>

Returns a list containing all elements that are not null.

Since Kotlin 1.0
Link copied to clipboard
fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(destination: C): C
fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(destination: C): C

Appends all elements that are not null to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

Appends all entries not matching the given predicate into the given destination.

Since Kotlin 1.1
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(destination: C, predicate: (Boolean) -> Boolean): C
inline fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(destination: C, predicate: (Byte) -> Boolean): C
inline fun <C : MutableCollection<in Char>> CharArray.filterNotTo(destination: C, predicate: (Char) -> Boolean): C
inline fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(destination: C, predicate: (Double) -> Boolean): C
inline fun <C : MutableCollection<in Float>> FloatArray.filterNotTo(destination: C, predicate: (Float) -> Boolean): C
inline fun <C : MutableCollection<in Int>> IntArray.filterNotTo(destination: C, predicate: (Int) -> Boolean): C
inline fun <C : MutableCollection<in Long>> LongArray.filterNotTo(destination: C, predicate: (Long) -> Boolean): C
inline fun <C : MutableCollection<in Short>> ShortArray.filterNotTo(destination: C, predicate: (Short) -> Boolean): C
inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C

Appends all elements not matching the given predicate to the given destination.

Since Kotlin 1.0
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

Appends all entries not matching the given predicate into the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

Appends all entries matching the given predicate into the mutable map given as destination parameter.

Since Kotlin 1.1
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(destination: C, predicate: (T) -> Boolean): C
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(destination: C, predicate: (Boolean) -> Boolean): C
inline fun <C : MutableCollection<in Byte>> ByteArray.filterTo(destination: C, predicate: (Byte) -> Boolean): C
inline fun <C : MutableCollection<in Char>> CharArray.filterTo(destination: C, predicate: (Char) -> Boolean): C
inline fun <C : MutableCollection<in Double>> DoubleArray.filterTo(destination: C, predicate: (Double) -> Boolean): C
inline fun <C : MutableCollection<in Float>> FloatArray.filterTo(destination: C, predicate: (Float) -> Boolean): C
inline fun <C : MutableCollection<in Int>> IntArray.filterTo(destination: C, predicate: (Int) -> Boolean): C
inline fun <C : MutableCollection<in Long>> LongArray.filterTo(destination: C, predicate: (Long) -> Boolean): C
inline fun <C : MutableCollection<in Short>> ShortArray.filterTo(destination: C, predicate: (Short) -> Boolean): C
inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C

Appends all elements matching the given predicate to the given destination.

Since Kotlin 1.0
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

Appends all entries matching the given predicate into the mutable map given as destination parameter.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V>

Returns a map containing all key-value pairs with values matching the given predicate.

Since Kotlin 1.1
inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V>

Returns a map containing all key-value pairs with values matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.find(predicate: (T) -> Boolean): T?
inline fun BooleanArray.find(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.find(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.find(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.find(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.find(predicate: (Float) -> Boolean): Float?
inline fun IntArray.find(predicate: (Int) -> Boolean): Int?
inline fun LongArray.find(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.find(predicate: (Short) -> Boolean): Short?
inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

Returns the first element matching the given predicate, or null if no such element was found.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.findLast(predicate: (T) -> Boolean): T?
inline fun BooleanArray.findLast(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.findLast(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.findLast(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.findLast(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.findLast(predicate: (Float) -> Boolean): Float?
inline fun IntArray.findLast(predicate: (Int) -> Boolean): Int?
inline fun LongArray.findLast(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.findLast(predicate: (Short) -> Boolean): Short?
inline fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
inline fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?

Returns the last element matching the given predicate, or null if no such element was found.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.first(): T
fun <T> Iterable<T>.first(): T
fun <T> List<T>.first(): T

Returns first element.

Since Kotlin 1.0
inline fun <T> Array<out T>.first(predicate: (T) -> Boolean): T
inline fun BooleanArray.first(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.first(predicate: (Byte) -> Boolean): Byte
inline fun CharArray.first(predicate: (Char) -> Boolean): Char
inline fun DoubleArray.first(predicate: (Double) -> Boolean): Double
inline fun FloatArray.first(predicate: (Float) -> Boolean): Float
inline fun IntArray.first(predicate: (Int) -> Boolean): Int
inline fun LongArray.first(predicate: (Long) -> Boolean): Long
inline fun ShortArray.first(predicate: (Short) -> Boolean): Short
inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T

Returns the first element matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.firstOrNull(): T?

Returns the first element, or null if the array is empty.

Since Kotlin 1.0
fun <T> Iterable<T>.firstOrNull(): T?

Returns the first element, or null if the collection is empty.

Since Kotlin 1.0
fun <T> List<T>.firstOrNull(): T?

Returns the first element, or null if the list is empty.

Since Kotlin 1.0
inline fun <T> Array<out T>.firstOrNull(predicate: (T) -> Boolean): T?
inline fun BooleanArray.firstOrNull(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.firstOrNull(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.firstOrNull(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.firstOrNull(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.firstOrNull(predicate: (Float) -> Boolean): Float?
inline fun IntArray.firstOrNull(predicate: (Int) -> Boolean): Int?
inline fun LongArray.firstOrNull(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.firstOrNull(predicate: (Short) -> Boolean): Short?
inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?

Returns the first element matching the given predicate, or null if element was not found.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Iterable<R>): List<R>
inline fun <R> BooleanArray.flatMap(transform: (Boolean) -> Iterable<R>): List<R>
inline fun <R> ByteArray.flatMap(transform: (Byte) -> Iterable<R>): List<R>
inline fun <R> CharArray.flatMap(transform: (Char) -> Iterable<R>): List<R>
inline fun <R> DoubleArray.flatMap(transform: (Double) -> Iterable<R>): List<R>
inline fun <R> FloatArray.flatMap(transform: (Float) -> Iterable<R>): List<R>
inline fun <R> IntArray.flatMap(transform: (Int) -> Iterable<R>): List<R>
inline fun <R> LongArray.flatMap(transform: (Long) -> Iterable<R>): List<R>
inline fun <R> ShortArray.flatMap(transform: (Short) -> Iterable<R>): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each element of original array.

Since Kotlin 1.0
inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each element of original collection.

Since Kotlin 1.0
inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each entry of original map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(destination: C, transform: (Boolean) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(destination: C, transform: (Byte) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> CharArray.flatMapTo(destination: C, transform: (Char) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(destination: C, transform: (Double) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(destination: C, transform: (Float) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> IntArray.flatMapTo(destination: C, transform: (Int) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> LongArray.flatMapTo(destination: C, transform: (Long) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(destination: C, transform: (Short) -> Iterable<R>): C

Appends all elements yielded from results of transform function being invoked on each element of original array, to the given destination.

Since Kotlin 1.0
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C

Appends all elements yielded from results of transform function being invoked on each element of original collection, to the given destination.

Since Kotlin 1.0
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Iterable<R>): C

Appends all elements yielded from results of transform function being invoked on each entry of original map, to the given destination.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out Array<out T>>.flatten(): List<T>

Returns a single list of all elements from all arrays in the given array.

Since Kotlin 1.1

Returns a single list of all elements from all collections in the given collection.

Since Kotlin 1.1
fun <T> Array<out Array<out T>>.flatten(): List<T>

Returns a single list of all elements from all arrays in the given array.

Since Kotlin 1.0

Returns a single list of all elements from all collections in the given collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, R> Grouping<T, K>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is the same initialValue for each group.

Since Kotlin 1.1
inline fun <T, K, R> Grouping<T, K>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Map<K, R>

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is provided by initialValueSelector function.

Since Kotlin 1.1
inline fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R
inline fun <R> BooleanArray.fold(initial: R, operation: (acc: R, Boolean) -> R): R
inline fun <R> ByteArray.fold(initial: R, operation: (acc: R, Byte) -> R): R
inline fun <R> CharArray.fold(initial: R, operation: (acc: R, Char) -> R): R
inline fun <R> DoubleArray.fold(initial: R, operation: (acc: R, Double) -> R): R
inline fun <R> FloatArray.fold(initial: R, operation: (acc: R, Float) -> R): R
inline fun <R> IntArray.fold(initial: R, operation: (acc: R, Int) -> R): R
inline fun <R> LongArray.fold(initial: R, operation: (acc: R, Long) -> R): R
inline fun <R> ShortArray.fold(initial: R, operation: (acc: R, Short) -> R): R
inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element.

Since Kotlin 1.0
inline fun <T, K, R> Grouping<T, K>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is the same initialValue for each group.

Since Kotlin 1.1
inline fun <T, K, R> Grouping<T, K>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Map<K, R>

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is provided by initialValueSelector function.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T, R> Array<out T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R
inline fun <R> BooleanArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): R
inline fun <R> ByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): R
inline fun <R> CharArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): R
inline fun <R> DoubleArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): R
inline fun <R> FloatArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): R
inline fun <R> IntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): R
inline fun <R> LongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): R
inline fun <R> ShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element with its index in the original array.

Since Kotlin 1.0
inline fun <T, R> Iterable<T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

Accumulates value starting with initial value and applying operation from left to right to current accumulator value and each element with its index in the original collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R> Array<out T>.foldRight(initial: R, operation: (T, acc: R) -> R): R
inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, acc: R) -> R): R
inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, acc: R) -> R): R
inline fun <R> CharArray.foldRight(initial: R, operation: (Char, acc: R) -> R): R
inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, acc: R) -> R): R
inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, acc: R) -> R): R
inline fun <R> IntArray.foldRight(initial: R, operation: (Int, acc: R) -> R): R
inline fun <R> LongArray.foldRight(initial: R, operation: (Long, acc: R) -> R): R
inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, acc: R) -> R): R
inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, acc: R) -> R): R

Accumulates value starting with initial value and applying operation from right to left to each element and current accumulator value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R> Array<out T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R
inline fun <R> BooleanArray.foldRightIndexed(initial: R, operation: (index: Int, Boolean, acc: R) -> R): R
inline fun <R> ByteArray.foldRightIndexed(initial: R, operation: (index: Int, Byte, acc: R) -> R): R
inline fun <R> CharArray.foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): R
inline fun <R> DoubleArray.foldRightIndexed(initial: R, operation: (index: Int, Double, acc: R) -> R): R
inline fun <R> FloatArray.foldRightIndexed(initial: R, operation: (index: Int, Float, acc: R) -> R): R
inline fun <R> IntArray.foldRightIndexed(initial: R, operation: (index: Int, Int, acc: R) -> R): R
inline fun <R> LongArray.foldRightIndexed(initial: R, operation: (index: Int, Long, acc: R) -> R): R
inline fun <R> ShortArray.foldRightIndexed(initial: R, operation: (index: Int, Short, acc: R) -> R): R

Accumulates value starting with initial value and applying operation from right to left to each element with its index in the original array and current accumulator value.

Since Kotlin 1.0
inline fun <T, R> List<T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R

Accumulates value starting with initial value and applying operation from right to left to each element with its index in the original list and current accumulator value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(destination: M, initialValue: R, operation: (accumulator: R, element: T) -> R): M

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map. An initial value of accumulator is the same initialValue for each group.

Since Kotlin 1.1
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(destination: M, initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): M

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map. An initial value of accumulator is provided by initialValueSelector function.

Since Kotlin 1.1
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(destination: M, initialValue: R, operation: (accumulator: R, element: T) -> R): M

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map. An initial value of accumulator is the same initialValue for each group.

Since Kotlin 1.1
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(destination: M, initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): M

Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map. An initial value of accumulator is provided by initialValueSelector function.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> Iterator<T>.forEach(operation: (T) -> Unit)

Performs the given operation on each element of this Iterator.

Since Kotlin 1.1
inline fun <T> Array<out T>.forEach(action: (T) -> Unit)
inline fun BooleanArray.forEach(action: (Boolean) -> Unit)
inline fun ByteArray.forEach(action: (Byte) -> Unit)
inline fun CharArray.forEach(action: (Char) -> Unit)
inline fun DoubleArray.forEach(action: (Double) -> Unit)
inline fun FloatArray.forEach(action: (Float) -> Unit)
inline fun IntArray.forEach(action: (Int) -> Unit)
inline fun LongArray.forEach(action: (Long) -> Unit)
inline fun ShortArray.forEach(action: (Short) -> Unit)
inline fun <T> Iterable<T>.forEach(action: (T) -> Unit)

Performs the given action on each element.

Since Kotlin 1.0
inline fun <T> Iterator<T>.forEach(operation: (T) -> Unit)

Performs the given operation on each element of this Iterator.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit)

Performs the given action on each entry.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.forEachIndexed(action: (index: Int, T) -> Unit)
inline fun BooleanArray.forEachIndexed(action: (index: Int, Boolean) -> Unit)
inline fun ByteArray.forEachIndexed(action: (index: Int, Byte) -> Unit)
inline fun CharArray.forEachIndexed(action: (index: Int, Char) -> Unit)
inline fun DoubleArray.forEachIndexed(action: (index: Int, Double) -> Unit)
inline fun FloatArray.forEachIndexed(action: (index: Int, Float) -> Unit)
inline fun IntArray.forEachIndexed(action: (index: Int, Int) -> Unit)
inline fun LongArray.forEachIndexed(action: (index: Int, Long) -> Unit)
inline fun ShortArray.forEachIndexed(action: (index: Int, Short) -> Unit)
inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit)

Performs the given action on each element, providing sequential index with the element.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <K, V> Map<out K, V>.get(key: K): V?

Returns the value corresponding to the given key, or null if such a key is not present in the map.

Since Kotlin 1.1
inline operator fun <K, V> Map<out K, V>.get(key: K): V?

Returns the value corresponding to the given key, or null if such a key is not present in the map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V

Returns the value for the given key, or the result of the defaultValue function if there was no entry for the given key.

Since Kotlin 1.1
inline fun <T> Array<out T>.getOrElse(index: Int, defaultValue: (Int) -> T): T
inline fun BooleanArray.getOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean
inline fun ByteArray.getOrElse(index: Int, defaultValue: (Int) -> Byte): Byte
inline fun CharArray.getOrElse(index: Int, defaultValue: (Int) -> Char): Char
inline fun DoubleArray.getOrElse(index: Int, defaultValue: (Int) -> Double): Double
inline fun FloatArray.getOrElse(index: Int, defaultValue: (Int) -> Float): Float
inline fun IntArray.getOrElse(index: Int, defaultValue: (Int) -> Int): Int
inline fun LongArray.getOrElse(index: Int, defaultValue: (Int) -> Long): Long
inline fun ShortArray.getOrElse(index: Int, defaultValue: (Int) -> Short): Short

Returns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this array.

Since Kotlin 1.0
inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T

Returns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this list.

Since Kotlin 1.0
inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V

Returns the value for the given key, or the result of the defaultValue function if there was no entry for the given key.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.getOrNull(index: Int): T?
fun ByteArray.getOrNull(index: Int): Byte?
fun CharArray.getOrNull(index: Int): Char?
fun IntArray.getOrNull(index: Int): Int?
fun LongArray.getOrNull(index: Int): Long?

Returns an element at the given index or null if the index is out of bounds of this array.

Since Kotlin 1.0
fun <T> List<T>.getOrNull(index: Int): T?

Returns an element at the given index or null if the index is out of bounds of this list.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

Returns the value for the given key. If the key is not found in the map, calls the defaultValue function, puts its result into the map under the given key and returns it.

Since Kotlin 1.1
inline fun <K, V> ConcurrentMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

Concurrent getOrPut, that is safe for concurrent maps.

Since Kotlin 1.0
inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

Returns the value for the given key. If the key is not found in the map, calls the defaultValue function, puts its result into the map under the given key and returns it.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Map<K, V>.getValue(key: K): V

Returns the value for the given key or throws an exception if there is no such key in the map.

Since Kotlin 1.1
inline operator fun <V, V1 : V> Map<in String, V>.getValue(thisRef: Any?, property: KProperty<*>): V1

Returns the value of the property for the given object from this read-only map.

Since Kotlin 1.1
inline operator fun <V, V1 : V> MutableMap<in String, out V>.getValue(thisRef: Any?, property: KProperty<*>): V1

Returns the value of the property for the given object from this mutable map.

Since Kotlin 1.1
fun <K, V> Map<K, V>.getValue(key: K): V

Returns the value for the given key or throws an exception if there is no such key in the map.

Since Kotlin 1.1
inline operator fun <V, V1 : V> Map<in String, V>.getValue(thisRef: Any?, property: KProperty<*>): V1

Returns the value of the property for the given object from this read-only map.

Since Kotlin 1.0
@JvmName(name = "getVar")
inline operator fun <V, V1 : V> MutableMap<in String, out V>.getValue(thisRef: Any?, property: KProperty<*>): V1

Returns the value of the property for the given object from this mutable map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K> Array<out T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
inline fun <K> BooleanArray.groupBy(keySelector: (Boolean) -> K): Map<K, List<Boolean>>
inline fun <K> ByteArray.groupBy(keySelector: (Byte) -> K): Map<K, List<Byte>>
inline fun <K> CharArray.groupBy(keySelector: (Char) -> K): Map<K, List<Char>>
inline fun <K> DoubleArray.groupBy(keySelector: (Double) -> K): Map<K, List<Double>>
inline fun <K> FloatArray.groupBy(keySelector: (Float) -> K): Map<K, List<Float>>
inline fun <K> IntArray.groupBy(keySelector: (Int) -> K): Map<K, List<Int>>
inline fun <K> LongArray.groupBy(keySelector: (Long) -> K): Map<K, List<Long>>
inline fun <K> ShortArray.groupBy(keySelector: (Short) -> K): Map<K, List<Short>>

Groups elements of the original array by the key returned by the given keySelector function applied to each element and returns a map where each group key is associated with a list of corresponding elements.

Since Kotlin 1.0
inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>

Groups elements of the original collection by the key returned by the given keySelector function applied to each element and returns a map where each group key is associated with a list of corresponding elements.

Since Kotlin 1.0
inline fun <T, K, V> Array<out T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>
inline fun <K, V> BooleanArray.groupBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, List<V>>
inline fun <K, V> ByteArray.groupBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, List<V>>
inline fun <K, V> CharArray.groupBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, List<V>>
inline fun <K, V> DoubleArray.groupBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, List<V>>
inline fun <K, V> FloatArray.groupBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, List<V>>
inline fun <K, V> IntArray.groupBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, List<V>>
inline fun <K, V> LongArray.groupBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, List<V>>
inline fun <K, V> ShortArray.groupBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, List<V>>

Groups values returned by the valueTransform function applied to each element of the original array by the key returned by the given keySelector function applied to the element and returns a map where each group key is associated with a list of corresponding values.

Since Kotlin 1.0
inline fun <T, K, V> Iterable<T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>

Groups values returned by the valueTransform function applied to each element of the original collection by the key returned by the given keySelector function applied to the element and returns a map where each group key is associated with a list of corresponding values.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Array<out T>.groupByTo(destination: M, keySelector: (T) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Boolean>>> BooleanArray.groupByTo(destination: M, keySelector: (Boolean) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Byte>>> ByteArray.groupByTo(destination: M, keySelector: (Byte) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Char>>> CharArray.groupByTo(destination: M, keySelector: (Char) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Double>>> DoubleArray.groupByTo(destination: M, keySelector: (Double) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Float>>> FloatArray.groupByTo(destination: M, keySelector: (Float) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Int>>> IntArray.groupByTo(destination: M, keySelector: (Int) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Long>>> LongArray.groupByTo(destination: M, keySelector: (Long) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Short>>> ShortArray.groupByTo(destination: M, keySelector: (Short) -> K): M

Groups elements of the original array by the key returned by the given keySelector function applied to each element and puts to the destination map each group key associated with a list of corresponding elements.

Since Kotlin 1.0
inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M

Groups elements of the original collection by the key returned by the given keySelector function applied to each element and puts to the destination map each group key associated with a list of corresponding elements.

Since Kotlin 1.0
inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Array<out T>.groupByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> BooleanArray.groupByTo(destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ByteArray.groupByTo(destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> CharArray.groupByTo(destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> DoubleArray.groupByTo(destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> FloatArray.groupByTo(destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> IntArray.groupByTo(destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> LongArray.groupByTo(destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ShortArray.groupByTo(destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V): M

Groups values returned by the valueTransform function applied to each element of the original array by the key returned by the given keySelector function applied to the element and puts to the destination map each group key associated with a list of corresponding values.

Since Kotlin 1.0
inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

Groups values returned by the valueTransform function applied to each element of the original collection by the key returned by the given keySelector function applied to the element and puts to the destination map each group key associated with a list of corresponding values.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, K> Array<out T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>

Creates a Grouping source from an array to be used later with one of group-and-fold operations using the specified keySelector function to extract a key from each element.

Since Kotlin 1.1
inline fun <T, K> Iterable<T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>

Creates a Grouping source from a collection to be used later with one of group-and-fold operations using the specified keySelector function to extract a key from each element.

Since Kotlin 1.1
Link copied to clipboard
inline fun <K, V> hashMapOf(): HashMap<K, V>

Returns an empty new HashMap.

Since Kotlin 1.1
fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>

Returns a new HashMap with the specified contents, given as a list of pairs where the first component is the key and the second is the value.

Since Kotlin 1.1
inline fun <K, V> hashMapOf(): HashMap<K, V>

Returns an empty new HashMap.

Since Kotlin 1.1
fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>

Returns a new HashMap with the specified contents, given as a list of pairs where the first component is the key and the second is the value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> hashSetOf(): HashSet<T>

Returns an empty new HashSet.

Since Kotlin 1.1
fun <T> hashSetOf(vararg elements: T): HashSet<T>

Returns a new HashSet with the given elements.

Since Kotlin 1.1
inline fun <T> hashSetOf(): HashSet<T>

Returns an empty new HashSet.

Since Kotlin 1.1
fun <T> hashSetOf(vararg elements: T): HashSet<T>

Returns a new HashSet with the given elements.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.indexOf(element: T): Int
fun ByteArray.indexOf(element: Byte): Int
fun CharArray.indexOf(element: Char): Int
fun DoubleArray.indexOf(element: Double): Int
fun FloatArray.indexOf(element: Float): Int
fun IntArray.indexOf(element: Int): Int
fun LongArray.indexOf(element: Long): Int
fun ShortArray.indexOf(element: Short): Int

Returns first index of element, or -1 if the array does not contain element.

Since Kotlin 1.0
fun <T> Iterable<T>.indexOf(element: T): Int

Returns first index of element, or -1 if the collection does not contain element.

Since Kotlin 1.0
fun <T> List<T>.indexOf(element: T): Int

Returns first index of element, or -1 if the list does not contain element.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.indexOfFirst(predicate: (T) -> Boolean): Int
inline fun BooleanArray.indexOfFirst(predicate: (Boolean) -> Boolean): Int
inline fun ByteArray.indexOfFirst(predicate: (Byte) -> Boolean): Int
inline fun CharArray.indexOfFirst(predicate: (Char) -> Boolean): Int
inline fun DoubleArray.indexOfFirst(predicate: (Double) -> Boolean): Int
inline fun FloatArray.indexOfFirst(predicate: (Float) -> Boolean): Int
inline fun IntArray.indexOfFirst(predicate: (Int) -> Boolean): Int
inline fun LongArray.indexOfFirst(predicate: (Long) -> Boolean): Int
inline fun ShortArray.indexOfFirst(predicate: (Short) -> Boolean): Int

Returns index of the first element matching the given predicate, or -1 if the array does not contain such element.

Since Kotlin 1.0
inline fun <T> Iterable<T>.indexOfFirst(predicate: (T) -> Boolean): Int

Returns index of the first element matching the given predicate, or -1 if the collection does not contain such element.

Since Kotlin 1.0
inline fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int

Returns index of the first element matching the given predicate, or -1 if the list does not contain such element.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.indexOfLast(predicate: (T) -> Boolean): Int
inline fun BooleanArray.indexOfLast(predicate: (Boolean) -> Boolean): Int
inline fun ByteArray.indexOfLast(predicate: (Byte) -> Boolean): Int
inline fun CharArray.indexOfLast(predicate: (Char) -> Boolean): Int
inline fun DoubleArray.indexOfLast(predicate: (Double) -> Boolean): Int
inline fun FloatArray.indexOfLast(predicate: (Float) -> Boolean): Int
inline fun IntArray.indexOfLast(predicate: (Int) -> Boolean): Int
inline fun LongArray.indexOfLast(predicate: (Long) -> Boolean): Int
inline fun ShortArray.indexOfLast(predicate: (Short) -> Boolean): Int

Returns index of the last element matching the given predicate, or -1 if the array does not contain such element.

Since Kotlin 1.0
inline fun <T> Iterable<T>.indexOfLast(predicate: (T) -> Boolean): Int

Returns index of the last element matching the given predicate, or -1 if the collection does not contain such element.

Since Kotlin 1.0
inline fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int

Returns index of the last element matching the given predicate, or -1 if the list does not contain such element.

Since Kotlin 1.0
Link copied to clipboard
infix fun <T> Array<out T>.intersect(other: Iterable<T>): Set<T>
infix fun ByteArray.intersect(other: Iterable<Byte>): Set<Byte>
infix fun CharArray.intersect(other: Iterable<Char>): Set<Char>
infix fun IntArray.intersect(other: Iterable<Int>): Set<Int>
infix fun LongArray.intersect(other: Iterable<Long>): Set<Long>

Returns a set containing all elements that are contained by both this array and the specified collection.

Since Kotlin 1.0
infix fun <T> Iterable<T>.intersect(other: Iterable<T>): Set<T>

Returns a set containing all elements that are contained by both this collection and the specified collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.isEmpty(): Boolean
inline fun ByteArray.isEmpty(): Boolean
inline fun CharArray.isEmpty(): Boolean
inline fun FloatArray.isEmpty(): Boolean
inline fun IntArray.isEmpty(): Boolean
inline fun LongArray.isEmpty(): Boolean
inline fun ShortArray.isEmpty(): Boolean

Returns true if the array is empty.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Collection<T>.isNotEmpty(): Boolean

Returns true if the collection is not empty.

Since Kotlin 1.1
inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean

Returns true if this map is not empty.

Since Kotlin 1.1
inline fun <T> Array<out T>.isNotEmpty(): Boolean

Returns true if the array is not empty.

Since Kotlin 1.0
inline fun <T> Collection<T>.isNotEmpty(): Boolean

Returns true if the collection is not empty.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean

Returns true if this map is not empty.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Iterable(crossinline iterator: () -> Iterator<T>): Iterable<T>

Given an iterator function constructs an Iterable instance that returns values through the Iterator provided by that function.

Since Kotlin 1.1
inline fun <T> Iterable(crossinline iterator: () -> Iterator<T>): Iterable<T>

Given an iterator function constructs an Iterable instance that returns values through the Iterator provided by that function.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <T> Iterator<T>.iterator(): Iterator<T>

Returns the given iterator itself. This allows to use an instance of iterator in a for loop.

Since Kotlin 1.1
inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>>

Returns an Iterator over the entries in the Map.

Since Kotlin 1.1

Returns a MutableIterator over the mutable entries in the MutableMap.

Since Kotlin 1.1
operator fun <T> Enumeration<T>.iterator(): Iterator<T>

Creates an Iterator for an java.util.Enumeration, allowing to use it in for loops.

Since Kotlin 1.0
inline operator fun <T> Iterator<T>.iterator(): Iterator<T>

Returns the given iterator itself. This allows to use an instance of iterator in a for loop.

Since Kotlin 1.0
inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>>

Returns an Iterator over the entries in the Map.

Since Kotlin 1.0
@JvmName(name = "mutableIterator")
inline operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableMap.MutableEntry<K, V>>

Returns a MutableIterator over the mutable entries in the MutableMap.

Since Kotlin 1.0
Link copied to clipboard
fun <T, A : Appendable> Array<out T>.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): A
fun <A : Appendable> BooleanArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Boolean) -> CharSequence? = null): A
fun <A : Appendable> ByteArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Byte) -> CharSequence? = null): A
fun <A : Appendable> CharArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Char) -> CharSequence? = null): A
fun <A : Appendable> DoubleArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Double) -> CharSequence? = null): A
fun <A : Appendable> FloatArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Float) -> CharSequence? = null): A
fun <A : Appendable> IntArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Int) -> CharSequence? = null): A
fun <A : Appendable> LongArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Long) -> CharSequence? = null): A
fun <A : Appendable> ShortArray.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Short) -> CharSequence? = null): A
fun <T, A : Appendable> Iterable<T>.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): A

Appends the string from all the elements separated using separator and using the given prefix and postfix if supplied.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): String
fun BooleanArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Boolean) -> CharSequence? = null): String
fun ByteArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Byte) -> CharSequence? = null): String
fun CharArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Char) -> CharSequence? = null): String
fun DoubleArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Double) -> CharSequence? = null): String
fun FloatArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Float) -> CharSequence? = null): String
fun IntArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Int) -> CharSequence? = null): String
fun LongArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Long) -> CharSequence? = null): String
fun ShortArray.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (Short) -> CharSequence? = null): String
fun <T> Iterable<T>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): String

Creates a string from all the elements separated using separator and using the given prefix and postfix if supplied.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.last(): T
fun <T> Iterable<T>.last(): T
fun <T> List<T>.last(): T

Returns the last element.

Since Kotlin 1.0
inline fun <T> Array<out T>.last(predicate: (T) -> Boolean): T
inline fun BooleanArray.last(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.last(predicate: (Byte) -> Boolean): Byte
inline fun CharArray.last(predicate: (Char) -> Boolean): Char
inline fun DoubleArray.last(predicate: (Double) -> Boolean): Double
inline fun FloatArray.last(predicate: (Float) -> Boolean): Float
inline fun IntArray.last(predicate: (Int) -> Boolean): Int
inline fun LongArray.last(predicate: (Long) -> Boolean): Long
inline fun ShortArray.last(predicate: (Short) -> Boolean): Short
inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
inline fun <T> List<T>.last(predicate: (T) -> Boolean): T

Returns the last element matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.lastIndexOf(element: T): Int
fun ByteArray.lastIndexOf(element: Byte): Int
fun CharArray.lastIndexOf(element: Char): Int
fun IntArray.lastIndexOf(element: Int): Int
fun LongArray.lastIndexOf(element: Long): Int

Returns last index of element, or -1 if the array does not contain element.

Since Kotlin 1.0
fun <T> Iterable<T>.lastIndexOf(element: T): Int

Returns last index of element, or -1 if the collection does not contain element.

Since Kotlin 1.0
fun <T> List<T>.lastIndexOf(element: T): Int

Returns last index of element, or -1 if the list does not contain element.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.lastOrNull(): T?

Returns the last element, or null if the array is empty.

Since Kotlin 1.0
fun <T> Iterable<T>.lastOrNull(): T?

Returns the last element, or null if the collection is empty.

Since Kotlin 1.0
fun <T> List<T>.lastOrNull(): T?

Returns the last element, or null if the list is empty.

Since Kotlin 1.0
inline fun <T> Array<out T>.lastOrNull(predicate: (T) -> Boolean): T?
inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.lastOrNull(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.lastOrNull(predicate: (Float) -> Boolean): Float?
inline fun IntArray.lastOrNull(predicate: (Int) -> Boolean): Int?
inline fun LongArray.lastOrNull(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.lastOrNull(predicate: (Short) -> Boolean): Short?
inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
inline fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?

Returns the last element matching the given predicate, or null if no such element was found.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> linkedMapOf(): LinkedHashMap<K, V>

Returns an empty new LinkedHashMap.

Since Kotlin 1.1
fun <K, V> linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>

Returns a new LinkedHashMap with the specified contents, given as a list of pairs where the first component is the key and the second is the value.

Since Kotlin 1.1
inline fun <K, V> linkedMapOf(): LinkedHashMap<K, V>

Returns an empty new LinkedHashMap.

Since Kotlin 1.1
fun <K, V> linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>

Returns a new LinkedHashMap with the specified contents, given as a list of pairs where the first component is the key and the second is the value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> linkedSetOf(): LinkedHashSet<T>

Returns an empty new LinkedHashSet.

Since Kotlin 1.1
fun <T> linkedSetOf(vararg elements: T): LinkedHashSet<T>

Returns a new LinkedHashSet with the given elements. Elements of the set are iterated in the order they were specified.

Since Kotlin 1.1
inline fun <T> linkedSetOf(): LinkedHashSet<T>

Returns an empty new LinkedHashSet.

Since Kotlin 1.1
fun <T> linkedSetOf(vararg elements: T): LinkedHashSet<T>

Returns a new LinkedHashSet with the given elements. Elements of the set are iterated in the order they were specified.

Since Kotlin 1.0
Link copied to clipboard
fun <V> linkedStringMapOf(vararg pairs: Pair<String, V>): LinkedHashMap<String, V>

Constructs the specialized implementation of LinkedHashMap with String keys, which stores the keys as properties of JS object without hashing them.

Since Kotlin 1.1
Link copied to clipboard

Creates a new instance of the specialized implementation of LinkedHashSet with the specified String elements, which elements the keys as properties of JS object without hashing them.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> List(size: Int, init: (index: Int) -> T): List<T>

Creates a new read-only list with the specified size, where each element is calculated by calling the specified init function.

Since Kotlin 1.1
inline fun <T> List(size: Int, init: (index: Int) -> T): List<T>

Creates a new read-only list with the specified size, where each element is calculated by calling the specified init function.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> listOf(): List<T>

Returns an empty read-only list. The returned list is serializable (JVM).

Since Kotlin 1.1
fun <T> listOf(element: T): List<T>

Returns an immutable list containing only the specified object element.

Since Kotlin 1.1
fun <T> listOf(vararg elements: T): List<T>

Returns a new read-only list of given elements. The returned list is serializable (JVM).

Since Kotlin 1.1
inline fun <T> listOf(): List<T>

Returns an empty read-only list. The returned list is serializable (JVM).

Since Kotlin 1.0
fun <T> listOf(element: T): List<T>

Returns an immutable list containing only the specified object element. The returned list is serializable.

Since Kotlin 1.0
fun <T> listOf(vararg elements: T): List<T>

Returns a new read-only list of given elements. The returned list is serializable (JVM).

Since Kotlin 1.0
Link copied to clipboard
fun <T : Any> listOfNotNull(element: T?): List<T>

Returns a new read-only list either of single given element, if it is not null, or empty list if the element is null. The returned list is serializable (JVM).

Since Kotlin 1.1
fun <T : Any> listOfNotNull(vararg elements: T?): List<T>

Returns a new read-only list only of those given elements, that are not null. The returned list is serializable (JVM).

Since Kotlin 1.1
fun <T : Any> listOfNotNull(element: T?): List<T>

Returns a new read-only list either of single given element, if it is not null, or empty list if the element is null. The returned list is serializable (JVM).

Since Kotlin 1.0
fun <T : Any> listOfNotNull(vararg elements: T?): List<T>

Returns a new read-only list only of those given elements, that are not null. The returned list is serializable (JVM).

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>
inline fun <R> BooleanArray.map(transform: (Boolean) -> R): List<R>
inline fun <R> ByteArray.map(transform: (Byte) -> R): List<R>
inline fun <R> CharArray.map(transform: (Char) -> R): List<R>
inline fun <R> DoubleArray.map(transform: (Double) -> R): List<R>
inline fun <R> FloatArray.map(transform: (Float) -> R): List<R>
inline fun <R> IntArray.map(transform: (Int) -> R): List<R>
inline fun <R> LongArray.map(transform: (Long) -> R): List<R>
inline fun <R> ShortArray.map(transform: (Short) -> R): List<R>

Returns a list containing the results of applying the given transform function to each element in the original array.

Since Kotlin 1.0
inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

Returns a list containing the results of applying the given transform function to each element in the original collection.

Since Kotlin 1.0
inline fun <K, V, R> Map<out K, V>.map(transform: (Map.Entry<K, V>) -> R): List<R>

Returns a list containing the results of applying the given transform function to each entry in the original map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R> Array<out T>.mapIndexed(transform: (index: Int, T) -> R): List<R>
inline fun <R> BooleanArray.mapIndexed(transform: (index: Int, Boolean) -> R): List<R>
inline fun <R> ByteArray.mapIndexed(transform: (index: Int, Byte) -> R): List<R>
inline fun <R> CharArray.mapIndexed(transform: (index: Int, Char) -> R): List<R>
inline fun <R> DoubleArray.mapIndexed(transform: (index: Int, Double) -> R): List<R>
inline fun <R> FloatArray.mapIndexed(transform: (index: Int, Float) -> R): List<R>
inline fun <R> IntArray.mapIndexed(transform: (index: Int, Int) -> R): List<R>
inline fun <R> LongArray.mapIndexed(transform: (index: Int, Long) -> R): List<R>
inline fun <R> ShortArray.mapIndexed(transform: (index: Int, Short) -> R): List<R>

Returns a list containing the results of applying the given transform function to each element and its index in the original array.

Since Kotlin 1.0
inline fun <T, R> Iterable<T>.mapIndexed(transform: (index: Int, T) -> R): List<R>

Returns a list containing the results of applying the given transform function to each element and its index in the original collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Any> Array<out T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>

Returns a list containing only the non-null results of applying the given transform function to each element and its index in the original array.

Since Kotlin 1.0
inline fun <T, R : Any> Iterable<T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>

Returns a list containing only the non-null results of applying the given transform function to each element and its index in the original collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C

Applies the given transform function to each element and its index in the original array and appends only the non-null results to the given destination.

Since Kotlin 1.0
inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C

Applies the given transform function to each element and its index in the original collection and appends only the non-null results to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C
inline fun <R, C : MutableCollection<in R>> BooleanArray.mapIndexedTo(destination: C, transform: (index: Int, Boolean) -> R): C
inline fun <R, C : MutableCollection<in R>> ByteArray.mapIndexedTo(destination: C, transform: (index: Int, Byte) -> R): C
inline fun <R, C : MutableCollection<in R>> CharArray.mapIndexedTo(destination: C, transform: (index: Int, Char) -> R): C
inline fun <R, C : MutableCollection<in R>> DoubleArray.mapIndexedTo(destination: C, transform: (index: Int, Double) -> R): C
inline fun <R, C : MutableCollection<in R>> FloatArray.mapIndexedTo(destination: C, transform: (index: Int, Float) -> R): C
inline fun <R, C : MutableCollection<in R>> IntArray.mapIndexedTo(destination: C, transform: (index: Int, Int) -> R): C
inline fun <R, C : MutableCollection<in R>> LongArray.mapIndexedTo(destination: C, transform: (index: Int, Long) -> R): C
inline fun <R, C : MutableCollection<in R>> ShortArray.mapIndexedTo(destination: C, transform: (index: Int, Short) -> R): C

Applies the given transform function to each element and its index in the original array and appends the results to the given destination.

Since Kotlin 1.0
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C

Applies the given transform function to each element and its index in the original collection and appends the results to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>

Returns a new Map with entries having the keys obtained by applying the transform function to each entry in this Map and the values of this map.

Since Kotlin 1.1
inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>

Returns a new Map with entries having the keys obtained by applying the transform function to each entry in this Map and the values of this map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

Populates the given destination map with entries having the keys obtained by applying the transform function to each entry in this Map and the values of this map.

Since Kotlin 1.1
inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

Populates the given destination map with entries having the keys obtained by applying the transform function to each entry in this Map and the values of this map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Any> Array<out T>.mapNotNull(transform: (T) -> R?): List<R>

Returns a list containing only the non-null results of applying the given transform function to each element in the original array.

Since Kotlin 1.0
inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>

Returns a list containing only the non-null results of applying the given transform function to each element in the original collection.

Since Kotlin 1.0
inline fun <K, V, R : Any> Map<out K, V>.mapNotNull(transform: (Map.Entry<K, V>) -> R?): List<R>

Returns a list containing only the non-null results of applying the given transform function to each entry in the original map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapNotNullTo(destination: C, transform: (T) -> R?): C

Applies the given transform function to each element in the original array and appends only the non-null results to the given destination.

Since Kotlin 1.0
inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C

Applies the given transform function to each element in the original collection and appends only the non-null results to the given destination.

Since Kotlin 1.0
inline fun <K, V, R : Any, C : MutableCollection<in R>> Map<out K, V>.mapNotNullTo(destination: C, transform: (Map.Entry<K, V>) -> R?): C

Applies the given transform function to each entry in the original map and appends only the non-null results to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> mapOf(): Map<K, V>

Returns an empty read-only map.

Since Kotlin 1.1
fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

Returns a new read-only map with the specified contents, given as a list of pairs where the first value is the key and the second is the value.

Since Kotlin 1.1
fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V>

Returns an immutable map, mapping only the specified key to the specified value.

Since Kotlin 1.1
inline fun <K, V> mapOf(): Map<K, V>

Returns an empty read-only map.

Since Kotlin 1.0
fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

Returns a new read-only map with the specified contents, given as a list of pairs where the first value is the key and the second is the value.

Since Kotlin 1.0
fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V>

Returns an immutable map, mapping only the specified key to the specified value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo(destination: C, transform: (T) -> R): C
inline fun <R, C : MutableCollection<in R>> BooleanArray.mapTo(destination: C, transform: (Boolean) -> R): C
inline fun <R, C : MutableCollection<in R>> ByteArray.mapTo(destination: C, transform: (Byte) -> R): C
inline fun <R, C : MutableCollection<in R>> CharArray.mapTo(destination: C, transform: (Char) -> R): C
inline fun <R, C : MutableCollection<in R>> DoubleArray.mapTo(destination: C, transform: (Double) -> R): C
inline fun <R, C : MutableCollection<in R>> FloatArray.mapTo(destination: C, transform: (Float) -> R): C
inline fun <R, C : MutableCollection<in R>> IntArray.mapTo(destination: C, transform: (Int) -> R): C
inline fun <R, C : MutableCollection<in R>> LongArray.mapTo(destination: C, transform: (Long) -> R): C
inline fun <R, C : MutableCollection<in R>> ShortArray.mapTo(destination: C, transform: (Short) -> R): C

Applies the given transform function to each element of the original array and appends the results to the given destination.

Since Kotlin 1.0
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C

Applies the given transform function to each element of the original collection and appends the results to the given destination.

Since Kotlin 1.0
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo(destination: C, transform: (Map.Entry<K, V>) -> R): C

Applies the given transform function to each entry of the original map and appends the results to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>

Returns a new map with entries having the keys of this map and the values obtained by applying the transform function to each entry in this Map.

Since Kotlin 1.1
inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>

Returns a new map with entries having the keys of this map and the values obtained by applying the transform function to each entry in this Map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

Populates the given destination map with entries having the keys of this map and the values obtained by applying the transform function to each entry in this Map.

Since Kotlin 1.1
inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

Populates the given destination map with entries having the keys of this map and the values obtained by applying the transform function to each entry in this Map.

Since Kotlin 1.0
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.max(): T?
fun IntArray.max(): Int?
fun <T : Comparable<T>> Iterable<T>.max(): T?
Since Kotlin 1.0
Since Kotlin 1.1
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxBy(selector: (T) -> R): T?
inline fun <R : Comparable<R>> BooleanArray.maxBy(selector: (Boolean) -> R): Boolean?
inline fun <R : Comparable<R>> ByteArray.maxBy(selector: (Byte) -> R): Byte?
inline fun <R : Comparable<R>> CharArray.maxBy(selector: (Char) -> R): Char?
inline fun <R : Comparable<R>> DoubleArray.maxBy(selector: (Double) -> R): Double?
inline fun <R : Comparable<R>> FloatArray.maxBy(selector: (Float) -> R): Float?
inline fun <R : Comparable<R>> IntArray.maxBy(selector: (Int) -> R): Int?
inline fun <R : Comparable<R>> LongArray.maxBy(selector: (Long) -> R): Long?
inline fun <R : Comparable<R>> ShortArray.maxBy(selector: (Short) -> R): Short?
inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T?
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.maxWith(comparator: Comparator<in T>): T?
fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte?
fun CharArray.maxWith(comparator: Comparator<in Char>): Char?
fun DoubleArray.maxWith(comparator: Comparator<in Double>): Double?
fun FloatArray.maxWith(comparator: Comparator<in Float>): Float?
fun IntArray.maxWith(comparator: Comparator<in Int>): Int?
fun LongArray.maxWith(comparator: Comparator<in Long>): Long?
fun ShortArray.maxWith(comparator: Comparator<in Short>): Short?
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?
inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.min(): T?
fun IntArray.min(): Int?
fun <T : Comparable<T>> Iterable<T>.min(): T?
Since Kotlin 1.0
Since Kotlin 1.1
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minBy(selector: (T) -> R): T?
inline fun <R : Comparable<R>> BooleanArray.minBy(selector: (Boolean) -> R): Boolean?
inline fun <R : Comparable<R>> ByteArray.minBy(selector: (Byte) -> R): Byte?
inline fun <R : Comparable<R>> CharArray.minBy(selector: (Char) -> R): Char?
inline fun <R : Comparable<R>> DoubleArray.minBy(selector: (Double) -> R): Double?
inline fun <R : Comparable<R>> FloatArray.minBy(selector: (Float) -> R): Float?
inline fun <R : Comparable<R>> IntArray.minBy(selector: (Int) -> R): Int?
inline fun <R : Comparable<R>> LongArray.minBy(selector: (Long) -> R): Long?
inline fun <R : Comparable<R>> ShortArray.minBy(selector: (Short) -> R): Short?
inline fun <T, R : Comparable<R>> Iterable<T>.minBy(selector: (T) -> R): T?
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>

Returns a map containing all entries of the original map except the entry with the given key.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys array.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys collection.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys sequence.

Since Kotlin 1.1
operator fun <T> Iterable<T>.minus(element: T): List<T>

Returns a list containing all elements of the original collection without the first occurrence of the given element.

Since Kotlin 1.0
operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T>

Returns a list containing all elements of the original collection except the elements contained in the given elements array.

Since Kotlin 1.0
operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T>

Returns a list containing all elements of the original collection except the elements contained in the given elements collection.

Since Kotlin 1.0
operator fun <T> Iterable<T>.minus(elements: Sequence<T>): List<T>

Returns a list containing all elements of the original collection except the elements contained in the given elements sequence.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>

Returns a map containing all entries of the original map except the entry with the given key.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys array.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys collection.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys sequence.

Since Kotlin 1.1
operator fun <T> Set<T>.minus(element: T): Set<T>

Returns a set containing all elements of the original set except the given element.

Since Kotlin 1.0
operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T>

Returns a set containing all elements of the original set except the elements contained in the given elements array.

Since Kotlin 1.0
operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T>

Returns a set containing all elements of the original set except the elements contained in the given elements collection.

Since Kotlin 1.0
operator fun <T> Set<T>.minus(elements: Sequence<T>): Set<T>

Returns a set containing all elements of the original set except the elements contained in the given elements sequence.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <T> MutableCollection<in T>.minusAssign(element: T)

Removes a single instance of the specified element from this mutable collection.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Array<T>)

Removes all elements contained in the given elements array from this mutable collection.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Iterable<T>)

Removes all elements contained in the given elements collection from this mutable collection.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Sequence<T>)

Removes all elements contained in the given elements sequence from this mutable collection.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)

Removes the entry with the given key from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>)

Removes all entries the keys of which are contained in the given keys array from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>)

Removes all entries the keys of which are contained in the given keys collection from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>)

Removes all entries from the keys of which are contained in the given keys sequence from this mutable map.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.minusAssign(element: T)

Removes a single instance of the specified element from this mutable collection.

Since Kotlin 1.0
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Array<T>)

Removes all elements contained in the given elements array from this mutable collection.

Since Kotlin 1.0
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Iterable<T>)

Removes all elements contained in the given elements collection from this mutable collection.

Since Kotlin 1.0
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Sequence<T>)

Removes all elements contained in the given elements sequence from this mutable collection.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)

Removes the entry with the given key from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>)

Removes all entries the keys of which are contained in the given keys array from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>)

Removes all entries the keys of which are contained in the given keys collection from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>)

Removes all entries from the keys of which are contained in the given keys sequence from this mutable map.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> Iterable<T>.minusElement(element: T): List<T>

Returns a list containing all elements of the original collection without the first occurrence of the given element.

Since Kotlin 1.0
inline fun <T> Set<T>.minusElement(element: T): Set<T>

Returns a set containing all elements of the original set except the given element.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.minWith(comparator: Comparator<in T>): T?
fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte?
fun CharArray.minWith(comparator: Comparator<in Char>): Char?
fun DoubleArray.minWith(comparator: Comparator<in Double>): Double?
fun FloatArray.minWith(comparator: Comparator<in Float>): Float?
fun IntArray.minWith(comparator: Comparator<in Int>): Int?
fun LongArray.minWith(comparator: Comparator<in Long>): Long?
fun ShortArray.minWith(comparator: Comparator<in Short>): Short?
fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T?
fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T>

Creates a new mutable list with the specified size, where each element is calculated by calling the specified init function.

Since Kotlin 1.1
inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T>

Creates a new mutable list with the specified size, where each element is calculated by calling the specified init function.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> mutableListOf(): MutableList<T>

Returns an empty new MutableList.

Since Kotlin 1.1
fun <T> mutableListOf(vararg elements: T): MutableList<T>

Returns a new MutableList with the given elements.

Since Kotlin 1.1
inline fun <T> mutableListOf(): MutableList<T>

Returns an empty new MutableList.

Since Kotlin 1.1
fun <T> mutableListOf(vararg elements: T): MutableList<T>

Returns a new MutableList with the given elements.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> mutableMapOf(): MutableMap<K, V>

Returns an empty new MutableMap.

Since Kotlin 1.1
fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

Returns a new MutableMap with the specified contents, given as a list of pairs where the first component is the key and the second is the value.

Since Kotlin 1.1
inline fun <K, V> mutableMapOf(): MutableMap<K, V>

Returns an empty new MutableMap.

Since Kotlin 1.1
fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

Returns a new MutableMap with the specified contents, given as a list of pairs where the first component is the key and the second is the value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> mutableSetOf(): MutableSet<T>

Returns an empty new MutableSet.

Since Kotlin 1.1
fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

Returns a new MutableSet with the given elements. Elements of the set are iterated in the order they were specified.

Since Kotlin 1.1
inline fun <T> mutableSetOf(): MutableSet<T>

Returns an empty new MutableSet.

Since Kotlin 1.1
fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

Returns a new MutableSet with the given elements. Elements of the set are iterated in the order they were specified.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.none(): Boolean

Returns true if the array has no elements.

Since Kotlin 1.0
fun <T> Iterable<T>.none(): Boolean

Returns true if the collection has no elements.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.none(): Boolean

Returns true if the map has no entries.

Since Kotlin 1.0
inline fun <T> Array<out T>.none(predicate: (T) -> Boolean): Boolean
inline fun BooleanArray.none(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.none(predicate: (Byte) -> Boolean): Boolean
inline fun CharArray.none(predicate: (Char) -> Boolean): Boolean
inline fun DoubleArray.none(predicate: (Double) -> Boolean): Boolean
inline fun FloatArray.none(predicate: (Float) -> Boolean): Boolean
inline fun IntArray.none(predicate: (Int) -> Boolean): Boolean
inline fun LongArray.none(predicate: (Long) -> Boolean): Boolean
inline fun ShortArray.none(predicate: (Short) -> Boolean): Boolean
inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

Returns true if no elements match the given predicate.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.none(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

Returns true if no entries match the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, C : Iterable<T>> C.onEach(action: (T) -> Unit): C

Performs the given action on each element and returns the collection itself afterwards.

Since Kotlin 1.1
inline fun <K, V, M : Map<out K, V>> M.onEach(action: (Map.Entry<K, V>) -> Unit): M

Performs the given action on each entry and returns the map itself afterwards.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> Collection<T>?.orEmpty(): Collection<T>

Returns this Collection if it's not null and the empty list otherwise.

Since Kotlin 1.1
inline fun <T> List<T>?.orEmpty(): List<T>

Returns this List if it's not null and the empty list otherwise.

Since Kotlin 1.1
inline fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>

Returns the Map if its not null, or the empty Map otherwise.

Since Kotlin 1.1
inline fun <T> Set<T>?.orEmpty(): Set<T>

Returns this Set if it's not null and the empty set otherwise.

Since Kotlin 1.1
expect inline fun <T> Array<out T>?.orEmpty(): Array<out T>

Returns the array if it's not null, or an empty array otherwise.

Since Kotlin 1.0
inline fun <T> Collection<T>?.orEmpty(): Collection<T>

Returns this Collection if it's not null and the empty list otherwise.

Since Kotlin 1.0
inline fun <T> List<T>?.orEmpty(): List<T>

Returns this List if it's not null and the empty list otherwise.

Since Kotlin 1.0
inline fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>

Returns the Map if its not null, or the empty Map otherwise.

Since Kotlin 1.0
inline fun <T> Set<T>?.orEmpty(): Set<T>

Returns this Set if it's not null and the empty set otherwise.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>
inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<List<Boolean>, List<Boolean>>
inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<Byte>, List<Byte>>
inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<Char>, List<Char>>
inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<List<Double>, List<Double>>
inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List<Float>, List<Float>>
inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int>, List<Int>>
inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<Long>, List<Long>>
inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List<Short>, List<Short>>

Splits the original array into pair of lists, where first list contains elements for which predicate yielded true, while second list contains elements for which predicate yielded false.

Since Kotlin 1.0
inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>

Splits the original collection into pair of lists, where first list contains elements for which predicate yielded true, while second list contains elements for which predicate yielded false.

Since Kotlin 1.0
Link copied to clipboard
operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given array of key-value pairs.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>

Creates a new read-only map by replacing or adding an entry to this map from a given key-value pair.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given collection of key-value pairs.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from another map.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value pairs.

Since Kotlin 1.1
expect operator fun <T> Array<T>.plus(element: T): Array<T>
expect operator fun BooleanArray.plus(element: Boolean): BooleanArray
expect operator fun ByteArray.plus(element: Byte): ByteArray
expect operator fun CharArray.plus(element: Char): CharArray
expect operator fun DoubleArray.plus(element: Double): DoubleArray
expect operator fun FloatArray.plus(element: Float): FloatArray
expect operator fun IntArray.plus(element: Int): IntArray
expect operator fun LongArray.plus(element: Long): LongArray
expect operator fun ShortArray.plus(element: Short): ShortArray

Returns an array containing all elements of the original array and then the given element.

Since Kotlin 1.0
expect operator fun <T> Array<T>.plus(elements: Array<out T>): Array<T>
expect operator fun BooleanArray.plus(elements: BooleanArray): BooleanArray
expect operator fun ByteArray.plus(elements: ByteArray): ByteArray
expect operator fun CharArray.plus(elements: CharArray): CharArray
expect operator fun DoubleArray.plus(elements: DoubleArray): DoubleArray
expect operator fun FloatArray.plus(elements: FloatArray): FloatArray
expect operator fun IntArray.plus(elements: IntArray): IntArray
expect operator fun LongArray.plus(elements: LongArray): LongArray
expect operator fun ShortArray.plus(elements: ShortArray): ShortArray

Returns an array containing all elements of the original array and then all elements of the given elements array.

Since Kotlin 1.0
expect operator fun <T> Array<T>.plus(elements: Collection<T>): Array<T>
expect operator fun BooleanArray.plus(elements: Collection<Boolean>): BooleanArray
expect operator fun ByteArray.plus(elements: Collection<Byte>): ByteArray
expect operator fun CharArray.plus(elements: Collection<Char>): CharArray
expect operator fun DoubleArray.plus(elements: Collection<Double>): DoubleArray
expect operator fun FloatArray.plus(elements: Collection<Float>): FloatArray
expect operator fun IntArray.plus(elements: Collection<Int>): IntArray
expect operator fun LongArray.plus(elements: Collection<Long>): LongArray
expect operator fun ShortArray.plus(elements: Collection<Short>): ShortArray

Returns an array containing all elements of the original array and then all elements of the given elements collection.

Since Kotlin 1.0
operator fun <T> Collection<T>.plus(element: T): List<T>
operator fun <T> Iterable<T>.plus(element: T): List<T>

Returns a list containing all elements of the original collection and then the given element.

Since Kotlin 1.0
operator fun <T> Collection<T>.plus(elements: Array<out T>): List<T>
operator fun <T> Iterable<T>.plus(elements: Array<out T>): List<T>

Returns a list containing all elements of the original collection and then all elements of the given elements array.

Since Kotlin 1.0
operator fun <T> Collection<T>.plus(elements: Iterable<T>): List<T>
operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T>

Returns a list containing all elements of the original collection and then all elements of the given elements collection.

Since Kotlin 1.0
operator fun <T> Collection<T>.plus(elements: Sequence<T>): List<T>
operator fun <T> Iterable<T>.plus(elements: Sequence<T>): List<T>

Returns a list containing all elements of the original collection and then all elements of the given elements sequence.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given array of key-value pairs.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>

Creates a new read-only map by replacing or adding an entry to this map from a given key-value pair.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given collection of key-value pairs.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from another map.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value pairs.

Since Kotlin 1.0
operator fun <T> Set<T>.plus(element: T): Set<T>

Returns a set containing all elements of the original set and then the given element if it isn't already in this set.

Since Kotlin 1.0
operator fun <T> Set<T>.plus(elements: Array<out T>): Set<T>

Returns a set containing all elements of the original set and the given elements array, which aren't already in this set.

Since Kotlin 1.0
operator fun <T> Set<T>.plus(elements: Iterable<T>): Set<T>

Returns a set containing all elements of the original set and the given elements collection, which aren't already in this set. The returned set preserves the element iteration order of the original set.

Since Kotlin 1.0
operator fun <T> Set<T>.plus(elements: Sequence<T>): Set<T>

Returns a set containing all elements of the original set and the given elements sequence, which aren't already in this set.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <T> MutableCollection<in T>.plusAssign(element: T)

Adds the specified element to this mutable collection.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Array<T>)

Adds all elements of the given elements array to this mutable collection.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Iterable<T>)

Adds all elements of the given elements collection to this mutable collection.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Sequence<T>)

Adds all elements of the given elements sequence to this mutable collection.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)

Appends or replaces all pairs from the given array of pairs in this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)

Appends or replaces the given pair in this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)

Appends or replaces all pairs from the given collection of pairs in this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)

Appends or replaces all entries from the given map in this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)

Appends or replaces all pairs from the given sequence of pairs in this mutable map.

Since Kotlin 1.1
inline operator fun <T> MutableCollection<in T>.plusAssign(element: T)

Adds the specified element to this mutable collection.

Since Kotlin 1.0
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Array<T>)

Adds all elements of the given elements array to this mutable collection.

Since Kotlin 1.0
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Iterable<T>)

Adds all elements of the given elements collection to this mutable collection.

Since Kotlin 1.0
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Sequence<T>)

Adds all elements of the given elements sequence to this mutable collection.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)

Appends or replaces all pairs from the given array of pairs in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)

Appends or replaces the given pair in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)

Appends or replaces all pairs from the given collection of pairs in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)

Appends or replaces all entries from the given map in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)

Appends or replaces all pairs from the given sequence of pairs in this mutable map.

Since Kotlin 1.0
Link copied to clipboard
expect inline fun <T> Array<T>.plusElement(element: T): Array<T>

Returns an array containing all elements of the original array and then the given element.

Since Kotlin 1.0
inline fun <T> Collection<T>.plusElement(element: T): List<T>
inline fun <T> Iterable<T>.plusElement(element: T): List<T>

Returns a list containing all elements of the original collection and then the given element.

Since Kotlin 1.0
inline fun <T> Set<T>.plusElement(element: T): Set<T>

Returns a set containing all elements of the original set and then the given element if it isn't already in this set.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)

Puts all the given pairs into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.1
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K, V>>)

Puts all the elements of the given collection into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.1
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K, V>>)

Puts all the elements of the given sequence into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.1
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)

Puts all the given pairs into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.0
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K, V>>)

Puts all the elements of the given collection into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.0
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K, V>>)

Puts all the elements of the given sequence into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <S, T : S, K> Grouping<T, K>.reduce(operation: (key: K, accumulator: S, element: T) -> S): Map<K, S>

Groups elements from the Grouping source by key and applies the reducing operation to the elements of each group sequentially starting from the second element of the group, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is the first element of the group.

Since Kotlin 1.1
inline fun <S, T : S> Array<out T>.reduce(operation: (acc: S, T) -> S): S
inline fun BooleanArray.reduce(operation: (acc: Boolean, Boolean) -> Boolean): Boolean
inline fun ByteArray.reduce(operation: (acc: Byte, Byte) -> Byte): Byte
inline fun CharArray.reduce(operation: (acc: Char, Char) -> Char): Char
inline fun DoubleArray.reduce(operation: (acc: Double, Double) -> Double): Double
inline fun FloatArray.reduce(operation: (acc: Float, Float) -> Float): Float
inline fun IntArray.reduce(operation: (acc: Int, Int) -> Int): Int
inline fun LongArray.reduce(operation: (acc: Long, Long) -> Long): Long
inline fun ShortArray.reduce(operation: (acc: Short, Short) -> Short): Short
inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S

Accumulates value starting with the first element and applying operation from left to right to current accumulator value and each element.

Since Kotlin 1.0
inline fun <S, T : S, K> Grouping<T, K>.reduce(operation: (key: K, accumulator: S, element: T) -> S): Map<K, S>

Groups elements from the Grouping source by key and applies the reducing operation to the elements of each group sequentially starting from the second element of the group, passing the previously accumulated value and the current element as arguments, and stores the results in a new map. An initial value of accumulator is the first element of the group.

Since Kotlin 1.1
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S
inline fun BooleanArray.reduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean
inline fun ByteArray.reduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte
inline fun CharArray.reduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): Char
inline fun DoubleArray.reduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): Double
inline fun FloatArray.reduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): Float
inline fun IntArray.reduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): Int
inline fun LongArray.reduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): Long
inline fun ShortArray.reduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): Short

Accumulates value starting with the first element and applying operation from left to right to current accumulator value and each element with its index in the original array.

Since Kotlin 1.0
inline fun <S, T : S> Iterable<T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S

Accumulates value starting with the first element and applying operation from left to right to current accumulator value and each element with its index in the original collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRight(operation: (T, acc: S) -> S): S
inline fun BooleanArray.reduceRight(operation: (Boolean, acc: Boolean) -> Boolean): Boolean
inline fun ByteArray.reduceRight(operation: (Byte, acc: Byte) -> Byte): Byte
inline fun CharArray.reduceRight(operation: (Char, acc: Char) -> Char): Char
inline fun DoubleArray.reduceRight(operation: (Double, acc: Double) -> Double): Double
inline fun FloatArray.reduceRight(operation: (Float, acc: Float) -> Float): Float
inline fun IntArray.reduceRight(operation: (Int, acc: Int) -> Int): Int
inline fun LongArray.reduceRight(operation: (Long, acc: Long) -> Long): Long
inline fun ShortArray.reduceRight(operation: (Short, acc: Short) -> Short): Short
inline fun <S, T : S> List<T>.reduceRight(operation: (T, acc: S) -> S): S

Accumulates value starting with the last element and applying operation from right to left to each element and current accumulator value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S
inline fun BooleanArray.reduceRightIndexed(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean
inline fun ByteArray.reduceRightIndexed(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte
inline fun CharArray.reduceRightIndexed(operation: (index: Int, Char, acc: Char) -> Char): Char
inline fun DoubleArray.reduceRightIndexed(operation: (index: Int, Double, acc: Double) -> Double): Double
inline fun FloatArray.reduceRightIndexed(operation: (index: Int, Float, acc: Float) -> Float): Float
inline fun IntArray.reduceRightIndexed(operation: (index: Int, Int, acc: Int) -> Int): Int
inline fun LongArray.reduceRightIndexed(operation: (index: Int, Long, acc: Long) -> Long): Long
inline fun ShortArray.reduceRightIndexed(operation: (index: Int, Short, acc: Short) -> Short): Short

Accumulates value starting with the last element and applying operation from right to left to each element with its index in the original array and current accumulator value.

Since Kotlin 1.0
inline fun <S, T : S> List<T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S

Accumulates value starting with the last element and applying operation from right to left to each element with its index in the original list and current accumulator value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <S, T : S, K, M : MutableMap<in K, S>> Grouping<T, K>.reduceTo(destination: M, operation: (key: K, accumulator: S, element: T) -> S): M

Groups elements from the Grouping source by key and applies the reducing operation to the elements of each group sequentially starting from the second element of the group, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map. An initial value of accumulator is the first element of the group.

Since Kotlin 1.1
inline fun <S, T : S, K, M : MutableMap<in K, S>> Grouping<T, K>.reduceTo(destination: M, operation: (key: K, accumulator: S, element: T) -> S): M

Groups elements from the Grouping source by key and applies the reducing operation to the elements of each group sequentially starting from the second element of the group, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map. An initial value of accumulator is the first element of the group.

Since Kotlin 1.1
Link copied to clipboard
inline fun <T> MutableCollection<out T>.remove(element: T): Boolean

Removes a single instance of the specified element from this collection, if it is present.

Since Kotlin 1.1
inline fun <T> MutableList<T>.remove(index: Int): T

Removes the element at the specified index from this list. In Kotlin one should use the MutableList.removeAt function instead.

Since Kotlin 1.1
inline fun <K, V> MutableMap<out K, V>.remove(key: K): V?

Removes the specified key and its corresponding value from this map.

Since Kotlin 1.1
inline fun <T> MutableCollection<out T>.remove(element: T): Boolean

Removes a single instance of the specified element from this collection, if it is present.

Since Kotlin 1.0
inline fun <T> MutableList<T>.remove(index: Int): T

Removes the element at the specified index from this list. In Kotlin one should use the MutableList.removeAt function instead.

Since Kotlin 1.0
inline fun <K, V> MutableMap<out K, V>.remove(key: K): V?

Removes the specified key and its corresponding value from this map.

Since Kotlin 1.0
Link copied to clipboard
fun <T> MutableCollection<in T>.removeAll(elements: Array<out T>): Boolean

Removes all elements from this MutableCollection that are also contained in the given elements array.

Since Kotlin 1.1
inline fun <T> MutableCollection<out T>.removeAll(elements: Collection<T>): Boolean

Removes all of this collection's elements that are also contained in the specified collection.

Since Kotlin 1.1

Removes all elements from this MutableCollection that are also contained in the given elements collection.

Since Kotlin 1.1

Removes all elements from this MutableCollection that are also contained in the given elements sequence.

Since Kotlin 1.1
fun <T> MutableIterable<T>.removeAll(predicate: (T) -> Boolean): Boolean

Removes all elements from this MutableIterable that match the given predicate.

Since Kotlin 1.1
fun <T> MutableList<T>.removeAll(predicate: (T) -> Boolean): Boolean

Removes all elements from this MutableList that match the given predicate.

Since Kotlin 1.1
fun <T> MutableCollection<in T>.removeAll(elements: Array<out T>): Boolean

Removes all elements from this MutableCollection that are also contained in the given elements array.

Since Kotlin 1.0
inline fun <T> MutableCollection<out T>.removeAll(elements: Collection<T>): Boolean

Removes all of this collection's elements that are also contained in the specified collection.

Since Kotlin 1.0

Removes all elements from this MutableCollection that are also contained in the given elements collection.

Since Kotlin 1.0

Removes all elements from this MutableCollection that are also contained in the given elements sequence.

Since Kotlin 1.0
fun <T> MutableIterable<T>.removeAll(predicate: (T) -> Boolean): Boolean

Removes all elements from this MutableIterable that match the given predicate.

Since Kotlin 1.0
fun <T> MutableList<T>.removeAll(predicate: (T) -> Boolean): Boolean

Removes all elements from this MutableList that match the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T : Any> Array<T?>.requireNoNulls(): Array<T>
fun <T : Any> List<T?>.requireNoNulls(): List<T>

Returns an original collection containing all the non-null elements, throwing an IllegalArgumentException if there are any null elements.

Since Kotlin 1.0
Link copied to clipboard
fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolean

Retains only elements of this MutableCollection that are contained in the given elements array.

Since Kotlin 1.1
inline fun <T> MutableCollection<out T>.retainAll(elements: Collection<T>): Boolean

Retains only the elements in this collection that are contained in the specified collection.

Since Kotlin 1.1

Retains only elements of this MutableCollection that are contained in the given elements collection.

Since Kotlin 1.1

Retains only elements of this MutableCollection that are contained in the given elements sequence.

Since Kotlin 1.1
fun <T> MutableIterable<T>.retainAll(predicate: (T) -> Boolean): Boolean

Retains only elements of this MutableIterable that match the given predicate.

Since Kotlin 1.1
fun <T> MutableList<T>.retainAll(predicate: (T) -> Boolean): Boolean

Retains only elements of this MutableList that match the given predicate.

Since Kotlin 1.1
fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolean

Retains only elements of this MutableCollection that are contained in the given elements array.

Since Kotlin 1.0
inline fun <T> MutableCollection<out T>.retainAll(elements: Collection<T>): Boolean

Retains only the elements in this collection that are contained in the specified collection.

Since Kotlin 1.0

Retains only elements of this MutableCollection that are contained in the given elements collection.

Since Kotlin 1.0

Retains only elements of this MutableCollection that are contained in the given elements sequence.

Since Kotlin 1.0
fun <T> MutableIterable<T>.retainAll(predicate: (T) -> Boolean): Boolean

Retains only elements of this MutableIterable that match the given predicate.

Since Kotlin 1.0
fun <T> MutableList<T>.retainAll(predicate: (T) -> Boolean): Boolean

Retains only elements of this MutableList that match the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<T>.reverse()

Reverses elements in the array in-place.

Since Kotlin 1.0
expect fun <T> MutableList<T>.reverse()

Reverses elements in the list in-place.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.reversed(): List<T>
fun <T> Iterable<T>.reversed(): List<T>

Returns a list with elements in reversed order.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

Allows to use the index operator for storing values in a mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

Allows to use the index operator for storing values in a mutable map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> setOf(): Set<T>

Returns an empty read-only set. The returned set is serializable (JVM).

Since Kotlin 1.1
fun <T> setOf(element: T): Set<T>

Returns an immutable set containing only the specified object element.

Since Kotlin 1.1
fun <T> setOf(vararg elements: T): Set<T>

Returns a new read-only set with the given elements. Elements of the set are iterated in the order they were specified. The returned set is serializable (JVM).

Since Kotlin 1.1
inline fun <T> setOf(): Set<T>

Returns an empty read-only set. The returned set is serializable (JVM).

Since Kotlin 1.0
fun <T> setOf(element: T): Set<T>

Returns an immutable set containing only the specified object element. The returned set is serializable.

Since Kotlin 1.0
fun <T> setOf(vararg elements: T): Set<T>

Returns a new read-only set with the given elements. Elements of the set are iterated in the order they were specified. The returned set is serializable (JVM).

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <V> MutableMap<in String, in V>.setValue(thisRef: Any?, property: KProperty<*>, value: V)

Stores the value of the property for the given object in this mutable map.

Since Kotlin 1.1
inline operator fun <V> MutableMap<in String, in V>.setValue(thisRef: Any?, property: KProperty<*>, value: V)

Stores the value of the property for the given object in this mutable map.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.single(): T

Returns the single element, or throws an exception if the array is empty or has more than one element.

Since Kotlin 1.0
fun <T> Iterable<T>.single(): T

Returns the single element, or throws an exception if the collection is empty or has more than one element.

Since Kotlin 1.0
fun <T> List<T>.single(): T

Returns the single element, or throws an exception if the list is empty or has more than one element.

Since Kotlin 1.0
inline fun <T> Array<out T>.single(predicate: (T) -> Boolean): T
inline fun BooleanArray.single(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.single(predicate: (Byte) -> Boolean): Byte
inline fun CharArray.single(predicate: (Char) -> Boolean): Char
inline fun DoubleArray.single(predicate: (Double) -> Boolean): Double
inline fun FloatArray.single(predicate: (Float) -> Boolean): Float
inline fun IntArray.single(predicate: (Int) -> Boolean): Int
inline fun LongArray.single(predicate: (Long) -> Boolean): Long
inline fun ShortArray.single(predicate: (Short) -> Boolean): Short
inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T

Returns the single element matching the given predicate, or throws exception if there is no or more than one matching element.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.singleOrNull(): T?

Returns single element, or null if the array is empty or has more than one element.

Since Kotlin 1.0

Returns single element, or null if the collection is empty or has more than one element.

Since Kotlin 1.0
fun <T> List<T>.singleOrNull(): T?

Returns single element, or null if the list is empty or has more than one element.

Since Kotlin 1.0
inline fun <T> Array<out T>.singleOrNull(predicate: (T) -> Boolean): T?
inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.singleOrNull(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.singleOrNull(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean): Float?
inline fun IntArray.singleOrNull(predicate: (Int) -> Boolean): Int?
inline fun LongArray.singleOrNull(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean): Short?
inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean): T?

Returns the single element matching the given predicate, or null if element was not found or more than one element was found.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>
fun ByteArray.slice(indices: Iterable<Int>): List<Byte>
fun CharArray.slice(indices: Iterable<Int>): List<Char>
fun IntArray.slice(indices: Iterable<Int>): List<Int>
fun LongArray.slice(indices: Iterable<Int>): List<Long>
fun <T> List<T>.slice(indices: Iterable<Int>): List<T>

Returns a list containing elements at specified indices.

Since Kotlin 1.0
fun <T> Array<out T>.slice(indices: IntRange): List<T>
fun ByteArray.slice(indices: IntRange): List<Byte>
fun CharArray.slice(indices: IntRange): List<Char>
fun IntArray.slice(indices: IntRange): List<Int>
fun LongArray.slice(indices: IntRange): List<Long>
fun <T> List<T>.slice(indices: IntRange): List<T>

Returns a list containing elements at indices in the specified indices range.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<T>.sliceArray(indices: Collection<Int>): Array<T>

Returns an array containing elements of this array at specified indices.

Since Kotlin 1.0
fun <T> Array<T>.sliceArray(indices: IntRange): Array<T>

Returns an array containing elements at indices in the specified indices range.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.sort(comparison: (a: T, b: T) -> Int)
inline fun ByteArray.sort(noinline comparison: (a: Byte, b: Byte) -> Int)
inline fun CharArray.sort(noinline comparison: (a: Char, b: Char) -> Int)
inline fun DoubleArray.sort(noinline comparison: (a: Double, b: Double) -> Int)
inline fun FloatArray.sort(noinline comparison: (a: Float, b: Float) -> Int)
inline fun IntArray.sort(noinline comparison: (a: Int, b: Int) -> Int)
inline fun LongArray.sort(noinline comparison: (a: Long, b: Long) -> Int)
inline fun ShortArray.sort(noinline comparison: (a: Short, b: Short) -> Int)

Sorts the array in-place according to the order specified by the given comparison function.

Since Kotlin 1.1
fun <T> Array<out T>.sort()
expect inline fun <T : Comparable<T>> Array<out T>.sort()

Sorts the array in-place according to the natural order of its elements.

Since Kotlin 1.0
expect fun ByteArray.sort()
expect fun CharArray.sort()
expect fun DoubleArray.sort()
expect fun FloatArray.sort()
expect fun IntArray.sort()
expect fun LongArray.sort()
expect fun ShortArray.sort()

Sorts the array in-place.

Since Kotlin 1.0
expect fun <T : Comparable<T>> MutableList<T>.sort()

Sorts elements in the list in-place according to their natural sort order.

Since Kotlin 1.0
inline fun <T> MutableList<T>.sort(comparator: Comparator<in T>)
inline fun <T> MutableList<T>.sort(comparison: (T, T) -> Int)
Since Kotlin 1.0
fun <T> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size)
expect fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)

Sorts a range in the array in-place.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortBy(crossinline selector: (T) -> R?)

Sorts elements in the array in-place according to natural sort order of the value returned by specified selector function.

Since Kotlin 1.0
inline fun <T, R : Comparable<R>> MutableList<T>.sortBy(crossinline selector: (T) -> R?)

Sorts elements in the list in-place according to natural sort order of the value returned by specified selector function.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortByDescending(crossinline selector: (T) -> R?)

Sorts elements in the array in-place descending according to natural sort order of the value returned by specified selector function.

Since Kotlin 1.0
inline fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(crossinline selector: (T) -> R?)

Sorts elements in the list in-place descending according to natural sort order of the value returned by specified selector function.

Since Kotlin 1.0
Link copied to clipboard

Sorts elements in the array in-place descending according to their natural sort order.

Since Kotlin 1.0

Sorts elements in the list in-place descending according to their natural sort order.

Since Kotlin 1.0
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.sorted(): List<T>

Returns a list of all elements sorted according to their natural sort order.

Since Kotlin 1.0
Link copied to clipboard

Returns an array with all elements of this array sorted according to their natural sort order.

Since Kotlin 1.0
Link copied to clipboard
Link copied to clipboard
fun <T> Array<out T>.sortedArrayWith(comparator: Comparator<in T>): Array<out T>

Returns an array with all elements of this array sorted according the specified comparator.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortedBy(crossinline selector: (T) -> R?): List<T>
inline fun <R : Comparable<R>> BooleanArray.sortedBy(crossinline selector: (Boolean) -> R?): List<Boolean>
inline fun <R : Comparable<R>> ByteArray.sortedBy(crossinline selector: (Byte) -> R?): List<Byte>
inline fun <R : Comparable<R>> CharArray.sortedBy(crossinline selector: (Char) -> R?): List<Char>
inline fun <R : Comparable<R>> DoubleArray.sortedBy(crossinline selector: (Double) -> R?): List<Double>
inline fun <R : Comparable<R>> FloatArray.sortedBy(crossinline selector: (Float) -> R?): List<Float>
inline fun <R : Comparable<R>> IntArray.sortedBy(crossinline selector: (Int) -> R?): List<Int>
inline fun <R : Comparable<R>> LongArray.sortedBy(crossinline selector: (Long) -> R?): List<Long>
inline fun <R : Comparable<R>> ShortArray.sortedBy(crossinline selector: (Short) -> R?): List<Short>
inline fun <T, R : Comparable<R>> Iterable<T>.sortedBy(crossinline selector: (T) -> R?): List<T>

Returns a list of all elements sorted according to natural sort order of the value returned by specified selector function.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>
inline fun <R : Comparable<R>> BooleanArray.sortedByDescending(crossinline selector: (Boolean) -> R?): List<Boolean>
inline fun <R : Comparable<R>> ByteArray.sortedByDescending(crossinline selector: (Byte) -> R?): List<Byte>
inline fun <R : Comparable<R>> CharArray.sortedByDescending(crossinline selector: (Char) -> R?): List<Char>
inline fun <R : Comparable<R>> DoubleArray.sortedByDescending(crossinline selector: (Double) -> R?): List<Double>
inline fun <R : Comparable<R>> FloatArray.sortedByDescending(crossinline selector: (Float) -> R?): List<Float>
inline fun <R : Comparable<R>> IntArray.sortedByDescending(crossinline selector: (Int) -> R?): List<Int>
inline fun <R : Comparable<R>> LongArray.sortedByDescending(crossinline selector: (Long) -> R?): List<Long>
inline fun <R : Comparable<R>> ShortArray.sortedByDescending(crossinline selector: (Short) -> R?): List<Short>
inline fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>

Returns a list of all elements sorted descending according to natural sort order of the value returned by specified selector function.

Since Kotlin 1.0
Link copied to clipboard

Returns a list of all elements sorted descending according to their natural sort order.

Since Kotlin 1.0
Link copied to clipboard
fun <K : Comparable<K>, V> sortedMapOf(vararg pairs: Pair<K, V>): SortedMap<K, V>

Returns a new SortedMap with the specified contents, given as a list of pairs where the first value is the key and the second is the value.

Since Kotlin 1.0
Link copied to clipboard
fun <T> sortedSetOf(vararg elements: T): TreeSet<T>

Returns a new java.util.SortedSet with the given elements.

Since Kotlin 1.0
fun <T> sortedSetOf(comparator: Comparator<in T>, vararg elements: T): TreeSet<T>

Returns a new java.util.SortedSet with the given comparator and elements.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.sortedWith(comparator: Comparator<in T>): List<T>
fun ByteArray.sortedWith(comparator: Comparator<in Byte>): List<Byte>
fun CharArray.sortedWith(comparator: Comparator<in Char>): List<Char>
fun IntArray.sortedWith(comparator: Comparator<in Int>): List<Int>
fun LongArray.sortedWith(comparator: Comparator<in Long>): List<Long>
fun <T> Iterable<T>.sortedWith(comparator: Comparator<in T>): List<T>

Returns a list of all elements sorted according to the specified comparator.

Since Kotlin 1.0
Link copied to clipboard
actual fun <T> Array<out T>.sortWith(comparator: Comparator<in T>)

Sorts the array in-place according to the order specified by the given comparator.

Since Kotlin 1.1
actual fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)

Sorts elements in the list in-place according to the order specified with comparator.

Since Kotlin 1.1
expect fun <T> Array<out T>.sortWith(comparator: Comparator<in T>)

Sorts the array in-place according to the order specified by the given comparator.

Since Kotlin 1.0
expect fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)

Sorts elements in the list in-place according to the order specified with comparator.

Since Kotlin 1.0
expect fun <T> Array<out T>.sortWith(comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size)

Sorts a range in the array in-place with the given comparator.

Since Kotlin 1.0
Link copied to clipboard
fun <V> stringMapOf(vararg pairs: Pair<String, V>): HashMap<String, V>

Constructs the specialized implementation of HashMap with String keys, which stores the keys as properties of JS object without hashing them.

Since Kotlin 1.1
Link copied to clipboard
fun stringSetOf(vararg elements: String): HashSet<String>

Creates a new instance of the specialized implementation of HashSet with the specified String elements, which elements the keys as properties of JS object without hashing them.

Since Kotlin 1.1
Link copied to clipboard
infix fun <T> Array<out T>.subtract(other: Iterable<T>): Set<T>
infix fun ByteArray.subtract(other: Iterable<Byte>): Set<Byte>
infix fun CharArray.subtract(other: Iterable<Char>): Set<Char>
infix fun FloatArray.subtract(other: Iterable<Float>): Set<Float>
infix fun IntArray.subtract(other: Iterable<Int>): Set<Int>
infix fun LongArray.subtract(other: Iterable<Long>): Set<Long>
infix fun ShortArray.subtract(other: Iterable<Short>): Set<Short>

Returns a set containing all elements that are contained by this array and not contained by the specified collection.

Since Kotlin 1.0
infix fun <T> Iterable<T>.subtract(other: Iterable<T>): Set<T>

Returns a set containing all elements that are contained by this collection and not contained by the specified collection.

Since Kotlin 1.0
Link copied to clipboard
@JvmName(name = "sumOfByte")
fun ByteArray.sum(): Int
@JvmName(name = "sumOfDouble")
fun DoubleArray.sum(): Double
@JvmName(name = "sumOfFloat")
fun FloatArray.sum(): Float
@JvmName(name = "sumOfInt")
fun IntArray.sum(): Int
@JvmName(name = "sumOfLong")
fun LongArray.sum(): Long
@JvmName(name = "sumOfShort")
fun ShortArray.sum(): Int

Returns the sum of all elements in the array.

Since Kotlin 1.0
@JvmName(name = "sumOfByte")
fun Iterable<Byte>.sum(): Int
@JvmName(name = "sumOfDouble")
fun Iterable<Double>.sum(): Double
@JvmName(name = "sumOfFloat")
fun Iterable<Float>.sum(): Float
@JvmName(name = "sumOfInt")
fun Iterable<Int>.sum(): Int
@JvmName(name = "sumOfLong")
fun Iterable<Long>.sum(): Long
@JvmName(name = "sumOfShort")
fun Iterable<Short>.sum(): Int

Returns the sum of all elements in the collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.sumBy(selector: (T) -> Int): Int
inline fun BooleanArray.sumBy(selector: (Boolean) -> Int): Int
inline fun ByteArray.sumBy(selector: (Byte) -> Int): Int
inline fun CharArray.sumBy(selector: (Char) -> Int): Int
inline fun DoubleArray.sumBy(selector: (Double) -> Int): Int
inline fun FloatArray.sumBy(selector: (Float) -> Int): Int
inline fun IntArray.sumBy(selector: (Int) -> Int): Int
inline fun LongArray.sumBy(selector: (Long) -> Int): Int
inline fun ShortArray.sumBy(selector: (Short) -> Int): Int

Returns the sum of all values produced by selector function applied to each element in the array.

Since Kotlin 1.0
inline fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int

Returns the sum of all values produced by selector function applied to each element in the collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.sumByDouble(selector: (T) -> Double): Double
inline fun BooleanArray.sumByDouble(selector: (Boolean) -> Double): Double
inline fun ByteArray.sumByDouble(selector: (Byte) -> Double): Double
inline fun CharArray.sumByDouble(selector: (Char) -> Double): Double
inline fun DoubleArray.sumByDouble(selector: (Double) -> Double): Double
inline fun FloatArray.sumByDouble(selector: (Float) -> Double): Double
inline fun IntArray.sumByDouble(selector: (Int) -> Double): Double
inline fun LongArray.sumByDouble(selector: (Long) -> Double): Double
inline fun ShortArray.sumByDouble(selector: (Short) -> Double): Double

Returns the sum of all values produced by selector function applied to each element in the array.

Since Kotlin 1.0
inline fun <T> Iterable<T>.sumByDouble(selector: (T) -> Double): Double

Returns the sum of all values produced by selector function applied to each element in the collection.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.take(n: Int): List<T>
fun <T> Iterable<T>.take(n: Int): List<T>

Returns a list containing first n elements.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.takeLast(n: Int): List<T>
fun <T> List<T>.takeLast(n: Int): List<T>

Returns a list containing last n elements.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.takeLastWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.takeLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.takeLastWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.takeLastWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.takeLastWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.takeLastWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.takeLastWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.takeLastWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.takeLastWhile(predicate: (Short) -> Boolean): List<Short>
inline fun <T> List<T>.takeLastWhile(predicate: (T) -> Boolean): List<T>

Returns a list containing last elements satisfying the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Array<out T>.takeWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.takeWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.takeWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.takeWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.takeWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.takeWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.takeWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.takeWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.takeWhile(predicate: (Short) -> Boolean): List<Short>
inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T>

Returns a list containing first elements satisfying the given predicate.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Boolean containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Boolean containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Byte containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Byte containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Char containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Char containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard
fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(destination: C): C
fun <C : MutableCollection<in Byte>> ByteArray.toCollection(destination: C): C
fun <C : MutableCollection<in Char>> CharArray.toCollection(destination: C): C
fun <C : MutableCollection<in Double>> DoubleArray.toCollection(destination: C): C
fun <C : MutableCollection<in Float>> FloatArray.toCollection(destination: C): C
fun <C : MutableCollection<in Int>> IntArray.toCollection(destination: C): C
fun <C : MutableCollection<in Long>> LongArray.toCollection(destination: C): C
fun <C : MutableCollection<in Short>> ShortArray.toCollection(destination: C): C
fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(destination: C): C

Appends all elements to the given destination collection.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Double containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Double containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Float containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Float containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Int containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Int containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <T> Enumeration<T>.toList(): List<T>

Returns a list containing the elements returned by this enumeration in the order they are returned by the enumeration.

Since Kotlin 1.0
fun <T> Array<out T>.toList(): List<T>
fun <T> Iterable<T>.toList(): List<T>

Returns a List containing all elements.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>>

Returns a List containing all key-value pairs.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Long containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Long containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V>

Returns a new map containing all key-value pairs from the given array of pairs.

Since Kotlin 1.1
fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>

Returns a new map containing all key-value pairs from the given collection of pairs.

Since Kotlin 1.1
fun <K, V> Map<out K, V>.toMap(): Map<K, V>

Returns a new read-only map containing all key-value pairs from the original map.

Since Kotlin 1.1
fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V>

Returns a new map containing all key-value pairs from the given sequence of pairs.

Since Kotlin 1.1
fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given array of pairs.

Since Kotlin 1.1
fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given collection of pairs.

Since Kotlin 1.1
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given map.

Since Kotlin 1.1
fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given sequence of pairs.

Since Kotlin 1.1
fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V>

Returns a new map containing all key-value pairs from the given array of pairs.

Since Kotlin 1.0
fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>

Returns a new map containing all key-value pairs from the given collection of pairs.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.toMap(): Map<K, V>

Returns a new read-only map containing all key-value pairs from the original map.

Since Kotlin 1.1
fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V>

Returns a new map containing all key-value pairs from the given sequence of pairs.

Since Kotlin 1.0
fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given array of pairs.

Since Kotlin 1.0
fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given collection of pairs.

Since Kotlin 1.0
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given map.

Since Kotlin 1.1
fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given sequence of pairs.

Since Kotlin 1.0
Link copied to clipboard
Link copied to clipboard
fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>

Returns a new mutable map containing all key-value pairs from the original map.

Since Kotlin 1.1
fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>

Returns a new mutable map containing all key-value pairs from the original map.

Since Kotlin 1.1
Link copied to clipboard
fun <T> Array<out T>.toMutableSet(): MutableSet<T>

Returns a new MutableSet containing all distinct elements from the given array.

Since Kotlin 1.0

Returns a new MutableSet containing all distinct elements from the given collection.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map.Entry<K, V>.toPair(): Pair<K, V>

Converts entry to Pair with key being first component and value being second.

Since Kotlin 1.1
inline fun <K, V> Map.Entry<K, V>.toPair(): Pair<K, V>

Converts entry to Pair with key being first component and value being second.

Since Kotlin 1.0
Link copied to clipboard

Converts this Map to a Properties object.

Since Kotlin 1.0
Link copied to clipboard
fun <T> Array<out T>.toSet(): Set<T>
fun <T> Iterable<T>.toSet(): Set<T>

Returns a Set of all elements.

Since Kotlin 1.0
Link copied to clipboard

Returns an array of Short containing all of the elements of this generic array.

Since Kotlin 1.0

Returns an array of Short containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard
fun <K : Comparable<K>, V> Map<out K, V>.toSortedMap(): SortedMap<K, V>

Converts this Map to a SortedMap. The resulting SortedMap determines the equality and order of keys according to their natural sorting order.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.toSortedMap(comparator: Comparator<in K>): SortedMap<K, V>

Converts this Map to a SortedMap. The resulting SortedMap determines the equality and order of keys according to the sorting order provided by the given comparator.

Since Kotlin 1.0
Link copied to clipboard
inline fun ByteArray.toString(charset: Charset): String

Converts the contents of this byte array to a string using the specified charset.

Since Kotlin 1.0
Link copied to clipboard

Returns a typed object array containing all of the elements of this primitive array.

Since Kotlin 1.0
expect inline fun <T> Collection<T>.toTypedArray(): Array<T>

Returns a typed array containing all of the elements of this collection.

Since Kotlin 1.0
Link copied to clipboard
infix fun <T> Array<out T>.union(other: Iterable<T>): Set<T>
infix fun ByteArray.union(other: Iterable<Byte>): Set<Byte>
infix fun CharArray.union(other: Iterable<Char>): Set<Char>
infix fun DoubleArray.union(other: Iterable<Double>): Set<Double>
infix fun FloatArray.union(other: Iterable<Float>): Set<Float>
infix fun IntArray.union(other: Iterable<Int>): Set<Int>
infix fun LongArray.union(other: Iterable<Long>): Set<Long>
infix fun ShortArray.union(other: Iterable<Short>): Set<Short>
infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>

Returns a set containing all distinct elements from both collections.

Since Kotlin 1.0
Link copied to clipboard
fun <T, R> Array<out Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

Returns a pair of lists, where first list is built from the first values of each pair from this array, second list is built from the second values of each pair from this array.

Since Kotlin 1.1
fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

Returns a pair of lists, where first list is built from the first values of each pair from this collection, second list is built from the second values of each pair from this collection.

Since Kotlin 1.1
fun <T, R> Array<out Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

Returns a pair of lists, where first list is built from the first values of each pair from this array, second list is built from the second values of each pair from this array.

Since Kotlin 1.0
fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

Returns a pair of lists, where first list is built from the first values of each pair from this collection, second list is built from the second values of each pair from this collection.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>

Returns a wrapper of this read-only map, having the implicit default value provided with the specified function defaultValue.

Since Kotlin 1.1
fun <K, V> MutableMap<K, V>.withDefault(defaultValue: (key: K) -> V): MutableMap<K, V>

Returns a wrapper of this mutable map, having the implicit default value provided with the specified function defaultValue.

Since Kotlin 1.1
fun <K, V> Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>

Returns a wrapper of this read-only map, having the implicit default value provided with the specified function defaultValue.

Since Kotlin 1.0
@JvmName(name = "withDefaultMutable")
fun <K, V> MutableMap<K, V>.withDefault(defaultValue: (key: K) -> V): MutableMap<K, V>

Returns a wrapper of this mutable map, having the implicit default value provided with the specified function defaultValue.

Since Kotlin 1.0
Link copied to clipboard

Returns an Iterator that wraps each element produced by the original iterator into an IndexedValue containing the index of that element and the element itself.

Since Kotlin 1.1

Returns a lazy Iterable that wraps each element of the original array into an IndexedValue containing the index of that element and the element itself.

Since Kotlin 1.0

Returns a lazy Iterable that wraps each element of the original collection into an IndexedValue containing the index of that element and the element itself.

Since Kotlin 1.0

Returns an Iterator that wraps each element produced by the original iterator into an IndexedValue containing the index of that element and the element itself.

Since Kotlin 1.0
Link copied to clipboard
infix fun <T, R> Array<out T>.zip(other: Array<out R>): List<Pair<T, R>>
infix fun <R> BooleanArray.zip(other: Array<out R>): List<Pair<Boolean, R>>
infix fun <R> ByteArray.zip(other: Array<out R>): List<Pair<Byte, R>>
infix fun ByteArray.zip(other: ByteArray): List<Pair<Byte, Byte>>
infix fun <R> CharArray.zip(other: Array<out R>): List<Pair<Char, R>>
infix fun CharArray.zip(other: CharArray): List<Pair<Char, Char>>
infix fun <R> DoubleArray.zip(other: Array<out R>): List<Pair<Double, R>>
infix fun <R> FloatArray.zip(other: Array<out R>): List<Pair<Float, R>>
infix fun FloatArray.zip(other: FloatArray): List<Pair<Float, Float>>
infix fun <R> IntArray.zip(other: Array<out R>): List<Pair<Int, R>>
infix fun IntArray.zip(other: IntArray): List<Pair<Int, Int>>
infix fun <R> LongArray.zip(other: Array<out R>): List<Pair<Long, R>>
infix fun LongArray.zip(other: LongArray): List<Pair<Long, Long>>
infix fun <R> ShortArray.zip(other: Array<out R>): List<Pair<Short, R>>
infix fun ShortArray.zip(other: ShortArray): List<Pair<Short, Short>>

Returns a list of pairs built from the elements of this array and the other array with the same index. The returned list has length of the shortest collection.

Since Kotlin 1.0
infix fun <T, R> Array<out T>.zip(other: Iterable<R>): List<Pair<T, R>>
infix fun <R> BooleanArray.zip(other: Iterable<R>): List<Pair<Boolean, R>>
infix fun <R> ByteArray.zip(other: Iterable<R>): List<Pair<Byte, R>>
infix fun <R> CharArray.zip(other: Iterable<R>): List<Pair<Char, R>>
infix fun <R> DoubleArray.zip(other: Iterable<R>): List<Pair<Double, R>>
infix fun <R> FloatArray.zip(other: Iterable<R>): List<Pair<Float, R>>
infix fun <R> IntArray.zip(other: Iterable<R>): List<Pair<Int, R>>
infix fun <R> LongArray.zip(other: Iterable<R>): List<Pair<Long, R>>
infix fun <R> ShortArray.zip(other: Iterable<R>): List<Pair<Short, R>>

Returns a list of pairs built from the elements of this collection and other array with the same index. The returned list has length of the shortest collection.

Since Kotlin 1.0
infix fun <T, R> Iterable<T>.zip(other: Array<out R>): List<Pair<T, R>>

Returns a list of pairs built from the elements of this collection and the other array with the same index. The returned list has length of the shortest collection.

Since Kotlin 1.0
infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>>

Returns a list of pairs built from the elements of this collection and other collection with the same index. The returned list has length of the shortest collection.

Since Kotlin 1.0
inline fun <T, R, V> Array<out T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>
inline fun <R, V> BooleanArray.zip(other: Array<out R>, transform: (a: Boolean, b: R) -> V): List<V>
inline fun <R, V> ByteArray.zip(other: Array<out R>, transform: (a: Byte, b: R) -> V): List<V>
inline fun <R, V> CharArray.zip(other: Array<out R>, transform: (a: Char, b: R) -> V): List<V>
inline fun <R, V> DoubleArray.zip(other: Array<out R>, transform: (a: Double, b: R) -> V): List<V>
inline fun <R, V> FloatArray.zip(other: Array<out R>, transform: (a: Float, b: R) -> V): List<V>
inline fun <R, V> IntArray.zip(other: Array<out R>, transform: (a: Int, b: R) -> V): List<V>
inline fun <R, V> LongArray.zip(other: Array<out R>, transform: (a: Long, b: R) -> V): List<V>
inline fun <R, V> ShortArray.zip(other: Array<out R>, transform: (a: Short, b: R) -> V): List<V>

Returns a list of values built from the elements of this array and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Since Kotlin 1.0
inline fun <T, R, V> Array<out T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>
inline fun <R, V> BooleanArray.zip(other: Iterable<R>, transform: (a: Boolean, b: R) -> V): List<V>
inline fun <R, V> ByteArray.zip(other: Iterable<R>, transform: (a: Byte, b: R) -> V): List<V>
inline fun <R, V> CharArray.zip(other: Iterable<R>, transform: (a: Char, b: R) -> V): List<V>
inline fun <R, V> DoubleArray.zip(other: Iterable<R>, transform: (a: Double, b: R) -> V): List<V>
inline fun <R, V> FloatArray.zip(other: Iterable<R>, transform: (a: Float, b: R) -> V): List<V>
inline fun <R, V> IntArray.zip(other: Iterable<R>, transform: (a: Int, b: R) -> V): List<V>
inline fun <R, V> LongArray.zip(other: Iterable<R>, transform: (a: Long, b: R) -> V): List<V>
inline fun <R, V> ShortArray.zip(other: Iterable<R>, transform: (a: Short, b: R) -> V): List<V>

Returns a list of values built from the elements of this array and the other collection with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Since Kotlin 1.0
inline fun <V> BooleanArray.zip(other: BooleanArray, transform: (a: Boolean, b: Boolean) -> V): List<V>
inline fun <V> ByteArray.zip(other: ByteArray, transform: (a: Byte, b: Byte) -> V): List<V>
inline fun <V> CharArray.zip(other: CharArray, transform: (a: Char, b: Char) -> V): List<V>
inline fun <V> DoubleArray.zip(other: DoubleArray, transform: (a: Double, b: Double) -> V): List<V>
inline fun <V> FloatArray.zip(other: FloatArray, transform: (a: Float, b: Float) -> V): List<V>
inline fun <V> IntArray.zip(other: IntArray, transform: (a: Int, b: Int) -> V): List<V>
inline fun <V> LongArray.zip(other: LongArray, transform: (a: Long, b: Long) -> V): List<V>
inline fun <V> ShortArray.zip(other: ShortArray, transform: (a: Short, b: Short) -> V): List<V>

Returns a list of values built from the elements of this array and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest array.

Since Kotlin 1.0
inline fun <T, R, V> Iterable<T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>

Returns a list of values built from the elements of this collection and the other array with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Since Kotlin 1.0
inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>

Returns a list of values built from the elements of this collection and the other collection with the same index using the provided transform function applied to each pair of elements. The returned list has length of the shortest collection.

Since Kotlin 1.0