Why do functions defined with SetDelayed and Function behave differently in callbacks?

Question

It seems to me that functions defined using a simple pattern and SetDelayed (the usual way to define a "function") should be equivalent in all respects to functions defined using Function: both say what to do with a value provided in a slot, and merely have different methods of designating the slot. But they are not. Observe:

f1[x_] := x^2;
f2 = Function[#^2];
{f1[3], f2[3]}

(* {9, 9} *)

So far, so good. However:

g[ff_Function, y_] := ff[y];
{g[f1, 3], g[f2, 3]}

(* {g[f1, 3], 9} *)

One can be passed around via its symbol and be invoked as a callback, and the other cannot. It would be convenient (and, for the novice programmers I teach, less confusing) to define functions for callbacks with the more transparent SetDelayed notation, rather than with pure function notation.

Clearly, there is some deep difference between these two rules that I do not understand. Perhaps someone wiser than I can illuminate?

Answer 1

Most functions in Mathematica are actually global rules, with Function being an (very important) exception. Argument patterns in functions defined by rules are typically used as a flexible typing mechanism. You can go from completely untyped definitions (where you use patterns like _, __, etc.), to something in the middle (like e.g. {__List}), to completely strongly typed, like _h, where the head h serves as a type.

In your case, when you define

g[ff_Function, y_] := ff[y];

this definition will only apply if your first argument matches the pattern _Function, that is, has the head Function. If you want your function g to accept any callback function, simply leave this restriction out:

ClearAll[g];
g[ff_, y_] := ff[y];

It is important to keep in mind the rule-based nature of the language, and that for many constructs, which look similar to their analogs in other languages, while such similarity was intentional, the underlying mechanisms behind them may be very different.