Guards in Haskell are a way to make decisions in your code based on boolean expressions. They are often used in function definitions to choose between different actions based on the values of the function's arguments. Guards provide a more readable and expressive way to handle multiple conditions compared to nested if-then-else statements.

1. Syntax of Guards:

   • Guards are written using the pipe symbol (|).
   • Each guard is followed by a boolean expression.
   • If the boolean expression evaluates to True, the corresponding result is returned.
   • An otherwise guard can be used as a catch-all condition.

2. Usage in Function Definitions:

   • Guards are typically used in function definitions to handle different cases.
   • They can be used to simplify complex conditional logic.

3. Order of Evaluation:

   • Guards are evaluated from top to bottom.
   • The first guard that evaluates to True will determine the result.

Let's define a function absolute that returns the absolute value of a number using guards.

Explanation:

• The function absolute takes an integer x as input.
• The first guard checks if x is less than 0. If true, it returns -x.
• The otherwise guard is a catch-all that returns x if none of the previous guards are true.

Let's create a function grade that assigns a letter grade based on a numerical score.

Explanation:

• The function grade takes an integer score as input.
• It uses multiple guards to check the range of the score and returns the corresponding letter grade.
• The guards are evaluated in order, so the first matching condition determines the result.

Write a function maxOfThree that takes three integers and returns the maximum of the three using guards.

Write a function bmi that calculates the Body Mass Index (BMI) and categorizes it into "Underweight", "Normal", "Overweight", or "Obese".

Explanation:

• The function bmi takes weight (in kilograms) and height (in meters) as inputs.
• It calculates the BMI value using the formula weight / (height * height).
• Guards are used to categorize the BMI value into different weight categories.

• Order of Guards: Ensure that guards are ordered correctly. The first guard that evaluates to True will be the result, so more specific conditions should come before more general ones.
• Boolean Expressions: Guards must be followed by boolean expressions. Ensure that each guard condition is a valid boolean expression.
• Catch-All Guard: Use otherwise as a catch-all guard to handle any cases not covered by previous guards.

Guards in Haskell provide a powerful and readable way to handle multiple conditions in your code. By using guards, you can simplify complex conditional logic and make your functions more expressive. Practice using guards in different scenarios to become comfortable with this feature of Haskell. In the next module, we will explore higher-order functions, which are a fundamental concept in functional programming.