Merging maps in list based on matching value

benonymus

Hey I have a list of maps, and those maps are items such:

[
%purchase{
    amount: #Decimal<2.0>,
    command: "buy",
    id: 71,
    price: #Decimal<90.394>,
  },
%purchase{
    amount: #Decimal<1.0>,
    command: "buy",
    id: 72,
    price: #Decimal<90.394>,
  }
]

As you can see the prices are the same but the amount isn’t how would you go through the list to merge the items with the same price to get something like this:

[
%purchase{
    amount: #Decimal<3.0>,
    command: "buy",
    price: #Decimal<90.394>,
  }
]

5 comments

#maps #structs #list

0 2497 5

2019-05-05 17:36:40 UTC

Showing Posts 1 to 5

Show Best Posts
Show All Posts (oldest first)
Show All Posts (newest first)

benwilson512

Author of Craft GraphQL APIs in Elixir with Absinthe

Hey @benonymus what have you tried so far? If you need help getting started, check out the functions in Enum — Elixir v1.20.2 and see if there’s something that might like you group_by the items with the same price, after which you could go through each price group and reduce them into a single purchase.

Post #1

benonymus

Hey, I came up with 2 solutions so far:

for order <- buy do
      Enum.reduce(
        buy,
        order,
        fn x, y ->
          cond do
            Decimal.cmp(x.price, y.price) == :eq and x.id != y.id ->
              new_amount = Decimal.add(x.amount, y.amount)
              Map.put(y, :amount, new_amount)

            true ->
              y
          end
        end
      )
    end
    |> Enum.uniq_by(fn x -> x.price end)

and

    for order <- buy do
      Enum.map(buy, fn x ->
        cond do
          Decimal.cmp(x.price, order.price) == :eq and x.id != order.id ->
            new_amount = Decimal.add(x.amount, order.amount)
            Map.put(order, :amount, new_amount)

          true ->
            order
        end
      end)
    end
    |> List.flatten()
    |> Enum.uniq_by(fn x -> x.price end)

But I am having a hard time deciding which one to stick with
Edit:
I decided to stick with the reduce version, so I don’t need to flatten a list

Post #2

dimitarvp

Needlessly verbose IMO. Here’s how I went about it:

defmodule Stock do
  def aggregate_by_price(items) do
    items
    |> Enum.group_by(&(Decimal.reduce(&1.price)))
    |> Enum.map(fn({_price, items}) ->
      Enum.reduce(items, fn(acc, item) ->
        %{acc | amount: Decimal.add(acc.amount, item.amount)}
      end)
    end)
  end
end

Then in iex:

items = [
  %{price: Decimal.from_float(90.394), amount: Decimal.from_float(2.0)},
  %{price: Decimal.from_float(90.394), amount: Decimal.from_float(1.0)},
  %{price: Decimal.from_float(17.64738), amount: Decimal.from_float(10.0)},
  %{price: Decimal.from_float(90.394), amount: Decimal.from_float(5.0)},
  %{price: Decimal.from_float(17.64738), amount: Decimal.from_float(13.0)}
]

Stock.aggregate_by_price(items)

This returns:

[
  %{amount: #Decimal<8.0>, price: #Decimal<90.394>},
  %{amount: #Decimal<23.0>, price: #Decimal<17.64738>}
]

Which seems to be what you need.

Post #3

benwilson512

Author of Craft GraphQL APIs in Elixir with Absinthe

We can golf this slightly smaller by using Enum.reduce/2 which does the hd/tl thing for you:

      Enum.reduce(items, fn(acc, item) ->
        %{acc | amount: Decimal.add(acc.amount, item.amount)}
      end)

The only real concern with this approach I’m realizing is that it compares price based on term equality not Decimal.cmp. That may require manual grouping, but that shouldn’t be too bad.

Post #4

dimitarvp

Heh, always thought Enum.reduce/2 repeats the first element when iterating. Thanks for ridding me of that dumb illusion!

Oops, I actually thought of addressing this but forgot. We can get away with it by using Decimal.reduce/1 because sometimes even identical float values – but represented differently when passed to Decimal.from_float – yield false when compared with == (which I agree should not be done).

Edited above to reflect your remarks.

Post #5

— All posts loaded —