cond evaluates test of each clauses in order, until
it yields a true value. Once it yields true, if the clause
is the first form, the corresponding exprs are evaluated
and the result(s) of last expr is(are) returned; if the clause
is the second form, the expr is evaluated and it must yield
a procedure that takes one argument. Then the result of test
is passed to it, and the result(s) it returns will be returned.

The third form is specified in SRFI-61. In this form, test
can yield arbitrary number of values. The result(s)
of test is(are) passed to guard; if it returns a true value,
expr is applied with an equivalent argument list, and its
result(s) is(are) returned. If guard returns #f,
the evaluation proceeds to the next clause.

If no test yields true, and the last clause is not the fourth form
(else clause), an undefined value is returned.

If the last clause is else clause and all tests are failed,
exprs in the else clause are evaluated, and its last
expr’s result(s) is(are) returned.

[R7RS][SRFI-87]
Key may be any expression.
Each clause should have the form

((datum ...) exprexpr2 …)
((datum ...) => proc)

where each datum is an external representation of some object.
All the datums must be distinct. The last clause
may be an “else clause,” which has the form

(else exprexpr2 …)
(else => proc)

First, key is evaluated and its result is compared against each
datum. If the result of evaluating key is equivalent
(using eqv?, see Equality), to a datum,
then the expressions in the corresponding clause are evaluated
sequentially, and the result(s) of the last expression in the
clause is(are) returned from the case expression.
The forms containing => are specified in SRFI-87. In these
forms, the result of key is passed to proc, and its
result(s) is(are) returned from the case expression.

If the result of evaluating key is different from every datum,
then if there is an else clause its expressions are evaluated and
the result(s) of the last is(are) the result(s) of the case expression;
otherwise the result of the case expression is undefined.

This works exactly like case, except when there’s
no else clause and the value of key expression
doesn’t match any of datums provided in clauses.
While case form returns undefined value for such case,
ecase raises an error.

It is taken from Common Lisp. It’s a convenient form when
you want to detect when unexpected value is passed just in case.

[R7RS]
The test expressions are evaluated from left to right,
and the value of the first expression that evaluates to a false
value is returned.
Any remaining expressions are not evaluated.
If all the expressions evaluate to true values,
the value of the last expression is returned.
If there are no expressions then #t is returned.

[R7RS]
The test expressions are evaluated from left to right,
and the value of the first expression that evaluates to a true
value is returned. Any remaining expressions are not evaluated.
If all expressions evaluate to false values, the value of the
last expression is returned. If there are no expressions then
#f is returned.

[R7RS]
Evaluates test. If it yields true value (or false in case of
unless), expr1 and expr2 … are evaluated
sequentially, and the result(s) of the last evaluation is(are) returned.
Otherwise, undefined value is returned.