Making a list-function acting one-to one in a list of elements

Question

Consider a pair of functions f1 and f2, and a vector {x,y}. I can get easily {f1[x],f2[y]} by doing MapThread[#1@#2 &,{f1,f2},{x,y}].

Now imagine that I have a function F defined as

F := {f1[#],f2[#]} &

Of course I cannot use the same procedure to get the same result, because now F is not a list of functions (as it was {f1,f2}), but a function itself that returns a list.

One way to get this result (and that admits generalization to longer lists) is

Diagonal[F/@{x,y}]

With this solution we build a whole matrix of elements of F acting on elements of the arguments list and we select the ones that we want.

I was wondering if there is a solution kind of like MapThread that gives the direct result, making act one-to-one the $n$-th element of the function with the $n$-th argument.

Answer 1

For f = {f1[#], f2[#], f3[#]} &; you can also turn f into a list of functions using

Function/@f[[1]] 

or using

First@MapAt[Function, f, {1, All}] (* thanks : Szabolcs *)
Thread[f] (* thanks: WReach *)

and then MapThread the resulting function list with the argument list:

ClearAll[mthreadF]
mthreadF = MapThread[#@#2 &, {Thread@#, #2}] &;

mthreadF[f, {x, y, z}]

{f1[x], f2[y], f3[z]}

Alternatively, you can use Inner:

ClearAll[innerF]
innerF = Inner[#@#2 &, Thread@#, #2, List] &;

innerF[f, {x, y, z}]

{f1[x], f2[y], f3[z]}

Answer 2

There isn't a reasonable way to avoid computing both f1 and f2 in this case. But we can avoid storing the whole matrix, which would (temporarily) take up a lot of memory. One way is MapIndexed.

f = {f1[#], f2[#]} &;

MapIndexed[Extract[f[#1], #2] &, {x, y}]
(* {f1[x], f2[y]} *)

Unless the lists are large enough that the matrix would take up a lot of memory, it's probably not worth bothering with this. I would choose your solution with Diagonal because I find it clearer than MapIndexed. This is, of course, just my personal preference.