anchor.diff:        (set! out `(,(.. (pretty k) " " (pretty v)) ,@out)))
       (.. "{" (.. (concat out " ") "}"))))
   
  +(defmethod (pretty multimethod) (x)
  +  (.. "«method: (" (get-idx (getmetatable x) :name) " " (concat (get-idx (getmetatable x) :args) " ") ")»"))
  +
   (defdefault pretty (x)
     (tostring x))
   
  
positive.code:       (set! n (+ 1 n))
        (set-idx! out n k))
      (set-idx! out :n n)
      (unpack out 1 (get-idx out :n))))
  
  (defun s->s (x) :hidden (get-idx x :contents))
  
  
negative.code:    out = \"foo\"
     ```"
    (let* [(this (gensym 'this))
           (key (gensym 'key))
           (method (gensym 'method))]
      `(define ,name
         ,@attrs
         (setmetatable
           { :lookup {}
             :tag :multimethod }
           { :__call (lambda (,this ,@ll)
                       (let* [(,method (deep-get ,this :lookup ,@(map (lambda (x)
                                                                        `(type ,x)) ll)))]
                         (unless ,method
                           (if (get-idx ,this :default)
                             (set! ,method (get-idx ,this :default))
                             (error (.. "No matching method to call for ("
                                        (concat (list
                                                  ,(s->s name)
                                                  ,@(map (lambda (x) `(type ,x)) ll))
                                                " ")
                                        ")\n  "
                                        (let* [(,key (keys (get-idx ,this :lookup)))]
                                          (if (>= (n ,key) 1)
                                            (.. "There are methods to call for "
                                                (concat (map (lambda (,key)
                                                               (.. "  - " ,key))
                                                             (keys (get-idx ,this :lookup)))
                                                        "\n"))
                                            "There are no methods to call."))))))
                         (,method ,@ll)))
             :name ,(s->s name)
             :args (list ,@(map s->s ll)) }))))
  
  (defun put! (t typs l) :hidden
    "Insert the method L (at TYPS) into the lookup table T, creating any needed
  