Common Lisp 类型与类的区别

在帖子中Common Lisp 类层次结构 https://stackoverflow.com/questions/42514204/common-lisp-class-hierarchy、Rainer Joswig 和 Joshua Taylor 仔细区分了内置 Common Lisp 之间的一些差异types and classes，其中类构成基线的 CLOS 扩展的一部分。类型/类别（加上拖把）的区别也反映在 Pfeil 的综合层次图 http://sellout.github.io/media/CL-type-hierarchy.png。使用该图，似乎可以提取两个不同的层次结构。特别是，我目前对层次结构的顶层最感兴趣；即，直接子类型和子类t (since t既是类型又是类）。以下是从图中提取的一些临时子类型/子类：

对于类型层次结构，直接子类型t似乎是atom, character, random-state, hash-table, restart, readtable, package, pathname, stream, function, array, sequence, number, and condition。所有其他类型，例如float or list是这些类型之一的子类型。类型层次结构也不是严格的层次结构（因为(subtype t t) => T，但这似乎是唯一的例外）。 （ps：类型symbol and structure-object不包含在图中，但也可能是直接子类型t.)

对于类层次结构，直接子类t包括上述所有类型的相应类（除了atom，也许structure-object现在是standard-object(?))，加上standard-object.

MOP 通过添加类来扩展 CLOSmetaobject（加上一些元子类），但似乎没有添加到直接子类t.

有人可以验证这种理解是否正确，或提供额外的说明吗？

注意：我在上面的类型层次结构描述中发现了至少一个错误。所有列出的亚型（character等）显然是子类型atom，所以它们不是直接子类型t。唯一的其他直接子类型t似乎是sequence，因为序列可以是cons（非原子）。而且，symbol事实上，包含在图中，并且也是atom.

在 LispWorks 中绘制 T 的 CL 子类型:

查找子类型：

(defun find-synonym-types (type1 types)
  (remove-if-not (lambda (type2)
                   (and (not (eq type1 type2))
                        (subtypep type1 type2)
                        (subtypep type2 type1)))
                 types))

(defun find-all-types-in-packages (packages &key include-nil)
  (let ((types nil))
    (loop for package in packages
          when (find-package package)
          do (do-external-symbols (sym (find-package package))
               (when (ignore-errors (subtypep sym t))
                 (let ((synonyms (find-synonym-types sym types)))
                   (if synonyms
                       (pushnew sym (get (first synonyms) :type-synonyms))
                     (pushnew sym types))))))
    (if include-nil types (remove nil types))))

(defun direct-subtypes (supertype &key all-types)
  (loop with subtypes = (remove supertype (loop for type in all-types
                                                when (subtypep type supertype)
                                                collect type))

        for type in subtypes
        when (loop for type2 in (remove type subtypes)
                   never (subtypep type type2))
        collect type))

将其绘制成图形：

#+capi
(defun class-color (class-name)
  (typecase (find-class class-name)
    (standard-class  :blue)
    (built-in-class  :violet)
    (structure-class :brown)
    (otherwise       :red)))

#+capi
(defun graph-subtypes-from-t ()
  (let ((all-types (find-all-types-in-packages '("CL" "CLOS"))))
    (capi:contain
     (make-instance
      'capi:graph-pane
      :roots '(t)
      :children-function (lambda (type)
                           (direct-subtypes type :all-types all-types))
      :node-pane-function #'(lambda (graph-pane node)
                              (declare (ignore graph-pane))
                              (make-instance
                               'capi:item-pinboard-object
                               :text (format
                                      nil "~{~a~^, ~}"
                                      (cons node
                                            (get node :type-synonyms)))
                               :graphics-args `(:foreground
                                                ,(if (find-class node
                                                                 nil)
                                                     (class-color node)
                                                   :black))))
      :edge-pane-function #'(lambda (self from to)
                              (declare (ignore self from to))
                              (make-instance
                               'capi:arrow-pinboard-object
                               :graphics-args '(:foreground
                                                :grey))))
     :title "Common Lisp Subtypes in LispWorks")))

Graph

具有相应 CLOS 类的类型以蓝色书写，结构类以棕色书写。方式NIL没有绘制。包括来自 CLOS MOP 的类型/类别。有些类型有多个名称。另请注意，该图是特定于 LispWorks 的，特别是哪些类型实际上也是结构、CLOS 类、内置类或其他类型。