How does MapThread work with Associations?

Question

According to the documentation, MapThread works on Association objects. But it doesn't seem to evaluate the passed function. For example:

MapThread[#1 + #2 &, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]

returns:

<|a -> (#1 + #2 &)[1, 5], b -> (#1 + #2 &)[2, 6]|>

I would have expected <| a -> 6, b -> 8 |>.

It seems to work if the Associations are in separate Lists: MapThread[#1 + #2 &, {{<|a -> 1, b -> 2|>}, {<|a -> 5, b -> 6|>}}] — RunnyKine, Oct 16 '14 at 08:27
@RunnyKine I think that is merely accomplishing <|a -> 1, b -> 2|> + <|a -> 5, b -> 6|>. (Which itself is of interest however.) — Mr.Wizard, Oct 16 '14 at 08:37

score 4 · Answer 1 · answered Sep 16 '23 at 08:45

It works with V 13.3 (and maybe with some versions preceding it)

data = {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}
MapThread[#1 + #2 &, data]

<|a -> 6, b -> 8|>

MapThread[Plus, data]

<|a -> 6, b -> 8|>

But this fails without warnings:

MapThread[Total] @ data

<|a -> 1, b -> 2|>

Anyway, I think one should use Merge, which was specifically designed to work with Lists of Rules and Associations.

Merge[Total] @ data

<|a -> 6, b -> 8|>

Merge[Apply @ Plus] @ data

<|a -> 6, b -> 8|>

(+1) Also MapThread[Total[{##}]&, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}] — user1066, Sep 16 '23 at 15:37

kglr · Answer 2 · 2014-10-16T09:18:42.663

4

Not an answer... some observations:

Activate/@MapThread[(#+#2)&, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]
Normal@MapThread[(#+#2)&,{<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]
ReleaseHold/@MapThread[(#+#2)&, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]
Evaluate/@MapThread[(#+#2)&, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]
MapThread[(#+#2)&,{<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}, 0]

all give

<|a -> 6, b -> 8|>

and, as noted by Mr. Wizard, all are equivalent to,

<|a -> 1, b -> 2|> + <|a -> 5, b -> 6|>

edited Oct 16 '14 at 09:18

answered Oct 16 '14 at 08:41

kglr

394,356
18
477
896

+1 but realize that only Map is important here; e.g. Evaluate is incidental. – Mr.Wizard Oct 16 '14 at 08:45
In your example using Thread, Thread is superfluous; you are merely adding the two associations which triggers automatic threading. Likewise the use of MapThread with levelspec 0. See eldo's deleted answer and my just-posed question on the subject. – Mr.Wizard Oct 16 '14 at 08:55
@Mr.W got it ... finally ... thanks:) – kglr Oct 16 '14 at 09:07
One down, one to go. (grin) Now realize that MapThread[(# + #2) &, {x, y}, 0] is merely x + y. – Mr.Wizard Oct 16 '14 at 09:09
Mr.W it is indeed... – kglr Oct 16 '14 at 09:10

score 4 · Answer 3 · edited Apr 13 '17 at 12:55

Evaluation with Association is at present poorly defined (IMO). See: Held keys in associations. Your example shows that MapThread does work on associations but the RHS fails to evaluate. Map causes the elements to evaluate:

MapThread[# + #2 &, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]

Identity /@ %

<|a -> (#1 + #2 &)[1, 5], b -> (#1 + #2 &)[2, 6]|>
<|a -> 6, b -> 8|>

Since there appears to be confusion with regard to the function of some different proposals in other answers and comments I feel it needs to be pointed out that several of them work by simply evaluating:

<|a -> 1, b -> 2|> + <|a -> 5, b -> 6|>

Which somewhat surprisingly yields:

<|a -> 6, b -> 8|>

As I cannot recall seeing this in the documentation I asked:

Listable functions thread over Associations; is this documented?

score 1 · Answer 4 · answered Oct 16 '14 at 08:40

It seems that the resulting association from your code is unevaluated.

In=  MapThread[#1 + #2 &, {<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}]
Out= <|a -> (#1 + #2 &)[1, 5], b -> (#1 + #2 &)[2, 6]|>
In=  %[a]
Out= 6

I think you can do it by

Merge[{<|a -> 1, b -> 2|>, <|a -> 5, b -> 6|>}, Total]

How does MapThread work with Associations?

4 Answers4

Linked