Pattern Matching – Haskell

Haskell offers several elegant and powerful features that allow for concise, readable code. One of the most notable features is pattern matching, a technique that lets you match values and structures directly, making your code more intuitive and expressive.

In this article, we’ll explore the concept of pattern matching in Haskell, explain how it works, and demonstrate its practical uses with examples.

What is Pattern Matching?

Pattern matching in Haskell is a way to deconstruct data structures, check conditions, and bind variables simultaneously. When you write a function in Haskell, you can use patterns to directly match against the shape or structure of the input, allowing for concise handling of different cases.

Instead of writing complex if-else or switch-case statements like in other languages, Haskell’s pattern matching lets you simplify your code by handling different data structures or values in a clear, declarative style.

What are the Benefits of Pattern Matching?

Pattern matching in Haskell is a powerful feature that allows you to deconstruct and inspect data structures concisely and expressively. It’s a fundamental tool in Haskell for working with complex data types and recursive structures like lists and trees, and it provides several key benefits:

1. Clarity and Readability

• Pattern matching lets you specify exactly how different shapes or cases of data should be handled. By matching patterns directly in the function definition, it makes code more readable and descriptive, as it’s clear how each possible case is processed.
• Each pattern has its own separate branch, allowing you to define different behaviors in a clean and structured way.

Example:

describeList :: [a] -> String
describeList []     = "The list is empty."
describeList [x]    = "The list has one element."
describeList (x:xs) = "The list has multiple elements."

Here, the function describeList provides different descriptions based on the structure of the input list, making it very clear what each case does.

2. Safety and Exhaustiveness Checking

• Haskell’s pattern matching provides exhaustiveness checking during compilation, ensuring all possible cases are covered in a function. If a pattern is missing (e.g., handling an empty list), the compiler will warn you, helping prevent runtime errors and making your code safer.
• This is particularly useful when working with custom data types or recursive structures, as it ensures that all cases are handled appropriately.

Example:

data TrafficLight = Red | Yellow | Green

stopOrGo :: TrafficLight -> String
stopOrGo Red    = "Stop"
stopOrGo Yellow = "Prepare to stop"
stopOrGo Green  = "Go"

If you forget to handle one of the TrafficLight cases, Haskell will raise a warning, preventing unhandled cases from causing runtime errors.

3. Expressive Power with Complex Data Types

• Pattern matching allows you to easily work with nested and complex data structures like lists, tuples, and custom data types. You can match and bind values within these structures, giving you direct access to the data in a clean and concise way.
• This is especially valuable with recursive data structures, like lists and trees, where pattern matching simplifies operations like traversal, search, and transformation.

Example:

sumList :: [Int] -> Int
sumList []     = 0
sumList (x:xs) = x + sumList xs

Here, pattern matching breaks down the list recursively, with x representing the head and xs the tail, allowing you to define a recursive function with minimal syntax.

4. Simplifies Function Definitions

• Pattern matching can often replace conditionals (if-else) and nested cases, leading to shorter and more readable code. It’s particularly useful for functions that behave differently based on data types or values, eliminating the need for verbose conditionals.
• With guards, pattern matching also allows you to apply specific conditions to patterns, making it even easier to handle complex cases concisely.

Example with Guards:

grade :: Int -> String
grade score
  | score >= 90 = "A"
  | score >= 80 = "B"
  | score >= 70 = "C"
  | otherwise   = "F"

This use of pattern matching with guards is much more readable than an equivalent if-else chain.

5. Supports Recursive Patterns Naturally

• Pattern matching fits naturally with Haskell’s recursive approach, allowing you to process data structures one layer at a time. This makes it especially well-suited for functions that operate on lists, trees, and other recursive data structures.
• You can break down each case recursively, working with the head and tail of a list or the branches of a tree without extra code for traversal.

Example:

factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

Pattern matching allows a simple definition of the base case (0) and recursive case (n), making recursion concise and intuitive.

6. Enhanced Code Maintainability

• Because pattern matching is concise and structured, it’s easier to read, debug, and extend. Adding new cases to functions that use pattern matching is straightforward, making code less error-prone and more adaptable to changes.
• When new data constructors are added to a type, you can update functions by adding new patterns, which makes maintaining and evolving code simpler and safer.

Summary of Benefits

In Haskell, pattern matching:

• Makes code clear and readable by defining behavior for each possible shape of data.
• Enhances safety with exhaustiveness checks.
• Simplifies function definitions, replacing verbose conditionals.
• Is well-suited to recursive operations on lists and trees.
• Helps with maintainability by providing a structured way to handle cases.

Overall, pattern matching is a core feature that leverages Haskell’s type system to improve code clarity, safety, and functionality, making it an essential tool in functional programming with Haskell.

Basic Pattern Matching with Lists

One of the most common uses of pattern matching is with lists. In Haskell, lists are a fundamental data structure, and pattern matching lets you break them down easily into their components.

Example: Sum of a List

Let’s create a function to compute the sum of a list of integers. Using pattern matching, we can define different cases based on the structure of the list:

sumList :: [Int] -> Int
sumList [] = 0  -- Case 1: The empty list
sumList (x:xs) = x + sumList xs  -- Case 2: A non-empty list

Explanation:

• []: This pattern matches the empty list. When the list is empty, the sum is 0.
• (x:xs): This pattern matches a non-empty list. The x represents the first element (the head of the list), and xs represents the rest of the list (the tail). We recursively call sumList on the tail of the list, adding x to the result.

This allows us to break down the list into smaller pieces and handle each element step by step.

Example Usage:

sumList [1, 2, 3, 4]  -- Result: 10
sumList []            -- Result: 0

Pattern Matching with Tuples

Pattern matching is not limited to lists—it also works with tuples, which are fixed-size collections of values of potentially different types. You can match each element of a tuple directly.

Example: Adding Pairs of Integers

Let’s create a function that adds two pairs of integers:

addPairs :: (Int, Int) -> (Int, Int) -> (Int, Int)
addPairs (x1, y1) (x2, y2) = (x1 + x2, y1 + y2)

Explanation:

• (x1, y1) matches the first pair of integers.
• (x2, y2) matches the second pair.
• The result is a new tuple where each element is the sum of the corresponding elements from the input tuples.

Example Usage:

addPairs (1, 2) (3, 4)  -- Result: (4, 6)

Pattern Matching with Algebraic Data Types

Haskell allows you to define your own data types, and pattern matching is essential for working with these custom types. Algebraic data types (ADTs) in Haskell are often defined using the data keyword and consist of one or more constructors.

Example: Defining a Data Type for Shapes

Let’s define a data type Shape that can represent either a Circle or a Rectangle:

data Shape = Circle Float | Rectangle Float Float

We can now write a function to calculate the area of a shape using pattern matching:

area :: Shape -> Float
area (Circle r) = pi * r^2
area (Rectangle w h) = w * h

Explanation:

• (Circle r) matches a Circle and extracts its radius r.
• (Rectangle w h) matches a Rectangle and extracts its width w and height h.

Example Usage:

area (Circle 3)     -- Result: 28.27 (approximately)
area (Rectangle 4 5)    -- Result: 20.0

Pattern Matching with Maybe

Haskell provides the Maybe type, which is often used to represent values that may or may not exist. The Maybe type has two constructors: Just (for a value) and Nothing (for the absence of a value). Pattern matching on Maybe types allows you to handle both cases cleanly.

Example: Extracting a Value from Maybe

getValue :: Maybe Int -> Int
getValue Nothing = 0  -- If there's no value, return 0
getValue (Just x) = x  -- If there's a value, return it

Explanation:

• Nothing: If the input is Nothing, we return 0.
• (Just x): If the input is Just x, we extract the value x.

Example Usage:

getValue Nothing       -- Result: 0
getValue (Just 42)     -- Result: 42

Pattern Matching with Wildcards and As-Patterns

Haskell provides a few special pattern matching features to handle more advanced cases:

• Wildcards (_): The wildcard pattern matches anything, but it does not bind the matched value to a variable. This is useful when you don’t care about some part of the data structure.

-- A function that returns the first element of a list, or 0 if the list is empty
firstElement :: [Int] -> Int
firstElement [] = 0
firstElement (x:_) = x

In this example, (x:_) matches any non-empty list, and the wildcard (_) ignores the rest of the list.

As-patterns (@): As-patterns allow you to bind a variable to the whole structure while also deconstructing it.

-- A function that returns both the first element and the entire list
firstAndList :: [Int] -> (Int, [Int])
firstAndList xs@(x:_) = (x, xs)

In this case, xs@(x:_) allows us to refer to the whole list as xs while also matching the first element as x.

Here’s an example to better understand:

capital :: String -> String  
capital "" = "Empty string, whoops!"  
capital all@(x:xs) = "The first letter of " ++ all ++ " is " ++ [x] 

capital "Dracula"  
-- Result: "The first letter of Dracula is D"  

Normally we use as patterns to avoid repeating ourselves when matching against a bigger pattern when we have to use the whole thing again in the function body. – Learn You a Haskell

Pattern Matching in Function Definitions

Pattern matching can be used directly in function definitions to make your code clearer and more concise. This lets you handle different cases of input with simple and declarative code.

Example: Handling Boolean Values

describeBool :: Bool -> String
describeBool True = "It's True!"
describeBool False = "It's False!"

Explanation:

• We match directly on the True and False constructors of the Bool type, returning a specific string for each case.

Example Usage:

describeBool True   -- Result: "It's True!"
describeBool False  -- Result: "It's False!"

Exhaustive Pattern Matching

One important aspect of pattern matching in Haskell is ensuring that all possible patterns are covered. If you miss a pattern, Haskell will raise a non-exhaustive patterns warning or error at runtime. To avoid this, you should make sure that all potential cases are accounted for in your pattern matches.

Example: Handling All Cases in a List

describeList :: [a] -> String
describeList [] = "The list is empty."
describeList (x:xs) = "The list is non-empty."

Here, we handle both the empty list ([]) and the non-empty list ((x:xs)), ensuring that all possible cases are covered.

Explain Pattern Matching Like I’m Five Years Old (ELI5)

Alright, imagine you have a bunch of different toy boxes. Each box has a special label on it to tell you what’s inside. Now, if you want to open the right box to find something specific, you just look at the label on each box and pick the one that matches what you’re looking for.

In Haskell, pattern matching is like looking at the labels to figure out what’s inside and decide what to do with it! You set up different “patterns” (like the labels) to match what the input looks like, and then Haskell knows exactly what to do with each pattern.

Let’s look at a simple example with patterns:

Suppose you have a list of numbers, but sometimes the list is empty, and sometimes it has numbers in it. Here’s how you might use pattern matching to “look” inside the list and act differently depending on what you see:

• If the list is empty, you want to say “no toys here.”
• If the list has a first number (let’s say 5) and maybe some other numbers, you want to say, “I found 5 as the first toy!”

So in Haskell, you might write it like this:

describeList :: [Int] -> String
describeList [] = "No toys here!" -- Empty list case
describeList (5:_) = "I found 5 as the first toy!" -- First item is 5 case

Here’s what each line does:

• [] matches an empty list (no toys). If the list is empty, Haskell says, “No toys here!”
• (5:_) matches a list where the first toy is 5. If this is true, Haskell says, “I found 5 as the first toy!”

So, pattern matching is like setting up “labels” that help Haskell know what to do based on what’s inside your input. Each pattern you write lets Haskell handle different cases without needing long explanations, just like reading labels!

Conclusion

Pattern matching is one of the most powerful and flexible features in Haskell, allowing you to write clean and concise code by directly handling the structure of data. Whether you are working with lists, tuples, algebraic data types, or the Maybe type, pattern matching makes it easy to deconstruct values and work with them efficiently.

Mastering pattern matching in Haskell will not only make your code more readable but also help you better understand and leverage the functional programming paradigm. By combining pattern matching with Haskell’s other features, you can write expressive, modular, and maintainable code.