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: (defmacro match (exp)
     (let ((end-of-chain? (not (cdr exp))))
        (if (listp (car exp))
            (awhen (gethash (caar exp) destr-match-clauses)
                   (funcall it (cdar exp) (cdr exp) end-of-chain?)) ;; ew 
            (if (stringp (car exp))
                (generate-match-code exp end-of-chain?)
                (generate-bind-code exp end-of-chain?)))))
  
  ;; clauses
  ;;   switch - matches forms, takes the first to work, analogous to parmesan choice
  ;;   any - causes it to match zero or more list elements
  ;;   single - causes it to match only one form
  ;;   optional - if it matches, take that out of the list, keep matching either way,
  ;;     putting a single binding var at the end will break everything, as usual
  ;;   test - means the form must match the condition described as well as the structure of the match
  ;;   key - same as test, except the result of the function is bound instead of the normal result
  ;;   on-fail - expression to be returned by the whole thing if that subform fails to match
  
  (def-match-clause optional (forms rest end)
     (if end
  
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
  