I'm not sure if that is really necessary in the Wolfram Language;

if you just have a function definitions like:

f[x_] := x^2

and you try to evaluate f[2,3] or f[1,2,3] or f[], it will just remain unevaluated; i.e. it automatically checks if the number of arguments matches...

As the language is not compiled, you must realize that every time you use a function g or whatever, it is actually going through a big list of functions and look for a definition of g, is nothing matches then it leaves it unevaluated. Mathematica by its very core is a pattern-matching system, even for simple things like 1+2, or 4! or ....

I meant; I'm not sure how you can circumvent this behaviour ;)

A more in-depth version would be something like:

ClearAll[Arities]
Arities[g_]:=Module[{dv,bl,blns,bls,opts,num},
    dv=DownValues[g];
    dv=dv[[All,1]];
    bl=Count[#,Verbatim[Blank[]],\[Infinity]]&/@dv;
    bls=Count[#,Verbatim[BlankSequence[]],\[Infinity]]&/@dv;
    blns=Count[#,Verbatim[BlankNullSequence[]],\[Infinity]]&/@dv;
    opts=Count[#,Verbatim[Optional][_,_],\[Infinity]]&/@dv;
    num=MapThread[#1+If[#2>0,#2 {1,\[Infinity]},0]+If[#3>0, #3{0,\[Infinity]},0]-#4{1,0}&,{bl,bls,blns,opts}];
    {dv,bl,bls,blns,opts,num}
]

ClearAll[F]
F[x_, y_, z_, f_, g_: 2, x2_: 3] := 14
F[x_, y_, z_, f_, g_: 2] := 14
F[x_, z_, f_, y___] := 14
F[x_, z_, y__] := 14
F[x_, y_] := 14
F[x_] := 23
F[] := 12

Arities[F] // Transpose // Grid

returns:

Which is a list of Definition, # of Blanks, # of BlankSequences, # of BlankNullSequenced, # of optional arguments, and range of number of arguments.

May I ask why you need the arities of the function? I can't really think of a use in 'normal' calculations...

Thank you Sander for your detailed explanations. I will need some time to study and digest your code, though.

I am interested in function arities in the context of an algorithm that tentatively applies function symbols to lists... Knowing beforehand the arities of the functions would allow me to use some indexing scheme so as to avoid applying functions of arities n to argument lists of length n' != n. In my case, the functions do not rely on sequence patterns, and have arities known beforehand.