anchor.diff:        (error 'ptree-undefined-function-error :id id))
       (unwrap-result
        (result
  -      (cond ((computedp root)
  -             root)
  -            (t
  -             (wait-for-compute ptree)
  -             (cond ((computedp root)
  -                    root)
  -                   (t
  -                    (check-kernel)
  -                    (compute-ptree root ptree *kernel*)))))))))
  +      (if (computedp root)
  +          root
  +          (with-lock-held ((lock ptree))
  +            (wait-for-compute ptree)
  +            (if (computedp root)
  +                root
  +                (compute-ptree root ptree (check-kernel)))))))))
   
   (defun has-lambda-list-keyword-p (list)
     (some (lambda (elem) (find elem lambda-list-keywords)) list))
  
positive.code: computations.
  
  `ptree' is the ptree instance in which the node is being defined."
    (with-%ptree-slots (nodes) ptree
      (flet ((fetch-node (id) (or (gethash id nodes)
                                  (setf (gethash id nodes)
                                        (make-node-instance :id id)))))
        (let ((node (fetch-node id)))
          (with-node-slots ((node-function function)
                            (node-children children)) node
            (when node-function
              (error 'ptree-redefinition-error :id id))
            (setf node-function function)
            (let ((children (mapcar #'fetch-node args)))
              (dolist (child children)
                (with-node-slots (parents) child
                  (push node parents)))
              (setf node-children children))))))
    id)
  
  (defun call-ptree (id ptree)
  
negative.code: (defun check-ptree (ptree)
    "Verify that all nodes have been defined with an associated
  function. If not, `ptree-undefined-function-error' is signaled."
    (with-lock-held ((lock ptree))
      (each-node ptree #'check-node)))
  
  (defun clear-ptree (ptree)
    "Clear all node results in `ptree', restoring the tree to its
  uncomputed state."
    (with-lock-held ((lock ptree))
      (wait-for-compute ptree)
      (each-node ptree #'clear-node)))
  
  (defun clear-ptree-errors (ptree)
    "Clear all error results in `ptree', allowing the computation to
  resume from its latest pre-error state."
    (with-lock-held ((lock ptree))
      (wait-for-compute ptree)
      (each-node ptree #'clear-node-error)))
  
  (defun ptree-fn (id args function ptree)
    "Define a ptree node with identifier `id', which is some unique
  