Pattern Matching and Its Types in Scala

Hacker hands using laptop computer to code
Reading Time: 4 minutes

In this blog, we will read about pattern matching in Scala followed by various types of patterns in match expressions.

What is Pattern Matching?

Pattern matching in Scala is a powerful mechanism of checking a value against a pattern. Thus, we match a value against a pattern and a successful match deconstructs the value into its constituent parts to be used further. While providing the ability to match components against complex patterns, it enables more concise and legible code.

Types of Patterns

Wildcard Patterns

The wildcard pattern (_) is used to match against any case or type. It is used as a default case i.e., a catch-all alternative. It can also be used to represent an element of an object whose value is not required. However, it is advised to use such type of pattern only as an alternative.

Constant Patterns

Constant Patterns are used to match against itself. That means any literal may be used as a constant in the match expression.

Code snippet

Stable Pattern

Generally It is similar to constant patterns. When a constant to be matched is declared somewhere else in the program, then we use a Stable Pattern to match against a variable.

Variable Patterns

The Wildcard and variable pattern are pretty similar, however, with this pattern matching, we are permitted to bind an object’s value to a variable so that we can use the value wherever it is needed.

Sequence Patterns

Additionally, we have the option of pattern matching against sequences. Eventually, element-based data structures include arrays, lists, and vectors used to form patterns. Any number of the pattern’s elements can be specified using wildcards. Underscore wildcard (_) is used to match a single element whereas the star wildcard (*) is used to match a variable number of elements.

Constructor Patterns

Pattern matching particularly shines when used with constructors. A distinct category of classes called case classes is designed specifically for pattern matching. Deep matching is another name for pattern matching of case classes, which involves examining the contents of case class instances. It first checks that the object is a member of the named case class then checks that the constructor parameters of the object match the extra patterns supplied.

List Patterns

List collections differ slightly from other types of collections. It is made up of “cons” cells and ends with a Nil element. Using the:: operator, we can match onto List expressions. This helps in deconstructing the list patterns into their constituent parts.

Tuple Patterns

Tuple patterns are useful when we have multiple objects or values to match against a pattern. Tuples are objects with a small number of sub-objects. We can imagine them as small collections of mixed elements.

Typed Patterns

Scala is a typed language, which means that each object has a fixed type that cannot be altered. We can match on the basis of expression type. Here, we bound object-mapped variables to specific data types.

Option Type Patterns

Scala has a standard type named Option for optional values. That means a value can be of two types: Some(x) object, where x is the actual value, or the None object, which represents a missing value. These constitute option-type patterns.


In this blog post, we discussed pattern matching in Scala and various types of patterns in a match expression. To read more blogs like this, do check out here

For exploring more regarding pattern matching refer to

Written by 

Pragati is currently working as a Software Engineer at Knoldus Inc. She is having more than 1.5 year of experience working in IT industry and working in the Scala domain.