* A feature I like about kotlin are the receivers, with which you can write type-safe builders:
https://kotlinlang.org/docs/reference/type-safe-builders.htm...* Multiple receivers are possible enabling extension methods like this:
class EnglishToGermanDictionary {
val translations = mapOf(
"dog" to "Hund"
)
/* extension method for string in the context of dictionary */
val String.inGerman get() =
translations[this@String]
}
/* usage */
with (EnglishToGermanDictionary()) {
val word = "dog"
println("The translation of $word is ${word.inGerman}")
}
"cat".inGerman ---> compile error, method not found
* Built-in Singletons are also very convenient. Swap the word `class` for `object` and you get a singleton.
* The article left out lambdas. The function:
fun greet(name: String, day: String): String {
return "Hello $name, today is $day."
}
Can also be written as
val greet = {name, day -> "Hello $name, today is $day."}
* The compiler is really smart in infering types. Extension values don't need type-specification, e.g.:
val Double.km get() = this * 1000
* "when" in Kotlin doesn't need an argument, you can write arbitray rule-sets with it, with correctly inferred conditions:
val myVar = when {
stack.isEmpty() -> true
x == null -> false
currentIdx >= a && obj is MyType -> true /* here x has been inferred to be not null from the previous branch! */
else -> when {
user.isPresent() -> calculateSomething()
else -> throw IllegalStateException()
}
}
* sealed classes allow you to limit inheritance and get error when you miss something in a when
/* you actually don't have to nest the classes this way, but you can */
sealed class Expr {
sealed class IntExpr : Expr {
class Plus(val left: Int, val right: Int): IntExpr
class Minus(val left: Int, val right: Int): IntExpr
}
sealed class StringExpr : Expr {
class Substring(val str: String, val start: Int, val end: Int): StringExpr
}
}
/* Usage: */
val x: Expr
when (x) {
is Substring -> ...
is Plus -> x.left + x.right
/* compile error, we forgot to handle "Minus" from above */
}