anchor.diff: -(proclaim '(optimize (speed 3) (safety 0) (debug 0) (space 3)))
  +(proclaim '(optimize (speed 3) (safety 0) (debug 0) (space 0)))
   ;(declaim #+sbcl(sb-ext:muffle-conditions style-warning))
   ;(declaim #+sbcl(sb-ext:muffle-conditions warning))
   (setf *print-case* :downcase)
   ;; (ql:quickload '(alexandria iterate anaphora) :silent t)
   
   (defpackage destr-match
  - (:use cl alexandria iterate anaphora))
  +  (:use cl alexandria iterate anaphora)
  +  (:shadow switch))
   (in-package destr-match)
   
   ;; TODO
   ;;   [ ] finish off matching clauses
  +;;   [ ] make the actual macro nicer
   ;;   [ ] add neat switch macro
  -;;   [x] key argument for matching strings instead of symbols
  -;;   [x]   another for case sensitivity? 
  -;;   [x]   more key args
  -;;   [x] test everything
   ;;   [ ] fill out the README with examples and documentation
  -;;   [x] optimize binding code with tagbody and setf
   ;;   [ ] figure out some way to condense all that repeated bind code
  -;;   [ ] regex matching
   
   (defparameter destr-match-clauses (make-hash-table :test #'equalp))
   (defparameter matching-style 'symbol) ;; symbol, string, case-sensitive, regex, symbol-regex
  
positive.code: 
  (def-match-clause test (var rest end)
     (if end
         `(when (and list (funcall ,(second var) list)) (setf ,(first var) list) t)
         (with-gensyms (v x w r loop succeed fail end)
           `(let ((,v (list (car list))) (,x (cdr list)) (,w nil) (,r nil))
                  (tagbody
                    ,loop
                       (when (not ,x) (go ,fail))
                       (setf ,w (let ((list ,x)) (match ,(cdr exp))))
                       (when (and (eq ,w t) (funcall ,(second var) ,w)) (go ,succeed))
                       (appendf ,v (list (car ,x)))
                       (setf ,x (cdr ,x))
                       (go ,loop)
                    ,fail
                       (setf ,(car exp) nil)
                       (setf ,r nil)
                       (go ,end)
                    ,succeed
                       (setf ,(car exp) ,v)
                       (setf ,r ,w)
                    ,end)
                  ,r))))
  
negative.code:                  (if ,foo ,foo (match ,rest))))))
  
  (def-match-clause switch (forms rest end)
     (print `(switch ,forms ,rest ,(append (car forms) rest)))
     (if (not (cdr forms))
        `(match ,(car forms))
         (if end
             (with-gensyms (foo)
               `(let ((,foo (match ,(first forms))))
                      (if ,foo ,foo (match ((switch ,@(cdr forms)))))))
             (with-gensyms (foo)
               `(let ((,foo (match ,(append (car forms) rest))))
                      (if ,foo ,foo (match ,(append `((switch ,@(cdr forms))) rest))))))))
  
  (def-match-clause single (var rest end)
     (if end
  