XLISP case

Nyquist / XLISP 2.0 - Contents | Tutorials | Examples | Reference

# case

Type: | - | special form (fsubr)
Source: | - | xlcont.c

## Syntax

(case expr [(value action) ... ])
  expr - an expression that can be compared via eql
  value - an unevaluated expression or list of unevaluated expressions
  action - one or more expressions
  returns - the value of the last expression of the matching case

## Description

The 'case' special form first evaluates 'expr', the return value of this evaluation is then compared against all the 'value' entries:

    (case expr
      (value-1 action-1)
      (value-2 action-2)
        ...
      (value-n action-n))

If 'value' is a single atom, the atom is compared against 'expr':

    > (case 'a
        ('a "a")
        ('b "b"))
    "a"

If 'value' is a list, each of the elements of the list are compared against 'expr':

    > (case 'a
        ((1 2 3 4) "number")
        ((a b c d) "alpha"))
    "alpha"

The 'action' associated with the first 'value' that matches 'expr' is evaluated and returned as the result of the 'case' special form.

If no 'value' matches, NIL is returned:

    > (case 'c
        ('a "a")
        ('b "b"))
    NIL

If the last 'value' is the symbol T and no other 'value' has matched 'expr', then 'case' will evaluate the 'action' associated with T :

    > (case 3
        (1 "one")
        (2 "two")
        (t "no match"))
    "no match"

If there are multiple T entries, the first is considered to be the end of the 'case':

    > (case 9
        (1 "one")
        (t "first t")
        (t "second t"))
    "first t"

Note: The 'case' special form does not work with a list or string as the 'expr' because 'case' uses eql which cannot compare lists or strings:

    > (case "a"   ; doesn't work!
        ("a" 'a)
        ("b" 'b))
    NIL

The cond special form can be used to test Lisp expressions that cannot be handled by 'case'.

## Examples

    (case)     => NIL
    (case 'a)  => NIL

    (defun c-type (expr)
      (case (type-of expr)
        (flonum  "float")
        (fixnum  "integer")
        (string  "string")
        (cons    "non-empty list")
        (nil     "empty list")
        (t       "other")))

    (c-type 1.2)     => "float"
    (c-type 3)       => "integer"
    (c-type "ab")    => "string"
    (c-type '(a b))  => "non-empty list"
    (c-type '())     => "empty list"
    (c-type 'a)      => "other"

See defun, type-of.

See also:

- Contents → Control Constructs

Back to Top

Nyquist / XLISP 2.0 - Contents | Tutorials | Examples | Reference