First off, there are thousands of symbols, so it doesn't seem practical to be inspecting them directly.
Second, many built-in symbols are ReadProtected
, so you can't really inspect them very closely. Even symbols that aren't ReadProtected
might still hide their implementation details.
Third, some symbols don't have any definitions--they're more like reserved symbols. E.g. \[FormalA]
. And some others are interpreted differently in different situations. E.g. Automatic
.
If you're not actually wanting to inspect all built-in symbols, but instead want "to learn how to distinguish functions from non-functions", then you need to be clear about what you mean by "function". To the Wolfram Language, everything is an expression, and the Wolfram Language has a process for evaluating expressions that involves replacement rules. The concept of function is a mathematical one--the Wolfram Language can only give you some tools for modeling functions in code.
Here are two different ways you could model a function in WL:
(* Set/SetDelayed *)
(* This adds an element to DownValues *)
somefunc[x_, y_] := x + 3 y;
(* Function *)
(* This adds an elemnt to OwnValues, but that element is an expression
that will be applied to arguments when it appears as the head of an expression*)
otherfunc = Function[{x, y}, x + 3 y];
Are these both functions to you? It's hard to find a property that will select these correctly. You can't just say "if it has down-values then it's a function".
DownValues[somefunc]
(* {HoldPattern[somefunc[x_, y_]] :> x + 3 y} *)
DownValues[otherfunc]
(* {} *)
OwnValues[somefunc]
(* {} *)
OwnValues[otherfunc]
(* {HoldPattern[otherfunc] :> Function[{x, y}, x + 3 y]} *)
So, your question doesn't really seem to be well-specified. What is it that you're actually wanting to do or learn? Do you actually need a rigorous way to distinguish function from non-function, or is there some other way to achieve your objective?