# Elixir Basics: Looping and Recursion

When I first started learning Elixir a couple years ago, recursion was not something I was using on a day-to-day basis. But the functional nature of Elixir forced me to learn the concepts and I thought I would share some of my findings.

## An Example Not in Elixir

As an example, lets find the minimum value in a list of numbers. A very simple approach in a language like C# could look something like this:

```
int[] numbers = new int[] { 11, 4, 19, 18, 6, 5, 24, 8, 4 };
int min = numbers[0];
for (int i = 0; i < numbers.Length; i++)
{
if (numbers[i] < min)
{
min = numbers[i];
}
}
return min;
```

Now how would we accomplish something similar in Elixir? The first thing you will realize is that there is no `for`

loop in Elixir. And since we will not have mutable state outside of our “loop”, we will need a way to keep track of the state.

## Elixir Example

If you’ve read through the Elixir guides, you’ll find that recursion is the way to solve this in Elixir.

So lets start with a basic `List`

in Elixir:

```
numbers = [ 11, 4, 19, 18, 6, 5, 24, 8, 4 ]
```

Now lets create a public `min/1`

function to take in the list of numbers and some private functions that will be used to iterate over each item in the collection.

*Note: I am leaving out some guard clauses and validation in favor of simplicity for this post.*

```
def min(numbers) do
min(numbers, hd(numbers))
end
defp min([head | tail], min) when min <= head do
min(tail, min)
end
defp min([head | tail], min) when min > head do
min(tail, head)
end
defp min([], min) do
min
end
```

The first function is public, and accepts the list of numbers and proceeds to call `min/2`

passing the list as well as the first item in the list as the starting “min” value:

```
def min(numbers) do
min(numbers, hd(numbers))
end
```

`hd/1`

is an easy way to get the first item, or “head” of a list.

Next we have two functions that pattern match on a list using `[head | tail]`

as the first argument as well as keeping track of the current “min” value as we go.

```
defp min([head | tail], min) when min <= head do
# Pass the rest of the list to the next iteration and since the min value
# didn't change we just keep the existing min value
min(tail, min)
end
defp min([head | tail], min) when min > head do
# We encountered a new min value so we take the new value and set
# the current state (the "min" argument) to the current head
min(tail, head)
end
```

The guard clauses on the functions ensure that the correct function gets called depending on if we encounter a new minimum value, thus resetting the `min`

variable and passing it along to the next call.

The last function pattern matches on an empty list:

```
defp min([], min) do
min
end
```

This tells us that we have reached the end of the list and there are no further items to iterate over. We simply return the current `min`

value and the recursion has come to an end.

At this point we end up with `4`

being returned as the min value from our original list.

## Tail Call Optimization

Erlang includes a nifty optimization for tail recursion that will help us with large lists. As explained in the excellent post by Phillip Brown about Tail Call Optimization:

Tall Call Optimisation is where if the last thing a function does is call another function, the compiler can jump to the other function and then back again without allocating any additional memory.

As you can see in the code above we are taking advantage of this optimization, so we should not run into any memory issues with large lists of numbers.

## Closing Thoughts

There are other ways a “min” function could be written. For instance, similar algorithms could be solved using the `map`

or `reduce`

functions in the Enum module built into Elixir; but that is a topic for a future post. For now, I wanted to show how to implement something simple using recursion, and I hope this post will help you.

You can pull this example and others (along with tests) from the following repo: https://github.com/mkchandler/MathFunctionsElixir