Pattern matching is a powerful feature in Haskell that allows you to check a value against a pattern. It is a fundamental concept that is used extensively in Haskell for deconstructing data structures, handling different cases, and simplifying code.

1. Basic Pattern Matching:

   • Matching literals and variables.
   • Using patterns in function definitions.

2. Pattern Matching with Lists:

   • Deconstructing lists.
   • Using the cons operator (:).

3. Pattern Matching with Tuples:

   • Deconstructing tuples.
   • Matching nested tuples.

4. Wildcard Patterns:

   • Ignoring parts of a pattern with _.

5. As-Patterns:

   • Capturing the entire value while matching its components.

In Haskell, you can use pattern matching in function definitions to handle different cases. Here’s a simple example:

• isZero 0 = True: This pattern matches if the input is 0.
• isZero _ = False: The underscore _ is a wildcard pattern that matches any value.

Lists are a fundamental data structure in Haskell, and pattern matching is often used to deconstruct them.

• head' [] = error "Empty list": This pattern matches an empty list and throws an error.
• head' (x:_) = x: This pattern matches a non-empty list, where x is the head and _ is the tail (ignored).

Tuples are another common data structure, and pattern matching can be used to deconstruct them.

• addPairs (a, b) (c, d) = (a + c, b + d): This pattern matches two pairs of integers and adds their corresponding elements.

Wildcard patterns are useful when you want to ignore certain parts of a pattern.

• hasOneElement (_:[]) = True: This pattern matches a list with exactly one element (ignoring the element itself).
• hasOneElement _ = False: This pattern matches any other list.

As-patterns allow you to capture the entire value while matching its components.

• xs@(x:_) = x : xs: This pattern matches a non-empty list, captures it as xs, and constructs a new list with the head duplicated.
• duplicateHead [] = []: This pattern matches an empty list and returns an empty list.

Write a function sumList that calculates the sum of all elements in a list.

• sumList [] = 0: This pattern matches an empty list and returns 0.
• sumList (x:xs) = x + sumList(xs): This pattern matches a non-empty list, adds the head x to the sum of the tail xs.

Write a function lengthList that calculates the length of a list.

• lengthList [] = 0: This pattern matches an empty list and returns 0.
• lengthList (_:xs) = 1 + lengthList(xs): This pattern matches a non-empty list, adds 1 to the length of the tail xs.

• Forgetting Base Cases: Always include base cases (e.g., empty list) to avoid runtime errors.
• Overlapping Patterns: Ensure patterns are mutually exclusive or ordered correctly to avoid unexpected behavior.
• Using Wildcards Wisely: Use wildcards to ignore irrelevant parts, but avoid overusing them as they can make code less readable.

Pattern matching is a versatile and powerful feature in Haskell that simplifies code by allowing you to deconstruct data structures and handle different cases elegantly. By mastering pattern matching, you can write more concise and readable Haskell code. In the next topic, we will explore Guards, which provide another way to handle different cases in function definitions.