Can we intelligently control evaluation in Thread?

Question

This is a bid at creating a canonical Q&A.

Many questions have been asked that come down to the fact that Thread evaluates its first argument before threading is attempted. In a few minutes I found:

• Threading behavior of SameQ vs Equals
• Implementing myMapThread with Thread, Apply
• Threading over a list of lists of lists and a list of atomic expressions
• Why does Thread FileDate give an error message?
• Efficient calculation of diagonal matrix elements
• List operation list1 >= list2 should compare elements
• How to Thread with custom functions? Thread vs Map?
• Why doesn't Thread always thread?
• Map works but Thread doesn't
• Function of Five Variables, and iterating over the last 3
• Thread Part ([[]]) over two lists
• Inconsistent behavior of thread on empty llists

Basic examples of the problem:

Thread[{1, 2, 3} == {3, 2, 1}]

False

(One might have expected {False, True, False})

Thread[Print[{a, b, c}, " = ", {1, 2, 3}]];

{a,b,c} = {1,2,3}

(One might have expected a=1, b=2, c=3, on three separate lines.)

How can this most easily and robustly be addressed?

Answer 1

Analysis of the problem

All functions in Mathematica either hold one or more of their arguments, or per The Standard Evaluation Procedure the arguments are evaluated before the function is applied. Thread has no HoldFirst attribute therefore it falls into the latter category.

Because of this in an expression like Thread[Print[{a, b, c}, " = ", {1, 2, 3}]]; Print evaluates entirely free of Thread, and Thread only sees the result of that which is Null.

Manual evaluation control

The typical solution to this problem is to manually take control of the evaluation order. A common recommendation is MapThread as the head to be applied is kept separate from the expression elements until construction is complete:

MapThread[Equal, {{1, 2, 3}, {3, 2, 1}}]

This is hardly a complete solution however as MapThread only operates over List and does not handle singletons.

Sometimes one can use Thread and Apply a head afterward, which handles singletons:

Print @@@ Thread[{{a, b, c}, " = ", {1, 2, 3}}];

a = 1

b = 2

c = 3

One may wonder why Thread does not have HoldFirst as referenced at the start. The mechanism of Unevaluated effectively gives us a one-off operation as though that attribute applied:

Thread[ Unevaluated[ {1, 2, 3} == {3, 2, 1} ] ]

{False, True, False}

This is not a general solution however because it interferes with expected evaluation in other cases:

p = {1, 2, 3};
q = {3, 2, 1};
Thread[ Unevaluated[ foo[p, q] ] ]

foo[{1, 2, 3}, {3, 2, 1}]

More complicated cases may require one to inject various evaluated forms into an Unevaluated expression:

p = a + b + c;
q = x + y + z;

With[{p = p, q = q},
  Thread[ Unevaluated[p*q*r], Plus]
]

a r x + b r y + c r z

Automated solution

Wouldn't it be nice to have Thread just work in most cases without having to resort to manual evaluation control? I think so, and I am going to try to make it happen.

Here is my initial attempt. It surely has limitations and I expect more than a couple of bugs, but already I think it is applicable in a wide range of cases. I hope that with feedback from the community I can continue to refine and extend it.

I will be using a modified form of my step function from How do I evaluate only one step of an expression? with a specific container to differentiate its results from appearances of HoldForm.

The code in provided at the bottom to avoid interrupting the flow of this long post.

Basic examples

autoThread[{1, 2, 3} == {3, 2, 1}]

 {False, True, False}

autoThread[Print[{a, b, c}, " = ", {1, 2, 3}]];

a = 1

b = 2

c = 3

p = {1, 2, 3};
q = {3, 2, 1};
autoThread[foo[p, q]]

{foo[1, 3], foo[2, 2], foo[3, 1]}

p = a + b + c;
q = x + y + z;
autoThread[p*q*r, Plus]

a r x + b r y + c r z

Advanced stepwise evaluation

By leveraging the special evaluation provided by step my function can do things that are almost impossible otherwise.

x := 1 + 2 + 3;
y := a + b + c

autoThread[x*y, Plus]

a + 2 b + 3 c

foo[6] := x*y
bar := foo;

autoThread[bar[2*3], Plus]

a + 2 b + 3 c

autoThread Code

SetAttributes[{step, $stepHold}, HoldAll]
step[expr_] :=
  Module[{P},
    P = (P = Return[$stepHold @@ #, TraceScan] &) &;
    TraceScan[P, expr, TraceDepth -> 1]
  ]

Attributes[autoThread] = HoldFirst;

autoThread[body_] := autoThread[body, List]

autoThread[body : _[___, h_[___], ___], h_, seq_: All] := 
  Thread[Unevaluated @ body, h, seq]

autoThread[body : f_[arg___], h_, seq_: All] :=
  With[{new = 
    Replace[
      MapAll[step, Unevaluated[body], Heads -> True],
      (step | $stepHold)[x_] :> x, -1, Heads -> True
    ]},
   (new /. $stepHold[eval_] :> autoThread[eval, h, seq])
      /; new =!= $stepHold[body]
  ]

autoThread[else_, x___] :=
  step[else] /. $stepHold[eval_] :> autoThread[eval, x]

Answer 2

First, let me tell you that my answer here is by no means a replacement for the trickier, but more capable implementation of Mr. Wizard. What I want to show is that the examples I point out at the end can be handled with a shorter approach. Keep this in mind. For a new user of Mathematica, the implementation below might serve as a starting point in understanding, why we need evaluation control for this kind of problem.

The following solution works by temporarily replacing the head, the outermost function, of a given expression with some dummy function that does nothing. Since the dummy function does nothing, Thread can do its work and afterward, we simply re-substitute the original head.

As Kuba pointed out, in some cases, it might be a good idea to give the dummy function the same attributes as the original head. I will give an example when this is a good idea.

SetAttributes[myThread, {HoldAllComplete}];
myThread[head_[args__]] := Module[{dummy},
  SetAttributes[dummy, Attributes[head]];
  Thread[dummy[args]] /. dummy :> head
]

Here are the examples that give the desired output:

myThread[{1, 2, 3} == {3, 2, 1}]
(* {False, True, False} *)

and

myThread[Print[{a,b,c}," = ",{1,2,3}]];
(*
a = 1
b = 2
c = 3
*)

and

lst1 = {{5, -9, 15}, {12, -15, 4}};
indices = {{2, 1, 3}, {1, 3, 2}};

myThread[Part[lst1, indices]]     
(* {{-9, 5, 15}, {12, 4, -15}} *)

and

myThread@D[{x, y}, {x, y}]
(* {1, 1} *)

and

findPrime[n_] := 
  If[PrimeQ[n], i = 1; While[Prime[i] < n, i = i + 1]; i, False];

myThread[findPrime[{7, 8, 37, 127}]]
(* {4, False, 12, 31} *)

and

myThread[{2, 3, 5, 4, 1, 8, 7}~Max~{1, 4, 6, 3, 2, 8, 8}]
(* {2, 4, 6, 4, 2, 8, 8} *)

and finally

appendTo[ll_, item_] := Map[Append[#, item] &, ll];
myThread[appendTo[list1, list2]]
(* {{{1, 2, "a"}, {3, 4, 5, "a"}}, {{1, 3, 5, "b"}, {9, 8, 
   "b"}}} *)

I left out the "C:.." example because there is no such thing on my machine but it should work as well. One example where we need to give dummy the original attributes of the head is this

myThread[{1, 2, 3} :> {Print[1], Print[2], Print[3]}]
(* {1 :> Print[1], 2 :> Print[2], 3 :> Print[3]} *)

If we don't do this, the Print statements would be evaluated and we would be left with

{1:>Null,2:>Null,3:>Null}

which is not wanted.

Answer 3

Specific solutions

Since my goal is for not only this Question to become canonical but also my solution my function must be applicable to most cases that come up.

• Threading behavior of SameQ vs Equals -- used as the opening example.

• Implementing myMapThread with Thread, Apply -- not applicable

• Threading over a list of lists of lists and a list of atomic expressions -- success

  autoThread[appendTo[list1, list2]]
  

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

• Why does Thread FileDate give an error message? -- success

  autoThread[FileDate[FileNames["*", "C:\\Temp\\", 1]]]
  
    (* correct output *)
  

• Efficient calculation of diagonal matrix elements -- not applicable(?)

• List operation list1 >= list2 should compare elements -- success

   autoThread[{2, 3, 5, 4, 1, 8, 7} ~Max~ {1, 4, 6, 3, 2, 8, 8}]
  

  {2, 4, 6, 4, 2, 8, 8}
  

• How to Thread with custom functions? Thread vs Map? -- success

  autoThread[findPrime[{7, 8, 37, 127}]]
  

  {4, False, 12, 31}
  

  x = {7, 8, 37, 127};
  
  autoThread[findPrime[x]]
  

  {4, False, 12, 31}
  

• Why doesn't Thread always thread? -- duplicate

• Map works but Thread doesn't -- success

  autoThread @ D[{x, y}, {x, y}]
  

  {1, 1}
  

  xy = {x, y};
  autoThread @ D[xy, xy]
  

  {1, 1}
  

• Function of Five Variables, and iterating over the last 3 -- not applicable

• Thread Part ([[]]) over two lists -- success

  lst1 = {{5, -9, 15}, {12, -15, 4}};
  indices = {{2, 1, 3}, {1, 3, 2}};
  
  autoThread[Part[lst1, indices]]      (* no warning messages *)
  

  {{-9, 5, 15}, {12, 4, -15}}
  

• Inconsistent behavior of thread on empty llists -- success

  autoThread[f2[{}, 5]]
  

  {}