anchor.diff:             (let ,(mapcar (lambda (var) (list var var)) variables)
                ,@body))))))
   
  +(defmacro with-parsed-arguments (shell-lambda-list args &body body)
  +  "Parse the given arguments according to the given shell lambda list.
  +
  +See `shell-lambda' for documentation on what a shell lambda list
  +consists of.
  +
  +This macro is equivalent to creating a shell lambda and then invoking
  +it with the given args."
  +  `(apply (shell-lambda ,shell-lambda-list
  +            ,@body)
  +          ,args))
  +
   (defmacro %define-command (&whole whole class name shell-lambda-list &body body)
     (multiple-value-bind (function-sym string-form) (parse-name name)
       (when (find #\/ string-form)
  
positive.code:   (print-unreadable-object (sll stream :type t)
      (format stream "~S" (unparse-shell-lambda-list sll))))
  
  (defmacro shell-lambda (shell-lambda-list &body body)
    "`lambda' with shell argument processing.
  
  
negative.code: 
  &whole [var]
  Binds var to the full list of arguments received.  Note that the first
  element of the list is the command name.  You must not mutate the list.
  
  &argv0 [var]
  Binds var to the first argument received (i.e. the command name).
  
  &flag {(var sigil-str*) | var}*
  &option {(var sigil-str*) | var}*
  Flags and options model the common shell convetion of --arguments.
  The difference between a flag and an option is how many parameters
  they consume.  A flag consumes no command arguments.  An option
  consumes one command argument.  Although you must place flags before
  options in your shell lambda list, flags and options can be intermixed
  when the lambda is invoked.
  
  If you do not provide a sigil-str, it will default to the lower-case
  name of the variable symbol.  If you provide multiple sigil-str
  values, all of them will be associated with the flag/option.  This
  allows you to achieve the common pattern of having long
  names (e.g. --long-name) and short names (e.g. -L) for a single flag.
  You could also use this to model flags that are mutually
  exclusive (e.g. --foobar vs --no-foobar).
  
  With &flag, var will be bound to an array containing the sigils that
  were found.  So, if a single flag is provided more than once, the
  array will have multiple elements.  With &option, var will be bound to
  an array containing the values provided for that option.
  
  &required {var}*
  Vars listed in the required section correspond to positional arguments
  that must be provided by the caller.  After proccessing argv0, flags,
  and options, the required section works just like required arguments
  in a normal lambda list.
  
  &optional {(var default-form) | var}*
  The optional section behaves just like the optional section of a
  normal lambda list.
  
  &rest [var]
  The rest section behaves just like the rest section of a normal lambda
  list."
    ;; I went back and forth on whether &flag arguments should be
    ;; array-valued or list-valued.  I ultimately decided that it was
    ;; better to default to the option with better performance.  Unlike
    ;; &whole and &rest, &flag and &option don't have analogs in normal
    ;; lambda lists and so there's no convention to follow.
  
    ;; The end result is that we use lists for some arguments and arrays
    ;; for others.  I bet this is going to cause some people a great
    ;; deal of annoyance...
    (let* ((sll (parse-shell-lambda-list shell-lambda-list))
           (args (gensym "ARGS"))
           (arg (gensym "ARG"))
           (option-table (gensym "OPTION-TABLE"))
           (flag-table (gensym "FLAG-TABLE"))
           (option-setter (gensym "OPTION-SETTER"))
           (flag-setter (gensym "FLAG-SETTER"))
           (variables (shell-lambda-list-variables sll)))
      (with-slots (whole argv0 flags options required-args optional-args rest)
          sll
  