# Suggest me to better idea to Nested Loop

I have data in multidimensional array. And I will not use nested loop. so please give me suggestion, what I can do for print each array data.
Below code related to single loop.

map = %{}
Enum.each [1, 2, 3], fn x ->
Map.put(map, x, x)
end
map

But, I need nested loop.

Hard to answer without understanding more â€¦

What is the shape of your data, exactly? You say a multidimensional array, but can you provide an example?

When you say you want to print each bit of data, what sort of output are you hoping for, exactly? Can you can give an example of what you would like to see as output?

I have the feeling that these statements contradict each other.

Also, Iâ€™m pretty sure that you are not dealing with arrays at all but nested lists.

Then we do not have â€śloopsâ€ť in elixir, we have comprehensions, and you should be able to nest them of courseâ€¦

Still, itâ€™s as @aseigoalready said, without knowing more about your input and your expected output it is hard to tell whatâ€™s the best way to solve the problem.

Perhaps you can tell more about the original problem, then only asking about a way to solve it?

1 Like

If you have nested lists, you can use nested Enum.each to iterate over them.

two_dimensional_list = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

Enum.each(two_dimensional_list, fn row ->
Enum.each(row, fn value ->
some_side_effect(value)
end)
end)

map = %{}
Enum.each [1, 2, 3], fn x ->
Map.put(map, x, x)
end
map

you can use Enum.reduce or Enum.into.

input = [1, 2, 3]
Enum.reduce(input, %{}, fn x, acc -> Map.put(acc, x, x) end)

or

input = [1, 2, 3]

input
|> Enum.map(input, fn value -> {value, value} end) # {key, value}
|> Enum.into(%{})

This doesnâ€™t even work, as you discard the map that you put into. Therefore the last map will still be %{}.

3 Likes

You can also nest comprehensions. For example:

list = Enum.to_list(1..9)
list_of_lists = Enum.chunk_every(list, 3)
IO.puts("#{inspect(list_of_lists, [charlists: :as_lists])}")
fun = &(&1*&1)
result =
for {row,index} <- Enum.with_index(list_of_lists), into: %{}, do:
{index, (
for element <- row, into: %{}, do: {element, fun.(element)}
)}
IO.puts("#{inspect(result)}")
iex(1)> list = Enum.to_list(1..9)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
iex(2)> list_of_lists = Enum.chunk_every(list, 3)
[[1, 2, 3], [4, 5, 6], '\a\b\t']
iex(3)> IO.puts("#{inspect(list_of_lists, [charlists: :as_lists])}")
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
:ok
iex(4)> fun = &(&1*&1)
#Function<6.127694169/1 in :erl_eval.expr/5>
iex(5)> result =
...(5)>   for {row,index} <- Enum.with_index(list_of_lists), into: %{}, do:
...(5)>     {index, (
...(5)>       for element <- row, into: %{}, do: {element, fun.(element)}
...(5)>     )}
%{
0 => %{1 => 1, 2 => 4, 3 => 9},
1 => %{4 => 16, 5 => 25, 6 => 36},
2 => %{7 => 49, 8 => 64, 9 => 81}
}
iex(6)> IO.puts("#{inspect(result)}")
%{0 => %{1 => 1, 2 => 4, 3 => 9}, 1 => %{4 => 16, 5 => 25, 6 => 36}, 2 => %{7 => 49, 8 => 64, 9 => 81}}
:ok
iex(7)>

â€¦ keeping in mind that for is a comprehension expression, not a for (loop) statement. As a rule you do not use comprehensions for side effects like â€śprinting dataâ€ť but for data transformation into a Collectable (a list by default).

2 Likes