How would a function FunctionQ
look like, maybe in a way I can even specify the number of arguments allowed?
views:
97answers:
3Here's something quick and dirty which may do what you need:
FunctionQ[x_] := Head[x] == Function || DownValues[x] =!= {}
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.
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}