# Threading over a list of lists of lists and a list of atomic expressions

Although I solved the following problem using MapThread, I'm curious about why Thread does not work as I expect it to here.

Given two lists of length n, where the first list is a list of lists of lists and the second is a list of atomic expressions, such as:

list1 = {{{1, 2}, {3, 4, 5}}, {{1, 3, 5}, {9, 8}}};
list2 = {"a", "b"};


and where list1[[n]] can contain 1 or more lists of atomic expressions. I would like to create a single list that places the nth element of the second list at the end of every sublist of list1[[n]], producing:

{{{1, 2, "a"}, {3, 4, 5, "a"}}, {{1, 3, 5, "b"}, {9, 8, "b"}}}


I first tried the following

appendTo[ll_, item_] := Map[Append[#, item] &, ll];


But this returns:

{{{1, 2}, {1, 3, 5}}, {{3, 4, 5}, {9, 8}}, {{"a", "b"}, {"a", "b"}}}


even though threading an undefined function seems to produce the right expressions:

Thread[f[a, b]]
{f[{{1, 2}, {3, 4, 5}}, "a"], f[{{1, 3, 5}, {9, 8}}, "b"]}


MapThread works fine:

MapThread[appendTo, {list1, list2}]
{{{1, 2, "a"}, {3, 4, 5, "a"}}, {{1, 3, 5, "b"}, {9, 8, "b"}}}


So why is Thread producing the behavior shown above instead of giving the same result as MapThread?

Threading Rule on the same lists also produces what I expect:

Thread[Rule[list1, list2]]
{{{1, 2}, {3, 4, 5}} -> "a", {{1, 3, 5}, {9, 8}} -> "b"}

• In addition to the answers already posted, you can look here, where I discussed this exact issue. – Leonid Shifrin Nov 5 '12 at 4:49
• Incidentally, Inner is good for this kind of transformation: Inner[Append, list1, list2, List]. – WReach Nov 5 '12 at 5:25

The simple answer: Thread does not have the attribute HoldAll, so its contents are executed before it processes them.

But, it is not quite that simple. If you add HoldAll, you still don't get what you want

InternalInheritedBlock[{Thread},
]
(* {{{1, 2}, {3, 4, 5}, {"a", "b"}}, {{1, 3, 5}, {9, 8}, {"a", "b"}}} *)


which implies that in this form only the first list is threaded over.

Note, I used InternalInheritedBlock to retain the behavior of Thread while not allowing my modifications to leak.

• I understand now. This also explains why Rule works, unlike appendTo: when Rule is evaluated it expands to an expression that when operated on by Thread produces the result shown above. – Todd Johnson Nov 6 '12 at 21:27
• " in this form only the first list is threaded over" this explanation isn't right, in this case nothing is threaded over, the output is the same as that of appendTo[list1, list2]. See this post for more information. – xzczd Feb 29 '16 at 7:04
• @xzczd you're absolutely correct. I must have been asleep when I wrote this. – rcollyer Feb 29 '16 at 13:29

There is a much simpler alternative here - to use the Block trick. What we need is to give appendTo a case of temporal amnesia, which is what Block excels at:

Block[{appendTo}, Thread[appendTo[list1, list2]]]


As rcollyer already pointed out, appendTo is evaluated as parameter to Thread. You can of course simply Hold it and release it after the Thread:

Thread[Hold[appendTo][list1, list2]] // ReleaseHold

(* {{{1, 2, "a"}, {3, 4, 5, "a"}}, {{1, 3, 5, "b"}, {9, 8, "b"}}} *)


There is another possibility which is clear and needs no further adjustment like Hold or InternalInheritedBlock

appendTo @@@ Transpose[{list1, list2}]

• Another route: Thread[f[list1, list2]] /. f -> appendTo` – J. M.'s torpor Nov 5 '12 at 4:32