**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Algebraic Data Types and Pattern Matching **Topic:** Advanced pattern matching techniques Pattern matching in Haskell is a powerful tool for controlling the flow of your program and deconstructing data. You have already seen the basics of pattern matching in previous topics. In this topic, we will dive deeper into advanced pattern matching techniques. **Pattern Matching with Algebraic Data Types** Algebraic data types are composed of constructors that can be used for pattern matching. In addition to simple constructors like `Int` and `String`, you can use pattern matching with more complex data types, such as lists, tuples, and records. For example, consider a data type `Tree` defined as follows: ```haskell data Tree = Leaf Int | Branch Tree Tree ``` You can use pattern matching to define functions on this data type. For example, you can define a function to sum all the leaves in a tree: ```haskell sumLeaves :: Tree -> Int sumLeaves (Leaf x) = x sumLeaves (Branch left right) = sumLeaves left + sumLeaves right ``` **Pattern Matching with Guards** Guards are another powerful feature of pattern matching in Haskell. A guard is a boolean expression that can be used to further refine the pattern matching. Guards are written after a vertical bar `|` and can be used to filter the data being matched. For example, you can use guards to define a function that sums all the even numbers in a list: ```haskell sumEvens :: [Int] -> Int sumEvens [] = 0 sumEvens (x:xs) | x `mod` 2 == 0 = x + sumEvens xs | otherwise = sumEvens xs ``` **Pattern Matching with `where` Clauses** You can also use `where` clauses to define functions that are only used within the scope of a pattern match. This is useful for breaking down complex functions into smaller, more manageable parts. For example, you can use a `where` clause to define a function that calculates the area of a rectangle: ```haskell area :: (Int, Int) -> Int area (x, y) = area' x y where area' :: Int -> Int -> Int area' x y = x * y ``` **Pattern Matching with `as` Patterns** Sometimes, you want to bind the original value to a new name, even after you've pattern-matched it. You can use the `@` symbol to achieve this. This is called an "as" pattern. For example, you can use an "as" pattern to define a function that calculates the length of a list: ```haskell length :: [Int] -> Int length xs@[] = 0 length xs@(_:xs') = 1 + length xs' ``` In this example, `xs` is bound to the original list, and `xs` is also pattern-matched to `[]` or `_:xs'`. **Conclusion** Pattern matching is a powerful feature of Haskell that can be used to control the flow of your program and deconstruct data. In this topic, we have covered advanced pattern matching techniques, including pattern matching with algebraic data types, pattern matching with guards, `where` clauses, and "as" patterns. Remember that practice makes perfect, so try to apply these techniques to your own code. **Practical Exercise** 1. Write a function that calculates the maximum value in a list using pattern matching. 2. Write a function that calculates the length of a list using pattern matching with an "as" pattern. 3. Write a function that calculates the sum of all even numbers in a list using pattern matching with guards. **Additional Resources** * [Haskell Pattern Matching Documentation](https://haskell-lang.org/tutorial/pattern-matching) * [Pattern Matching in Haskell: A tutorial](https://rio.cmj.rs/presentations/2002/oct/pattern_matching/pattern_matching_tutorial.html) **Leave a comment below or ask for help** if you have any questions or difficulties understanding this material.

data Tree = Leaf Int | Branch Tree Tree

sumLeaves :: Tree -> Int
sumLeaves (Leaf x) = x
sumLeaves (Branch left right) = sumLeaves left + sumLeaves right

sumEvens :: [Int] -> Int
sumEvens [] = 0
sumEvens (x:xs) | x `mod` 2 == 0 = x + sumEvens xs
                | otherwise       = sumEvens xs

area :: (Int, Int) -> Int
area (x, y) = area' x y
  where
    area' :: Int -> Int -> Int
    area' x y = x * y

length :: [Int] -> Int
length xs@[] = 0
length xs@(_:xs') = 1 + length xs'