Recently ‘discovered’ the reduce: option for comprehensions. Very useful, yet there is a syntax difference between into: and reduce: that I don’t understand:

• into: requires the comprehension’s code block to return the element that is to be inserted into the collection:

  for x<-0..2, y<-0..3, into: %{} do
    {{x, y}, x*y}
  end
  

• reduce: requires a accumulator -> code block

  for x<-0..2, y<-0..3, reduce: %{} do 
    acc -> acc |> Map.put({x, y}, x*y)
  end
  

  This allows doing multiple modifications to the collections which actually was my use case:

  for x<-0..2, y<-0..3, reduce: %{} do 
    acc -> acc |> Map.put({x, y}, x*y) |> Map.put({x+10, y+10}, x*y)
  end
  

I was wondering why in the first case we simply return the element to be inserted while in the second case we need a acc -> code(acc) block. I believe it’s for having the possibility to name the accumulator, but is this assumption correct?

I could imagine that for into: we could return a tuple of all the inserts to be done:

for x<-0..2, y<-0..3, into: %{} do
  { {{x, y}, x*y}, {{x+10, y+10}, x*y} }
end

or for reduce: to have a syntax like reduce: {acc_name, acc_initial_value}:

for x<-0..2, y<-0..3, reduce: {acc, %{}} do 
  acc |> Map.put({x, y}, x*y) |> Map.put({x+10, y+10}, x*y)
end

(I actually never really thought about what acc -> some_code(acc) means. I simply use it because the documentations says so. So I may also need a quick explanation on this topic…)