How can I get the number of slots in Function?

Question

Suppose that I define

f = Function[#1 + #2];

And I want to define a new function, argsNum, so that it returns a number of arguments of input function:

argsNum[f]

2

since f has 2 slots, #1 and #2.

I found the good Q&A, Function that counts the number of arguments of other functions but it does not work on functions of form like Function[#1 + #2] or etc.

It works on Function[{x, y}, x + y]. But I need a function that works on slots.

How can I modify the function in above link or define a new function which also works on slots?

Answer 1

Your question is not well specified for several reasons:

1. Pure functions accept a flexible number of arguments

   #1 + #2 &[a, b, c, d]
   

   a + b
   

2. It is common for some arguments to not be used:

   #1 + #3 & @@ {a, b, c, d}
   

   a + c
   

3. SlotSequence includes all arguments after the given position:

   +##3 & @@ {a, b, c, d}
   

   c + d
   

Without clarifying how each of these cases is to be counted it is impossible to give a general answer.

Answer 2

As @Mr.Wizard has pointed out, your question isn't well specified. However, a pure function always needs a minimum number of arguments, otherwise an error message is thrown:

#1 + #2 &[a]

Function::slotn: Slot number 2 in #1+#2& cannot be filled from (#1+#2&)[a] >>

a + #2

So finding the minimum number of required arguments of a pure function is a well-posed problem. We can solve it by simply detecting if the above error message is thrown for a given number of arguments; if so, we increase the number of arguments and try again:

EnoughArgumentsQ[f_Function, numargs_Integer] := 
  Quiet[
    Check[
      f @@ ConstantArray[Null, numargs]; True, 
      False, 
      Function::slotn
    ],
    Function::slotn
  ];

MinNumberOfArguments[f_Function] := 
  NestWhile[# + 1 &, 0, ! EnoughArgumentsQ[f, #] &]

This is not a very efficient approach, but it gets the job done in a pretty robustly fashion:

MinNumberOfArguments /@ {
  (* 0 *)
  Function[{}, Null],
  (* 1 *)
  MapIndexed[#1^#2 &, #] &,
  (* 2 *)
  #1 + #2 &,
  (* 3 *)
  {#1,#2,#3,##} &,
  (* 4 *)
  #1 + #4 &
}

{0,1,2,3,4}

Mathematica is bound to have a cleverer internal way of determining the minimum number of arguments before it throws the Function::slotn message. If anybody knows how this is done, and if it's accessible, that'd be great :).

Answer 3

Here's my approach to determine the number of slots in the pure function without counting those in any sub-functions. That means MapIndexed[#1^#2 &, #1] & (per @TeakeNutma's comment in @JohnMcGee's answer) will only return one slot. I do this by deleting all inner Functions before counting the slots:

Clear[slotCount]
slotCount[f_Function]:=Module[{deleteInner},
deleteInner=Replace[f,_Function:>Sequence[],{1,Infinity}];
DeleteDuplicates[Cases[deleteInner,_Slot,{1,Infinity},Heads->True]]//Length
]

Notes: Using Heads->True for Cases will count slots correctly for cases like #1[#2].

---

Testing on the example functions in @TeakeNutma's answer

{#,slotCount[#]}&/@{Function[{},Null],MapIndexed[#1^#2&,#]&,#1+#2&,{#1,#2,#3,##}&,#1+#4&}//Grid[#,Frame->All]&

I'm not quite sure #1 + #4 & would have 4 slots (instead of just 2). Below is a modified version of my slotCount function that will return 4:

Clear[slotCountPositionAware]
slotCountPositionAware[f_Function]:=Module[{deleteInner,slotList,maxSlot},
deleteInner=Replace[f,_Function:>Sequence[],{1,Infinity}];
slotList=DeleteDuplicates[Cases[deleteInner,_Slot,{1,Infinity},Heads->True]];
maxSlot[l_List]:=If[l=={},0,l/.Slot[x_]:>x//Max];
maxSlot[slotList]
]

{#,slotCountPositionAware[#]}&/@{Function[{},Null],MapIndexed[#1^#2&,#]&,#1+#2&,{#1,#2,#3,##}&,#1+#4&}//Grid[#,Frame->All]&

Answer 4

Try

Length@Union@Cases[f, _Slot, Infinity]

2

The Union eliminates duplicates