anchor.diff:    "Applies FUNCTION to children, overlapping REGION, in the order they
   were added."
     (declare (ignore x-offset y-offset))
  -  (loop with children = (output-record-children record)
  -        for child across children
  -        when (region-intersects-region-p region child)
  -          do (apply function child function-args)))
  +  (let ((function (alexandria:ensure-function function)))
  +    (loop with children = (output-record-children record)
  +          for child across children
  +          when (region-intersects-region-p region child)
  +          do (apply function child function-args))))
   
   ;;; tree output recording
   
  
positive.code:   "Applies FUNCTION to children, containing (X,Y), in the reversed
  order they were added."
    (declare (ignore x-offset y-offset))
    (loop with children = (output-record-children record)
          for i from (1- (length children)) downto 0
          for child = (aref children i)
          when (and (multiple-value-bind (min-x min-y max-x max-y)
                        (output-record-hit-detection-rectangle* child)
                      (and (<= min-x x max-x) (<= min-y y max-y)))
                    (output-record-refined-position-test child x y))
            do (apply function child function-args)))
  
  (defmethod map-over-output-records-overlapping-region
      (function (record standard-sequence-output-record) region
  
negative.code: 
  (defmethod %tree-recompute-extent* ((record compound-output-record))
    ;; Internal helper function
    (if (zerop (output-record-count record)) ; no children
        (with-slots (x y) record
          (values x y x y))
        (let ((new-x1 0)
              (new-y1 0)
              (new-x2 0)
              (new-y2 0)
              (first-time t))
          (flet ((do-child (child)
                   (cond ((null-bounding-rectangle-p child))
                         (first-time
                          (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
                            (bounding-rectangle* child))
                          (setq first-time nil))
                         (t
                          (with-bounding-rectangle* (cx1 cy1 cx2 cy2) 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))
          (values new-x1 new-y1 new-x2 new-y2))))
  
  (defgeneric tree-recompute-extent-aux (record))
  