Destructuring, Type Aliases & Idioms — Kotlin Course

What you'll learn

This module gathers small features that make Kotlin flow: destructuring to unpack objects, type aliases to name complex types, and a tour of the idioms that make code read like idiomatic Kotlin.

By the end you'll be able to:

Destructure objects and map entries into variables
Skip components you don't need
Name complex types with typealias
Recognise and write common Kotlin idioms

Destructuring declarations

Destructuring unpacks an object's properties into separate variables in one line. It works with any type that provides componentN() functions — which data classes (Module 15) and Pair/Triple do automatically. It's especially clean in map loops:

Destructure.kt

data class User(val name: String, val age: Int)

val (name, age) = User("Sara", 25)   // unpack into two variables
println("$name is $age")

// destructure entries while looping a map
val ages = mapOf("Sara" to 25, "Omar" to 30)
for ((person, years) in ages) {
    println("$person: $years")
}

Skipping & multi-return

Destructuring pairs perfectly with functions that return multiple values (as a Pair or Triple). And you can use an underscore _ to skip a component you don't need:

Skip.kt

fun minMax(nums: List<Int>) = Pair(nums.min(), nums.max())

val (low, high) = minMax(listOf(4, 1, 8, 3))
println("$low..$high")     // 1..8

// use _ to skip a component you don't need
val (first, _, third) = Triple("a", "b", "c")
println("$first $third")   // a c

Type aliases

A type alias gives an existing type a shorter or more meaningful name. It doesn't create a new type — just an alias — but it makes complex generic or function types far more readable:

Aliases.kt

typealias Name = String
typealias UserMap = Map<String, Int>
typealias ClickHandler = (String) -> Unit

val users: UserMap = mapOf("Sara" to 25)
val onClick: ClickHandler = { msg -> println("Handled: $msg") }

onClick("click")
println(users["Sara"])

Note

typealias ClickHandler = (String) -> Unit turns a cryptic function type into a named concept. Because it's just an alias, a ClickHandler and a (String) -> Unit are fully interchangeable — the alias is for humans, not the compiler.

Kotlin idioms

Idiomatic Kotlin leans on the features you've learned to say more with less. A few you'll use constantly:

Idioms.kt

// a few beloved Kotlin idioms:

// null default with Elvis
val name = user?.name ?: "Guest"

// if / when as expressions
val label = if (score >= 60) "Pass" else "Fail"

// build a list concisely
val squares = (1..5).map { it * it }

// safe cast + smart cast in one
val length = (value as? String)?.length ?: 0

Tip

These aren't tricks — they're the natural way to write Kotlin: Elvis for defaults, if/when as expressions, collection operations over loops, and safe calls over null checks. Reading real Kotlin code, you'll see these everywhere.

Recap & quick check

Key takeaways

Destructuring unpacks an object's properties into variables: val (a, b) = obj.
It works with anything that has componentN() — data classes, Pair, Triple, map entries.
Use _ to skip a component you don't need.
typealias names an existing type (especially complex function/generic types) — it's not a new type.
Idiomatic Kotlin favours Elvis defaults, expressions, collection ops, and safe calls.

Quick check

1. What does 'val (a, b) = point' do?

2. What must a type provide to be destructured?

3. How do you skip a component while destructuring?

4. Does a typealias create a new type?

5. Which is an idiomatic Kotlin way to provide a default for a nullable value?

Great — your Kotlin reads cleaner than ever. Next up: Module 26 — Exceptions & Error Handling.