**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Algebraic Data Types and Pattern Matching **Topic:** Using `case` expressions and guards for control flow. ### 1. Introduction In the previous topics, we've covered pattern matching as a way to control flow and deconstruct data in Haskell. However, there's another powerful tool for control flow that we haven't discussed yet: `case` expressions. In this topic, we'll learn about using `case` expressions and guards to control the flow of our programs. ### 2. `case` Expressions `case` expressions are a way to perform different actions based on the value of an expression. They consist of a series of alternatives, each of which specifies an expression to match and a corresponding action to take. The general syntax of a `case` expression is: ```haskell case expression of pattern1 -> action1 pattern2 -> action2 ... patternN -> actionN ``` Here's a simple example: ```haskell describeLetter :: Char -> String describeLetter c = case c of 'a' -> "It's the letter 'a'" 'b' -> "It's the letter 'b'" _ -> "It's not 'a' or 'b'" ``` In this example, the `describeLetter` function uses a `case` expression to determine what to return based on the value of its argument. ### 3. Guards Guards are a way to add conditions to patterns in `case` expressions and function definitions. They're denoted by the `|` symbol, and are used to filter patterns. The general syntax of a guard is: ```haskell pattern | guard1, guard2, ... ``` Here's an example of using guards in a `case` expression: ```haskell describeInteger :: Integer -> String describeInteger n = case n of 0 | n == 0 -> "It's zero" _ | n > 0 -> "It's positive" | n < 0 -> "It's negative" ``` In this example, the `describeInteger` function uses a `case` expression with guards to determine what to return based on the value of its argument. ### 4. Combining `case` Expressions and Guards `case` expressions and guards can be combined to create powerful and elegant control flow. Here's an example: ```haskell describeShape :: (Integer, Integer) -> String describeShape (x, y) = case (x, y) of (0, 0) -> "It's the origin" (0, _) -> "It's on the y-axis" (_, 0) -> "It's on the x-axis" (x, y) | x > 0, y > 0 -> "It's in the first quadrant" | x < 0, y > 0 -> "It's in the second quadrant" | x < 0, y < 0 -> "It's in the third quadrant" | x > 0, y < 0 -> "It's in the fourth quadrant" ``` In this example, the `describeShape` function uses a `case` expression with guards to determine what to return based on the coordinates of a point. ### 5. Conclusion In this topic, we've learned about using `case` expressions and guards to control the flow of our programs. We've seen how `case` expressions can be used to perform different actions based on the value of an expression, and how guards can be used to add conditions to patterns. ### 6. Key Takeaways * `case` expressions are a way to perform different actions based on the value of an expression. * Guards are a way to add conditions to patterns in `case` expressions and function definitions. * `case` expressions and guards can be combined to create powerful and elegant control flow. ### 7. Exercises 1. Write a function that uses a `case` expression to determine whether a given character is a digit, letter, or something else. 2. Write a function that uses guards to determine whether a given integer is even or odd. 3. Write a function that uses a `case` expression with guards to determine whether a given point is inside, outside, or on a circle. ### 8. Additional Resources * [ Haskell Official Documentation: Pattern Matching ](https://www.haskell.org/tutorial/patterns.html) * [ Haskell Official Documentation: Guards ](https://www.haskell.org/tutorial/guards.html) ### 9. Discussion and Feedback Please leave a comment below if you have any questions or feedback about this topic.