bind specific 'Slots' to specific 'Map'

Question

Is it possible to construct a pure function using multiple slots, with the following concept :

Binding specific slot to specific apply or map

For example :

In this example,

To reproduce the output for In(1), namely Out(1),

In[1] Table[Take[#, n], {n, 1, Length[#]}] & /@ test
Out[1] {{{4}, {4, 2}, {4, 2, 2}}, {{9}, {9, 1}, {9, 1, 5}}, 
       {{5}, {5, 2}, {5, 2, 9}, {5, 2, 9, 3}}, 
       {{5}, {5, 2}, {5, 2, 7}, {5, 2, 7, 1}, {5, 2, 7, 1, 1}}}

without using 'Table' symbol, I could do

In[2] Function[x, (Function[y, Take[x, y]] /@ Range[Length[x]])] /@ test

But I want to reproduce Out(1), only with slot symbols and Map.

The codes

((Take[#1, #2] &) /@ Range[Length[#1]]) & /@ test

or

((Take[#, #] &) /@ Range[Length[#]]) & /@ test

are tryable but they fails.

My imaginary working colored code is like :

Violet # binds to violet & and violet /@,
Green # binds to green & and green /@

What about: Function[x, Take[x, #] & /@ Range[Length[x]]] /@ test — Daniel Huber, Apr 01 '21 at 15:46
Try e.g.: FoldList[Append, {First@#}, Rest@#] & /@ test or i f you are a fan of cryptic code: (t = #; Take[t, #] & /@ Range[Length[#]]) & /@ test — Daniel Huber, Apr 01 '21 at 16:30
It's worth noting, by the way, that & with # is simply shorthand for Function with a parameter, so the Function solution is actually how you would bind a slot (in this case, named x) in an anonymous function properly. — thorimur, Apr 01 '21 at 17:20
You cannot bind a Slot to a Function constructor & outside another constructor & ("outside" being defined by syntactic precedence). As far as I know, at least. This came up before, but as I recall, it was not the central question, just the explanation of the problem with the OP's code. — Michael E2, Apr 01 '21 at 20:02
Another way to look at it is that Slot[] binds to the first Function going up the expression tree to the head. To visualize your last example: (Take[#1, #1] &) /@ Range[Length[#1]] & // TreeForm The first Slot[1] in Take[..] won't bind to the topmost Function as desired. You would need a way to label the slots and the function, but such a way is already provided by symbolic arguments. — Michael E2, Apr 01 '21 at 20:11
This question comes up a lot but unfortunately there is no canonical one. See also: (38393), (16953), (74140), (79538), (72196), (28983), (SO 4920194). — WReach, Apr 02 '21 at 13:11

kglr · Answer 1 · 2021-04-01T20:01:48.480

You can do it even without slots:

Map[Map[Flatten @* List] @* FoldList[List]] @ test

 {{{4}, {4, 2}, {4, 2, 2}}, 
  {{9}, {9, 1}, {9, 1, 5}}, 
  {{5}, {5, 2}, {5,  2, 9}, {5, 2, 9, 3}}, 
  {{5}, {5, 2}, {5, 2, 7}, {5, 2, 7, 1}, {5, 2, 7, 1, 1}}}

Also

Map[Extract[#, Map[List] @ Range @ Range @ Length @ #] &] @ test

 {{{4}, {4, 2}, {4, 2, 2}}, 
  {{9}, {9, 1}, {9, 1, 5}}, 
  {{5}, {5, 2}, {5,  2, 9}, {5, 2, 9, 3}}, 
  {{5}, {5, 2}, {5, 2, 7}, {5, 2, 7, 1}, {5, 2, 7, 1, 1}}}

WReach · Accepted Answer · 2021-04-02T14:38:55.707

There is no direct notation for anonymous slot references to outer pure function arguments (named arguments to Function having been ruled out). But we can use the higher-order function OperatorApplied as a way to avoid explicit argument naming:

OperatorApplied[Take, 2][#] /@ Range@Length[#] & /@ test
(* {{{4}, {4,2}, {4,2,2}},
    {{9}, {9,1}, {9,1,5}},
    {{5}, {5,2}, {5,2,9}, {5,2,9,3}},
    {{5}, {5,2}, {5,2,7}, {5,2,7,1}, {5,2,7,1,1}}} *)

or, equivalently:

OperatorApplied[Take[#2, #]&][#] /@ Range@Length[#] & /@ test

For this particular case, CurryApplied could be substituted for OperatorApplied. We could also use Curry (my old favourite) but it has been deprecated and slated for removal some day.

See (197168) for more discussion of this currying technique within nested pure functions.

Just For Fun

If Wolfram Language had some kind of forking operator, we could dispense with slot notation for this example and write in point-free form:

fork[f_][g_, h_][x_] = f[g[x], h[x]]
test // Map@fork[Map][Curry[Take,2], Range@*Length]
(* {{{4}, {4,2}, {4,2,2}},
    {{9}, {9,1}, {9,1,5}},
    {{5}, {5,2}, {5,2,9}, {5,2,9,3}},
    {{5}, {5,2}, {5,2,7}, {5,2,7,1}, {5,2,7,1,1}}} *)

The Query sublanguage has something resembling a fork operator, so we can write:

test // Query[All, Apply[Map]@*{Curry[Take, 2], Range@*Length}]

I'm really going to miss Curry. I dislike long names like OperatorApplied or CurryApplied for common (at least for me) operations. — WReach, Apr 02 '21 at 13:34

bind specific 'Slots' to specific 'Map'

2 Answers2