anchor.diff:  VERTICES and whose values are lists of vertices."
     (when edges
       (maphash (lambda (k v)
  -               (assert (and (memqual k vertices)
  -                            (mapc (lambda (x) (memqual x vertices)) v))))
  +               (assert (and (member k vertices :test #'equal)
  +                            (mapc (lambda (x) (member x vertices :test #'equal)) v))))
                edges))
     (make-instance 'graph :vertices vertices :edges edges))
  +
  +;;; TRAVERSAL
  
positive.code: 
  (defun add-vertex (graph vertex)
    "Adds VERTEX to GRAPH."
    (pushqual vertex (vertices graph))
    graph)
  
  (defun remove-vertex (graph vertex)
    "Removes VERTEX from GRAPH."
    (setf (vertices graph) (remqual vertex (vertices graph)))
    (let ((edges (edges graph)))
      (maphash (lambda (k v)
                 (cond ((equal k vertex) (remhash k (edges graph)))
                       ((memqual vertex v)
                        (setf (gethash k edges) (remqual vertex v)))
                       (t)))
               edges))
    graph)
  
  (defun add-edge (graph x y)
    "Adds an edge from X to Y in GRAPH."
    (pushqual y (gethash x (edges graph)))
    graph)
  
  (defun remove-edge (graph x y)
    "Removes the edge from X to Y in GRAPH."
    (setf (gethash x (edges graph))
          (remqual y (gethash x (edges graph))))
    graph)
  #| TODO
  (macrolet ((get-vertex-value ()
  
negative.code: (in-package #:cl-directed-graph)
  
  (defclass graph ()
    ((vertices :accessor vertices :initarg :vertices)
     (edges    :accessor edges    :initarg :edges)))
  
  (defmethod print-object ((object graph) stream)
    (print-unreadable-object (object stream)
      (format stream "DIRECTED GRAPH ~:S" (vertices object))))
  
  (defun adjacent (graph x y)
    "Tests whether GRAPH contains an edge from X to Y."
    (if (member y (gethash x (edges graph)) :test #'equal)
        t nil))
  
  (defun neighbors (graph vertex)
  