Kotlin Basics

// Inferred: the compiler reads the type off the right-hand side
val age = 30                  // Int
val price = 19.99            // Double
val label = "widget"          // String
val ready = true              // Boolean

// Explicit: needed when there's no initializer, or you want
// a wider/different type than the default inference
val id: Long                  // no initializer: must state the type
id = 42L

val handler: Runnable = Runnable { println("run") }
// declared as the interface, even though the value is a lambda impl

// Function return types are inferred for single-expression functions,
// but required on any function with a block body
fun square(n: Int) = n * n            // inferred: Int
fun cube(n: Int): Int { return n * n * n } // required

val name = "Ada"
val age = 36

// $var: simple variable substitution
println("Hello, $name! You are $age.")
// prints: Hello, Ada! You are 36.

// ${expr}: any expression, including calls and property access
println("Name has ${name.length} letters")
// prints: Name has 3 letters

println("Next year: ${age + 1}")
// prints: Next year: 37

// A literal $ or braces need escaping
println("Price: \$${9.99}")
// prints: Price: $9.99

// Triple-quoted strings need no escaping and can span lines
val json = """
    {
      "name": "$name",
      "age": $age
    }
""".trimIndent()

// Great for regexes, since backslashes stay literal
val pattern = """\d{3}-\d{4}""".toRegex()

// trimIndent() strips the common leading whitespace from every line,
// so you can indent the literal to match surrounding code

val score = 82

// No "break" needed: branches don't fall through
val grade = when {
    score >= 90 -> "A"
    score >= 80 -> "B"
    score >= 70 -> "C"
    else         -> "F"
}
println(grade) // B

// Matching a subject value against multiple candidates
val day = "SAT"
val kind = when (day) {
    "SAT", "SUN" -> "weekend"
    else          -> "weekday"
}

fun describe(x: Any): String = when (x) {
    is Int    -> "int: $x"            // type check, x is smart-cast to Int here
    is String -> "string of length ${x.length}"
    in 1..10  -> "small number"  // range check
    null       -> "nothing"
    else       -> "unknown: $x"
}

// Branches can hold arbitrary boolean expressions too
fun classify(n: Int) = when {
    n < 0          -> "negative"
    n == 0         -> "zero"
    n % 2 == 0    -> "even"
    else            -> "odd"
}

enum class Direction { NORTH, SOUTH, EAST, WEST }

// Used as an expression, when must cover every enum constant.
// Add a new constant later and this fails to compile until you handle it.
fun heading(d: Direction): Int = when (d) {
    Direction.NORTH -> 0
    Direction.EAST  -> 90
    Direction.SOUTH -> 180
    Direction.WEST  -> 270
    // no else needed: every constant is covered
}

// 1..5 is inclusive on both ends: 1, 2, 3, 4, 5
for (i in 1..5) print("$i ") // 1 2 3 4 5

// ..< excludes the end (Kotlin 1.7+); reads like most index loops
for (i in 0..<5) print("$i ") // 0 1 2 3 4

// downTo counts backward
for (i in 5 downTo 1) print("$i ") // 5 4 3 2 1

// step changes the increment
for (i in 0..10 step 2) print("$i ") // 0 2 4 6 8 10

// in tests membership: no loop involved
val valid = 7 in 1..10   // true

val fruits = listOf("apple", "banana", "cherry")

// Direct element iteration: no index bookkeeping
for (fruit in fruits) {
    println(fruit)
}

// withIndex() when you need both
for ((index, fruit) in fruits.withIndex()) {
    println("$index: $fruit")
}
// 0: apple, 1: banana, 2: cherry

// indices gives you a range over valid index positions
for (i in fruits.indices) {
    println("${fruits[i]} at $i")
}

// Destructuring a Map's entries directly in the loop header
val ages = mapOf("Ada" to 36, "Grace" to 85)
for ((name, age) in ages) {
    println("$name is $age")
}

// Block body: explicit return type required
fun add(a: Int, b: Int): Int {
    return a + b
}

// Single-expression body: "= expr" instead of a block,
// return type is inferred
fun multiply(a: Int, b: Int) = a * b

// Unit is Kotlin's "no meaningful value" type (like Go's absence
// of a return type). It's almost always omitted.
fun logMessage(msg: String): Unit {
    println(msg)
}
// equivalent, and idiomatic:
fun logMessage2(msg: String) { println(msg) }

// Parameters can have default values
fun greet(name: String, greeting: String = "Hello", punctuation: String = "!") {
    println("$greeting, $name$punctuation")
}

greet("Ada")                              // Hello, Ada!
greet("Ada", "Hi")                        // Hi, Ada!

// Named arguments: skip earlier defaults, any order, self-documenting
greet(name = "Ada", punctuation = "?!")   // Hello, Ada?!
greet(punctuation = ".", name = "Ada")   // order doesn't matter with names

// Named args are especially valuable when several params
// share a type: prevents silently swapped arguments
fun createUser(firstName: String, lastName: String, isAdmin: Boolean = false) { /* ... */ }
createUser(firstName = "Grace", lastName = "Hopper", isAdmin = true)

// vararg collects trailing args into an Array inside the function
fun sum(vararg numbers: Int): Int = numbers.sum()

sum(1, 2, 3)        // 6
sum()                // 0: zero args is fine

// Spread operator * expands an existing array into vararg position
val nums = intArrayOf(4, 5, 6)
sum(*nums)            // 15

val a = 10
val b = 20

// The old way: mutable placeholder, reassigned in each branch
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}

// Idiomatic: if is an expression, both branches must produce a value
val max2 = if (a > b) a else b

// Kotlin has no ternary operator (cond ? a : b): if-expression is it
val label = if (max2 % 2 == 0) "even" else "odd"

// A single-expression function body is itself an expression,
// so an if/when as the body needs no explicit "return"
fun max(a: Int, b: Int) = if (a > b) a else b

fun sign(n: Int) = when {
    n > 0  -> 1
    n < 0  -> -1
    else   -> 0
}

// Everything (even a block) technically has a type in Kotlin;
// statements like assignments and loops evaluate to Unit,
// the type with exactly one value, roughly Go's absence of a result
val nothingUseful: Unit = println("side effect")