anchor.diff:     (let ((match-form (macroexpand `(match ,match-form)))
            (bindings (parse-out-free-symbols match-form)))       
            `(let ,(append `((list ,exp)) (simple-pair bindings nil))
  -            (aif ,match-form
  -                 ,@body 
  +            (if ,match-form
  +                ,@body 
                    nil))))
  
positive.code: ;;   add neat switch macro
  ;;   key argument for matching strings instead of symbols
  ;;     another for case sensitivity? 
  ;;   test everything
  ;;   fill out the README with examples and documentation
  
  (defparameter destr-match-clauses (make-hash-table :test #'equalp))
  
  (defmacro def-match-clause (name ll &rest rest)
     `(setf (gethash ',name destr-match-clauses) (lambda ,ll ,@rest)))
  
  (defun parse-out-free-symbols (exp)
     (delete-duplicates
        (if (listp exp) 
            (iter (for x in exp)
                  (when (and (eq x (car exp)) (gethash x destr-match-clauses)) (next-iteration))
                  (aif (parse-out-free-symbols x) (appending it)))
            (when (symbolp exp) (list exp)))))
  
  (defun generate-match-code (exp end)
  
negative.code:                 (declare (fixnum ,i))
                  (for ,v = (subseq list 0 ,i))
                  (setf ,(car exp) ,v)
                  (for ,w = (let ((list (subseq list ,i))) (match ,(cdr exp))))
                  (when ,(if match-whole-list? `(eq ,w t) w) (leave ,w))
                  (finally (setf ,(car exp) nil) (return nil))))))
  
  (defmacro match (exp)
     (print 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?)))))
  