anchor.diff:           (dbind ,(map #'cadr alist) (list ,@(map #'car alist))
              ,@body)))))
   
  -(mac new-fn (args &body body)
  +(mac dfn (args &body body)
     "Same as fn but allows ?, !, and argument destructuring."
     (mvb (new-args alist) (parse-args args)
       (if (null alist)
  
positive.code: (def parse-args (args)
    "Parses an entire argslist and returns a new argslist, along with an
     alist of arguments that need to be destructured."
    (withs (new-args (add-keywords args)
            pos (pos [mem _ lambda-list-keywords] (add-keywords new-args)))
      (if (null pos)
          (parse-normal new-args)
          (mvb (new-args1 alist1) (parse-normal (cut new-args 0 pos))
            (mvb (new-args2 alist2) (parse-optional (cut new-args (+ pos 1)))
              (values (append new-args1 (list (elt new-args pos)) new-args2)
                      (append alist1 alist2)))))))
  
  (def parse-normal (args)
  
negative.code: ;;;; for optional arguments, ! for keyword arguments, and an improper
  ;;;; argument list is equivalent to one that uses &rest [scheme
  ;;;; style]). One can even use a symbol to represent all of the
  ;;;; arguments. For example (dfn args (reduce #'+ args)) is a
  ;;;; procedure which sums its arguments. Even cooler is (dfn dfn dfn)
  ;;;; which is equivalent to the list procedure. To use destructuring
  ;;;; with optional arguments, they needs to be surrounded by parens,
  ;;;; otherwise it is ambigous as to whether (x a) meas that x defaults
  ;;;; to the value of a, or this is meant to destructure into variables
  ;;;; x and a.
  
  ;;;; Issues
  ;;;; Keyword arguments do not work with destructuring. What would the
  