Lectures

We break down lambda expressions in Kotlin as “values”: how to store a lambda in val and call it like a function, how the basic syntax -> works, when you can use the it parameter, why the result of a lambda is the last expression (and how to accidentally return Unit), and where the compiler needs type hints (for example, (Int) -> Boolean) and which errors are most common.

We break down how to read Kotlin function types of the form (A) -> B, what a predicate (T) -> Boolean is, why higher-order functions are needed, and how to stop copying loops by passing “behavior” as a parameter. In practice, we will write our own versions of countMatching, forEachIf, and findFirstOrNull and apply them to a mini expense-tracking project on MutableList with a Triple model.

We break down callable references in Kotlin via the :: operator: how to replace a wrapper lambda like { x -> f(x) } with a reference ::f, why this works only when the signature matches strictly ( (T) -> R), how to store a function reference in a val, and where :: improves readability (predicates, input-processing steps) — with examples and a breakdown of common mistakes.

We break down the comparison contract via a function of the form ( T , T ) -> Int: why order needs three outcomes (less/equal/greater), how to assemble a Comparator<T> with the compare method from a lambda, how to apply a comparator to pick the “best” element without sorting, how to do a tie-breaker via return @ Comparator, and why it’s better to write compareTo instead of a - b.

We break down closures in Kotlin: how lambdas and local functions capture outer context, how capturing val differs from capturing var, and why an “innocent” predicate like (Int) -> Boolean can suddenly become a source of hidden state and side effects (for example, via println or a counter). At the end, there is a practical mini-case with Triple and a set of habits that help keep effects visible and local (separating predicate and action, short lifetime of closures).