anchor.diff:    (with-slots (height width cells) p
       (loop for x below height do
            (loop for y below width
  -            do (setf (puzzle (aref cells x y)) p)))))
  +            do (setf (puzzle-of (aref cells x y)) p)))))
   
   (defun puzzle-cell (p x y)
     "get the cell object in `p` at coordinates (`x`, `y`)"
  
positive.code:                 for cell = (entry-cell (read stream) x y)
                  do (setf (aref cells x y) cell)
                  if (typep cell 'blank-cell)
                  do (setf (horiz cell) (svref curr-horiz-constraints x)
                           (verti cell) (svref curr-verti-constraints y))
                  else
                  if (typep cell 'wall-cell)
                  do (setf (svref curr-horiz-constraints x) nil
  
negative.code:   "list all candidate entries"
    (loop for i from 1 upto +max-digit+ collect i))
  
  (defun candidates (cell)
    "find all the numbers that `cell` could possibly hold"
    (declare (cell cell))
    ;; TODO cleanup
    (let ((cand (make-all-candidates)))
      ;; figure out possible sets of numbers for the respective row/column sums
      (when (and (constraint-row cell) (horizontal-constraint (constraint-row cell)))
        (let ((row-sum (horizontal-constraint (constraint-row cell)))
              (row (cell-row cell)))
          (setf cand (nintersection cand
                                    (reduce #'union
                                            (ways row-sum (length row) row))))))
      (when (and (constraint-col cell) (vertical-constraint (constraint-col cell)))
        (let ((col-sum (vertical-constraint (constraint-col cell)))
              (col (cell-col cell)))
          (setf cand (nintersection cand
                                    (reduce #'union
                                            (ways col-sum (length col) col))))))
      ;; remove any candidates which are already in the row/column
      (let ((col (cell-col cell)))
        (loop for cell in col
           if (mark cell)
           do (setf cand (delete (mark cell) cand))))
      (let ((row (cell-row cell)))
        (loop for cell in row
           if (mark cell)
           do (setf cand (delete (mark cell) cand))))
  