Grouping/precedence for "/@" operator

Question

This returns errors:

{#[[1]],#[[3]]} & /@ {#[[1]],#[[2]],#[[3]]} & /@ {{"A","B","C"},{1,2,3}}

Part::partd: Part specification A[[1]] is longer than depth of object. >>
...

But when adding parentheses after first /@ (Map) and closing it on the end of expression, as in:

{#[[1]],#[[3]]} & /@ ({#[[1]],#[[2]],#[[3]]} & /@ {{"A","B","C"},{1,2,3}})

everything goes fine and returns expected result: {{"A", "C"}, {1, 3}}

How to explain the behavior of first case? I cannot figure out what cause errors in first case.

Answer 1

Perhaps this example helps:

3 # & /@ Sin[#] & /@ {x, y, z}
(*{Sin[3 x], Sin[3 y], Sin[3 z]}*)

vs.

3 # & /@ (Sin[#] & /@ {x, y, z})
(*{3 Sin[x], 3 Sin[y], 3 Sin[z]}*)

Answer 2

To understand grouping and precedence, use HoldForm and PrecedenceForm. I'll insert a screenshot to make the output clearer:

It is useful to know that // has even lower precedence than & and can save you some parentheses.

You probably meant:

({#[[1]], #[[3]]} &) /@ ({#[[1]], #[[2]], #[[3]]} &) /@ {{"A", "B", "C"}, {1, 2, 3}}

It is useful to parenthesize the entire function because & has very low precedence, lower than most other operators. Thus it tends to act on everything preceding it.

---

Another common mistake with & is using it like this in options:

SomeFunction -> #&

This is really (SomeFunction -> #)& and not SomeFunction -> (#&).

---

One of the few operators that have even lower precedence than & is //. Thus this is safe:

argument // #&

It groups as argument // (#&) and not as (argument // #)&.

---

Alternative ways to write you expression are:

Map[{#[[1]], #[[3]]} &] @ Map[{#[[1]], #[[2]], #[[3]]} &] @ {{"A", "B", "C"}, {1, 2, 3}}

{{"A", "B", "C"}, {1, 2, 3}} // Map[{#[[1]], #[[2]], #[[3]]} &] // Map[{#[[1]], #[[3]]} &]

You may or may not find these more readable than the explicitly parenthesized version.

Recently I prefer the latter when doing a lot of chaining.