Kotlin

https://kotlinlang.org/spec/kotlin-spec.html
Admin
Kotlin is a multiplatform, statically typed, general-purpose programming language designed to...
Tokens:126,999
Snippets:807
Trust Score:9.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Constructor delegation examples

Source: https://kotlinlang.org/spec/kotlin-spec.html

Illustrates constructor delegation rules: classes without a primary constructor can delegate to super or another secondary constructor; classes with a primary constructor must delegate to primary or secondary via this(...). Includes commented-out error and valid delegation examples.

```kotlin
open class Base

class POKO : Base() {}

class NotQuitePOKO : Base {
    constructor() : super() {}
}

class Primary(val s: String) : Base() {
    constructor(i: Int) : this(i.toString()) {}

    constructor(d: Double) : this(d.toInt()) {}

    // Error, has primary ctor,
    //   needs to delegate to primary or secondary ctor
    // constructor() : super() {}
}

class Secondary : Base {
    constructor(i: Int) : super() {}

    constructor(s: String) : this(s.toInt()) {}

    // Ok, no primary ctor,
    //   can delegate to `super(...)`
    constructor() : super() {}
}
```

--------------------------------

### Type capturing example with bounded type parameter

Source: https://kotlinlang.org/spec/kotlin-spec.html

Illustrates type capturing with a bounded type parameter and contravariant type argument. The example defines invariant, covariant, and contravariant interfaces, then uses a bounded interface to show how a contravariant argument leads to a captured type with bounds B <: KB <: A, enabling the assignment to Root<in C>.

```kotlin
interface Inv<T>
interface Out<out T>
interface In<in T>

interface Root<T>

interface A
interface B : A
interface C : B

fun <T> mk(): T = TODO()

interface Bounded<T : A> : Root<T>

fun test01() {

    val bounded: Bounded<in B> = mk()

    // Bounded<in B> <: Bounded<KB> where B <: KB <: A
    //   (from type capturing)
    // Bounded<KB> <: Root<KB>
    //   (from supertype relation)

    val test: Root<in C> = bounded
```

--------------------------------

### Enum class example with implicit members and overrides

Source: https://kotlinlang.org/spec/kotlin-spec.html

This example shows a simple enum class State with three entries and demonstrates the implicit members: name, ordinal, comparison, toString, valueOf, and values. It also shows an enum class Direction with additional declarations and overridden properties in its entries.

```kotlin
enum class State { LIQUID, SOLID, GAS }

...
State.SOLID.name // "SOLID"
State.SOLID.ordinal // 1
State.GAS > State.LIQUID // true
State.SOLID.toString() // "SOLID"
State.valueOf("SOLID") // State.SOLID
State.valueOf("Foo") // throws exception
State.values() // arrayOf(State.LIQUID, State.SOLID, State.GAS)

...

// enum class can have additional declarations that may be overridden in its values:
enum class Direction(val symbol: Char) {
    UP('^') {
        override val opposite: Direction
            get() = DOWN
    },
    DOWN('v') {
        override val opposite: Direction
            get() = UP
    },
    LEFT('<') {
        override val opposite: Direction
            get() = RIGHT
    },
    RIGHT('>') {
        override val opposite: Direction
            get() = LEFT
    };
    abstract val opposite: Direction
}
```

--------------------------------

### Initialized variable analysis with run contract

Source: https://kotlinlang.org/spec/kotlin-spec.html

Example showing that the `run` contract allows assignment to a read-only variable inside its lambda, avoiding an initialization error.

```kotlin
val x: Int
run { // run invokes its argument exactly once
    x = 4
}
// could be error: x is not initialized
// but is ok
println(x) 
```

--------------------------------

### Smart cast with require contract

Source: https://kotlinlang.org/spec/kotlin-spec.html

Example showing that the `require` contract smart-casts `x` to non-null after the check, making the addition legal.

```kotlin
val x: Int? = ...
// x is known to be non-null thanks to assume introduced by 
// the contract of require
require(x != null)
val y = x + 4 // would be illegal without contract
```

--------------------------------

### Fully-qualified call example

Source: https://kotlinlang.org/spec/kotlin-spec.html

Illustrates a fully-qualified call: the overload candidate set contains all top-level callables with the specified name in the specified package, and the call `a.b.c.foo()` resolves among them.

```kotlin
package a.b.c

fun foo(a: Int) {}
fun foo(a: Double) {}
fun foo(a: List<Char>) {}
val foo = {}
. . .
a.b.c.foo()
```

--------------------------------

### Kotlin class initialization order example

Source: https://kotlinlang.org/spec/kotlin-spec.html

Illustrates the initialization order for a Kotlin class with a primary constructor, a secondary constructor, interface delegation, and init blocks. The commented output shows the order of initialization and how uninitialized properties can leak undefined values.

```kotlin
open class Base(val v: Any?) {
    init {
        println("2: $this")
    }
}

interface I

class Init(val a: Number) : Base(0xC0FFEE) /* (2) */,
    I by object : I {
        init { println("2.5") }
    } /* (2.5) */ {

    init {
        println("3: $this") /* (3) */
    }

    constructor(v: Int) : this(v as Number) {
        println("10: $this") /* (10) */
    }

    val b: String = a.toString() /* (4) */

    init {
        println("5: $this") /* (5) */
    }

    var c: Any? = "b is $b" /* (6) */

    init {
        println("7: $this") /* (7) */
    }

    val d: Double = 42.0 /* (8) */

    init {
        println("9: $this") /* (9) */
    }

    override fun toString(): String {
        return "Init(a=$a, b='$b', c=$c, d=$d)"
    }
}

fun main() {
    Init(5)
    // 2: Init(a=null, b='null', c=null, d=0.0)
    // 3: Init(a=5, b='null', c=null, d=0.0)
    // 5: Init(a=5, b='5', c=null, d=0.0)
    // 7: Init(a=5, b='5', c=b is 5, d=0.0)
    // 9: Init(a=5, b='5', c=b is 5, d=42.0)
    // 10: Init(a=5, b='5', c=b is 5, d=42.0)
    
    // Here we can see how the undefined values for
    //   uninitialized properties may leak outside
}
```

--------------------------------

### Override visibility inheritance example

Source: https://kotlinlang.org/spec/kotlin-spec.html

Shows how overriding declarations inherit or weaken visibility from the base declaration. The example includes classes B, C, and D, where C inherits protected visibility and D explicitly declares public visibility, which is weaker than protected. The snippet also starts an open class P with an open function g, but the example is incomplete as provided.

```kotlin
open class B {
    protected open fun f() {}
}
class C : B() {
    open override fun f() {}
    // `f` is protected, as its visibility is
    //   inherited from the base declaration
}
class D : B() {
    public open override fun f() {}
    // this is correct, as public visibility is
    //   weaker that protected visibility
    //   from the base declaration
}

open class P {
    open fun g() {}
}
```

--------------------------------

### Declarations for operator interoperation example

Source: https://kotlinlang.org/spec/kotlin-spec.html

Declares types used to demonstrate how operator conventions interoperate: `A` supports increment, `B` supports indexed get/set returning `A`, and `C` supports indexed get returning `B`. The expression `C[0][0]++` is expanded step by step in the following examples.

```kotlin
class A {
    operator fun inc(): A { ... }
}

object B {
    operator fun get(i: Int): A { ... }
    operator fun set(i: Int, value: A) { ... }
}

object C {
    operator fun get(i: Int): B { ... }
}
```

--------------------------------

### Simple class declaration examples

Source: https://kotlinlang.org/spec/kotlin-spec.html

Illustrates simple class declarations: a base class without supertypes, a class with a primary constructor property, a class with an init block, a class with a secondary constructor delegating to the supertype, and a class with a companion object. The comments explain each part.

```kotlin
// An open class with no supertypes
//
open class Base

// A class inherited from `Base`
//
// Has a single read-only property `i`
//   declared in its primary constructor
//
class B(val i: Int) : Base()

// An open class with no superclasses
//
// Has a single read-only property `i`
//   declared in its body
//
// Initial value for the property is calculated
//   in the init block
//
open class C(arg: Int) {
    val i: Int
    
    init {
        i = arg * arg
    }
}

// A class inherited from `C`
//   Does not have a primary constructor,
//   thus does not need to invoke the supertype constructor
//
// The secondary constructor delegates to the supertype constructor
class D : C {
    constructor(s: String) : super(s.toInt())
}

// An open class inherited from `Base`
//
// Has a companion object with a mutable property `name`
class E : Base() {
    companion object /* Companion */ {
        var name = "I am a companion object of E!"
    }
}
```

--------------------------------

### Transformed property access as getter functions

Source: https://kotlinlang.org/spec/kotlin-spec.html

Shows the equivalent transformed class AA where property access is replaced by synthetic getter functions a$get(). The example is incomplete in the source, but it illustrates the transformation described in the surrounding text.

```kotlin
class AA {
    fun a$get(): Int = 5 // (1)

    fun Double.a$get(): Boolean // (2)
              = this != 42.0

    fun test() {

        println(a$get()) // Resolves to (1)

```

--------------------------------

### Kotlin this-expression example: interface B and object C

Source: https://kotlinlang.org/spec/kotlin-spec.html

Declares an interface B and an object C, used as a minimal example for labeled this-expressions in the Kotlin specification.

```kotlin
interface B
object C
```

--------------------------------

### Call handleConfig with a mutable map

Source: https://kotlinlang.org/spec/kotlin-spec.html

Calls handleConfig with a mutable map containing the keys "parent" and "host". This is the main entry point for the example that demonstrates property delegation with a map.

```kotlin
fun main() {
    handleConfig(mutableMapOf(
        "parent" to "",
        "host" to "https://kotlinlang.org/"
    ))
}
```

--------------------------------

### Kotlin example for killDataFlow inference

Source: https://kotlinlang.org/spec/kotlin-spec.html

Kotlin code used as an example for the killDataFlow inference analysis. It contains nested loops with assignments to x and y, which are used to illustrate where killDataFlow instructions would be inserted.

```kotlin
var x: Int = 0
var y: Int = 0
while (b1) {
    y = f()
    do {
        x = g()
    } while (b2)
}
```

--------------------------------

### Effectively immutable smart cast sink examples

Source: https://kotlinlang.org/spec/kotlin-spec.html

Shows valid and invalid placements of direct and nested redefinitions relative to smart cast sinks. The functions named Ok satisfy the effectively immutable conditions, while the Bad functions violate them by placing a redefinition between the definition and the sink or after a nested sink.

```kotlin
fun directSinkOk() {
    var x: Int? = 42 // definition
    if (x != null)   // smart cast source
        x.inc()      // direct sink
    run {
        x = null     // nested redefinition
    }
}

fun directSinkBad() {
    var x: Int? = 42 // definition
    run {
        x = null     // nested redefinition
                     //   between a definition
                     //   and a sink
    }
    if (x != null)   // smart cast source
        x.inc()      // direct sink
}

fun nestedSinkOk() {
    var x: Int? = 42     // definition
    x = getNullableInt() // direct redefinition
    run {
        if (x != null)   // smart cast source
            x.inc()      // nested sink
    }
}

fun nestedSinkBad01() {
    var x: Int? = 42     // definition
    run {
        if (x != null)   // smart cast source
            x.inc()      // nested sink
    }
    x = getNullableInt() // direct redefinition
                         //   after the nested sink
}

fun nestedSinkBad02() {
    var x: Int? = 42     // definition
    run {
        x = null         // nested redefinition
    }
    run {
        if (x != null)   // smart cast source
            x.inc()      // nested sink
    }
}
```

--------------------------------

### Overload specificity example with f(Int, String) and f(Any?, CharSequence)

Source: https://kotlinlang.org/spec/kotlin-spec.html

Shows two overloaded functions where (1) is more specific than (2) because (1) can forward its arguments to (2) but not vice versa. Used to illustrate the rationale for choosing the most specific candidate from the overload candidate set.

```kotlin
fun f(arg: Int, arg2: String) {}        // (1)
fun f(arg: Any?, arg2: CharSequence) {} // (2)
...
f(2, "Hello")
```

--------------------------------

### Class declaration with init blocks

Source: https://kotlinlang.org/spec/kotlin-spec.html

Class declaration with declarations and init blocks. Control flow is propagated through every element in order of appearance.

```kotlin
class A (...) { 
    'declaration 1'
    'declaration 2'
    'init-block 1'
    'declaration 3'
    'init-block 2'
    ...
}
```

--------------------------------

### Function with map and filter

Source: https://kotlinlang.org/spec/kotlin-spec.html

Example of a function using map and filter on a list.

```kotlin
fun f() = listOf(1, 2).map { it + 2 }.filter { it > 0 }
```

--------------------------------

### Function with labeled loop and break

Source: https://kotlinlang.org/spec/kotlin-spec.html

Example of a function with a labeled while loop and a break condition.

```kotlin
fun f(x: Int) {
    var y = x
    loop@ while(y != 500) {
        y++
        if(y % 20 == 3) break@loop
    }
}
```

--------------------------------

### Class implementing Comparable with swap and compareTo

Source: https://kotlinlang.org/spec/kotlin-spec.html

Shows a class implementing the Comparable interface, with a swap function and an override of compareTo. Demonstrates a class with a primary constructor and a supertype specifier.

```kotlin
class Pair(val a: Int, val b: Int) : Comparable<Pair> {

    fun swap(): Pair = Pair(b, a)

    override fun compareTo(other: Pair): Int {
        val f = a.compareTo(other.a)
        if (f != 0) return f
        return b.compareTo(other.b)
    }
}
```

--------------------------------

### kotlin.Enum ordinal property

Source: https://kotlinlang.org/spec/kotlin-spec.html

Property of kotlin.Enum<T> that contains the ordinal (position starting from zero) of the enumeration constant.

```kotlin
public final val ordinal: Int
```

--------------------------------

### Direct and nested smart cast sinks example

Source: https://kotlinlang.org/spec/kotlin-spec.html

Illustrates direct and nested smart cast sinks and redefinitions for a mutable local property. The comment markers identify each role: definition, nested sink, nested redefinition, direct sink, and direct redefinition.

```kotlin
fun example() {
    // definition
    var x: Int? = null

    if (x != null) {
        run {
            // nested smart cast sink
            x.inc()

            // nested redefinition
            x = ...
        }
        // direct smart cast sink
        x.inc()
    }

    // direct redefinition
    x = ...
}
```

--------------------------------

### Continuation resume and resumeWithException extension functions

Source: https://kotlinlang.org/spec/kotlin-spec.html

Extension functions on Continuation<T> that avoid explicitly creating a Result<T> when calling resumeWith. Use resume(value: T) to resume with a successful value and resumeWithException(exception: Throwable) to resume with an exception.

```kotlin
fun <T> Continuation<T>.resume(value: T)
fun <T> Continuation<T>.resumeWithException(exception: Throwable)
```
Tokens:
Raw