The special forms
or can be used as logical operators,
but they can also be used as control structures, which is why they are
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
returns that value as the value of the
and expression. If none of
#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
or takes any number of arguments, and returns the value
of the first one that returns a true value (i.e., anything but
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
notis just a procedure
not is a procedure that takes one argument, which may be
any kind of Scheme value, and returns
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.
(not 0) returns
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
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
================================================================== 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).)