Table of Contents

case

Usage: (case test-value & clauses)

Like cond, but test-value is compared against the value of each
test expression with =.  If they are equal, executes the "body"
expression.  Optional last expression is executed if none of the
test expressions match.

fcase

Usage: (fcase compare-fn case-value & test-expr-clauses)

Generic switch/case macro.  'fcase' is short for 'function case'.

The 'compare-fn' is a fn of two arguments.

The 'test-expr-clauses' are value-expression pairs without
surrounding parentheses, like in Clojure's 'cond'.

The 'case-value' is evaluated once and cached.  Then, 'compare-fn'
is called once for each clause, with the clause's test value as its
first argument and 'case-value' as its second argument.  If
'compare-fn' returns logical true, the clause's expression is
evaluated and returned.  If 'compare-fn' returns false/nil, we go to
the next test value.

If 'test-expr-clauses' contains an odd number of items, the last
item is the default expression evaluated if no case-value matches.
If there is no default expression and no case-value matches, fcase
returns nil.

See specific forms of this macro in 'case' and 're-case'.

The test expressions in 'fcase' are always evaluated linearly, in
order.  For a large number of case expressions it may be more
efficient to use a hash lookup.

in-case

Usage: (in-case test-value & clauses)

Like case, but test expressions are sequences.  The test expression
is true if any item in the sequence is equal (tested with '=') to
the test value.

instance-case

Usage: (instance-case test-value & clauses)

Like case, but the test expressions are Java class names, tested with
'instance?'.

re-case

Usage: (re-case test-value & clauses)

Like case, but the test expressions are regular expressions, tested
with re-find.