Implementing myMapThread with Thread, Apply

Question

Problem:

Exercise 5.2.1 from Wagner's Book: implement myMapThread in terms of Thread/Apply such that it works with the Power/Equal examples below.

My Attempt:

In[3]:= myMapThread[func_, list_] := 
  Thread[(Apply[func, #] &)[list]];
myMapThread[Power, {{a, b, c}, 3}]
myMapThread[Equal, {{1, 2, 3}, {1, 2, 4}}]

Out[4]= {a^3, b^3, c^3}

Out[5]= False

In[6]:= myMapThread[func_, list_] := 
  Thread[Unevaluated[(Apply[func, #] &)[list]]];
myMapThread[Power, {{a, b, c}, 3}]
myMapThread[Equal, {{1, 2, 3}, {1, 2, 4}}]

Out[7]= {a^b^c, 3}

Out[8]= {False, False}

Question

1) I screwed up. What is the correct answer?

2) What am I doing wrong?

Answer 1

You were doing it right, but Equal is peculiar in that it is also defined on lists, and returns single False if the lists are not exactly equal, and single True if they are. During the evaluation of myMapThread (say, with a generic function f), there is a stage like this:

(f@@#)&[{{1,2,3},{1,2,4}}]

(*  f[{1,2,3},{1,2,4}]  *)

And if you have Equal in place of f, it evaluates at this stage, before Thread has a chance to execute. In fact, Wagner emphasized this point in his main text, and I also discussed this here.

This is how I would do this: use Apply at level 1:

myMapThreadLS[f_, arg_List] := f @@@ Thread[arg];

This avoids this problem, since threading is guaranteed to happen here before the function is applied. To cure your version, there are probably better alternatives, but one which comes to mind right now is to use a dummy symbol without rules attached to it, in place of the function being applied, and substitute it with that function at the end:

myMapThreadAlt[func_, list_] :=
  Module[{f},
     Thread[(Apply[f, #] &)[list]] /. f -> func];

But, if you look at it, essentially this is doing the same as my shorter solution above, just in a slightly more complex way.

EDIT

Here is another way, which utilizes pattern-matching, and is closer to Wagner's discussion in the main text:

myMapThread2[f_, {parts__}] := Thread[Unevaluated[f[parts]]]

This has an advantage that you don't need two traversals of the threaded argument list, since pattern-matching is used to inject the list parts directly as a sequence, and then Apply is not needed.