// KOTLINRS — LANGUAGE REFERENCE

>_LANGUAGE REFERENCE

Every keyword, operator, type, builtin call and stdlib member the current kotlinrs build recognizes, grouped into chapters and carrying a signature, a description and a runnable example. This page is generated from the language-server corpus (src/lsp.rs) by the gen-docs binary, so it stays in sync with what the runtime and editor tooling actually know about: keywords mirror lexer.rs and the parser.rs modifier table, operators mirror lexer::operator, types mirror ast::Type::from_name, builtins mirror the arms of compiler::compile_call, and each member mirrors an arm of host::kt_method, char_method, obj_method, sequence_member or coll_hof. Descriptions state what this runtime does; where the behaviour diverges from Kotlin proper, the entry says so.

fun name(p: T, …): R { … }
fun name(p: T, …): R = expr

fun cube(n: Int): Int = n * n * n
fun main() { println(cube(3)) }   // 27

val name: T = expr

val x = 41
println(x + 1)   // 42

var name: T = expr

var i = 0
i += 1
println(i)   // 1

if (cond) { … } else { … }

val m = if (3 > 2) 3 else 2
println(m)   // 3

if (cond) { … } else { … }
when { … else -> … }

println(if (4 % 2 == 0) "even" else "odd")   // even

while (cond) { … }

var i = 0
while (i < 3) i += 1
println(i)   // 3

for (v in a..b) { … }
for (v in iterable) { … }

for (i in 1..3) print(i)      // 123
for (c in "ab") print(c)      // ab

for (v in iterable)
value in container

println(2 in 1..3)                  // true
println("b" in "abc")               // true
println("a" in mapOf("a" to 1))     // true

return
return expr

fun answer(): Int { return 42 }
fun main() { println(answer()) }

a until b

for (i in 0 until 3) print(i)   // 012

a downTo b

for (i in 3 downTo 1) print(i)   // 321

range step n

for (i in 0..10 step 5) print(i)   // 0510
println(1..10 step 3)              // 1..10 step 3

when (subject) { cond -> … else -> … }
when { boolExpr -> … }

val n = 5
println(when (n) { 1 -> "one"; in 2..9 -> "few"; else -> "many" })   // few

value is Type
value !is Type

val x: Any = "s"
println(when (x) { is String -> "str"; is Int -> "int"; else -> "?" })   // str

class Name(val p: T, …) : Super(args), Iface { … }

open class Animal(val name: String)
class Dog(n: String) : Animal(n)
fun main() { println(Dog("rex").name) }   // rex

interface Name { fun m(): T; fun d(): T = expr }

interface Greeter {
    fun greet(): String
    fun loud(): String = greet().uppercase()
}
class En : Greeter { override fun greet(): String = "hi" }
fun main() { println(En().loud()) }   // HI

object Name { … }

object Counter { var n = 0 }
fun main() { Counter.n = 5; println(Counter.n) }   // 5

data class Name(val p: T, …)

data class Pt(val x: Int, val y: Int)
fun main() { println(Pt(1, 2)) }   // Pt(x=1, y=2)

open class Name
open fun m(): T

open class Base { open fun f(): Int = 1 }
class D : Base() { override fun f(): Int = 2 }
fun main() { println(D().f()) }   // 2

override fun m(): T { … }

open class Base { open fun f(): Int = 1 }
class D : Base() { override fun f(): Int = 2 }
fun main() { val b: Base = D(); println(b.f()) }   // 2

abstract class Name
abstract fun m(): T

abstract class Shape { abstract fun area(): Double }
class Sq(val s: Double) : Shape() { override fun area(): Double = s * s }
fun main() { println(Sq(3.0).area()) }   // 9.0

sealed class Name

sealed class Expr
data class Num(val v: Int) : Expr()
fun main() { val e: Expr = Num(3); println(when (e) { is Num -> e.v; else -> 0 }) }   // 3

final fun m(): T

open class B { open fun f(): Int = 1 }
class C : B() { final override fun f(): Int = 2 }
fun main() { println(C().f()) }   // 2

private fun m()
private class C

private class Box(val v: Int)
fun main() { println(Box(7).v) }   // 7

inner class C

class Holder(val v: Int)
fun main() { println(Holder(1).v) }   // 1

super.m(args)
super<T>.m(args)

open class B { open fun f(): Int = 1 }
class D : B() { override fun f(): Int = super.f() + 1 }
fun main() { println(D().f()) }   // 2

this
this.property

class P(val x: Int) { fun twice(): Int = this.x * 2 }
fun main() { println(P(4).twice()) }   // 8

{ it }

println(listOf(1, 2, 3).map { it * 2 })   // [2, 4, 6]

break
break@label

for (i in 1..9) { if (i == 3) break; print(i) }   // 12

continue
continue@label

outer@ for (i in 1..2) { for (j in 1..3) { if (j == 2) continue@outer; print("$i$j") } }   // 1121

try { … } catch (e: T) { … } finally { … }

val n = try { 1 / 0 } catch (e: ArithmeticException) { -1 }
println(n)   // -1

catch (name: Type) { … }

try { "x".substring(9) } catch (e: Exception) { println(e.message) }

finally { … }

try { println("work") } finally { println("done") }

throw expr

val x: Int? = null
val v = x ?: throw IllegalStateException("missing")
// Exception in thread "main" java.lang.IllegalStateException: missing

null

val x: Int? = null
println(x ?: 0)   // 0

true

val ok: Boolean = true
println(ok)   // true

false

val done: Boolean = false
println(!done)   // true

import a.b.c
import a.b.*
import a.b.c as alias

import kotlin.math.*
fun main() { println(sqrt(9.0)) }   // 3.0

package a.b

package demo
fun main() { println("ok") }

import a.b.c as alias

import kotlin.math.abs as absolute
fun main() { println(absolute(-4)) }   // 4

rust { … }

fun main() {
    rust { #[no_mangle] pub extern "C" fn twice(n: i64) -> i64 { n * 2 } }
    println(twice(21))   // 42
}

class C { companion object { val K = 7; fun of(…): C = … } }

class C { companion object { val K = 7 } }
println(C.K)   // 7

fun f(vararg xs: T)

fun total(vararg xs: Int): Int { var t = 0; for (x in xs) t += x; return t }
println(total(1, 2, 3))   // 6

val name: T by lazy { … }

val z: Int by lazy { println("forcing"); 42 }
fun main() { println("before"); println(z); println(z) }

a + b

println(1 + 2)          // 3
println("a" + "b")      // ab
println('A' + 1)        // B

a - b
-a

println(5 - 2)          // 3
println('c' - 'a')      // 2

a * b

println(6 * 7)   // 42

a / b

println(7 / 2)       // 3
println(7 / 2.0)     // 3.5

a % b

println(7 % 3)    // 1
println(-7 % 3)   // -1

name = value
recv.prop = value
recv[i] = value

var i = 1
i = 2
val m = mutableMapOf<String, Int>()
m["a"] = 1
println("$i ${m["a"]}")   // 2 1

target += value

var s = "a"
s += "b"
println(s)   // ab

target -= value

var n = 5
n -= 2
println(n)   // 3

target *= value

var n = 6
n *= 7
println(n)   // 42

target /= value

var n = 9
n /= 2
println(n)   // 4

target %= value

var n = 9
n %= 4
println(n)   // 1

x++
++x

var k = 0
println(k++)   // 0
println(++k)   // 2

x--
--x

var k = 2
println(k--)   // 2
println(k)     // 1

a == b

println(listOf(1, 2) == listOf(1, 2))   // true
println(setOf(1, 2) == setOf(2, 1))     // true

a != b

println(1 != 2)   // true

a === b

println(listOf(1) === listOf(1))   // false
println(listOf(1) == listOf(1))    // true
val a = mutableListOf(1)
println(a === a)                   // true

a !== b

println(listOf(1) !== listOf(1))   // true

a < b

println(1 < 2)       // true
println('a' < 'z')   // true

a > b

println(3 > 2)   // true

a <= b

println(2 <= 2)   // true

a >= b

println(2 >= 3)   // false

a && b

val xs = listOf(1)
println(xs.isNotEmpty() && xs[0] == 1)   // true

a || b

println(false || 1 < 2)   // true

!a

println(!(1 > 2))   // true

a..b

val r = 1..5
println(r.sum())   // 15

recv?.member
recv?.method(args)

val s: String? = null
println(s?.length)   // null

a ?: b

val x: Int? = null
println(x ?: 0)   // 0

::fn
Type::member
receiver::member

fun inc(x: Int) = x + 1
println(listOf(1, 2).map(::inc))            // [2, 3]
println(listOf("aa", "b").map(String::length))   // [2, 1]

expr!!

val x: Int? = 1
println(x!! + 1)   // 2

T?

val x: Int? = null
println(x)   // null

recv[index]

println("abc"[1])                 // b
println(listOf(10, 20)[1])        // 20
println(mapOf("a" to 1)["z"])     // null

recv[index] = value

val xs = mutableListOf(1, 2)
xs[0] = 9
println(xs)   // [9, 2]

{ params -> body }
cond -> result

val f: (Int) -> Int = { n -> n * 2 }
println(f(21))   // 42

label@ for (…) { … }
break@label

outer@ for (i in 1..3) { for (j in 1..3) { if (j == 2) continue@outer; print(i) } }   // 123

"text $name text ${expr}"

val x = 2
println("x=$x sq=${x * x}")   // x=2 sq=4

first to second

val p = 1 to "one"
println(p.first)   // 1

value !in container

println(4 !in 1..3)   // true

value !is Type

val x: Any = 1
println(x !is String)   // true

recv.member
recv.method(args)

println(listOf(1, 2, 3).size)   // 3

name: Type
class C : Super(), Iface

val n: Int = 1
println(n)   // 1

stmt; stmt

var a = 1; a += 1; println(a)   // 2

value as T
value as? T

val a: Any = 5
println((a as Int) / 2)   // 2
println(a as? String)     // null

Int

val n: Int = 7 / 2
println(n)              // 3
println(Int.MAX_VALUE + 1)   // -2147483648

Long

val big: Long = 10L
println(big)                 // 10
println(2147483647L + 1L)    // 2147483648

Double

println(3.0)          // 3.0
println(1.0 / 0.0)    // Infinity

Float

val f: Float = 1.5f
println(f)   // 1.5

Boolean

val b: Boolean = 1 < 2
println(b)   // true

Char

val c: Char = 'A'
println(c + 1)         // B
println(listOf(c))     // [A]

String

val s: String = "n = ${1 + 1}"
println(s)   // n = 2

Unit

fun log(): Unit { println("hi") }
fun main() { log() }

Any

val x: Any = "s"
println(x is String)   // true

List<T>

val xs: List<Int> = listOf(1, 2, 3)
println(xs)   // [1, 2, 3]

MutableList<T>

val xs: MutableList<Int> = mutableListOf(1)
xs.add(2)
println(xs)   // [1, 2]

Set<T>

println(setOf(3, 1, 3))   // [3, 1]

MutableSet<T>

val s: MutableSet<Int> = mutableSetOf(1)
println(s.add(1))   // false

Map<K, V>

val m: Map<String, Int> = mapOf("a" to 1)
println(m)   // {a=1}

MutableMap<K, V>

val m: MutableMap<String, Int> = mutableMapOf()
m["a"] = 1
println(m)   // {a=1}

Pair<A, B>

val p: Pair<Int, String> = 1 to "one"
println(p.second)   // one

Array<T>

val a: Array<Int> = arrayOf(1, 2, 3)
println(a[1])              // 2
println(a.joinToString())  // 1, 2, 3

IntArray

val a: IntArray = IntArray(3)
println(a.sum())   // 0

IntRange

val r: IntRange = 1..5
println(r.sum())        // 15
println(r.reversed())   // 5 downTo 1 step 1

Nothing

fun fail(): Nothing = throw IllegalStateException("no")
fun main() { println(try { fail() } catch (e: Exception) { "caught" }) }

println()
println(value: Any?)

println(6 * 7)   // 42

print()
print(value: Any?)

print("a"); print("b")   // ab

listOf(vararg elements: T): List<T>

val xs = listOf(1, 2, 3)
println(xs.size)   // 3

mutableListOf(vararg elements: T): MutableList<T>

val xs = mutableListOf(1)
xs.add(2)
println(xs)   // [1, 2]

arrayListOf(vararg elements: T): MutableList<T>

println(arrayListOf(1, 2))   // [1, 2]

emptyList(): List<T>

println(emptyList<Int>())   // []

setOf(vararg elements: T): Set<T>

println(setOf(3, 1, 3))   // [3, 1]

mutableSetOf(vararg elements: T): MutableSet<T>

val s = mutableSetOf(1)
println(s.add(2))   // true

hashSetOf(vararg elements: T): MutableSet<T>

println(hashSetOf(3, 1))   // [1, 3]

linkedSetOf(vararg elements: T): MutableSet<T>

println(linkedSetOf(2, 1))   // [2, 1]

sortedSetOf(vararg elements: T): MutableSet<T>

println(sortedSetOf(3, 1, 2))   // [1, 2, 3]

emptySet(): Set<T>

println(emptySet<Int>())   // []

mapOf(vararg pairs: Pair<K, V>): Map<K, V>

val m = mapOf("a" to 1, "b" to 2)
println(m["a"])   // 1

mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

val m = mutableMapOf("a" to 1)
m["b"] = 2
println(m)   // {a=1, b=2}

hashMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

println(hashMapOf("b" to 1, "a" to 2))   // {a=2, b=1}

HashMap(): MutableMap<K, V> / HashMap(other: Map<K, V>): MutableMap<K, V>

val m = HashMap<String, Int>()
m["a"] = 1
println(m)   // {a=1}

LinkedHashMap(): MutableMap<K, V> / LinkedHashMap(other: Map<K, V>): MutableMap<K, V>

println(LinkedHashMap(mapOf("b" to 2)))   // {b=2}

HashSet(): MutableSet<T> / HashSet(other: Collection<T>): MutableSet<T>

println(HashSet(listOf(3, 1)))   // [1, 3]

LinkedHashSet(): MutableSet<T> / LinkedHashSet(other: Collection<T>): MutableSet<T>

println(LinkedHashSet(listOf(3, 1)))   // [3, 1]

TreeSet(): MutableSet<T> / TreeSet(other: Collection<T>): MutableSet<T>

println(TreeSet(listOf(3, 1, 2)))   // [1, 2, 3]

ArrayList(): MutableList<T> / ArrayList(other: Collection<T>): MutableList<T>

println(ArrayList(listOf(3, 1)))   // [3, 1]

emptyMap(): Map<K, V>

println(emptyMap<String, Int>())   // {}

arrayOf(vararg elements: T): Array<T>

val a = arrayOf(1, 2, 3)
println(a[1])   // 2

intArrayOf(vararg elements: Int): IntArray

println(intArrayOf(1, 2).sum())   // 3

doubleArrayOf(vararg elements: Double): DoubleArray

println(doubleArrayOf(1.5, 2.5).sum())   // 4.0

booleanArrayOf(vararg elements: Boolean): BooleanArray

println(booleanArrayOf(true, false).size)   // 2

charArrayOf(vararg elements: Char): CharArray

println(charArrayOf('a', 'b').joinToString(""))   // ab

IntArray(size: Int): IntArray
IntArray(size: Int) { i -> … }: IntArray

println(IntArray(3).sum())              // 0
println(IntArray(3) { it * 2 }.sum())   // 6

DoubleArray(size: Int): DoubleArray
DoubleArray(size: Int) { i -> … }: DoubleArray

println(DoubleArray(2).sum())   // 0.0

BooleanArray(size: Int): BooleanArray
BooleanArray(size: Int) { i -> … }: BooleanArray

println(BooleanArray(3).size)   // 3

CharArray(size: Int): CharArray
CharArray(size: Int) { i -> … }: CharArray

println(CharArray(2).size)   // 2

Array(size: Int) { i -> … }: Array<T>

println(Array(3) { it * 2 }.joinToString())   // 0, 2, 4

StringBuilder()
StringBuilder(text: CharSequence)
StringBuilder(capacity: Int)

val sb = StringBuilder()
sb.append("a").append(1).append(true)
println(sb)          // a1true
println(sb.length)   // 6

buildString(block: StringBuilder.() -> Unit): String
buildString(capacity: Int, block: StringBuilder.() -> Unit): String

println(buildString { append("a"); append(1) })   // a1

buildList(block: MutableList<T>.() -> Unit): List<T>

println(buildList { add(1); addAll(listOf(2, 3)) })   // [1, 2, 3]

listOfNotNull(vararg elements: T?): List<T>

println(listOfNotNull(1, null, 3))   // [1, 3]

repeat(times: Int, action: (Int) -> Unit)

repeat(3) { print(it) }   // 012

require(value: Boolean)
require(value: Boolean, lazyMessage: () -> Any)
requireNotNull(value: T?): T

try { require(1 > 2) { "bad input" } } catch (e: Exception) { println(e.message) }   // bad input

check(value: Boolean)
check(value: Boolean, lazyMessage: () -> Any)
checkNotNull(value: T?): T
error(message: Any): Nothing

try { check(false) } catch (e: Exception) { println(e.message) }   // Check failed.

TODO(): Nothing
TODO(reason: String): Nothing

try { TODO("later") } catch (e: Throwable) { println(e) }   // kotlin.NotImplementedError: An operation is not implemented: later

abs(n: Int): Int
abs(x: Double): Double

import kotlin.math.abs
fun main() { println(abs(-3)) }   // 3

sqrt(x: Double): Double

import kotlin.math.sqrt
fun main() { println(sqrt(9.0)) }   // 3.0

floor(x: Double): Double

import kotlin.math.floor
fun main() { println(floor(-1.5)) }   // -2.0

ceil(x: Double): Double

import kotlin.math.ceil
fun main() { println(ceil(1.2)) }   // 2.0

round(x: Double): Double

import kotlin.math.round
fun main() { println(round(2.5)) }   // 2.0

max(a: Int, b: Int): Int
max(a: Double, b: Double): Double

import kotlin.math.max
fun main() { println(max(2, 9)) }   // 9

min(a: Int, b: Int): Int
min(a: Double, b: Double): Double

import kotlin.math.min
fun main() { println(min(2, 9)) }   // 2

maxOf(a: T, b: T): T

println(maxOf(2, 9))   // 9

minOf(a: T, b: T): T

println(minOf(2, 9))   // 2

PI: Double

import kotlin.math.PI
fun main() { println(PI) }   // 3.141592653589793

E: Double

import kotlin.math.E
fun main() { println(E) }   // 2.718281828459045

Math.abs(…)  Math.max(…)  Math.min(…)
Math.sqrt(…)  Math.floor(…)  Math.ceil(…)
Math.round(…)  Math.PI  Math.E

println(Math.abs(-3))   // 3

Math.round(x: Double): Long

println(Math.round(2.5))   // 3

Throwable()
Throwable(message: String)

try { throw Throwable("boom") } catch (e: Throwable) { println(e.message) }   // boom

Exception()
Exception(message: String)

try { 1 / 0 } catch (e: Exception) { println("caught") }   // caught

Error()
Error(message: String)

try { throw Error("fatal") } catch (e: Throwable) { println("caught") }   // caught

RuntimeException()
RuntimeException(message: String)

try { throw RuntimeException("x") } catch (e: RuntimeException) { println(e.message) }   // x

ArithmeticException(message: String)

try { 1 / 0 } catch (e: ArithmeticException) { println(e.message) }   // / by zero

IllegalArgumentException(message: String)

try { listOf(1).take(-1) } catch (e: IllegalArgumentException) { println("caught") }   // caught

IllegalStateException(message: String)

val x: Int? = null
try { x ?: throw IllegalStateException("missing") } catch (e: Exception) { println(e.message) }

NumberFormatException(message: String)

try { throw NumberFormatException("bad") } catch (e: IllegalArgumentException) { println("caught") }

IndexOutOfBoundsException(message: String)

try { mutableListOf(1).removeAt(5) } catch (e: IndexOutOfBoundsException) { println("caught") }

StringIndexOutOfBoundsException(message: String)

try { "abc".substring(9) } catch (e: Exception) { println(e.message) }

ArrayIndexOutOfBoundsException(message: String)

try { listOf(1, 2)[5] } catch (e: Exception) { println(e.message) }

NullPointerException()
NullPointerException(message: String)

val x: Int? = null
try { x!! } catch (e: NullPointerException) { println("caught") }

ClassCastException(message: String)

try { throw ClassCastException("x") } catch (e: RuntimeException) { println("caught") }

UnsupportedOperationException(message: String)

try { listOf<Int>().reduce { a, b -> a + b } } catch (e: Exception) { println("caught") }

NegativeArraySizeException(message: String)

try { IntArray(-1) } catch (e: Exception) { println("caught") }

NoSuchElementException(message: String)

try { listOf<Int>().first() } catch (e: NoSuchElementException) { println(e.message) }

String.length: Int

println("abc".length)   // 3

String.uppercase(): String

println("abc".uppercase())   // ABC

String.toUpperCase(): String

println("abc".toUpperCase())   // ABC

String.lowercase(): String

println("ABC".lowercase())   // abc

String.toLowerCase(): String

println("ABC".toLowerCase())   // abc

String.trim(): String

println("  hi  ".trim())   // hi

String.isEmpty(): Boolean

println("".isEmpty())   // true

String.isNotEmpty(): Boolean

println("a".isNotEmpty())   // true

String.isBlank(): Boolean

println("  ".isBlank())   // true

String.isNotBlank(): Boolean

println(" x ".isNotBlank())   // true

String.contains(other: Any): Boolean

println("abc".contains("bc"))   // true
println("abc".contains('b'))     // true

String.startsWith(prefix: Any): Boolean

println("abc".startsWith("ab"))   // true

String.endsWith(suffix: Any): Boolean

println("abc".endsWith("bc"))   // true

String.plus(other: Any): String

println("ab".plus("c"))   // abc

String.replace(old: Any, new: Any): String

println("a-b-c".replace("-", "+"))   // a+b+c

String.repeat(n: Int): String

println("ab".repeat(2))   // abab

String.indexOf(needle: Any): Int

println("abc".indexOf("c"))   // 2

String.substring(start: Int): String
String.substring(start: Int, end: Int): String

println("hello".substring(1, 3))   // el

Char.code: Int

println('A'.code)   // 65

Char.digitToInt(): Int

println('7'.digitToInt())   // 7

Char.isDigit(): Boolean

println('7'.isDigit())   // true

Char.isLetter(): Boolean

println('a'.isLetter())   // true

Char.isLetterOrDigit(): Boolean

println('_'.isLetterOrDigit())   // false

Char.isWhitespace(): Boolean

println(' '.isWhitespace())   // true

Char.isUpperCase(): Boolean

println('A'.isUpperCase())   // true

Char.isLowerCase(): Boolean

println('a'.isLowerCase())   // true

Char.uppercaseChar(): Char

println('a'.uppercaseChar())   // A

Char.lowercaseChar(): Char

println('A'.lowercaseChar())   // a

Char.uppercase(): String

println('a'.uppercase())   // A

Char.lowercase(): String

println('A'.lowercase())   // a

Char.compareTo(other: Char): Int

println('b'.compareTo('a'))   // 1

Char.plus(n: Int): Char

println('A'.plus(1))   // B

Char.minus(n: Int): Char
Char.minus(other: Char): Int

println('c'.minus(1))     // b
println('c'.minus('a'))   // 2

Char.equals(other: Any?): Boolean

println('a'.equals('a'))   // true

Char.hashCode(): Int

println('A'.hashCode())   // 65

Char.toString(): String

println('A'.toString() + "!")   // A!

size: Int

println(listOf(1, 2, 3).size)   // 3

count(): Int

println((1..5).count())   // 5

isEmpty(): Boolean

println(emptyList<Int>().isEmpty())   // true

isNotEmpty(): Boolean

println(listOf(1).isNotEmpty())   // true

first(): T

println(listOf(10, 20).first())   // 10

last(): T

println(listOf(10, 20).last())   // 20

get(index: Int): T

println(listOf(10, 20).get(1))   // 20

contains(element: T): Boolean

println(listOf(1, 2).contains(2))   // true

containsAll(elements: Collection<T>): Boolean

println(listOf(1, 2, 3).containsAll(listOf(1, 3)))   // true

indexOf(element: T): Int

println(listOf("a", "b").indexOf("b"))   // 1

sum(): Int
sum(): Double

println(listOf(1, 2, 3).sum())   // 6

average(): Double

println(listOf(1, 2).average())   // 1.5

max(): T

println(listOf(3, 1, 2).max())   // 3

min(): T

println(listOf(3, 1, 2).min())   // 1

toList(): List<T>

println((1..3).toList())   // [1, 2, 3]

toMutableList(): MutableList<T>

println(setOf(1, 2).toMutableList())   // [1, 2]

toTypedArray(): Array<T>

println(listOf(1, 2).toTypedArray())   // [1, 2]

asList(): List<T>

println(intArrayOf(1, 2).asList())   // [1, 2]

toSet(): Set<T>

println(listOf(3, 1, 3).toSet())   // [3, 1]

toMutableSet(): MutableSet<T>

println(listOf(1, 1).toMutableSet())   // [1]

toHashSet(): MutableSet<T>

println(listOf(2, 1, 2).toHashSet())   // [2, 1]

distinct(): List<T>

println(listOf(3, 1, 3).distinct())   // [3, 1]

plus(element: T): List<T> / plus(elements: Iterable<T>): List<T>

println(listOf(1, 2) + 3)   // [1, 2, 3]

minus(element: T): List<T> / minus(elements: Iterable<T>): List<T>

println(listOf(1, 2, 3) - 2)   // [1, 3]

plusElement(element: T): List<T>

println(listOf(1, 2).plusElement(listOf(3)))   // [1, 2, [3]]

minusElement(element: T): List<T>

println(listOf(1, 2, 2).minusElement(2))   // [1, 2]

union(other: Iterable<T>): Set<T>

println(listOf(1, 2).union(listOf(2, 3)))   // [1, 2, 3]

intersect(other: Iterable<T>): Set<T>

println(listOf(1, 2, 3).intersect(listOf(2, 3, 4)))   // [2, 3]

subtract(other: Iterable<T>): Set<T>

println(listOf(1, 2, 3).subtract(listOf(2)))   // [1, 3]

sorted(): List<T>

println(listOf(3, 1, 2).sorted())   // [1, 2, 3]

sortedDescending(): List<T>

println(listOf(3, 1, 2).sortedDescending())   // [3, 2, 1]

take(n: Int): List<T>

println(listOf(1, 2, 3).take(2))   // [1, 2]

takeLast(n: Int): List<T>

println(listOf(1, 2, 3).takeLast(2))   // [2, 3]
println("abcde".takeLast(2))            // de

drop(n: Int): List<T>

println(listOf(1, 2, 3).drop(1))   // [2, 3]

dropLast(n: Int): List<T>

println(listOf(1, 2, 3).dropLast(1))   // [1, 2]
println("abcde".dropLast(2))            // abc

generateSequence(seed: T?, next: (T) -> T?): Sequence<T>

println(generateSequence(1) { it * 2 }.take(5).toList())                     // [1, 2, 4, 8, 16]
println(generateSequence(1) { if (it < 20) it * 2 else null }.toList())      // [1, 2, 4, 8, 16, 32]

String.splitToSequence(vararg delimiters: String): Sequence<String>

println("a,b,c".splitToSequence(",").toList())   // [a, b, c]

unzip(): Pair<List<A>, List<B>>

println(listOf(1 to "a", 2 to "b").unzip())   // ([1, 2], [a, b])

zipWithNext(): List<Pair<T, T>>
zipWithNext(transform: (T, T) -> R): List<R>

println(listOf(1, 2, 3).zipWithNext())                  // [(1, 2), (2, 3)]
println(listOf(1, 2, 3).zipWithNext { a, b -> a + b })   // [3, 5]

joinToString(): String
joinToString(separator: Any): String

println(listOf(1, 2, 3).joinToString("-"))   // 1-2-3

reversed(): List<T>
IntRange.reversed(): IntProgression

println(listOf(1, 2, 3).reversed())   // [3, 2, 1]
println((1..3).reversed())            // 3 downTo 1 step 1

MutableList.add(element: T): Boolean
MutableSet.add(element: T): Boolean

val s = mutableSetOf(1)
println(s.add(1))   // false
println(s.add(2))   // true

MutableList.remove(element: T): Boolean
MutableSet.remove(element: T): Boolean
MutableMap.remove(key: K): Boolean

val xs = mutableListOf(1, 2)
println(xs.remove(1))   // true
println(xs)             // [2]

MutableList.removeAt(index: Int): T

val xs = mutableListOf(1, 2)
println(xs.removeAt(0))   // 1

MutableCollection<T>.addAll(elements: Collection<T>): Boolean
MutableCollection<T>.removeAll(elements: Collection<T>): Boolean
MutableCollection<T>.retainAll(elements: Collection<T>): Boolean

val xs = mutableListOf(1, 2)
println(xs.addAll(listOf(3)))   // true
println(xs)                    // [1, 2, 3]

Map.size: Int

println(mapOf("a" to 1, "b" to 2).size)   // 2

Map.isEmpty(): Boolean

println(emptyMap<String, Int>().isEmpty())   // true

Map.isNotEmpty(): Boolean

println(mapOf("a" to 1).isNotEmpty())   // true

Map.containsKey(key: K): Boolean

println(mapOf("a" to 1).containsKey("a"))   // true

Map.get(key: K): V?

println(mapOf("a" to 1).get("z"))   // null

Map.keys: Set<K>

println(mapOf("a" to 1, "b" to 2).keys)   // [a, b]

Map.values: List<V>

println(mapOf("a" to 1, "b" to 2).values)   // [1, 2]

Map.toList(): List<Pair<K, V>>

println(mapOf(1 to "a", 2 to "b").toList())   // [(1, a), (2, b)]

Map.filterKeys(predicate: (K) -> Boolean): Map<K, V>

println(mapOf(1 to "a", 2 to "b").filterKeys { it > 1 })   // {2=b}

Map.filterValues(predicate: (V) -> Boolean): Map<K, V>

println(mapOf(1 to "a", 2 to "b").filterValues { it == "a" })   // {1=a}

Map.toSortedMap(): Map<K, V>

println(mapOf(2 to "b", 1 to "a").toSortedMap())   // {1=a, 2=b}

MutableMap.put(key: K, value: V): V?

val m = mutableMapOf("a" to 1)
println(m.put("a", 2))   // 1

MutableMap.remove(key: K): Boolean

val m = mutableMapOf("a" to 1)
println(m.remove("a"))   // true

Pair.first: A

println((1 to "one").first)   // 1

Pair.second: B

println((1 to "one").second)   // one

Int.plus(other: Int): Int
Double.plus(other: Double): Double

println(2.plus(3))   // 5

Int.minus(other: Int): Int
Double.minus(other: Double): Double

println(5.minus(2))   // 3

Int.times(other: Int): Int
Double.times(other: Double): Double

println(6.times(7))   // 42

Int.div(other: Int): Int
Double.div(other: Double): Double

println(7.div(2))     // 3
println(2.5.div(2.0)) // 1.25

Int.rem(other: Int): Int
Double.rem(other: Double): Double

println(7.rem(2))   // 1

Int.toDouble(): Double
Double.toDouble(): Double

println(3.toDouble())   // 3.0

Int.toInt(): Int
Long.toInt(): Int
Double.toInt(): Int
String.toInt(): Int

println(3.9.toInt())            // 3
println(2147483648L.toInt())    // -2147483648

Int.toLong(): Long
Double.toLong(): Long
String.toLong(): Long

println(3.9.toLong())                // 3
println(2147483647.toLong() + 1L)    // 2147483648

Int.toShort(): Short

println(32768.toShort())   // -32768

Int.toByte(): Byte

println(200.toByte())   // -56

Int.toChar(): Char

println(65.toChar())   // A

Any.toString(): String

println(listOf(1, 2).toString())   // [1, 2]

Any.hashCode(): Int

data class Pt(val x: Int, val y: Int)
fun main() { println(Pt(1, 2).hashCode() == Pt(1, 2).hashCode()) }   // true

Any.equals(other: Any?): Boolean

println(listOf(1).equals(listOf(1)))   // true

component1(): T  component2(): T  …

data class Pt(val x: Int, val y: Int)
fun main() { val (a, b) = Pt(1, 2); println("$a $b") }   // 1 2

copy(vararg overrides: Any): T

data class Pt(val x: Int, val y: Int)
fun main() { println(Pt(1, 2).copy(9)) }   // Pt(x=9, y=2)

Throwable.message: String?

try { 1 / 0 } catch (e: Exception) { println(e.message) }   // / by zero

map(transform: (T) -> R): List<R>

println(listOf(1, 2, 3).map { it * 2 })   // [2, 4, 6]

mapIndexed(transform: (Int, T) -> R): List<R>

println(listOf(1, 2, 3).mapIndexed { i, v -> i * v })   // [0, 2, 6]

flatMap(transform: (T) -> Iterable<R>): List<R>

println(listOf(1, 2).flatMap { listOf(it, it) })   // [1, 1, 2, 2]

flatMapIndexed(transform: (Int, T) -> Iterable<R>): List<R>

println(listOf(1, 2).flatMapIndexed { i, v -> listOf(i, v) })   // [0, 1, 1, 2]

mapNotNull(transform: (T) -> R?): List<R>

println(listOf(1, 2, 3).mapNotNull { if (it > 1) it else null })   // [2, 3]

onEach(action: (T) -> Unit): C

println(listOf(1, 2).onEach { print(it) }.size)   // 122

runningFold(initial: R, operation: (R, T) -> R): List<R>

println(listOf(1, 2, 3).runningFold(0) { a, n -> a + n })   // [0, 1, 3, 6]

runningReduce(operation: (T, T) -> T): List<T>

println(listOf(1, 2, 3).runningReduce { a, n -> a + n })   // [1, 3, 6]

withIndex(): List<IndexedValue<T>>

println("ab".withIndex().map { it.index.toString() + it.value })   // [0a, 1b]

filter(predicate: (T) -> Boolean): List<T>

println(listOf(1, 2, 3, 4).filter { it % 2 == 0 })   // [2, 4]

filterNot(predicate: (T) -> Boolean): List<T>

println(listOf(1, 2, 3).filterNot { it > 2 })   // [1, 2]

forEach(action: (T) -> Unit): Unit

listOf(1, 2).forEach { print(it) }   // 12

fold(initial: R, operation: (R, T) -> R): R

println(listOf(1, 2, 3).fold(0) { acc, n -> acc + n })   // 6

foldRight(initial: R, operation: (T, R) -> R): R

println(listOf(1, 2, 3).foldRight("") { a, b -> "$a$b" })   // 123

reduce(operation: (T, T) -> T): T

println(listOf(1, 2, 3).reduce { a, b -> a * b })   // 6

reduceRight(operation: (T, T) -> T): T

println(listOf(1, 2, 3).reduceRight { a, b -> a - b })   // 2

any(predicate: (T) -> Boolean): Boolean

println(listOf(1, 2, 3).any { it > 2 })   // true

all(predicate: (T) -> Boolean): Boolean

println(listOf(2, 4).all { it % 2 == 0 })   // true

none(predicate: (T) -> Boolean): Boolean

println(listOf(1, 2).none { it > 5 })   // true

count(predicate: (T) -> Boolean): Int

println(listOf(1, 2, 3).count { it > 1 })   // 2

sumOf(selector: (T) -> Int): Int
sumOf(selector: (T) -> Double): Double

println(listOf("ab", "c").sumOf { it.length })   // 3

maxByOrNull(selector: (T) -> R): T?

println(listOf("a", "abc").maxByOrNull { it.length })   // abc

minByOrNull(selector: (T) -> R): T?

println(listOf("abc", "a").minByOrNull { it.length })   // a

sortedBy(selector: (T) -> R): List<T>

println(listOf("abc", "a").sortedBy { it.length })   // [a, abc]

sortedByDescending(selector: (T) -> R): List<T>

println(listOf("a", "abc").sortedByDescending { it.length })   // [abc, a]

sortedWith(comparator: Comparator<T>): List<T>
sortedWith(compare: (T, T) -> Int): List<T>

println(listOf(3, 1, 2).sortedWith(compareBy { it }))       // [1, 2, 3]
println(listOf(3, 1, 2).sortedWith { a, b -> b - a })       // [3, 2, 1]

compareBy(vararg selectors: (T) -> R): Comparator<T>

println(listOf(3, 1, 2).sortedWith(compareBy { it }))   // [1, 2, 3]

compareByDescending(vararg selectors: (T) -> R): Comparator<T>

println(listOf(1, 3, 2).sortedWith(compareByDescending { it }))   // [3, 2, 1]

Comparator<T>.thenBy(selector: (T) -> R): Comparator<T>

val byLen = compareBy<String> { it.length }
println(listOf("cc", "a", "bb").sortedWith(byLen.thenBy { it }))   // [a, bb, cc]

Comparator<T>.thenByDescending(selector: (T) -> R): Comparator<T>

val byLen = compareBy<String> { it.length }
println(listOf("cc", "a", "bb").sortedWith(byLen.thenByDescending { it }))   // [a, cc, bb]

associate(transform: (T) -> Pair<K, V>): Map<K, V>

println(listOf(1, 2).associate { it to it * it })   // {1=1, 2=4}

associateBy(keySelector: (T) -> K): Map<K, T>

println(listOf("ab", "c").associateBy { it.length })   // {2=ab, 1=c}

associateWith(valueSelector: (T) -> V): Map<T, V>

println(listOf(1, 2, 3).associateWith { it * 2 })   // {1=2, 2=4, 3=6}

groupBy(keySelector: (T) -> K): Map<K, List<T>>

println(listOf(1, 2, 3, 4).groupBy { it % 2 })   // {1=[1, 3], 0=[2, 4]}

groupingBy(keySelector: (T) -> K): Grouping<T, K>

println(listOf(1, 2, 3, 4).groupingBy { it % 2 }.eachCount())   // {1=2, 0=2}

eachCount(): Map<K, Int>

println(listOf("a", "bb", "cc").groupingBy { it.length }.eachCount())   // {1=1, 2=2}

T.let(block: (T) -> R): R

println(listOf(1, 2).let { it.size })   // 2

T.also(block: (T) -> Unit): T

println(listOf(1, 2).also { print(it.size) })   // 2[1, 2]

T.takeIf(predicate: (T) -> Boolean): T?

println(5.takeIf { it > 3 })   // 5
println(2.takeIf { it > 3 })   // null

T.takeUnless(predicate: (T) -> Boolean): T?

println(5.takeUnless { it > 3 })   // null
println(2.takeUnless { it > 3 })   // 2

T.run(block: T.() -> R): R
run(block: () -> R): R

println("abc".run { length })   // 3
println(run { 1 + 2 })         // 3

T.apply(block: T.() -> Unit): T

class Box(var w: Int)
println(Box(1).apply { w = 5 }.w)   // 5

with(receiver: T, block: T.() -> R): R

println(with("hello") { uppercase() + length })   // HELLO5

runCatching(block: () -> T): Result<T>

println(runCatching { 6 / 2 })   // Success(3)
println(runCatching { 1 / 0 }.isFailure)   // true

Result<T>.getOrNull(): T?

println(runCatching { 6 / 2 }.getOrNull())   // 3
println(runCatching { 1 / 0 }.getOrNull())   // null

Result<T>.getOrElse(onFailure: (Throwable) -> T): T

println(runCatching { 1 / 0 }.getOrElse { -1 })   // -1

Result<T>.isSuccess: Boolean
Result<T>.isFailure: Boolean

println(runCatching { 6 / 2 }.isSuccess)   // true
println(runCatching { 6 / 2 }.map { it + 1 })   // Success(4)