ARRG! Still stuck in the imperative world! Help! :)

It is not very clear what You want to achieve… better put some data and expected result.

Anyway, this looks wrong (bad parens placement…)

Map.get(acc, key, MapSet.new())
      |> MapSet.put(get_value_to_add(key))

and piping once is something I try not to do. At least two pipes, otherwise I pass the parameter normally.

There is a Map.update function

Could alternatively be spelled:

update_in acc, [Access.key(key, MapSet.new())], &MapSet.put(&1, get_value_to_add(key))

better way for updating the MapSet within the Map?

["apple", "apricot", "banana", "blueberry", "kiwi", "blackberry"]
|> Enum.reduce(
  %{},
  fn word, acc ->
    first_letter = String.at(word, 0)
    acc |> Map.put(
      first_letter,
      Map.get(acc, first_letter, MapSet.new()) |> MapSet.put(word)
    )
  end
)
|> inspect
|> IO.puts

$ elixir ~/Downloads/elixir-tmp-1.exs
%{"a" => #MapSet<["apple", "apricot"]>, "b" => #MapSet<["banana", "blackberry", "blueberry"]>, "k" => #MapSet<["kiwi"]>}

Except the MapSet…

iex> list = ["apple", "apricot", "banana", "blueberry", "kiwi", "blackberry"]
["apple", "apricot", "banana", "blueberry", "kiwi", "blackberry"]
iex> Enum.group_by(list, &String.first/1)
%{
  "a" => ["apple", "apricot"],
  "b" => ["banana", "blueberry", "blackberry"],
  "k" => ["kiwi"]
} 

With MapSet…

list 
|> Enum.group_by(&String.first/1) 
|> Enum.reduce(%{}, fn {k, v}, acc -> Map.put(acc, k, MapSet.new(v)) end)
%{
  "a" => #MapSet<["apple", "apricot"]>,
  "b" => #MapSet<["banana", "blackberry", "blueberry"]>,
  "k" => #MapSet<["kiwi"]>
}

With MapSet, short version

iex> list 
|> Enum.group_by(&String.first/1) 
|> Enum.reduce(%{}, &Map.put(&2, elem(&1, 0), MapSet.new(elem(&1, 1))))  
%{
  "a" => #MapSet<["apple", "apricot"]>,
  "b" => #MapSet<["banana", "blackberry", "blueberry"]>,
  "k" => #MapSet<["kiwi"]>
}

A matter of personal preference, but I don’t like that reduce, because I tend to avoid using reduces unless it’s necessary, Enum.into is you much much more readable friend.

list = ["apple", "apricot", "banana", "blueberry", "kiwi", "blackberry"]

list
|> Enum.group_by(&String.first/1)
|> Enum.map(fn 
  {key, value} -> {key, Enum.into(value, MapSet.new()}
end)
|> Enum.into(%{})

I always think reduce is better than map into… but last time I checked with benchee, I was proved wrong

I tend to do things where network is very much the bottleneck, and correctness and easy debug/read legacy code is more important, so I’ve slowly let go of caring about performance =D

My only readability concern with my code is that it’s not immediately obvious that “group_by” returns a map. so I might put a comment to that effect. Also, I’m really surprised there wasn’t a List.to_mapset…

At least here I prefer … MapSet.new(value)

oh wow, great point. Yeah. Do that instead of my nested Enum.into monstrosity. I think I didn’t think of that because it “feels too OO”, lol.

That applies here too.

You could use…

|> Map.new()

…instead