anchor.diff:             [(or (>= j (n str))
                   (= (string/char-at str j) "}"))
               (set! i j)
  -            (let* [((frag anon-pos)
  -                    (handle-formatting-specifier parsed last-positional))]
  -              (when anon-pos
  -                (set! last-positional anon-pos))
  +            (let* [(frag (handle-formatting-specifier parsed last-positional))]
                 (push-cdr! frags frag))]
              (recur (.. parsed (string/char-at str j)) (+ 1 j)))]
           [else => (set! buf (.. buf it))])
  
positive.code:             [(string/find (string/char-at str 1) "#")
               (let* [((start end match)
                       (string/find str "#([a-zA-Z][^:%%@]*)"))]
                 (values-list (list 'implicitly-named match) end))]))]
      (values-list val (string/sub str (+ 1 end)))))
  
  (defun display-with-sep (sep frag) :hidden
  
negative.code:             (k (parse-format-formatter fmtr))]
         (lambda (ref)
           (list 'urn-format ref (display-with-sep (string/sub sep 2 (- (n sep) 1)) (k 'ignored)))))]
      [(= spec "") (lambda (ref) (list 'urn-format ref `display))]))
  
  (defun handle-formatting-specifier (spec last-pos) :hidden
    "Parse the entirety of the format specifier SPEC."
    (let* [((ref spec) (parse-format-reference spec last-pos))
           ((formatter spec) (parse-format-formatter spec))]
    (formatter ref)))
  
  (defun parse-format (str) :hidden
    "Parse the format string STR into a list of fragments."
    (let* [(cur "") ; the current character (for convenience)
           (buf "") ; a buffer
           ; we don't have pointers, so we keep it in a table.
           (last-positional { 1 1 }) ; for anonymous positions
           (frags '())]
      (loop [(i 1)]
        [(> i (n str))
  