anchor.diff:    "Creates a new standard-sheep object with SHEEPLE as its parents."
     (spawn-sheep sheeple))
   
  -(defgeneric copy-sheep (model))
  -(defmethod copy-sheep ((model standard-sheep))
  -  ;; TODO - this is bad.
  -  (let* ((parents (sheep-parents model))
  -         (properties (sheep-property-value-table model))
  -         (roles (sheep-direct-roles model))
  -         (new-sheep (clone parents)))
  -    (setf (sheep-property-value-table new-sheep)
  -          properties)
  -    (setf (sheep-direct-roles new-sheep)
  -          roles)
  -    new-sheep))
  -
  -(defgeneric finalize-sheep (sheep))
   (defmethod finalize-sheep ((sheep standard-sheep))
  +  "we memoize the hierarchy list here."
     (loop for parent in (sheep-parents sheep)
  -     do (setf (gethash sheep (%direct-children parent)) t))
  +     do (setf (gethash sheep (%children parent)) t))
     (memoize-sheep-hierarchy-list sheep)
     sheep)
   
   ;;; Inheritance setup
  -(defgeneric add-parent (new-parent sheep))
  +(defgeneric add-parent (new-parent sheep)
  +  (:documentation "Adds NEW-PARENT as a parent to SHEEP."))
  +
   (defmethod add-parent (unsheepish-parent (child standard-sheep))
  +  "If the given parent isn't already a sheep object, we box it before handing it down to
  +the real add-parent."
     (add-parent (sheepify unsheepish-parent) child))
  +
   (defmethod add-parent ((new-parent standard-sheep) (child standard-sheep))
  +  "Some basic checking here, and then the parent is actually added to the sheep's list."
     (cond ((equal new-parent child)
            (error "Sheeple cannot be parents of themselves."))
           ((member new-parent (sheep-parents child))
  
positive.code: ;; sheep-creation.lisp
  ;;
  ;; Sheep creation, cloning, inspection
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  (in-package :sheeple)
  (declaim (optimize (debug 1) (safety 1) (speed 3)))
  
  (defvar =t=)
  (defvar =dolly=)
  (defclass standard-sheep ()
    ((nickname :accessor sheep-nickname :initform nil)
     (documentation :accessor sheep-documentation :initform "")
     (direct-parents :accessor sheep-parents :initform nil :initarg :direct-parents)
     (%direct-children :accessor %direct-children
                       :initform  (make-weak-hash-table :weakness :key :test #'eq))
     (property-value-table :accessor sheep-property-value-table
                           :initform (make-hash-table :test #'eq))
     (property-metaobject-table :accessor sheep-property-metaobject-table
                          :initform (make-hash-table :test #'eq))
     (direct-roles :accessor sheep-direct-roles :initform nil)
     (hierarchy-list :accessor sheep-hierarchy-list :initform nil)))
  
  (defun allocate-sheep (&optional (class 'standard-sheep))
    (make-instance class))
  
  (defgeneric sheep-p (obj))
  (defmethod sheep-p (obj)
    (declare (ignore obj))
    nil)
  (defmethod sheep-p ((obj standard-sheep))
    (declare (ignore obj))
    t)
  
  ;;;
  ;;; Cloning
  ;;;
  (defun spawn-sheep (sheep-or-sheeple &rest all-keys
                      &key (metaclass 'standard-sheep)
                      &allow-other-keys)
  
negative.code:                              (sheep-parents child)))
                 (finalize-sheep child)
                 (error 'sheep-hierarchy-error
                        :format-control "A circular precedence graph was generated for ~A"
                        :format-args (list child)))))
           child)))
  
  (defun add-parents (parents sheep)
    "Mostly a utility function for easily adding multiple parents. They will be added to
  the front of the sheep's parent list in reverse order (so they will basically be appended
  to the front of the list)"
    (mapc (lambda (parent) 
            (add-parent parent sheep))
          (reverse parents))
    sheep)
  
  (defgeneric remove-parent (parent sheep)
    (:documentation "Remove PARENT as a parent of SHEEP."))
  
  (defmethod remove-parent (unsheepish-parent (child standard-sheep))
    "As with add-parent, we make sure to box the parent first if it's not already a standard-sheep."
    (remove-parent (sheepify unsheepish-parent) child))
  
  (defmethod remove-parent ((parent standard-sheep) (child standard-sheep))
    "Removing PARENT to SHEEP's parent list is a matter of deleting it from the parent list."
    (if (member parent (sheep-parents child))
        ;; TODO - this could check to make sure that the hierarchy list is still valid.
        (progn
          (setf (sheep-parents child)
                (delete parent (sheep-parents child)))
          (remhash child (%children parent))
          (finalize-sheep child)
          child)
        (error "~A is not a parent of ~A" parent child)))
  
  ;;; Inheritance predicates
  (defun parent-p (maybe-parent child)
    "A parent is a sheep directly in CHILD's parent list."
    (when (member maybe-parent (sheep-parents child))
      t))
  
  (defun ancestor-p (maybe-ancestor descendant)
    "A parent is a sheep somewhere in CHILD's hierarchy list."
    (when (member maybe-ancestor (cdr (sheep-hierarchy-list descendant)))
      t))
  
  (defun child-p (maybe-child parent)
    "A child is a sheep that has PARENT in its parent list."
    (parent-p parent maybe-child))
  
  (defun descendant-p (maybe-descendant ancestor)
    "A descendant is a sheep that has ANCESTOR in its hierarchy-list."
    (ancestor-p ancestor maybe-descendant))
  
  ;;;
  ;;; Hierarchy Resolution
  ;;;
  ;;; Most of this is taken almost verbatim from closette
  ;;;
  (defun collect-parents (sheep)
    (labels ((all-parents-loop (seen parents)
                (let ((to-be-processed
  