For more detail on how this works, I'll try to describe how it is implemented.

When the evaluator sees a combination such as (f (x y)), it evaluates f and checks if the result is a combiner (and terminates if not). It then tests if f is operative, and if so, it passes the operand list (x y) to the body of f, along with the current environment. If f is applicative, it evaluates each item in the operand list (by recursively calling the evaluator on each individually) to produce a list of arguments. The evaluator then conses the underlying combiner of the applicative with the argument list, and recursively calls the evaluator with the result. Something like this:

($define! eval
($lambda (object env)
($if (not? (environment? env))
(error "Second argument to eval must be an environment")
($cond ((symbol? object) (lookup env object))
((pair? object)
($let ((comb (car object)))
($cond ((operative? comb) (call comb (cdr object)) env)
((applicative? comb)
($let ((app (unwrap comb))
(args (eval-list (cdr object) env)))
(eval (cons app args) env)))
(#t (error "The first item of a combination must be a combiner")))))

;; If object is neither symbol nor pair, it must be a self-evaluating term.
(#t object)))))

The primitives used here, which I'll leave out for brevity:

(lookup env symbol) ; returns the expression mapped to the symbol in the dynamic environment env.
(call operative operand env) ; calls operative with operands and the dynamic environment.
(unwrap applicative) ; returns the underlying combiner of the applicative.
(eval-list objs env) ; evaluate each item in the list objs using the dynamic environment, in no specific order.

You can see the simplicity of this interpreter. It does not need special consideration for operators like || and &&, or any other special form. The only special forms are the primitives themselves, which are all operatives. The behaviour of `call` depends on whether or not an operative is primitive or not. Primitives are implementation specific as they're part of the interpreter itself.

Operatives which are not primitive are called compound operatives, and are constructed using $vau, as in the above example for the $and? operative. It has the form:

($vau formal-parameter-tree symbol-for-dynamic-env operative-body)

You can consider a compound operative to merely be a structure (or 4-tuple) which stores its 3 arguments plus the environment which is passed to `call` when the `$vau` operative itself is evaluated. (The static environment of the operative)

When the compound operative is later called, it constructs a new environment with its static environment as the parent, called the local-evironment. It then maps, in the local-environment, each symbol from its formal parameter tree to the respective operand in the operand list passed to it (the structures of the operands must match the parameter tree). It also maps the symbol-for-dynamic-environment to the environment passed to it by eval. Call then simply evaluates the body of the combiner with `local-environment` as the environment. Eg:

($define! call-compound-operative
($lambda (operative operands env)
($let ((local-env (make-environment (get-static-env operative))))
(set-parameters! local-env (get-parameter-tree operative) operands)
(set! local-env (get-symbol-for-dynamic-env operative) env)
(eval (get-body operative) local-env))))