myname's questions

我有一个类，希望在创建对象时将某些槽位设置为 nil，但这些槽位只能由特定类型的对象设置。例如：

(defclass Something ()
  ((foo :initarg :foo
        :type (or character 'nil)
        :initform nil
        :accessor something-foo)))

如果我说只是:type character，或:type (or character nil)，那么 SBCL 会抱怨它NIL不属于断言的字符类型。如果我说:type (or character 'nil)，那么它似乎接受字符和符号类型，因为任何符号似乎都适用：

CL-USER> (defvar *foo* (make-instance 'Something))
*FOO*
CL-USER> (setf (something-foo *foo*) 'test)
TEST
CL-USER> (something-foo *foo*)
TEST

有没有办法断言一个 slot 是 nil 还是具有给定的类型？或者我应该省略类型说明符，然后在访问器或写入器方法中断言类型？

编辑：

再三考虑之后，也许习惯用法是说:type character但保持其不受约束，然后检查插槽是否被绑定，而不是检查是否为零和非零？

考虑一下：

(defclass my-string ()
  ((data :initarg :data :type simple-string)
   (properties :initarg :properties :type interval-tree))
  (:documentation
   "Represents a string with properties."))

我想在 typecase 表达式中使用 my-string 作为类型：

(defun upcase (obj)
  (typecase obj
    (my-string (string-upcase (slot-value obj 'data)))
    (string (string-upcase obj))
    (integer (char-upcase (code-char obj)))
    (character (char-upcase obj))
    (otherwise (error "Wrong type argument ~S" obj))))

我以为类是类型，但显然不是，因为上面的代码是编译器错误。所以我声明了一个类型：

(deftype my-string (s) (typep s 'my-string))

看来我必须像这样使用它（否则我会收到编译错误，typedef 需要一个参数）：

(defun upcase (obj)
  (typecase obj
    ((my-string obj) (string-upcase (slot-value obj 'data)))
    (string (string-upcase obj))
    (integer (char-upcase (code-char obj)))
    (character (char-upcase obj))
    (otherwise (error "Wrong type argument ~S" obj))))

但是 SBCL 删除了我的代码，因为无法访问！:-)

我该怎么做？如何正确声明类的类型，以便可以在类型声明可用的表达式中使用它？

我知道我可以使用结构而不是类，在这种情况下，编译器会为该类型生成代码，并且初始类型“正常工作”：

(defstruct my-string
  data properties)

宏扩展和查看生成的代码并没有真正让我更加明白。我看到的是：

(SB-C:XDEFUN MY-STRING-P
     :PREDICATE
     NIL
     (SB-KERNEL::OBJECT)
   (TYPEP SB-KERNEL::OBJECT 'MY-STRING))

它确实做了我所做的事，但我认为该函数不参与其中，还是我错了？要么他们以某种方式在内部将结构与类型关联起来，要么我错过了生成代码的一些相关部分？我对这些都不是很熟悉，所以也很有可能。

一个相关的问题：在 CommonLisp 中，对扩展内置类型（如字符串）的自定义类进行建模的正确方法是什么？像在 my-string 中所做的那样，进行组合是一种更好的方法吗？还是从某个内置的 CL 字符串类继承更好？基于这个 SX 问题和答案，在我看来，继承并不是对类型进行建模的最佳方式，这可能是更好的，因为我们不喜欢 Java 或旧 C++ 中的分类法。

最后，在这种情况下，我甚至不需要 typecase，如果我将 upcase 变成一个专门针对这些类型的通用方法，整个问题就消失了，我完全知道这一点。但是，我想更多地了解类型和类，以及如何在 CL 中对类似上述内容进行建模。

抱歉，这篇文章有点长，而且一个问题太多了，我才刚刚开始学习。感觉我遇到的每一个问题和寻找答案的尝试都会引出另外 10 个问题 :)。

正如标题所说，我如何（以编程方式）以可移植的方式（如果可能）检查一个符号是否代表一个符号宏？

CL-USER> (define-symbol-macro some-macro some)
SOME-MACRO
CL-USER> (macro-function 'some-macro)
NIL
CL-USER> (fboundp 'some-macro)
NIL

SBCL 有 sb-impl::info：

CL-USER> (describe 'sb-impl::info)
SB-INT:INFO
  [symbol]

INFO names a compiled function:
  Lambda-list: (CATEGORY KIND NAME)
  Declared type: (FUNCTION (T T T) (VALUES T T &OPTIONAL))
  Source file: SYS:SRC;COMPILER;GLOBALDB.LISP

INFO has a compiler-macro:
  Source file: SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP

(SETF INFO) names a compiled function:
  Lambda-list: (NEW-VALUE CATEGORY KIND NAME)
  Declared type: (FUNCTION (T T T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;COMPILER;GLOBALDB.LISP

(SETF INFO) has a compiler-macro:
  Source file: SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP

似乎有效：

CL-USER> (sb-impl::info :variable :kind 'some-macro)
:MACRO
T

这就是他们在“描述”函数的源代码中所使用的内容（我通过查看那里发现了这一点）。

在此之前，我一直在研究 clhs，但一无所获。是我错过了还是没有标准方法？是否有一些可移植/“简单”的库可以做到这一点？

编辑：

在得到有用的答案之后，我找到了cltl2 的“简单”包装器。它似乎也在 quicklisp 中，因此除了内置的 'special-operator-p'之外，我们还可以拥有：

(defun special-variable-p (symbol)
    (multiple-value-bind (info ignore1 ignore2)
        (variable-information symbol)
      (declare (ignore ignore1 ignore2))
      (eq :special info)))

(defun symbol-macro-p (symbol)
    (multiple-value-bind (info ignore1 ignore2)
        (variable-information symbol)
      (declare (ignore ignore1 ignore2))
      (eq :symbol-macro info)))

我实际上更喜欢广义布尔值，看起来更有用，所以我使用这个：

(defun symbol-macro-p (symbol)
  "Return if SYMBOL stands for a symbol macro."
    (multiple-value-bind (info ignore1 ignore2)
        (variable-information symbol)
      (declare (ignore ignore1 ignore2))
      (when (eq :symbol-macro info)
        (multiple-value-bind (expansion ignored)
            (macroexpand symbol)
          (declare (ignore ignored))
          expansion))))

CL-USER> (symbol-macro-p 'some-macro)
SOME

这个有点令人尴尬，但是我被这个问题困扰的时间比我想承认的要长。

我想生成一个宏，如果在某个现有包中找到符号，则该宏会自动隐藏该符号。我只使用 :common-lisp 包，并将从标准中隐藏几个函数。

我之前保存过一个阴影和导出符号列表，但我不想保留这些列表。相反，我更愿意从宏中隐藏符号，这样我就可以同时拥有阴影和导出声明以及定义。这看起来很简单，但是，无论我以何种方式实现它，我要么违反了包锁，要么我的符号未定义，要么其他原因。首先，这是一个包定义：

(in-package :cl-user)

(uiop:define-package :foo-package
  (:nicknames :foo)
  (:use :common-lisp)
  (:shadow #:defun))

(in-package :foo)

测试函数不执行任何操作，只是对测试的一个小包装：

(defun make-string (length init)
  (cl:make-string length :initial-element init))

我的第一次尝试是这样的：

(cl:defmacro defun (name arglist &optional docstring &rest body)
  `(progn
     (when (symbol-package ',name)
       (shadow ',name))
     (cl:defun ,name ,arglist ,docstring ,@body)
     (export '(,name))))

但是，这会导致 SBCL 的包锁冲突，因此在我尝试使用 cl:defun 重新定义该函数之前，影子函数显然没有生效。

将其包装进去 (eval-when (:compile-toplevel :load-toplevel :execute)，以使其在编译时可用并没有帮助。

另一种尝试是使用发电机：

(eval-when (:compile-toplevel :load-toplevel :execute)
  (cl:defmacro defun (name args &optional docstring &rest body)
    (macrolet ((export-it (name args &optional docstring &rest body)
                 `(progn
                    (when (symbol-package ',name)
                      (shadow ',name))
                    (cl:defun ,name ,args ,docstring ,@body)
                    (export '(,name) *package*))))
      `(export-it ,name ,args ,docstring ,@body))))

这给了我 common-lisp:make-string unbound：

调试器在线程 #<THREAD "main thread" RUNNING {10044982F3}> 中的 UNBOUND-VARIABLE @10039FFD22 上调用：变量 MAKE-STRING 未绑定。

我曾尝试生成一个 lambda 并用 funcall 调用它，但也没有成功。

如果我从 repl: 手动隐藏 make-string (shadow 'make-string)，那么我之后可以重新定义并导出 make-string 而不会出现问题。

看来我误解了一些更基本的东西。

顺便说一句，我正在阅读 M. Cracauers 的编译时编程文章，并认为将所有内容放在同一位置是一个好主意，但我认为我对宏和编译时与运行时评估的熟悉程度还不够。

我知道我可以使用 SBCL 特定的东西来临时删除包锁，但我最初用来检查符号是否在：common-lisp 包中的“shadow”和“symbol-package”或“find-package”和“find-symbol”应该更具可移植性。