Difficulty understanding a program

Questions / Help
, ,
1

Hi,

I am going through a program in which we are given a list, let’s say

list = [1, 2, 3, 4, 5, 6]

Then the program should put the sum of that array and will repeat the process on the list tail until the list is empty. For example in the above given list:

[1, 2, 3, 4, 5, 6] = 21
[2, 3, 4, 5, 6] = 20
[3, 4, 5, 6] = 18
[4, 5, 6] = 15
[5, 6] = 11
[6] = 6
[] = 0

Here is the program that executes the above operation

Enum.scan([0 | list], Enum.sum(list), fn x, y -> y - x end)

I really don’t understand how the lambda function part work fn x, y -> y -x end

Thanks

2

This says that the anonymous function receives two arguments, x, y. The body of the function is y - x and since this is the last expression of the function, that value is returned. Perhaps easier to parse if you format it as fn(x,y) -> y - x end

3

Is it really the anonymous function that you have trouble understanding with?

It just subtracts one value from another. Where one value (x) is the current value from the input list and the other (y) is the return value from the previous call of the anonymous function.

4

How exactly it is working in the program … every time the head gets eliminated. what does y and x represent?

Can you kindly explain how the code is executing here?

5

so which value is x in the list let say we are considering list = [1, 2, 3, 4, 5, 6] and how it gets reduced to list = [2, 3, 4, 5, 6]. I really dont understand this.

6

Ok so Enum.scan/3 will iterate through the list provided as the first argument, and it’ll build up a reducer as it goes. At each step, the function will store the current reducer value in a list, and return that list at the end. The second argument is what the reducer should start as. Ok, so let’s step through an example.

At the beginning, we’re starting our reducer with the value Enum.sum(list), which equals 21. Then we start iterating through our list. The 21 gets passed to the function as the second argument, and the value from the list gets passed as the first. The first element in the list is a 0, so our first iteration looks like this:
X = 0
Y = 21
21 - 0 = 21
[21]
The result of the computation y - x is stored in the list and used as the accumulator for the next iteration. Let’s keep stepping through:
X = 1
Y = 21
21 - 1 = 20
[21, 20]

X = 2
Y = 20
20 - 2 = 18
[21, 20, 18]

X = 3
Y = 18
18 - 3 = 15
[21, 20, 18, 15]

You can fill in the rest yourself but hopefully this helps you visualize what’s happening. You can also do something like this to more easily visualize it in iex:

Enum.scan([0 | list], Enum.sum(list), fn x, y ->
  IO.inspect(y, label: "y") - IO.inspect(x, label: "x")
end)
6 Likes
7

Thats a perfect explanation … Thank you so much.

8

You’re welcome! Happy to help. I’ve never actually used Enum.scan so I learned something new as well!