;;;; Are the following two equivalent, except that in #2, foo-meta is
;;;; not reachable using find-class?

;;;; 1

(defclass foo-meta (standard-class)
  ())   

(defmethod closer-mop:validate-superclass ((class foo-meta)
                                           (superclass standard-class))
  t)

(defclass foo () () 
  (:metaclass foo-meta))



;;;; 2

(let ((meta (make-instance 'standard-class
                            :name 'foo-meta
                            :direct-superclasses (list (find-class 'standard-class)))))
  
  ;; Validate superclass
  (add-method #'closer-mop:validate-superclass
              (multiple-value-bind (method-lambda initargs)
                  (closer-mop:make-method-lambda 
                   #'closer-mop:validate-superclass
                   (closer-mop:class-prototype
                    (closer-mop:generic-function-method-class #'closer-mop:validate-superclass))
                   '(lambda (class superclass) t)
                   nil)
                (apply #'make-instance 'standard-method 
                       :lambda-list '(class superclass)
                       :specializers (list meta (find-class 'standard-class))
                       :function (compile nil method-lambda)
                       initargs)))
        
  (setf (find-class 'foo)
        (make-instance meta
                       :direct-superclasses nil
                       :name 'foo)))