Expressions are composed of operands contained in something I'll call a container. In some simple cases, it may not seem like a "container" in the usual sense of the word, but that's the best word that I can come up with for this elementary discussion. There are only a few fundamental types for these containers, and it'll only be the type of the container rather than the container itself that we'll need to consider.
A simple example is a list, for example, L:= [3, x+y, 7]. It's operands are the elements. They command op will return them:
3, x + y, 7
In most cases, the type of container is returned by op(0, ...):
The fundamental container types that should be understood for this particular Question thread are `+`, `*`, `^`, and function.
A:= x + y - z: op(A);
x, y, -z
Expressions whose primary operation is subtraction of 2 or more operands are also considered to be type `+`. Because of algebraic associativity, `+` expressions can have 2 or more operands.
P:= -x*y/z: op(P);
-1, x, y, 1/z
Note that the unary negation of the expression introduces -1 as a distinct operand. Expressions whose primary operation is division are also type `*` unless their numerator is 1 or their numerator and denominator are both integers. Because of associativity, `*` expressions can have 2 or more operands.
F:= Tanh(x, y, z): #Tanh is just made up for this example.
x, y, z
So, operand 0 of a function is the function's name rather than the literal word function.
To be continued...