# Enumerables

When we invoke a function in the Enum module, the first argument is usually a collection that must implement a certain protocol.

``````Enum.map([1, 2, 3], fn(x) -> x * 2 end)
Enum.reduce(1..3, 0, fn(x, acc) -> acc + x end)
Enum.reduce(1..3, 0, &+/2)
``````

Above we see both map and reduce being called.

What does `map` do?

It returns a list where each item is the result of invoking fun on each respective item of enumerable.

``````iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)
[2, 4, 6]
``````

`reduce(enumerable, fun)`

It invokes a function for each element in the enumerable, and passes each element and the accumulator as arguments.

The function returns the value stored in the accumulator.

``````iex> Enum.reduce([1, 2, 3, 4], fn(x, acc) -> x * acc end)
24
iex> Enum.reduce(["I", "Like", "Cheese"], "The truth is:", fn(x, sentence) -> sentence <> " " <> x end)
"The truth is: I Like Cheese"
``````

What other operators are available to Enumerable?

• all?
• any?
• chunk
• map
• reduce
• max
• sort
• uniq

We can see all the functions available to `Enum` with the following command:

``````Enum.__info__(:functions) |> Enum.each(&(IO.inspect(&1)))
``````

What do we think each of these functions do?

``````Enum.chunk([1, 2, 3, 4], 2)
Enum.map(1..6, fn(x) -> x - 1 end)
Enum.uniq([1, 1, 1, 2, 3])
``````

`Enum.chunk/2` will break up lists into multiple lists based on the integer provided as the second argument.

``````iex(7)> Enum.chunk([1, 2, 3, 4], 2)
[[1, 2], [3, 4]]
``````

`Enum.map/2` will return a new list with each result corresponding to the result of the function.

``````iex(8)> Enum.map(1..6, fn(x) -> x - 1 end)
[0, 1, 2, 3, 4, 5]
``````

`Enum.uniq/1` sill return a list of unique values. (iex(9)> Enum.uniq([1, 1, 1, 2, 3]) [1, 2, 3])