Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

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];
Thread[appendTo[list1, list2]]

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"}
share|improve this question
1  
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
3  
Incidentally, Inner is good for this kind of transformation: Inner[Append, list1, list2, List]. –  WReach Nov 5 '12 at 5:25
add comment

3 Answers

up vote 4 down vote accepted

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

Internal`InheritedBlock[{Thread},
 SetAttributes[Thread, HoldAll];
 Thread[appendTo[list1, list2]]
]
(* {{{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 Internal`InheritedBlock to retain the behavior of Thread while not allowing my modifications to leak.

share|improve this answer
    
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
add comment

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]]] 
share|improve this answer
add comment

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 Internal`InheritedBlock

appendTo @@@ Transpose[{list1, list2}]
share|improve this answer
1  
Another route: Thread[f[list1, list2]] /. f -> appendTo –  J. M. Nov 5 '12 at 4:32
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.