# 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:

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

{{{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:

{{{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. Nov 5, 2012 at 4:49
• Incidentally, Inner is good for this kind of transformation: Inner[Append, list1, list2, List]. Nov 5, 2012 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. Nov 6, 2012 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. Feb 29, 2016 at 7:04
• @xzczd you're absolutely correct. I must have been asleep when I wrote this. Feb 29, 2016 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: