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:           collect arg into new-args
          finally (return (values new-args alist))))
  
  (mac new-def (name args &body body)
    "Same as def but allows ?, !, and argument destructuring."
    (mvb (new-args alist) (parse-args args)
      (if (null alist)
  
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
  