Posted on

# Introduction

One of the students in my Introduction to Functional Programming course recently submitted a code snippet. It became evident that they assumed Elixir's 'for' construct operates similarly to 'for' loops in non-functional programming languages. However, this is not the case, as Elixir's 'for' is fundamentally different in its behavior.

## What's a list comprehension?

The command 'for' in Elixir is a list comprehension. The result of a 'for' is a list.

For instance, in the example below, 'i' goes from one to ten. The result is a list containing each value of 'i' multiplied by 10.

``````for i <- 1..10 do
i * 10
end
``````
``````[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
``````

You could do the same using Enum.map/2.

``````1..10
|> Enum.map(fn x -> x * 10 end)
``````
``````[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
``````

If, instead, you wanted the result of the sum of all the values of the list, you would have two options.

The first one is to use Enum.sum() to sum all values of the resulting list.

``````1..10
|> Enum.map(fn x -> x * 10 end)
|> Enum.sum()
``````
``````550
``````

The second option is to use Enum.reduce/2:

``````1..10
|> Enum.reduce(fn x, accum -> x * 10 + accum end)
``````
``````541
``````

The result is different. Why?

What if I wanted to multiply all values of the resulting list? The following solution would not work.

``````1..10
|> Enum.reduce(fn x, accum -> x * 10 * accum end)
``````
``````3628800000000000
``````

Because this is the value of 10 *... * 100:

``````10 * 20 * 30 * 40 * 50 * 60 * 70 * 80 * 90 * 100
``````
``````36288000000000000
``````

The correct way is:

``````1..10
|> Enum.reduce(1, fn x, accum -> x * 10 * accum end)
``````
``````36288000000000000
``````

What's the difference between Enum.reduce/2 and Enum.reduce/3?

## Back to for

'For' allows you to have more than one generator (the 'i <- 1..10' part):

``````for i <- 1..3, j <- ["Brasil", "Mexico", "Angola"] do
{:number, i, :country, j}
end
``````
``````[
{:number, 1, :country, "Brasil"},
{:number, 1, :country, "Mexico"},
{:number, 1, :country, "Angola"},
{:number, 2, :country, "Brasil"},
{:number, 2, :country, "Mexico"},
{:number, 2, :country, "Angola"},
{:number, 3, :country, "Brasil"},
{:number, 3, :country, "Mexico"},
{:number, 3, :country, "Angola"}
]
``````

``````require Integer

for i <- 1..3,
j <- ["Brasil", "Mexico", "Angola"],
Integer.is_even(i),
String.starts_with?(j, "B") do
{:number, i, :country, j}
end
``````
``````[{:number, 2, :country, "Brasil"}]
``````

There are many more things that you can do with 'for', 'map' and 'reduce'. Explore Elixir's docs (for, Enum)to learn more!