emptyList()

fun

val

.isEmpty()

.isNotEmpty()

ClosedRange

Array.copyOf

Array<out String>

out String

fun <T> Iterable<T>.forEachBetween(item: (T)->Unit, between: ()->Unit)

between

item

kotlin.random.Random

Random.Default

To get a seeded instance of random generator use Random function.

Random

Flow

val flow = flowOf(1, 2, 3, 4, 5)
fx {
  val n = !flow
  n + 1 //n is each of the elements in the flow
}
// flowOf(2, 3, 4, 5, 6)

Deferred

Observable

IO

flatMap

kotlin.coroutines.jvm.internal.ContinuationImpl

Future

ContinuationImpl

.also {
    targetList.addAll(it)
}

(5 downTo 3  step 3).forEach { println(it) }

(5 downTo 3).filter { it % 2 == 0}
        .forEach { println(it) }

(5 downTo 3  filter { it % 2 == 0})
        .forEach { println(it) }

step

Url

Url

list.take(n)

m

list.take(m)

Iterator

take(n)

take

for (item in this) {
        if (count++ == n)
            break
        list.add(item)
    }

for (item in this) {
        list.add(item)
        if (++count == n)
            break
    }

Vector

class Foo<StatType> {
    val stats = Vector<StatType>(8)
}

onEachIndexed

operator fun <R> KMutableProperty0<R>.setValue(host: Any?, property: KProperty<*>, value: R) = set(value)
operator fun <R> KMutableProperty0<R>.getValue(host: Any?, property: KProperty<*>): R = get()

var

Number

Map<K, V>.filterValues

(V) -> T

Map<K, V>.mapValues

(Map.Entry<K, V>) -> T

filterKeys

mapKeys

Double (12.456778)

12.34567.roundToPrecision(...)

class Foo(bar: Int?, baz: Int?, boz: Int?) {
    lateinit var bar: Int = bar // acceptable
    lateinit var baz = baz // implicitly assigned as non-nullable
    lateinit var boz: Int? = baz // unacceptable
}

withDefault

Locale

Int.sign

val foo = when (a.compareTo(b).sign) {
    -1 -> SomeEnum.LEFT
    0 -> SomeEnum.NONE
    1 -> SomeEnum.RIGHT
}

MutableMap

compute

override fun compute(key: T, remappingFunction: BiFunction<in T, in U?, out U?>): U?

computeIfAbsent

override fun computeIfAbsent(key: T, mappingFunction: Function<in T, out U>): U

?

U

computeIfAbsent

computeIfPresent

U?

operator fun <T> Pair<T, T>.iterator() = object : Iterator<T> {
    var i = 0
    
    override fun hasNext() = i < 2
    
    override fun next() = when (i++) {
        0 -> first
        1 -> second
        else -> throw NoSuchElementException()
    }
}

(0 to 0)..(1 to 1)

0 to 0, 0 to 1, 1 to 0, 1 to 1

operator fun Pair<Int, Int>.rangeTo(that: Pair<Int, Int>) = object : Iterable<Pair<Int, Int>> {
    override fun iterator() = object : Iterator<Pair<Int, Int>> {
        var i = this@rangeTo.first
        var j = this@rangeTo.second
        
        val m = that.first - i
        val n = that.second - j

        override fun hasNext() = i <= m && j <= n

        override fun next(): Pair<Int, Int> {
            val res = i to j
            
            if (j == n) {
                j = 0
                i++
            } else {
                j++
            }
            
            return res
        }
    }
}

List<Int>.rangeTo(other: List<Int>)

IntArray

String::split

fun String.split(
    delimiter: CharSequence = ", ",
    prefix: CharSequence = "",
    postfix: CharSequence = "",
    limit: Int = -1
): List<String>

fun <R> String.split(
    delimiter: CharSequence = ", ",
    prefix: CharSequence = "",
    postfix: CharSequence = "",
    limit: Int = -1,
    transform: (CharSequence) -> R
): List<R>