Welke mogelijkheden van de Kotlin-taal zou je graag…

Uitbreidingsfuncties: Hiermee kunnen nieuwe functies aan bestaande klassen worden toegevoegd zonder overerving of decoratormodellen. Verbeteren de leesbaarheid en organisatie van de code.
Null-veiligheid (null-safety): Systeem van types dat expliciet onderscheid maakt tussen nullable en non-nullable types, waardoor NullPointerExceptions tijdens compilatie worden voorkomen.
Data classes (gegevensklassen): Eenvoudige creatie van klassen voor het opslaan van gegevens met automatische generatie van equals(), hashCode(), toString(), copy().
```
data class User(val name: String, val age: Int)
```
While en when-uitdrukkingen: when is een krachtig alternatief voor switch met ondersteuning voor verschillende voorwaarden (types, bereiken, booleaanse voorwaarden), while kan een uitdrukking zijn die de waarde van de laatste geëvalueerde voorwaarde teruggeeft.
```
val result = when (x) {
    1 -> "één"
    in 2..10 -> "van twee tot tien"
    is String -> "tekenreeks"
    else -> "iets anders"
}
```
Coroutines: Lichtgewicht threads die asynchrone en niet-blokkerende programmering vergemakkelijken. Geïntegreerd op taalniveau.

Genummerde en optionele argumenten: Verbeteren de leesbaarheid bij het aanroepen van functies en maken het mogelijk om optionele parameters weg te laten.

fun greet(name: String, greeting: String = "Hallo") {
    println("$greeting, $name!")
}

greet(name = "Wereld") // Gebruik van het standaard optionele argument
greet(name = "Wereld", greeting = "Hoi") // Overschrijven van het optionele argument

Slimme casts (Smart casts): De compiler bepaalt automatisch het type van een variabele na een controle (bijvoorbeeld is), waardoor je zonder expliciete cast toegang hebt tot leden van dat type.

fun printLength(obj: Any) {
    if (obj is String) {
        // Nu wordt obj beschouwd als String
        println("Lengte van de string: ${obj.length}")
    }
}

Type-inferentie: De compiler kan automatisch het type van een variabele bepalen, waardoor redundantie wordt verminderd.

val number = 42 // Kotlin bepaalt dat het een Int is
val message = "Hallo" // Kotlin bepaalt dat het een String is

Lambda-expressies met impliciete it parameter: Handig voor eenvoudige lambdas met één parameter.

val list = listOf(1, 2, 3)
list.forEach { println(it) } // it is het element van de lijst

Welke mogelijkheden van de Kotlin-taal zou je graag in andere programmeertalen willen zien?