anchor.diff:  
   (with-zdd
     (enumerate
  -    (zdd-join (zdd-family '(1 2) '(7 8) '())
  -              (zdd-family '(1 5 9) nil)
  -              (zdd-set '(1)))))
  +    ))
   
   (with-zdd
     (enumerate
  -    (zdd-meet (zdd-family '(1 2) '(1 6))
  -              (zdd-family '(2)))))
  -
  +    (draw (zdd-meet (zdd-family '(1 2) '(1 6))
  +              (zdd-family '(2))))))
  +
  +
  +(with-zdd
  +  (-<> (zdd-join (zdd-family '(1 2) '(7 8) '())
  +                 (zdd-family '(1 5 9) nil)
  +                 (zdd-set '(1)))
  +    (zdd-remove-supersets-of <> '(5 9))
  +    ; (enumerate <>)
  +    (draw <>)
  +    (print-enumerated <>)
  +    (zdd-size <>)
  +    )
  +  )
  
positive.code:                                      (object t))
    (make-instance 'cl-dot:node
      :attributes (ematch object
                    ((leaf c) `(:label ,c :shape :ellipse))
                    ((node v) `(:label ,v :shape :box)))))
  
  (defmethod cl-dot:graph-object-points-to ((graph (eql 'zdd))
                                            (object t))
  
negative.code:     ,@body))
  
  (defun enumerate (zdd)
    "Return a list of all members of `zdd`."
    (ematch zdd
      ((leaf nil) nil)
      ((leaf t) (list nil))
      ((node variable hi lo)
       (append (mapcar (curry #'cons variable) (enumerate hi))
               (enumerate lo)))))
  
  (defun print-enumerated (zdd)
    (pr (enumerate zdd))
    zdd)
  
  
  (defun zdd-count (zdd)
    "Return the number of members of `zdd`."
    (ematch zdd
      ((leaf nil) 0)
      ((leaf t) 1)
      ((node _ hi lo) (+ (zdd-count hi)
                         (zdd-count lo)))))
  
  (defun zdd-size (zdd)
    "Return the number of unique nodes in `zdd`."
    (let ((seen (make-hash-table :test 'eq)))
      (recursively ((zdd zdd))
        (ematch zdd
          ((leaf) (setf (gethash zdd seen) t))
          ((node _ hi lo)
           (when (not (gethash zdd seen))
             (setf (gethash zdd seen) t)
             (recur lo)
             (recur hi)))))
      (hash-table-count seen)))
  
  (defun unit-patch (z)
    (ematch z
  