Compound conditions can be built by using the logical composition operators and, or and not.
The syntax of and is as follows:
(and expr1 expr2 ... exprn)Each of the expressions are evaluated in left-to-right order. If all expressions evaluate to true, then true is returned as the value of the and expression4.1, otherwise false is returned. If any expression is evaluated to false, the evaluation will stop and false will be returned without the rest of the expressions being evaluated.
For example,
>(define a 3) >(and (< 2 5) (number? a)) #t
2 is smaller than 5 and a, which has the value of 3, is indeed a number, hence #t is returned.
>(define a 3) >(define b 5) >(and (= a 3) (< b a) (and (number? a) (number? b))) #f
False will be returned, because b is not smaller than a. The last expression, which also is an and expression, will not even be evaluated.
The syntax of or is as follows:
(or expr1 expr2 ... exprn)Each of the expressions are evaluated in left-to-right order. As soon as one of the expressions evaluates to true, the evaluation will stop and true will be returned as the value of the or expression4.2. If all expressions evaluate to false then false will be returned.
For example,
>(define a 3) >(or (< 2 5) (number? a)) #t
After evaluating the first expression, the truth value can already be established and #t is returned without even evaluating the rest of the expressions.
The syntax of not is simple:
(not expr)
If the expression is true, then false will be returned, but if the expression is false, then true will be returned.
For example,
>(define a 5) >(not (< a 10)) #f
Actually, not always evaluates its argument and is therefore implemented as a normal procedure, whereas and and or are special forms.