Kotlin Academy · Lesson

Destructuring Declarations with componentN

Destructure data class instances into variables using component functions.

Destructuring Declarations with componentN is a free Kotlin Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Kotlin Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Destructuring Basics

A destructuring declaration unpacks an object into multiple variables in one step. It uses the componentN() operator functions.

Destructuring a Data Class

Data classes auto-generate component1, component2, ... so you can write val (a, b) = obj.

data class Point(val x: Int, val y: Int)
fun main() {
    val p = Point(3, 5)
    val (x, y) = p
    println("x=$x, y=$y")
}

Destructuring a Pair

The stdlib types Pair and Triple support destructuring out of the box.

fun main() {
    val pair = "Ada" to 35
    val (name, age) = pair
    println("$name is $age")
}

Destructuring a Triple

Triple holds three values; destructure into three variables.

fun main() {
    val rgb = Triple(255, 128, 0)
    val (r, g, b) = rgb
    println("R=$r G=$g B=$b")
}

Destructuring in Map Iteration

Map entries have component1 (key) and component2 (value). Destructure in a for loop header.

fun main() {
    val ages = mapOf("Alice" to 30, "Bob" to 25)
    for ((name, age) in ages) {
        println("$name -> $age")
    }
}

Destructuring in Lambdas

Lambdas accepting pairs can destructure parameters directly.

fun main() {
    val pairs = listOf("a" to 1, "b" to 2, "c" to 3)
    pairs.forEach { (letter, num) -> println("$letter=$num") }
}

Ignoring Values with _

Use underscore _ to skip values you don't need.

data class User(val name: String, val email: String, val age: Int)
fun main() {
    val u = User("Ada", "ada@example.com", 35)
    val (name, _, age) = u
    println("$name ($age)")
}

Returning Multiple Values

A function can return a Pair or a custom data class; the caller destructures.

data class Result(val sum: Int, val product: Int)
fun computeBoth(a: Int, b: Int) = Result(a + b, a * b)
fun main() {
    val (s, p) = computeBoth(4, 5)
    println("sum=$s product=$p")
}

Custom componentN

Any class can support destructuring by declaring operator fun componentN().

class RGB(val r: Int, val g: Int, val b: Int) {
    operator fun component1() = r
    operator fun component2() = g
    operator fun component3() = b
}
fun main() {
    val (red, green, blue) = RGB(255, 100, 0)
    println("$red $green $blue")
}

Destructuring with withIndex()

Pair index and value when iterating with withIndex().

fun main() {
    val fruits = listOf("apple", "banana", "cherry")
    for ((idx, fruit) in fruits.withIndex()) {
        println("$idx: $fruit")
    }
}

Limitation: Position-Based

Destructuring is positional, not by name. Reordering data class fields silently changes meaning at call sites.

data class Point(val x: Int, val y: Int)
fun main() {
    val p = Point(10, 20)
    val (a, b) = p // a=x, b=y
    // Add a property in the middle and old destructuring shifts!
    println("$a $b")
}

Quick Check

Which operator function enables destructuring of the i-th property?

Recap

Destructuring uses componentN() operator functions. Data classes, Pair, Triple, and Map entries support it out of the box. Use _ to skip values, and beware: destructuring is positional, not name-based.

Frequently asked questions

Is the “Destructuring Declarations with componentN” lesson free?

Yes — the full text of “Destructuring Declarations with componentN” is free to read here on the web, and the Kotlin Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Kotlin Academy course, upgrade to CoddyKit PRO.

What will I learn in “Destructuring Declarations with componentN”?

Destructure data class instances into variables using component functions. You practise Kotlin Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Kotlin Academy?

No prior experience is required. Kotlin Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Destructuring Declarations with componentN” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Kotlin Academy lesson?

Yes. Every Kotlin Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Data Class Basics: Auto-generated Methods
Copying with copy() and Partial Overrides
Destructuring Declarations with componentN
Data Classes in Collections and as Map Keys

← Back to Kotlin Academy