Macro | Package: excl | ToC | DocOverview | CGDoc | RelNotes | FAQ | Index | PermutedIndex
| Allegro CL version 9.0 Unrevised from 8.2 to 9.0. 8.2 version

## re-case

Arguments: string &rest clauses

string must be an expression that evaluates to a string. The clauses are then examined one by one, checking whether it matches string or not. clauses must be one of the following forms:

- `(``regexp bindings expr``...)`: if string matches `regexp`, (sub)matches are bound to the variables according to `bindings`, then `expr ...` are evaluated. See the documentation of re-lambda for information on the specifiction of `regexp` and `bindings`.
- `(:test` `proc expr ...``)`: `proc` must be an expression that evaluates to a procedure that takes single argument. `proc` is called with string, and if it returns a true value, evaluates `expr ...`.
- `(:testlet` `proc var expr ...``)`: like `:test` above, but binds the result of `proc` to `var` while evaluating `expr...`.
- `(t expr ...)`: always match and evaluates `expr ...`. This can be used to describe the fallback case.

If no clause match, `nil` is returned.

See also re-let and re-lambda.

### Example

    cl-user(4): (setq f
    	      (re-lambda "([^ ]+) ([^ ]+) ([^ ]+)"
    		  ((foo 1) (bar 2) (baz 3))
    		(list foo bar baz)))
    #<Interpreted Function (unnamed) @ #x71ed7892>
    cl-user(5): (funcall f "foo the bar")
    ("foo" "the" "bar")
    cl-user(6): (re-let "([^ ]+) ([^ ]+) ([^ ]+)"
    		"foo the bar"
    		((foo 1) (bar 2) (baz 3))
    	      (list foo bar baz))
    ("foo" "the" "bar")
    cl-user(7):

    cl-user(9): (re-case "foo the barmy"
    	      ("foo a (.*)" ((it 1)) (list it))
    	      ("foo the (.*)" ((it 1)) (list it))
    	      (t :no-match))
    ("barmy")
    cl-user(10): (re-case "foo a barmy"
    	      ("foo a (.*)" ((it 1)) (list it))
    	      ("foo the (.*)" ((it 1)) (list it))
    	      (t :no-match))
    ("barmy")
    cl-user(11): (re-case "foo xx barmy"
    	      ("foo a (.*)" ((it 1)) (list it))
    	      ("foo the (.*)" ((it 1)) (list it))
    	      (t :no-match))
    :no-match
    cl-user(12):

    cl-user(30): (labels ((parse-date (input)
                            (re-case input
                              ("^(\\d{4})([-/])(\\d{1,2})\\2(\\d{1,2})$"
                               ((year 1) (month 3) (day 4))
                               (mapcar #'read-from-string (list year month day)))
                              ("^(\\d{1,2})([-/])(\\d{1,2})\\2(\\d{4})$"
                               ((year 4) (month 1) (day 3))
                               (mapcar #'read-from-string (list year month day)))
                              ("^(\\d{2})([-/])(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\2(\\d{4})$"
                               ((year 4) (month 3) (day 1))
                               (list
                                (read-from-string year)
                                (cdr
                                 (assoc month
                                        '(("Jan" . 1) ("Feb" . 2) ("Mar" . 3)
                                          ("Apr" . 4) ("May" . 5) ("Jun" . 6)
                                          ("Jul" . 7) ("Aug" . 8) ("Sep" . 9)
                                          ("Oct" . 10) ("Nov" . 11) ("Dec" . 12))
                                        :test #'equal))
                                (read-from-string day))))))
                   (list (parse-date "2004/7/21")
                         (parse-date "7-21-2004")
                         (parse-date "21-Jul-2004")))
    ((2004 7 21) (2004 7 21) (2004 7 21))
    cl-user(31):

The symbol naming this operator is also exported from the regexp package.

See The new regexp2 module in regexp.htm for further information on this macro and the regexp2 module.

Copyright (c) 1998-2019, Franz Inc. Oakland, CA., USA. All rights reserved.
This page was not revised from the 8.2 page.
Created 2012.5.30.

|  | ToC | DocOverview | CGDoc | RelNotes | FAQ | Index | PermutedIndex
| Allegro CL version 9.0 Unrevised from 8.2 to 9.0. 8.2 version