Lectures

We break down how subtyping works for generic types in Kotlin: why List<Expense> can be safely used as List<Transaction>, but MutableList<Expense> cannot be lifted to MutableList<Transaction>. With examples, we show invariance of containers ( Box<T>), covariance of read-only collections, compiler errors, and practical API design techniques (accept List if you don’t need to mutate), plus intuition via function types (Transaction) -> String.

We break down declaration-site variance in Kotlin: how to declare covariant producer types via out and contravariant consumer types via in, why the compiler forbids unsafe operations (for example, a var with a type parameter), and how this relates to familiar types like List, Comparable, and function types (A) -> B. At the end: a practical refactoring (report source + printer) and a list of common design mistakes.

We break down why Array<T> in Kotlin is invariant, why casts via as are dangerous, and how use-site variance (type projections) “trims” the reference API down to a safe mode: out for reading (producer) and in for writing (consumer). We reinforce it with examples of copying arrays and contracts for MutableList, including a practical scenario with financial operations.

We break down star-projection * in Kotlin using List<*> and MutableList<*> as examples: what exactly “unknown type” means, why elements become Any? when reading, why writing into MutableList<*> is forbidden (the logic of in Nothing), how to use checks like is List<*>, and how the asterisk relates to out/ in projections. At the end: practical examples and common mistakes.

Let’s break down why generic types are “erased” on the JVM ( type erasure), why checks like is T and List < Int > are forbidden, and how to perform checks/casts legally using inline + reified. In practice, we’ll write universal utilities with as?, use T::class for messages, and collect elements of the required type from a List < Any >.