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:

## 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. :)