anchor.diff:         (tree-to-result rule-tree)))
       (_ (tree-to-result rule-tree))))
   
  -(defun walk-tree-negative (rule-tree heads)
  -  (adt:match scully.rule-trees::rule-tree rule-tree
  -    ((scully.rule-trees::node term hi lo)
  -     (if (member term heads)
  -       (walk-tree-negative hi heads)
  -       (walk-tree-negative lo heads)))
  -    (_ (tree-to-result rule-tree))))
  -
  -
   (defun walk-stratum-positive (stratum heads)
     (iterate
       (for (values new-stratum new-heads) =
  
positive.code: 
    "
    (adt:match scully.rule-trees::rule-tree tree
      ((scully.rule-trees::node term% _ lo)
       (if (< term% term)
         (advance-tree lo term)
         (tree-to-result tree)))
      (_ (tree-to-result tree))))
  
  (defun advance-forest (forest term)
    "Advance the rule forest up to (but not beyond) `term`.
  
    Two values will be returned:
  
negative.code: 
    "
    (iterate
      (for tree :in (stratum-rule-trees stratum))
      (for (values new-tree new-head) = (funcall function tree))
      (when new-tree (collect new-tree :into new-trees))
      (when new-head (collect new-head :into new-heads))
      (finally (return (values (update-stratum-with stratum new-trees)
                               new-heads)))))
  
  (defun process-forest (function forest)
    "Process the rule forest with `function`.
  