anchor.diff:     (if (and (listp (first var)) (symbol-eq (car (first var)) 'single))
         (key-single var rest end)
         (if end
  -        `(awhen (and list (funcall ,(second var) list)) (setf ,(first var) it) t)
  -        (with-gensyms (v x w r f 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 ,rest)))
  -                (let ((,f (funcall ,(second var) ,v))) 
  -                  (when (and (eq ,w t) ,f)
  -                    (setf ,(car var) ,f) 
  -                    (go ,succeed)))
  -                (appendf ,v (list (car ,x)))
  -                (setf ,x (cdr ,x))
  -                (go ,loop)
  -                ,fail
  -                (setf ,(car var) nil)
  -                (setf ,r nil)
  -                (go ,end)
  -                ,succeed
  -                (setf ,r ,w)
  -                ,end)
  -             ,r)))))
  +         `(awhen (and list (funcall ,(second var) list)) (setf ,(first var) it) t)
  +          (generate-bind-body (car var) rest 'key (second var)))))
   
   (defun simple-pair (list val)
      (mapcar (lambda (x) (list x val)) list))
  
positive.code: (in-package destr-match)
  
  ;; TODO
  ;; [x] MAKE THE PACKAGE NAME MATCH THE SYSTEM NAME
  ;; [x] neat switch macro
  ;; [ ] fill out the README with examples and documentation
  ;; [ ] sublists?
  ;; [x] make special parsing for single inside test and key
  ;; [x] make switch (list) raw forms, so everything still works
  ;; [ ] modify match so clause names without arguments are bindings
  ;; [ ] full literal value matching, using quotes for symbols?
  ;; [ ] fix indentation and maybe line length
  
  (defparameter destr-match-clauses (make-hash-table :test #'equalp))
  (defparameter matching-style 'symbol) ;; symbol, string, case-sensitive, regex, symbol-regex
  
  (defmacro def-match-clause (name ll &rest rest)
     `(setf (gethash ,(string name) destr-match-clauses) (lambda ,ll ,@rest)))
  
negative.code: 
  (defun test-single (var rest end)
     (if end
        `(when (and (car list) (funcall ,(second var) (car list)))
               (setf ,(second (first var)) (car list))
               (not (cdr list)))
        `(when (and (car list) (funcall ,(second var) (car list)))
               (setf ,(second (first var)) (car list))
               (let ((list (cdr list)))
                     (match ,rest)))))
  
  (def-match-clause test (var rest end)
     (if (and (listp (first var)) (symbol-eq (car (first var)) 'single))
         (test-single var rest end)
     (if end
        `(when (and list (funcall ,(second var) list)) (setf ,(first var) list) t)
         (generate-bind-body (car var) rest 'test (second var)))))
  
  (defun key-single (var rest end)
     (if end
  