# Understanding Enum.scan

Hi,

I am having a list of tuples

``````list = [{-1, 3}, {1, 5}, {10, 15}]
``````

When i pass it through Enum.scan, it gives me the following result. Its a program i saw on codewars but i really dont understand how the Enum.scan is working over here.

``````Enum.scan(list, fn {b, e}, {_, x} -> {max(b, x), max(e, x)} end)

output: [{-1, 3}, {3, 5}, {10, 15}]
``````

I tried IO.inspect to look at the results but still, it doesn’t make any sense. Here is the result of IO.inspect

``````b: 1
x1: 3
max(b, x): 3
e: 5
x2: 3
max(e, x): 5
b: 10
x1: 5
max(b, x): 10
e: 15
x2: 5
max(e, x): 15
[{-1, 3}, {3, 5}, {10, 15}]
``````

Hi,
It makes sense As you don’t pass initial accumulator, then the first element of the list was taken and the first element on output will be the same as on input - `{-1, 3}`.
Then, on first iteration

``````[b: 1, e: 5, x: 3]
``````

`b` and `e` are from the second element of the list and `x` is from accumulator which is the first element of the list.
Then you build new two-element tuple which is `{3, 5}`, it is used as second value in output list and as accumulator for the next element.
Then on the next iteration

``````[b: 10, e: 15, x: 5]
``````

`b` and `e` are from the last element and `x` is from accumulator. Newly built tuple is `{10, 15}`, it is used as third element.
So, we have

``````[{-1, 3}, {3, 5}, {10, 15}]
``````

Maybe, it would be easier for you if we reimplement `Enum.scan` using `Enum.map_reduce`:

``````def my_scan([], _callback), do: []
def my_scan([head | tail], callback) do
{map_result, _reduce_result} = Enum.map_reduce(tail, head,  fn x, acc ->
result = callback.(x, acc)
{result, result}
end)