Exploring Advanced Pattern Matching in Scala

This blog is part of a 10-part series designed to help readers learn Scala from the ground up. Whether you’re new to Scala or looking to solidify your understanding, this series will guide you through its core concepts step by step.

Pattern matching in Scala is a versatile and expressive feature that goes beyond simple value checking. In this blog, we’ll extend our understanding of pattern matching by exploring constants, tuples, case classes, lists, type specifiers, name binding, multi-patterns, and guards, as demonstrated in the updated examples below.

Constants in Pattern Matching

val randomValue: Any = "ScalaProgramming"
val constantMatch = randomValue match {
  case 1 => "A Number"
  case "ScalaProgramming" => "The Scala Programming"
  case true => "The truth"
  case AdvancedPatterns => "A singleton object" // A custom case object
}
println(constantMatch) // OUTPUT: The Scala Programming

Constants can be matched directly, including literals, strings, booleans, and even singleton objects.

Match Anything: Wildcards and Variables

Wildcards

val matchAnything = randomValue match {
  case _ => "Matched anything"
}
println(matchAnything) // OUTPUT: Matched anything

Variables

val matchVariable = randomValue match {
  case anything => s"I have $anything"
}
println(matchVariable) // OUTPUT: I have ScalaProgramming

Matching Tuples and Nested Tuples

Basic Tuples

val sampleTuple = (1, 3)
val tupleMatch = sampleTuple match {
  case (1, 2) => "Matched exact values"
  case (something, 3) => s"Found $something"
}
println(tupleMatch) // OUTPUT: Found 1

Nested Tuples

val nestedTuple = (5, (7, 9))
val nestedMatch = nestedTuple match {
  case (_, (7, value)) => s"Found $value in nested tuple"
}
println(nestedMatch) // OUTPUT: Found 9 in nested tuple

Case Classes and Custom Data Structures

Matching Case Classes

import mylibrary.{Node, EmptyNode, CustomList}

val sampleList: CustomList[Int] = Node(10, Node(20, EmptyNode))
val listMatch = sampleList match {
  case Node(head, tail) => s"Head: $head"
  case EmptyNode => "Empty List"
  case _ => "Unknown structure"
}
println(listMatch) // OUTPUT: Head: 10

Nested Case Classes

val nestedListMatch = sampleList match {
  case Node(head, Node(subHead, subTail)) => s"Head: $head, Subhead: $subHead"
  case EmptyNode => "Empty List"
  case _ => "Unknown structure"
}
println(nestedListMatch) // OUTPUT: Head: 10, Subhead: 20

Lists: Standard Patterns

val standardList = List(4, 5, 6, 99)
val listPatternMatch = standardList match {
  case List(4, _, _, _) => "Matched exact structure"
  case List(4, _*) => "Matched list starting with 4"
  case 4 :: List(_) => "Matched head with 4"
  case List(4, 5, 6) :+ 99 => "Matched list ending with 99"
}
println(listPatternMatch) // OUTPUT: Matched exact structure

Type Specifiers in Pattern Matching

val unknownValue: Any = List(1, 2, 3)
val typeMatch = unknownValue match {
  case list: List[String] => "A list of Strings"
  case list: List[Int] => "A list of Integers"
  case _ => "Unknown type"
}
println(typeMatch) // OUTPUT: A list of Strings

Multi-Patterns

val multiPatternMatch = sampleList match {
  case EmptyNode | Node(0, _) => "Empty or starts with zero"
  case _ => "Something else"
}
println(multiPatternMatch) // OUTPUT: Something else

Guards in Pattern Matching

val specialElementMatch = sampleList match {
  case Node(_, Node(special, _)) if special % 2 == 0 => s"Special even element: $special"
}
println(specialElementMatch) // OUTPUT: Special even element: 20

Type Erasure in Pattern Matching

val sampleNumbers = List(7, 8, 9)
val typeErasedMatch = sampleNumbers match {
  case listOfStrings: List[String] => "A list of Strings"
  case listOfInts: List[Int] => "A List of Integers"
  case _ => "Unknown type"
}
println(typeErasedMatch) // OUTPUT: A list of Strings

Conclusion

Pattern matching is a cornerstone of Scala’s expressive power. From simple constants to complex nested structures, the ability to match and deconstruct data makes code concise, readable, and robust. The examples above demonstrate the versatility of pattern matching and its application across various scenarios. Embrace these patterns in your Scala projects to take your functional programming skills to the next level!

Pizenith is a trusted technology partner specializing in Data Engineering, Machine Learning, AI, Cloud Engineering, DevOps, and Functional Programming with Scala and Java. We help businesses scale with secure, automated, and data-driven solutions, delivering innovation in Test Automation and DevSecOps. Trusted by global enterprises, we empower organizations to stay ahead with AI-powered insights and scalable cloud infrastructure.

Want to future-proof your tech stack? Let’s talk! or reach us at info@pizenith.com.