and and or

The special forms and and or can be used as logical operators, but they can also be used as control structures, which is why they are special forms.

and takes any number of expressions, and evaluates them in sequence, until one of them returns #f or all of them have been evaluated. At the point where one returns #f, and returns that value as the value of the and expression. If none of them returns #f, it returns the value of the last subexpression.

This is really a control construct, not just a logical operator, because whether subexpressions get evaluated depends on the reults of the previous subexpressions.

and is often used to express both control flow and value returning, like a sequence of if tests. You can write something like

(and (try-first-thing)
     (try-second-thing)
     (try-third-thing))

If the three calls all return true values, and returns the value of the last one. If any of them returns #f, however, none of the rest are evaluated, and #f is returned as the value of the overall expression.

Likewise, or takes any number of arguments, and returns the value of the first one that returns a true value (i.e., anything but #f). It stops when it gets a true value, and returns it without evaluating the remaining subexpressions.

(or (try-first-thing)
    (try-second-thing)
    (try-third-thing))

or keeps trying subexpressions until one of them does return a true value; if that happens, or stops and returns that value. If none of them returns anything but #f, it returns #f.

not is just a procedure

not is a procedure that takes one argument, which may be any kind of Scheme value, and returns #t or #f. If the argument value is #f (the unique false object), it returns #t, and otherwise returns #f. That is, all values count as true except for the false object--just as in a conditional. For example, (not 0) returns #f.

Given that and and or are special forms, you might think that the logical not operator is a special form as well. It isn't. It's just a procedure--in particular, a predicate.

This makes sense because not always evaluates its (one) argument, and returns a value. It doesn't treat any arguments specially--it's just a normal first-class procedure, whose argument is evaluated in the usual way before the procedure is actually called.

In general, operations that can be procedures are procedures. Scheme only has special forms for things that are actually special, and need their arguments treated differently from arguments to procedure calls. (Even Scheme's most powerful control construct, call-with-current-continuation, is just a first-class procedure.)

==================================================================
This is the end of Hunk A.

TIME TO TRY IT OUT

At this point, you should go read Hunk B of the next chapter
and work through the examples using a running Scheme system.
Then return here and resume this chapter.
==================================================================

(Go to Hunk B, which starts at section An Interactive Programming Environment (Hunk B).)