In conventional programming languages like C and Pascal, there's an
awkward distinction between procedure calls and other kinds of
expressions. In C, for example,
(a + b) is an expression but not
a procedure call, but
foo(a,b) is a procedure call in addition to
being an expression. In C, you can't do the same things with an
+ that you can do with a procedure. For instance,
you can pass a (pointer to a) procedure as an argument or assign it to a
variable, but you can't do the same thing with
is not a procedure.
In Scheme, things are much more uniform, both semantically and syntactically.
Most basic operations such as addition are procedures, and there is a unified
syntax for writing expressions--parenthesized prefix notation. So rather
(a + b) in Scheme, you write
(+ a b). And rather
foo(a,b), you write
(foo a b). Either way, it's
just an operation followed by its operands, all inside parentheses.
For any procedure call expression (also called a combination), all of the values to be passed are computed before the actual call to the procedure. (This is no different from C or Pascal.)