anchor.diff:  (defmethod map-over-output-records-1
       (function (record standard-sequence-output-record) function-args)
     "Applies FUNCTION to all children in the order they were added."
  -  (if function-args
  -      (loop with children = (output-record-children record)
  -            for child across children
  -            do (apply function child function-args))
  -      (loop with children = (output-record-children record)
  -            for child across children
  -            do (funcall function child))))
  +  (let ((function (alexandria:ensure-function function)))
  +    (if function-args
  +        (loop for child across (output-record-children record)
  +              do (apply function child function-args))
  +        (loop for child across (output-record-children record)
  +              do (funcall function child)))))
   
   (defmethod map-over-output-records-containing-position
       (function (record standard-sequence-output-record) x y
  
positive.code: 
  (defmethod %tree-recompute-extent* ((record compound-output-record))
    ;; Internal helper function
    (let ((new-x1 0)
          (new-y1 0)
          (new-x2 0)
          (new-y2 0)
          (first-time t))
      (map-over-output-records
       (lambda (child)
         (unless (null-bounding-rectangle-p child)
           (if first-time
               (progn
                 (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
                   (bounding-rectangle* child))
                 (setq first-time nil))
               (with-bounding-rectangle* (cx1 cy1 cx2 cy2) child
                 (minf new-x1 cx1)
                 (minf new-y1 cy1)
                 (maxf new-x2 cx2)
                 (maxf new-y2 cy2)))))
       record)
      (if first-time
          (with-slots (x y) record
            (values x y x y))
          (values new-x1 new-y1 new-x2 new-y2))))
  
  (defgeneric tree-recompute-extent-aux (record))
  
negative.code:   (bounding-rectangle* record))
  
  (defmethod tree-recompute-extent-aux ((record compound-output-record))
    (if (zerop (output-record-count record)) ; no children
        (bounding-rectangle* record)
        (let ((new-x1 0)
              (new-y1 0)
              (new-x2 0)
              (new-y2 0)
              (first-time t))
          (flet ((do-child (child)
                   (if first-time
                       (progn
                         (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
                           (tree-recompute-extent-aux child))
                         (setq first-time nil))
                       (multiple-value-bind (cx1 cy1 cx2 cy2)
                           (tree-recompute-extent-aux child)
                         (minf new-x1 cx1)
                         (minf new-y1 cy1)
                         (maxf new-x2 cx2)
                         (maxf new-y2 cy2)))))
            (declare (dynamic-extent #'do-child))
            (map-over-output-records #'do-child record))
          (with-slots (x y) record
            (setf x new-x1 y new-y1)
            (setf (rectangle-edges* record)
                  (values new-x1 new-y1 new-x2 new-y2))))))
  
  (defmethod recompute-extent-for-changed-child
      ((record compound-output-record) changed-child
  