when as an Expression

## What `when` is `when` is Kotlin's multi-way branching construct, replacing the C/Java `switch`. The general form is: ```kotlin when (x) { 1 -> "one" 2, 3 -> "two or three" // comma-grouped branch in 4..10 -> "small" // range check else -> "other" // catch-all (like default) } ``` Each line is `condition -> body`. Kotlin evaluates the branch conditions **top to bottom** and executes the **first** one that matches, then stops. ## Key differences from `switch` - **No fall-through, no `break`.** In C/Java a `case` without `break` falls into the next one. Kotlin branches are isolated; you never write `break`. - **`else` instead of `default`** as the catch-all. - **Conditions are expressions, not just constants.** `switch` typically allows only compile-time constants. `when` branches can use ranges (`in 1..10`), type tests (`is String`), or — in the subjectless form — arbitrary boolean expressions. - **It can be an expression.** `val s = when (x) { ... }` assigns the matched branch's value. As a statement, you just run side effects and ignore the result. ## Statement vs expression - **Statement form:** result discarded; `else` is optional. - **Expression form:** the value of the chosen branch becomes the `when` value, so it must be **exhaustive** (every possibility covered, usually via `else`) and every branch must produce a value. ## Branch bodies A body can be a single expression or a block: ```kotlin val label = when (n) { 0 -> "zero" else -> { val sign = if (n > 0) "+" else "-" "$sign$n" // last expression of the block is the branch value } } ``` Under the hood `when` compiles to ordinary conditional jumps (or a `tableswitch`/`lookupswitch` for dense integer/enum subjects), so it's as efficient as a `switch`.