In my last post about Learning Haskell, I’ve explained a little bit about the rules for recursion, and as an example, a `factorial`

recursive function. We can implement that `factorial`

function in many ways, for instance, with `Pattern Matching`

.

**Read the other posts of this serie:**

- Part 1
- Part 2 - Lambda functions
- Part 3 - First-class functions
- Part 4 - Lists
- Part 5 - Rules for recursion

## What is Pattern matching?

Pattern matching is a way to take some value and match it against some pattern. In other words, Pattern matching give us the ability to recognize values and break these values into parts.

## Factorial revisited (with Pattern matching)

To rewrite the factorial function with Pattern matching, let’s look to the `factorial`

function from my last post:

```
-- Factorial function - recursive version
factorial n =
if n < 2
then 1
else n * factorial (n - 1)
```

The condition is that if the number (n) is smaller than `2`

, we return `1`

, (that’s the factorial rule) otherwise, we return the number (n) times the factorial function.

By the rule above, we can start our factorial function using Pattern matching like this:

```
-- Factorial function - Pattern matching version
-- Matching the first case
factorial 0 = 1
```

And then we repeat the process for all the other conditions, for the second case, where the number (n) is `1`

:

```
-- Factorial function - Pattern matching version
-- Matching the second case
factorial 0 = 1
factorial 1 = 1
```

Finally, for the last case where the number (n) is any number equal or greater than `2`

:

```
-- Factorial function - Pattern matching version
-- Matching the second case
factorial 0 = 1
factorial 1 = 1
factorial n = n * factorial (n - 1)
```

That’s all!

Pattern matching forces you to declare all the scenario, making your code more readable. :)