pcond

PCOND is a conditional macro that does pattern matching, supporting Lisp predicates, regular expressions, and unification expressions. (The "P" in the name is for pattern matching.) This library was created and is maintained by Eric Normand?. It depends on cl-ppcre and cl-unification.

It binds variables to the values it matches to. Those bindings are available in the body of the conditional.

It currently has three pattern types it matches:

ordinary LISP predicates
- Example: (evenp x)

regular expressions

Example:

      (:re "xy(z+)" str (zs))  ;; matches the regular expression to
                               ;; the value of STR.  If it matches,
                               ;; ZS is bound to the matching group.

unification expressions

Example:

      (:pat (?x . ?rest) ls)   ;; matches the pattern against the value
                               ;; of LS.  Binds the variables ?X and
                               ;; ?REST to the results of the
                               ;; unification.

Another great feature is that you can "nest" the conditionals.
Examples

* (pcond:pcond 
    ((and (:pat (?x . ?xs) '(a b))
          (:re "xyz" "xyz"))
       'match))
MATCH

* (pcond:pcond
     ((and (:re "ab(\\d*)" "ab12" ((#'parse-integer num)))
           (some #'(lambda (x)
                     (and (:pat (?x ?y . ?rest) x)
	 		 (= ?y num)))
                 '((a 1) (b 2 h) (c 12 j) (f 12))))
        ?x))
C

Examples:

(defun my-map (fn ls)
  (pcond:pcond
    ((null ls)
      nil)
    ((:pat (?x . ?xs) ls)
      (cons (funcall fn ?x) (my-map fn ?xs)))))

(defun path-parser (path)
  (pcond:pcond
    ((or (null path) (:pat "" path))
      nil)
    ((:re "^(/)(.*)" path (slash rst))
      (cons "/" (path-parser rst)))
    ((:re "^([^/]*)