Case Expressions – Haskell

In Haskell, case expressions are a powerful tool for making decisions based on the structure and values of data. Case expressions allow you to match patterns, deconstruct data, and define behavior based on different scenarios, all within a single, flexible construct. This makes them especially useful in functional programming, where immutable data and pattern matching are fundamental.

In this article, we’ll explore what case expressions are, how they work, and some practical examples to help you understand their usage.

What is a Case Expression?

A case expression in Haskell allows you to branch on the value of an expression, testing it against a series of patterns. It’s somewhat similar to a switch statement in imperative languages but more powerful, as Haskell’s case expressions can handle complex patterns and data types.

The general syntax of a case expression is:

case expression of
    pattern1 -> result1
    pattern2 -> result2
    ...
    _        -> defaultResult

expression: The value or expression to be evaluated and matched.

patterns: Specific values or structures that expression can match.

results: The result or expression to be evaluated and returned if a pattern matches.

_ (underscore): A catch-all pattern that matches anything (similar to “default” in a switch statement). It’s useful for handling unmatched cases.

Why Use Case Expressions?

Case expressions are useful in scenarios where:

1. You need to handle multiple possible values or shapes of data.
2. You’re working with data structures that can have different forms, such as lists, tuples, or custom data types.
3. You want to keep code concise by eliminating multiple if-else chains.

Case expressions make code easier to read and maintain by clearly defining behavior for each case.

Basic Example of Case Expressions

Let’s start with a simple example that checks a number and returns a message based on its value.

describeNumber :: Int -> String
describeNumber x = case x of
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
    _ -> "A number greater than three"

Here’s how it works:

• x is the input value.
• The case x of expression matches x against specific patterns (1, 2, 3).
• If x matches any of these patterns, it returns the corresponding message.
• The _ pattern is a catch-all that matches any value not covered by the previous cases.

Usage:

describeNumber 1    -- Result: "One"
describeNumber 3    -- Result: "Three"
describeNumber 5    -- Result: "A number greater than three"

In this case, describeNumber uses a case expression to clearly handle each possible value of x, making the function concise and readable.

Working with Lists in Case Expressions

Case expressions are particularly useful with lists, allowing you to handle empty lists, single-element lists, and multi-element lists separately.

Example: Sum of List with Pattern Matching

Here’s a function that sums up a list of integers using a case expression:

sumList :: [Int] -> Int
sumList xs = case xs of
  []     -> 0    -- Case for an empty list
  (y:ys) -> y + sumList ys -- Case for a non-empty list

Explanation:

• If xs is an empty list ([]), the result is 0.
• If xs is a non-empty list, it matches the pattern (y:ys), where y is the head of the list and ys is the tail. The function adds y to the result of sumList ys.

Usage:

sumList []         -- Result: 0
sumList [1, 2, 3]  -- Result: 6

This example shows how case expressions let you recursively deconstruct lists in a clean and intuitive way.

Case Expressions with Custom Data Types

In Haskell, case expressions are also useful when working with custom data types. Here’s an example with a simple data type representing traffic lights.

data TrafficLight = Red | Yellow | Green

trafficAction :: TrafficLight -> String
trafficAction light = case light of
    Red    -> "Stop"
    Yellow -> "Caution"
    Green  -> "Go"

In this function:

• TrafficLight is a custom data type with three possible values: Red, Yellow, and Green.
• trafficAction uses a case expression to match each possible TrafficLight value and return the corresponding action.

Usage:

trafficAction Red    -- Result: "Stop"
trafficAction Green  -- Result: "Go"

Here, case expressions provide a straightforward way to handle each possible value of TrafficLight, making the code easy to read and extend if new cases are added.

Nested Case Expressions

You can also nest case expressions to handle more complex decision-making. However, it’s usually best to avoid excessive nesting to keep code readable.

Example: Nested Case for Decision-Making

Consider a function that returns a message based on the presence of two values in a tuple:

describePair :: (Maybe Int, Maybe Int) -> String
describePair pair = case pair of
    (Nothing, Nothing) -> "Both values are missing."
    (Just x, Nothing)  -> "The first value is " ++ show x ++ ", second is missing."
    (Nothing, Just y)  -> "The second value is " ++ show y ++ ", first is missing."
    (Just x, Just y)   -> "Both values are present: " ++ show x ++ " and " ++ show y

Here:

• describePair uses case expressions to handle each possible case of the input tuple (Maybe Int, Maybe Int).
• Each pattern (Nothing, Nothing), (Just x, Nothing), etc., matches a specific combination of Maybe values.

Usage:

describePair (Nothing, Just 5)     -- Result: "The second value is 5, first is missing."
describePair (Just 3, Just 7)      -- Result: "Both values are present: 3 and 7"

This pattern matching approach with nested structures allows for clear handling of each case without relying on multiple if-else conditions.

Advantages of Case Expressions

Case expressions offer several key advantages:

1. Clarity and Readability: By handling different patterns explicitly, case expressions make the code’s intent clear.
2. Exhaustiveness Checking: Haskell’s compiler checks that all possible cases are covered, helping prevent runtime errors.
3. Eliminates Complex Conditionals: Case expressions are more readable and concise than complex if-else statements, especially when working with structured data.
4. Flexible Pattern Matching: Case expressions can match specific values, data structures, and even use wildcards (_) for unmatched cases.

When to Use Case Expressions

Use case expressions when:

• You need to handle different shapes or values of data, especially with lists and custom data types.
• You want to avoid complex if-else chains.
• You need a clear, concise way to handle different cases in a single expression.

Summary

Case expressions in Haskell are a versatile tool for branching based on data structures and values. They enhance readability, ensure safety through exhaustiveness checks, and allow you to handle complex patterns concisely. Whether you’re working with lists, custom data types, or nested structures, case expressions help you write expressive, maintainable code that clearly defines behavior for every possible case. Understanding and using case expressions effectively is a key skill in functional programming with Haskell.