Like @LostKobrakai mentioned, scoping is one problem: code inside a do block can’t rebind variables outside of that block in a way that’s visible outside.
The other problem is that ++ makes a new list, it doesn’t mutate either argument. Code like what you posted is pretty common in other languages:
# in Ruby
list_a = []
list_b = []
list_c.each do |item|
item_a, item_b = process(item)
list_a.concat(item_a.inner_list)
list_b.concat(item_b.inner_list)
end
# in Python
list_a = []
list_b = []
for item in list_c:
item_a, item_b = process(item)
list_a.extend(item_a.inner_list)
list_b.extend(item_b.inner_list)
This approach will not work in Elixir. My suggestion is that you temporarily forget you even saw Enum.each; it’s only useful in a very narrow set of situations.
A better way to think about solving these kinds of problems in Elixir is to focus on how the “shape” of the data changes.
As a first step, we want to run process/1 on every element of list_c:
processed_list = Enum.map(list_c, &process/1)
Each element of processed_list is a tuple shaped like {item_a, item_b}.
There are several possibilities here: we could refine these tuples by extracting inner_list, but instead we’ll start by regrouping them.
What we have is a list of 2-element tuples.
What we want is a 2-element tuple of lists (what the original called list_a and list_b)
This kind of transformation comes up often enough that it has a name: Enum.unzip/1. Using it looks like:
tuple_of_lists = Enum.unzip(processed_list)
Now tuple_of_lists is shaped like {list_of_item_as, list_of_item_bs}
Finally, we need to extract the inner_list parts. We could use Enum.map again:
# not quite right - see below for a correct solution
{list_of_as, list_of_bs} = tuple_of_lists
list_a = Enum.map(list_of_as, & &1.inner_list)
list_b = Enum.map(list_of_bs, & &1.inner_list)
but this doesn’t quite do what we’re looking for: it results in list_a and list_b being lists of lists. You could use List.flatten/1, if the values in inner_list are not themselves lists.
BUT
There’s an easier way! Again, what we’re looking for is referenced enough to have a name: Enum.flat_map:
{list_of_as, list_of_bs} = tuple_of_lists
list_a = Enum.flat_map(list_of_as, & &1.inner_list)
list_b = Enum.flat_map(list_of_bs, & &1.inner_list)
Putting all the pieces together gives this code:
processed_list = Enum.map(list_c, &process/1)
tuple_of_lists = Enum.unzip(processed_list)
{list_of_as, list_of_bs} = tuple_of_lists
list_a = Enum.flat_map(list_of_as, & &1.inner_list)
list_b = Enum.flat_map(list_of_bs, & &1.inner_list)
This code can be tidied up with some Elixir syntax goodies:
# squish "processed_list" out of existence since it is bound and then immediately used
tuple_of_lists =
list_c
|> Enum.map(&process/1)
|> Enum.unzip()
{list_of_as, list_of_bs} = tuple_of_lists
list_a = Enum.flat_map(list_of_as, & &1.inner_list)
list_b = Enum.flat_map(list_of_bs, & &1.inner_list)
and even more with then which was recently added:
{list_a, list_b} =
list_c
|> Enum.map(&process/1)
|> Enum.unzip()
|> then(fn {list_of_as, list_of_bs} ->
{
Enum.flat_map(list_of_as, & &1.inner_list),
Enum.flat_map(list_of_bs, & &1.inner_list)
}
end)
This code does exactly the same steps as the first “un-simplified” version, but avoids having to name a bunch of variables that are used exactly once (like processed_items and tuple_of_lists).
