Deconstruction
Extract from data.
Deconstruction is a free Scala for Backend Engineering & Functional Programming lesson on CoddyKit — lesson 4 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 Scala for Backend Engineering & Functional Programming learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
What Is Deconstruction?
Deconstruction (also called destructuring) means extracting the parts of a data structure directly in a pattern.
Instead of calling accessor methods, you describe the shape and name the pieces you want.
Deconstructing a Tuple
A tuple groups several values. You can pull them apart in a single binding by writing names in parentheses.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Tuples in match
You can deconstruct a tuple inside a match, naming or matching each component.
object Main {
def quadrant(p: (Int, Int)): String = p match {
case (0, 0) => "origin"
case (x, 0) => s"on x-axis at $x"
case (0, y) => s"on y-axis at $y"
case (x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(quadrant((0, 0)))
println(quadrant((3, 0)))
println(quadrant((2, 5)))
}
}Deconstructing a List Head
The :: operator (cons) splits a list into its first element (head) and the rest (tail).
The pattern head :: tail matches any non-empty list.
object Main {
def first(xs: List[Int]): String = xs match {
case head :: tail => s"head=$head, rest=$tail"
case Nil => "empty"
}
def main(args: Array[String]): Unit = {
println(first(List(10, 20, 30)))
println(first(Nil))
}
}Matching Exact List Shapes
You can match lists of a specific length by listing their elements, like List(a, b) for exactly two items.
object Main {
def shape(xs: List[Int]): String = xs match {
case List() => "none"
case List(a) => s"one: $a"
case List(a, b) => s"two: $a, $b"
case _ => "many"
}
def main(args: Array[String]): Unit = {
println(shape(List()))
println(shape(List(1)))
println(shape(List(1, 2)))
println(shape(List(1, 2, 3)))
}
}Recursing With Head and Tail
Splitting head from tail enables clean recursion over a list.
Here we sum a list by adding the head to the sum of the tail.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Deconstructing Nested Structures
Patterns nest. You can deconstruct a tuple inside a list, or a list inside a tuple, all at once.
object Main {
def main(args: Array[String]): Unit = {
val data = List(("a", 1), ("b", 2))
data match {
case (key, value) :: _ => println(s"first key=$key value=$value")
case Nil => println("empty")
}
}
}Ignoring Parts With _
Use _ for components you do not care about. This keeps patterns focused on the data you actually need.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Binding First Two, Keeping Rest
You can name the first elements and capture everything after with a tail pattern.
object Main {
def main(args: Array[String]): Unit = {
val xs = List(1, 2, 3, 4, 5)
xs match {
case a :: b :: rest => println(s"a=$a b=$b rest=$rest")
case _ => println("too short")
}
}
}Why Deconstruction?
Deconstruction makes data access:
- Declarative: you describe the shape, not the steps
- Safe: the structure is checked as you extract
- Concise: multiple values bound in one pattern
It becomes even more powerful with case classes.
Putting It Together
This example deconstructs a list of tuples and reacts to the shape.
object Main {
def report(scores: List[(String, Int)]): String = scores match {
case Nil => "no scores"
case (name, pts) :: Nil => s"only $name with $pts"
case (name, pts) :: rest => s"top $name=$pts plus ${rest.size} more"
}
def main(args: Array[String]): Unit = {
println(report(Nil))
println(report(List(("Ann", 90))))
println(report(List(("Ann", 90), ("Bo", 80))))
}
}Quick Check
Test your understanding of deconstruction.
Recap
You learned to deconstruct data in patterns:
- Tuples split with
(a, b) - Lists split with
head :: tailor exact shapes likeList(a, b) Nilmatches the empty list- Use
_to ignore parts; nest patterns for deep structures - Head/tail splitting enables clean recursion
Frequently asked questions
Is the “Deconstruction” lesson free?
Yes — the full text of “Deconstruction” is free to read here on the web, and the Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming course, upgrade to CoddyKit PRO.
What will I learn in “Deconstruction”?
Extract from data. You practise Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No prior experience is required. Scala for Backend Engineering & Functional Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Deconstruction” 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 Scala for Backend Engineering & Functional Programming lesson?
Yes. Every Scala for Backend Engineering & Functional Programming 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.