Common Lisp类型与类别区别

By simon at 2018-02-28 • 0人收藏 • 90人看过

在[Common Lisp class 层次结构(https://stackoverflow.com/questions/42514204/common-lisp-class- Rainer)Joswig&Joshua Taylor仔细区分了一些 内置Common Lisp typesclasses之间的区别在哪里类 构成CLOS扩展至基线的一部分。类型/类(加拖把) 区别也反映在Pfeil公司多层次的 图](http://sellout.github.io/media/CL-type-hierarchy.png)。使用 图,似乎有可能extract两个不同的层次结构。在 特别是,我现在最感兴趣的是层次结构的顶尖人物; 即d直接t的子类型和子类别(自t 既是一种类型又是一类)。这里有一些临时亚型S /小类 从图表中提取: 对于类型层次结构,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的直接子类 相应的c适用于上述所有类型(除了atom,和 也许structure-object现在是standard-object(?)的子类)加 standard-object。 MOP通过添加类metaobject(加上一些meta- 子类),但似乎并不如此添加到的直接子类 t。 有人可以验证这种理解是正确的还是提供额外的 CLARifications? 注意:我发现类型层次结构描述中至少有一个错误 以上。所有列出的亚型(character等)显然是 atom的亚型,因此它们不是t的直接亚型。 唯一的另一个t的直接子类似乎是sequence, 因为一个序列可以是一个cons(非原子)。而且,symbol 实际上包含在图中,也是一个子类型 atom.

4 个回复 | 最后更新于 2018-02-28
2018-02-28   #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")))
图形 类型机智h对应的CLOS类以蓝色和结构写入 班是棕色的。类型NIL未绘制。包括一个回覆 CLOS MOP的类型/类。有些类型有多个名称。另请注意 该图特定于LispWorks,especially实际上是什么类型 还有结构,CLOS类,内置类或其他东西。 [![Common Lisp中的命名类型,唱 LispWorks](https://i.stack.imgur.com/vVHUU.png)](https://i.stack.imgur.com/vVHUU.png)

2018-02-28   #2

术语直接亚型几乎从来没有意义。 为什么你认为character是t的direct子类型?但character是atom的子类型,它是子类型 t! 那么,也许character是一个direct子类型为atom? 不,character是(or character number)的子类型,它是子类型 atom。 所以,也许character是(or character number)的direct子类型? 不,character是(or character integer)的子类型,它是一个子类型 (or character number)。 您可以将classes视为整数,types_视为有理数 - 没有 整数在3和4之间,但有plen任何两种理性之间的差异 不同的理性。

2018-02-28   #3

在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")))
图形 类型机智h对应的CLOS类以蓝色和结构写入 班是棕色的。类型NIL未绘制。包括一个回覆 CLOS MOP的类型/类。有些类型有多个名称。另请注意 该图特定于LispWorks,especially实际上是什么类型 还有结构,CLOS类,内置类或其他东西。 [![Common Lisp中的命名类型,唱 LispWorks](https://i.stack.imgur.com/vVHUU.png)](https://i.stack.imgur.com/vVHUU.png)

2018-02-28   #4

你已经知道Common Lisp中有类型和类。 类型分类对象,而类标记对象。此外,一个对象可能 有很多类型,但它是一个类的直接实例。 如果你问物体的类型通过gh 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,很薄与你一样,gs更令人困惑 可以随意生成类型,如(eql 1),(member 1),(or fixnum bignum), (and (integer * 1) (integer 1 *)),(not (satisfies zerop)),(satisfies oddp)等,以获得真实的结果 同样为了错误的结果。 但是,对于每个对象,你都有一类:
 (class-of 1)
=> #<BUILT-IN-CLASS INTEGER>
在实践中,你不能确定整个类型的层次结构。有这个概念 那什么都是t,没什么是nil,可能有一个 原子标准类型的层次结构。但现实是有的 合作mpound类型和用户定义的类型,所以在技术上不可能绘制 一个完整的类型层次结构,因为这需要看在...的结果 subtypep为每个可想象的对象。 即便如此,类型之间可能不存在层次结构。以the mistake 你说你找到了,我相信作者不想乱丢图表 箭头指向atom fo除了以外的每种类型 cons.但事实上,这可能不是一个正确的 有代表性,因为有些目标cts类型list和 sequence为cons,其他为atom, 空的列表是atom。 但是,即使一个类可以,也可以确定整个类的层次结构 有多个超类。 * * *有些实现会返回class-of中的fixnum类 例如,标准的扩展(fixnum是一种类型,但不是 类),允许在fixnum和/或允许CLOS方法专业化 优化技巧。 从f在我尝试的实现中,只有CLISP返回integer 类。

登录后方可回帖

Loading...