anchor.diff:  
   (defmethod print-object ((object edge) stream)
     (format stream "~A -> ~A"
  -          (id (car (nodes object)))
  -          (id (cadr (nodes object)))))    ;TODO: add attributes
  +          (string-downcase (id (car (nodes object))))
  +          (string-downcase (id (cadr (nodes object)))))) ;TODO: add attributes
   
   (defun dot-read (str)
     (string-trim-left " \n" str))
  
positive.code:                                               (subseq statement 0 arrow))
                                               (normalize-statement
                                                (subseq statement (+ 2 arrow)))))
             (make-instance 'node :id statement))))
      (symbol
       (normalize-statement (symbol-name statement)))))
  
  (defclass subgraph (identified)
    ((node-attrs :accessor node-attrs :initarg :node-attrs)
     (edge-attrs :accessor node-attrs :initarg :node-attrs)
     (statements :accessor statements :initarg :statements)))
  (defmethod :after initialize-instance ((object subgraph) &key &allow-other-keys)
    (mapc #'normalize-statement statements))
  
  (defmethod print-object ((object subgraph) stream)
    (format stream
            "~:[~;strict ~]~:[~:[subgraph~;graph~]~;~*digraph~] ~:[~;~:*~A ~]~%~
             {~%~{  ~A;~%~}}~%"
            (graph-strict object)
            (typep object 'digraph)
            (typep object 'graph)
            (when (id object) (string-downcase (id object)))
            (statements object)))
  
  ;;; A graph uses --
  (defclass graph (subgraph)
    ((strict :reader graph-strict :initarg :strict :initform nil :type (or nil t))
     (identifiers :accessor identifiers :initform (make-hash-table))))
  
  ;;; A digraph uses ->
  (defclass digraph (graph)
  
negative.code: 
  (defclass node (identified attributed)
    ())
  ;; (defmethod initialize-instance :after ((object node) &key &allow-other-keys)
  ;;; Perhaps set a reference to a hash of all nodes...
  ;;   (setf (get (id->symbol (id object)) 'node) object))
  
  (defmethod print-object :after ((object attributed) stream)
    (print-alist (attributes object) stream))
  
  (defmethod print-object ((object node) stream)
    (format stream "~A" (string-downcase (id object))))
  
  (defun node-or-subgraph? (element)
    (or (typep element 'node)
  