anchor.diff:  
   (defun find-types (prefix)
     (let ((type-list nil))
  -    (dolist (type-info *derivable-type-info*)
  -      (map-subtypes
  -       #'(lambda (type-number)
  -	   (pushnew type-number type-list))
  -       (first type-info) prefix))
  +    (maphash
  +     #'(lambda (type-number expander)
  +	 (declare (ignore expander))
  +	 (map-subtypes
  +	  #'(lambda (type-number)
  +	      (pushnew type-number type-list))
  +	  type-number prefix))
  +     *derivable-type-info*)
       type-list))
   
   (defun %sort-types-topologicaly (unsorted)
     (let ((sorted ()))
       (loop while unsorted do
         (dolist (type unsorted)
  -	(let ((dependencies (type-dependencies type)))
  +	(let ((dependencies (rest (type-hierarchy type))))
   	  (cond
   	   ((null dependencies)
   	    (push type sorted)
   	    (setq unsorted (delete type unsorted)))
   	   (t
   	    (unless (dolist (dep dependencies)
  -		      (when (find type (type-dependencies dep))
  -			(error "Cyclic type dependencies not yet supported"))
  +		      (when (find type (rest (type-hierarchy dep)))
  +			(error "Cyclic type dependencie"))
   		      (return-if (find dep unsorted)))
   	      (push type sorted)
   	      (setq unsorted (delete type unsorted))))))))
  
positive.code: 
  
  (defun expand-type-definitions (prefix &optional args)
    (flet ((type-options (type-number)
  	   (let ((name (find-type-name type-number)))
  	     (cdr (assoc name args :test #'string=)))))
  
      (let ((type-list
  	   (delete-if
  	    #'(lambda (type-number)
  		(let ((name (find-type-name type-number)))
  		  (or
  		   (getf (type-options type-number) :ignore)
  		   (find-if
  		    #'(lambda (options)
  			(and
  			 (string-prefix-p (first options) name)
  			 (getf (cdr options) :ignore-prefix)))
  		    args))))
  	    (find-types prefix))))
               
        (dolist (type-number type-list)
  	(let ((name (find-type-name type-number)))
  	  (register-type
  	   (getf (type-options type-number) :type (default-type-name name))
  	   type-number)))
  
        `(progn
  	 ,@(mapcar
  	    #'expand-type-definition
  	    (%sort-types-topologicaly type-list))))))
  	    
  (defmacro define-types-by-introspection (prefix &rest args)
    (expand-type-definitions prefix args))
  
negative.code: 
  ;;;; 
  
  (defvar *derivable-type-info* (make-hash-table))
  
  (defun register-derivable-type (type id expander)
    (register-type type id)
    (let ((type-number (register-type type id)))
      (setf (gethash type-number *derivable-type-info*) expander)))
  
  (defun find-type-info (type)
    (dolist (super (cdr (type-hierarchy type)))
      (let ((info (gethash super *derivable-type-info*)))
        (return-if info))))
  
  (defun expand-type-definition (type options)
    (let ((expander (find-type-info type)))
      (funcall expander (find-type-number type t) options)))
  
  (defbinding type-parent (type) type-number
    ((find-type-number type t) type-number))
  