**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Basic Types, Functions, and Pattern Matching **Topic:** Write functions with pattern matching and explore list operations. **Objective:** In this lab, you will practice writing functions using pattern matching and explore common list operations in Haskell. By the end of this lab, you should be able to apply pattern matching to write functions and use list operations to manipulate lists. **Pattern Matching Review** Pattern matching is a powerful technique in Haskell that allows you to define functions by specifying multiple alternatives for how to handle different inputs. You have already seen basic syntax and examples of pattern matching in previous topics. **Writing Functions with Pattern Matching** Let's write a simple function that uses pattern matching to double the elements of a list. We will call this function `doubleElements`. ```haskell doubleElements :: [Int] -> [Int] doubleElements [] = [] doubleElements (x:xs) = 2 * x : doubleElements xs ``` In the above example, we define `doubleElements` as a function that takes a list of `Int` and returns a list of `Int`. The first line of the function definition says that if the input is an empty list `[]`, then the result is also an empty list `[]`. The second line uses pattern matching to define what happens when the input is a non-empty list. The pattern `(x:xs)` matches a list where `x` is the first element and `xs` are the remaining elements. The expression `2 * x : doubleElements xs` says that the result is a new list where the first element is `2 * x` and the remaining elements are the result of calling `doubleElements` on `xs`. **Common List Operations** Haskell provides several common list operations that you can use to manipulate lists. Here are a few examples: 1. **Head and Tail**: The `head` function returns the first element of a list, and the `tail` function returns all elements except the first. ```haskell head :: [a] -> a tail :: [a] -> [a] ``` Example: ```haskell ghci> head [1, 2, 3] 1 ghci> tail [1, 2, 3] [2,3] ``` 2. **Length**: The `length` function returns the number of elements in a list. ```haskell length :: [a] -> Int ``` Example: ```haskell ghci> length [1, 2, 3] 3 ``` 3. **Null and Non-Null**: The `null` function checks if a list is empty, and the `nonNull` function checks if a list is not empty. ```haskell null :: [a] -> Bool nonNull :: [a] -> Bool ``` Example: ```haskell ghci> null [] True ghci> null [1, 2, 3] False ghci> nonNull [] False ghci> nonNull [1, 2, 3] True ``` 4. **Take and Drop**: The `take` function returns a specified number of elements from the beginning of a list, and the `drop` function removes a specified number of elements from the beginning of a list. ```haskell take :: Int -> [a] -> [a] drop :: Int -> [a] -> [a] ``` Example: ```haskell ghci> take 2 [1, 2, 3] [1,2] ghci> drop 2 [1, 2, 3] [3] ``` 5. **Map and Filter**: The `map` function applies a function to all elements of a list, and the `filter` function removes elements from a list that do not satisfy a predicate. ```haskell map :: (a -> b) -> [a] -> [b] filter :: (a -> Bool) -> [a] -> [a] ``` Example: ```haskell ghci> map double [1, 2, 3] [2,4,6] ghci> filter isOdd [1, 2, 3] [1,3] ``` where `isOdd` is a function that checks if a number is odd: ```haskell isOdd :: Int -> Bool isOdd x = x `mod` 2 == 1 ``` **Lab Exercises** Here are a few lab exercises to help you practice writing functions with pattern matching and using list operations: 1. **Double Elements**: Write a function called `doubleElements` that doubles the elements of a list. 2. **Product of List**: Write a function called `product` that calculates the product of a list of numbers. 3. **Reverse List**: Write a function called `reverseList` that reverses a list. 4. **Find Element**: Write a function called `findElement` that searches for a specified element in a list. 5. **Mean of List**: Write a function called `mean` that calculates the mean of a list of numbers. You can download the lab files at [Course GitHub Repository](https://github.com/course-repo/cfp-haskell) **References and Further Reading** For a more in-depth explanation of pattern matching and list operations in Haskell, see: * [Haskell Official Documentation: Patterns](https://www.haskell.org/tutorial/patterns.html) * [Haskell Official Documentation: Lists](https://www.haskell.org/tutorial/lists.html) * [Real World Haskell: Pattern Matching and Guards](http://book.realworldhaskell.org/read/types-and-functions.html#func%20eq) **What's Next?** In the next topic, we will explore **Recursion and Higher-Order Functions**. If you have any question or have issue with any of the lab files, please leave your message below, I will be more than happy to give you a feedback. Do not worry If you feel that any of the concept was not clear, we will still review and clarify all of them one more time before moving to final project.