Test if an expression is a Function?

Question

How would a function FunctionQ look like, maybe in a way I can even specify the number of arguments allowed?

Answer 1

I really feel bad posting after Simon and Daniel, but their codes fail on non-functions which are not symbols. Checking for that and adding a check for builtins via NumericFunction, as suggested by Simon, we arrive at something like

FunctionQ[_Function | _InterpolatingFunction | _CompiledFunction] = True;
FunctionQ[f_Symbol] := Or[
  DownValues[f] =!= {}, 
  MemberQ[ Attributes[f], NumericFunction ]]
FunctionQ[_] = False;

which should work in some (sigh) real-world cases

In[17]:= 
FunctionQ/@{Sin,Function[x,3x], Compile[x,3 x],Interpolation[Range[5]],FunctionQ,3x,"a string", 5}
Out[17]= {True,True,True,True,True,False,False,False}

If you know the signature of the function you are looking for (i.e. how many arguments and of what type), I would agree with Simon that the way to go is duck typing: Apply the function to typical arguments, and look for valid output. Caching might be worthwhile:

AlternativeFunctionQ[f_]:=AlternativeFunctionQ[f]=
  With[{TypicalArgs={1.0}},NumericQ[Apply[f,TypicalArgs]]];

In[33]= AlternativeFunctionQ/@{Sin,Function[x,3x], Compile[x, 3x],Interpolation[Range[5]],FunctionQ,3x,"a string", 5}
Out[34]= {True,True,True,True,False,False,False,False} 

Answer 2

As Daniel said, his test (which probably should read)

FunctionQ[x_] := Head[x] === Function || DownValues[x] =!= {}

Is quick and dirty. It will fail for built in functions, e.g. FunctionQ[Sin] will return False (Many built-in functions will be caught by checking for the Attribute NumericFunction). It will also fail for things like f[x_][y_] etc... It should probably also test UpValues, SubValues and maybe NValues (see here for their meanings).

This problem was discussed in this thread. Many useful ideas are in this thread - eg ways to find the number of arguments that some functions can take, but there was no real consensus reached in the discussion.

I think that the best approach is a kind of duck typing. You probably know how many and what type of arguments you want your function to take, so test it with ValueQ. Then make sure that you catch errors using Check.

EDIT: Another comp.soft-sys.math.mathematica thread.

Answer 3

Here's something quick and dirty which may do what you need:

FunctionQ[x_] := Head[x] == Function || DownValues[x] =!= {}