anchor.diff:                                      :path-cost (+ depth cost)
                                       :depth (1+ depth))))
                        (remove-if (lambda (temp-triple)
  -                                  (find (aref temp-triple 1) (fringe-elements fringe) :key #'node-state :test #'equal))
  +                                  (let ((heap-pos (fringe-find fringe (aref temp-triple 2))))
  +                                    (and heap-pos
  +                                         (equal (node-state heap-pos) (aref temp-triple 2)))))
                                   (mapcar (lambda (state-direction)
                                             (let ((state (car state-direction))
                                                   (direction (cdr state-direction)))
  
positive.code: (defun n-puzzle (search heuristic initial-state)
    (funcall search #'action heuristic #'goalp initial-state))
  
  (format t "A*-search~%")
  (time (format t "~A~%" (n-puzzle #'IDA*-search
                                   #'manhattan
                                   *start*)))
  
  (format t "IDA*-search~%")
  (time (format t "~A~%" (n-puzzle #'A*-search
                                   #'manhattan
                                   *start*)))
  
negative.code:   (key #'identity)
    (elements (make-heap)))
  
  (defun fringe-remove (f)
    (heap-pop (fringe-elements f) (fringe-key f)))
  
  (defun fringe-insert (f items)
    (mapc (lambda (item)
            (heap-insert (fringe-elements f) item (fringe-key f)))
          items)
    f)
  
  (defun fringe-find (f key-val)
    (heap-find (fringe-elements f) key-val (fringe-key f)))
  
  (defstruct node
    state
  