In comprehensions, why a syntax difference between `into:` and `reduce:`

The reduce syntax mimics the syntax of an anonymous function fn parameter -> body end. The reduce option uses that, because it‘s the only option on for, which gets an extra input beyond what is provided by generators or assignments in the for … do portion - the first parameter to the for special form.

Note, this is equivalent to

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

If you have a single clause for your accumulator, then you can likely find a way to convert to an into instead of reduce. Where reduce really shines is when you choose not to update the accumulator under some conditions. This implies multiple clauses. (And even some of those could use the filter feature of for but not many people are familiar or comfortable with for filters).

Well, I am the one who uses for comprehension if and only if I need a filter (maybe several nested clauses as well, but I don’t realy do numeric calculus often.) Specifically, I love filtering with pattern matching, not the bare x < 0-like filters:

for %{status: :error} = error <- results,
    %{origin: :some_cause} <- [error],
  do: error.description

YMMV.

This question is isomorphic to the following one:

Why Enum.map has arity 2, but Enum.reduce has arity 3?

One might abuse Enum.reduce/3 for mapping, but the actual difference is reduce is folding, decreasing the dimension of the input. In SQL that’s called aggregation. sum is arguably the most trivial example, receiving a list and producing a scalar. That’s obviously impossible without the accumulator.

Oh, but we do have Enum.reduce/2 also The first element of the enumerable is the initial accumulator which is only useful if your result is the same type as the elements of the enumerable, which arguably makes sum the poster child for Enum.reduce/2

Technically, we don’t. It’s just a syntactic sugar. But yes, I get your point

That’s how I think of it as well which reflects why it’s named “reduce”

Funnily enough though, OP’s example is using reduce to unfold and increase the dimension so whereas mapping is n to n, reducing is n to any though typically less than n ¯\_(ツ)_/¯

Simplest way to think about it is that :into is a convenient option that builds on top of reduce. You give it a data type and Elixir adds the reduce loop associated to that data structure for you (which is done via the collectable protocol).