Itertating a 2D matrix

In your specific example, it is better to use Enum.reduce.

On it! giving it a try

Hello and welcome,

The code You try to write is not going to work in FP, for many reasons… mostly because data is immutable, and scope is strict. What is defined in a do end block will disappear when the block end.

It’s not an array, it’s a list of list, more prcisely they are linked lists, and do not have the same properties (Not done for index access)

The final list is not going to leak into the wrapping code.
Using Enum.each is procedural

What You should do

final_list = Enum.map(row, ...)

but because You don’t want nil, You could…

final_list = row
|> Enum.map(...)
|> Enum.filter(...)

or better, as mentionned…

final_list = row
|> Enum.reduce([], fn el, acc -> 
  if ..., do: [el | acc], else: acc
end)

You need to use other tools, like the Enum module

Gave it a try but still not working!

iex(12)> Enum.each(list1, fn row ->                                             ...(12)> Enum.reduce(row, fn x, final_list -> final_list = [final_list | x] end) 
...(12)> end
...(12)> )
warning: variable "final_list" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)
  iex:13

:ok
iex(13)> final_list
[]

Thanks for your valuable reply, looks like I gotta lot to learn!

Trying to implement it again

Tried this too:

iex(14)> Enum.each(list1, fn row ->                                
...(14)> final_list = row                                          
...(14)> |> Enum.reduce([], fn el,acc ->                           
...(14)> if el >= 10 and el <= 99 do [el|acc] else acc end         
...(14)> end
...(14)> )
...(14)> end
...(14)> )

Still getting the same error

You might often realize that You could solve something like this with only one command.

This would be my solution.

final_list = Enum.reduce(row, [], fn 
  el, acc when el >= 10 and el <= 99 -> [el | acc] 
  _, acc -> acc
end)

You can see that You don’t need to initially set something to , You can set it in the function call.
It uses an anonymous function with multiple head, and guard clause, no need to use if.
You append an element to the list with [el | acc]
You can minimiize local variables with the use of pipe.

Oh, my code is only for 1 D, for 2 D I need to nest…

There is another tool, You might use in FP, it’s a zipper.

From your initial question I think you are missing a key difference between Python and Elixir. Elixir variables are immutable and you cannot modify them like you would in Python.

results = [] # <= create empty array
for x in range(1, 100):
  if 10 <= x <= 20:
    results.append(x) # <= append to the `results` array which is outside the `for` loop
  else:
   # skip x

# results = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

incorrectly translated to Elixir (similar to your initial attempt)

results = [] # <= create an empty array
Enum.each(1..100, fn x ->
  if x >= 10 and x <= 20, do: results = results ++ [x] # <= does NOT append to the `results` list
end)

# warning: variable "results" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)

instead should be written

results = Enum.reduce(1..100, [], fn x, acc -> # <= assign the final value of the accumulator to results
  if x >= 10 and x <= 20 do
    acc ++ [x] # <= append x to the accumulator
  else
    acc # <= do not modify the accumulator
  end
end)

# results = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

The difference is that Enum.reduce builds up the accumulator array and then assigns it all to results at the end, it doesn’t modify results as it processes each element of the list.
In fact, it cannot modify results even if we wanted to.

The full solution then looks like this,

list1 = [
  [1, 2, 3, 4, "nil"],
  [6, 7, 8, 9, 10],
  [11, "nil", 13, "nil", 15],
  [16, 17, "nil", 19, 20]
]
final_list = Enum.reduce(list1, [], fn inner_list, acc ->
  acc ++ Enum.reduce(inner_list, [], fn x, acc2 ->
    if x >= 10 and x <= 20 do
      acc2 ++ [x]
    else
      acc2
    end
  end)
end)

# => [10, 11, 13, 15, 16, 17, 19, 20]

If you don’t need to retain the nested structure or process the elements further, I would suggest a different approach. First flatten the inner lists and then filter with a simple boolean test.

final_list = list1 
|> List.flatten()
|> Enum.filter(&(&1 >=10 and &1 <= 20))

# final_list = [10, 11, 13, 15, 16, 17, 19, 20]

Banging your head against the wall is a slow way to learn, dude. Trust me I know, I’ve done the same way too many times.

You have to assign the result of almost every function to a variable in Elixir because it does NOT change a variable in place like in Python in many others; it returns a modified copy of the variable.

list = []
Enum.each([1,2,3], fn x ->
  list = list ++ (x*2)
end)

List is still [] in the end because the internal expression list = list ++ (x*2) is staying there and not going anywhere.

If you run the above you’ll get this message:

warning: variable "list" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)

It’s telling you that you are throwing away list from inside the Enum.each block.

The way you would achieve the desired result is this:

list = Enum.map([1,2,3], fn x ->
  x * 2
end)

This goes through each element of the list, modifies it, and appends it to a resulting list.

TL;DR forget about using Enum.each or for to modify variables. They are not used for that, only for side effects (like printing to terminal, writing to files or external network services etc.)

Really helpful one!

The thing is, I am understanding the code, but having issues in writing it! The syntax is a bit changed from languages like Cpp and Python, but I guess I’ll get there. Just need some practice!