How can I iterate two list of maps at once? - functional-programming

Question

I have two maps containing a list of maps. How can I filter "customers" map, returning only customers that have a proposal in the proposal list?
%{proposals:
[
%App.Structs.Proposal{customer_id: "5202845", ...other_fields},
%App.Structs.Proposal{customer_id: "9778978", ...other_fields}
]
}
%{customers:
[
%App.Structs.Customer{id: "5202845", ...other_fields},
%App.Structs.Customer{id: "5643635", ...other_fields},
%App.Structs.Customer{id: "9778978", ...other_fields},
%App.Structs.Customer{id: "3423454", ...other_fields}
]
}
What I want:
-> Given the list, I'll run a function that will return the name of this customer.
I've tried two "for", filter by ids then compare the two lists, reduce the customer list based in id... None of them worked.
Any suggestions?

Answer 1

The easiest way would be to use a comprehension (thanks #keroro520 for the formatted input):
proposals = [
%{customer_id: "5202845", other: "foo"},
%{customer_id: "9778978", other: "foo"}
]
customers = [
%{id: "5202845", name: "foo"},
%{id: "5643635", name: "bar"},
%{id: "9778978", name: "baz"},
%{id: "3423454", name: "boo"}
]
for %{customer_id: cid} <- proposals,
cs <- Enum.filter(customers, & &1.id == cid),
do: cs.name
#⇒ ["foo", "baz"]
I have to say, though, that you are doing it wrong in the first place. The lookup is unavoidably done for each proposal’s customer_id, leading to O(N²) efficiency, which is generally bad.
The best approach would be probably to convert proposals to Ecto schema, with customers embedded. The reinvented wheel would look like introducing a Proposal.new/2 method that will both update the struct itself and immediately lookup customers to update the nested customer_names field (the same should be done for Customer struct to update proposals respectively.) Both could live in Agent to maintain their state. Maybe it’s a premature optimization, though.

Answer 2

You could try the code below (However, I think maybe it is better if you change proposals and customers data structure, for example, use map data structure and id as key).
customer_ids = Enum.map(proposals, &Map.get(&1, :customer_id))
customers_id_names = Enum.map(customers, &{Map.get(&1, :id), Map.get(&1, :name)})
|> Enum.into(%{})
Map.take(customers_id_names, customer_ids)
Complete module code: https://gist.github.com/keroro520/61173bda3b1441e8a6be25eb0166c6f8

Answer 3

An easy way is to do exactly as you said: filter "customers" map
First, we shamelessly copy paste some of the hard work on part of #keroro520:
some_map = %{
proposals: [
%{customer_id: "5202845", other: "foo"},
%{customer_id: "9778978", other: "foo"}
],
customers: [
%{id: "5202845", name: "foo"},
%{id: "5643635", name: "bar"},
%{id: "9778978", name: "baz"},
%{id: "3423454", name: "boo"}
]}
Then we start off with singling out the foreign keys from proposals:
proposals = Enum.map(some_map[:proposals], &(&1[:customer_id]))
Then we do a simple filter over customers:
filtered_customers = Enum.filter(some_map[:customers], fn %{id: id} -> Enum.member?(proposals, id) end)
These are all the customers with their full fledged details that have a proposal belonging to them. If you only want their names, then map their names accordingly:
Enum.map(filtered_customers, &(&1[:name]))
And there pops out as your answer:
["foo", "baz"]

Answer 4

Just one other way of doing it, I personally use reduce a lot. (your data structures are also a bit weird and if you're assembling them somewhere you could skip the entire into just by making an "orders" map initially instead of a list - this also doesn't "iterate" two lists at once, but I doubt that's what you want either way)
proposals = %{proposals:
[
%App.Structs.Proposal{customer_id: "5202845", some: "foo"},
%App.Structs.Proposal{customer_id: "9778978", some: "baz"}
]
}
customers = %{customers:
[
%App.Structs.Customer{id: "5202845", name: "one"},
%App.Structs.Customer{id: "5643635", name: "two"},
%App.Structs.Customer{id: "9778978", name: "three"},
%App.Structs.Customer{id: "3423454", name: "four"}
]
}
props = Enum.into(proposals.proposals, %{}, fn(%App.Structs.Proposal{customer_id: ci}) ->
{ci, true} end)
Enum.reduce(customers.customers, [], fn(%App.Structs.Customer{id: id, name: name}, acc) ->
case props[id] do
nil -> acc
_ -> [name | acc]
end) end)