Control Constructs

(cond <pair>...)  EVALUATE CONDITIONALLY
    <pair>      pair consisting of:
                    (<pred> <expr>...)
                  where
                    <pred>      is a predicate expression
                    <expr>      evaluated if the predicate
                                is not nil
    returns     the value of the first expression whose predicate
                is not nil

(and <expr>...)  THE LOGICAL AND OF A LIST OF EXPRESSIONS
    <expr>      the expressions to be ANDed
    returns     nil if any expression evaluates to nil,
                otherwise the value of the last expression
                (evaluation of expressions stops after the first
                 expression that evaluates to nil)

(or <expr>...)  THE LOGICAL OR OF A LIST OF EXPRESSIONS
    <expr>      the expressions to be ORed
    returns     nil if all expressions evaluate to nil,
                otherwise the value of the first non-nil expression
                (evaluation of expressions stops after the first
                 expression that does not evaluate to nil)

(if <texpr> <expr1> [<expr2>])  EVALUATE EXPRESSIONS CONDITIONALLY
    <texpr>     the test expression
    <expr1>     the expression to be evaluated if texpr is non-nil
    <expr2>     the expression to be evaluated if texpr is nil
    returns     the value of the selected expression

(when <texpr> <expr>...)  EVALUATE ONLY WHEN A CONDITION IS TRUE
    <texpr>     the test expression
    <expr>      the expression(s) to be evaluted if texpr is non-nil
    returns     the value of the last expression or nil

(unless <texpr> <expr>...)  EVALUATE ONLY WHEN A CONDITION IS FALSE
    <texpr>     the test expression
    <expr>      the expression(s) to be evaluated if texpr is nil
    returns     the value of the last expression or nil

  (case <expr> <case>...)  SELECT BY CASE
    <expr>      the selection expression
    <case>      pair consisting of:
                    (<value> <expr>...)
                  where:
                    <value>     is a single expression or a list of
                                expressions (unevaluated)
                    <expr>      are expressions to execute if the
                                case matches
    returns     the value of the last expression of the matching case

(let (<binding>...) <expr>...)  CREATE LOCAL BINDINGS
(let* (<binding>...) <expr>...)  LET WITH SEQUENTIAL BINDING
    <binding>   the variable bindings each of which is either:
                1)  a symbol (which is initialized to nil)
                2)  a list whose car is a symbol and whose cadr
                        is an initialization expression
    <expr>      the expressions to be evaluated
    returns     the value of the last expression

(flet (<binding>...) <expr>...)  CREATE LOCAL FUNCTIONS
(labels (<binding>...) <expr>...)  FLET WITH RECURSIVE FUNCTIONS
(macrolet (<binding>...) <expr>...)  CREATE LOCAL MACROS
    <binding>   the function bindings each of which is:
                  (<sym> <fargs> <expr>...)
                where:
                    <sym>       the function/macro name
                    <fargs>     formal argument list (lambda list)
                    <expr>      expressions constituting the body of
                                the function/macro
    <expr>      the expressions to be evaluated
    returns     the value of the last expression

(catch <sym> <expr>...)  EVALUATE EXPRESSIONS AND CATCH THROWS
    <sym>       the catch tag
    <expr>      expressions to evaluate
    returns     the value of the last expression the throw expression

(throw <sym> [<expr>])  THROW TO A CATCH
    <sym>       the catch tag
    <expr>      the value for the catch to return (defaults to nil)
    returns     never returns

(unwind-protect <expr> <cexpr>...)  PROTECT EVALUATION OF AN EXPRESSION
    <expr>      the expression to protect
    <cexpr>     the cleanup expressions
    returns     the value of the expression
  Note:  unwind-protect guarantees to execute the cleanup expressions
         even if a non-local exit terminates the evaluation of the
         protected expression