anchor.diff:                                 [((_ (positional ?d) _)) d]
                                  [else nil])
                                fragments)))
  +         (named-map (gensym))
            ((positionals nameds)
             (loop [(pos '())
                    (nam {}) (expecting-nam nil)
  
positive.code:                       (.<! nam expecting-nam (car togo))
                        (push-cdr! pos (car togo)))
                      (recur pos nam nil (cdr togo))])))
           (interpret-spec
             (function
               [((positional ?k)) (nth positionals k)]
               [((implicitly-named ?k)) (str->sym k)]
               [((named ?k)) (or (.> nameds (.. ":" k))
                                 (error (string/format "(format %q): not given value for named argument %s"
                                                       str k)))]))]
      (when (> last-positional (n args))
        (error (string/format "(format %q): not given enough positional arguments (expected %d, got %d)"
                              str last-positional (n args))))
      `(format-output! ,out
                       ,(cons `.. (dolist [(frag fragments)]
                                    (compile-format-fragment frag interpret-spec))))))
  
negative.code: 
     Formatting specifiers take the form `{...}`, where `...` includes
     both a _reference_ (what's to be output) and a _formatter_ (how to
                                                                     output it).
  
     - If the reference starts with `#`, it is an implicit named symbol
     (something in scope, and not passed explicitly).
     - If the reference starts with an alphabetic character, it is
     _named_: something given to the [[format]] macro explicitly, as a
     keyword argument.
     - If the reference starts with `$`, it is a positional argument.
  
     The formatter can either start with `:`, in which case it references
  