Common Lisp 类型与类的区别

Question

在Common Lisp class hierarchy 的帖子中，Rainer Joswig 和 Joshua Taylor 仔细区分了内置 Common Lisptypes 和 classes 之间的一些区别，其中类构成了一部分CLOS 对基线的扩展。 Pfeil 的综合hierarchy diagram 也反映了类型/类别（加上拖把）的区别。使用该图，似乎可以提取两个不同的层次结构。特别是，我目前对层次结构的顶部最感兴趣；即t 的直接子类型和子类（因为t 既是类型又是类）。以下是从图中提取的一些临时子类型/子类：

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

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

MOP 通过添加类metaobject（加上一些元子类）扩展了CLOS，但似乎没有添加到t 的直接子类。

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

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

Answer 1

在 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")))

图表

对应CLOS类的类型用蓝色写，结构类用棕色写。 NIL 类型未绘制。包括来自 CLOS MOP 的类型/类。有些类型有多个名称。另请注意，此图特定于 LispWorks，尤其是哪些类型实际上也是结构、CLOS 类、内置类或其他东西。

Answer 2

直接子类型这个词几乎没有意义。

为什么你认为character 是t 的直接子类型？

但是character 是atom 的子类型，t 的子类型！

嗯，也许character 是atom 的直接 子类型？

不，character 是 (or character number) 的子类型，atom 的子类型。

那么，也许character 是(or character number) 的直接 子类型？

不，character 是 (or character integer) 的子类型，(or character number) 的子类型。

您可以将 类 视为整数，将 types 视为有理数 - 3 到 4 之间没有整数，但在任何两个不同的有理数之间都有很多有理数。

Answer 3

您已经知道 Common Lisp 中有类型和类。

类型对对象进行分类，而类标记对象。此外，一个对象可能有多种类型，但它是单个类的直接实例。

如果您通过type-of 询问对象的类型，您可能会得到许多有效的答案。一个非详尽的例子：

 (type-of 1)
=> (integer 1 1)
OR => bit
OR => (unsigned-byte 1)
OR => (mod 2)
OR => (integer (0) (2))
OR => (signed-byte 1)
OR => (signed-byte 16)
OR => fixnum
OR => integer
OR => (integer * *)
OR => rational
OR => real
OR => number
OR => t
OR => atom

对于typep 和subtypep，事情要复杂得多，因为您可以随意生成类型，例如(eql 1)、(member 1)、(or fixnum bignum)、(and (integer * 1) (integer 1 *))、(not (satisfies zerop))、@987654331 @ 等表示正确结果，同样表示错误结果。

但是，对于每个对象，您只有一个类：

 (class-of 1)
=> #<BUILT-IN-CLASS INTEGER>

实际上，您无法确定整个类型层次结构。有一种观念认为任何东西都是t，没有东西是nil，并且可能存在原子标准类型的层次结构。但现实情况是存在复合类型和用户定义类型，因此在技术上不可能绘制完整的类型层次结构，因为这需要查看每个可以想象的对象的 subtypep 的结果。

即便如此，类型之间可能不存在层次结构。考虑到你说你发现的错误，我相信作者不想在图表中乱扔指向atom 的箭头，而不是cons。但实际上，这可能根本不是一个正确的表示，因为list 和sequence 类型的一些对象是cons，而另一些是atom，具体来说，空列表是atom。

但是，您可以确定整个类层次结构，即使一个类可能有多个超类。

---

某些实现在 class-of 示例中返回 fixnum 类，这是标准的扩展（fixnum 是一种类型但不是类），以允许在 fixnum 上进行 CLOS 方法特化和/或允许优化技巧。

从我尝试的几个实现中，只有 CLISP 返回了 integer 类。