anchor.diff:                   (delayed-unknown-p (lazy-array-delayed-action unknown)))
         (error "Not an unknown: ~S" unknown))))
   
  -(defmethod backend-evaluator (backend lazy-arrays unknowns)
  +(defmethod backend-evaluator (backend (lazy-arrays null) (unknowns list))
  +  (lambda () (values)))
  +
  +(defmethod backend-evaluator (backend (lazy-arrays list) (unknowns list))
     (lambda (&rest arrays)
       (let ((*backend* backend))
         (apply #'compute
  
positive.code: ;;; the N values obtained by computing the supplied arrays after
  ;;; substituting each unknown in their definition with the supplied
  ;;; argument in the corresponding position.
  (defgeneric backend-evaluator (backend lazy-arrays unknowns))
  
  ;;; Returns whether the lazy arrays's collapsed value can be obtained at
  ;;; O(1) cost, so that we don't have to do any work during COMPUTE or
  
negative.code: ;;;
  ;;; Methods
  
  (defmethod delete-backend (backend)
    (values))
  
  (defmethod delete-backend ((backend backend))
    (change-class backend 'deleted-backend))
  
  (defmethod backend-compute (backend (lazy-arrays null))
    (list))
  
  ;;; The default method for BACKEND-COMPUTE is implemented in terms of
  ;;; BACKEND-EVALUATOR, and the default method for BACKEND-EVALUATOR is
  ;;; implemented in terms of BACKEND-COMPUTE.  A consequence is that
  ;;; erroneous or incomplete backends would lead to an infinite recursion.
  ;;; We avoid this with the following special variable.
  (defvar *backend-compute-recursion* nil)
  
  ;;; Unless there is a more specific version of BACKEND-COMPUTE available
  ;;; for a particular backend, attempt to emulate it by creating an
  ;;; evaluator and calling that.
  (defmethod backend-compute (backend (lazy-arrays list))
    (if (not *backend-compute-recursion*)
        (let ((*backend-compute-recursion* t))
          (funcall (backend-evaluator backend lazy-arrays '())))
        (call-next-method)))
  
  ;;; In case a more specific method of BACKEND-SCHEDULE signals an error,
  ;;; handle it by replacing the delayed actions of all lazy arrays of the
  