对象作为 lisp 中自身的参数

Question

在Python中，我会这样做：

class foo:
def __init__(self):
self.x = self

否则，现在对象是自身的参数。我怎样才能在普通的口齿中做到这一点？

(defclass mn ()
((pai   :accessor mn-pai
:initarg :pai
:initform self)))

Answer 1

在DEFCLASS槽描述中，不能引用对象本身。但是可以编写用于实例初始化的方法。这类似于您的 Python 示例。

我们的班级：

? (defclass foo ()
((bar :accessor foo-bar :initarg :foo)))
#<STANDARD-CLASS FOO>

我们为initialize-instance创建了一个:after方法。此通用函数由 CLOS 提供，其目的是初始化新实例。第一个参数是要初始化的实例。当我们创建类foo的实例时，Lisp 系统将调用该方法。

使用访问器foo-bar：

? (defmethod initialize-instance :after ((object foo) &key)
(setf (foo-bar object) object))
#<STANDARD-METHOD INITIALIZE-INSTANCE :AFTER (FOO)>

或通过(setf slot-value)设置插槽。

? (defmethod initialize-instance :after ((object foo) &key)
(setf (slot-value object 'bar) object))
#<STANDARD-METHOD INITIALIZE-INSTANCE :AFTER (FOO)>

请注意，我们可以用任何名称命名实例参数：object甚至self。但是这个名字没有语义。由于在 CLOS 中我们有多调度(调度可以处理多个参数，并且没有默认的调度参数(，因此没有self语义。

现在我们制作并描述类foo的实例：

? (describe (make-instance 'foo))
#<FOO #x302000D20C0D>
Class: #<STANDARD-CLASS FOO>
Wrapper: #<CCL::CLASS-WRAPPER FOO #x302000D2B43D>
Instance slots
BAR: #<FOO #x302000D20C0D>

如您所见，该实例的槽bar已设置为实例本身。

Answer 2

请注意，initform是在defclass的词法上下文中计算的，而是在make-instance的动态上下文中计算的。这允许您定义一个名为*this*的特殊变量(您可以使用this，但这可能会令人困惑(并在初始化对象时使用它。

(defvar *this*)

为可能引用*this*的类定义一个 mixin：

(defclass knows-this () ())
(defmethod shared-initialize :around ((object knows-this) slot-names &rest args)
(declare (ignore args))
(let ((*this* object))
(call-next-method)))

例如：

(defclass foo (knows-this)
((myself :initform *this*)))
(describe (make-instance 'foo))
#<FOO {100AC6EF13}>
[standard-object]
Slots with :INSTANCE allocation:
MYSELF                         = #<FOO {100AC6EF13}>

Answer 3

CLOS 没有"this"或"self"的概念，因为通过使用泛型函数，任何正在操作的实例都会作为参数传递。

因此，给定带有访问器的示例mn-pai：

(setf instance (make-instance 'mn))
(mn-pai instance 1)

在这里，instance作为参数传递给访问器。

如果创建了方法：

(defmethod inc-pai (an-mn amount)
(incf (mn-pai an-mn) amount))

同样，您会看到实例作为第一个参数传入。因此，您始终使用明确的参数。

现在考虑：

(defmethod inc-both (an-mn another-mn amount)
(incf (mn-pai an-mn) amount)
(incf (mn-pai another-mn) amount))

那么，在一个普通的基于类的系统中，你会把这种方法放在哪里？在实用工具类中？这是一个"mn"类方法吗？它有点无视现成的分类。

现在考虑：

(defclass mn2 ()
((pai   :accessor mn2-pai)))

如果我们这样做：

(setf an-mn (make-instance 'mn))
(setf an-mn2 (make-instance 'mn2))
(inc-both an-mn an-mn2)

第二行将失败，因为 mn2 没有mn-pai访问器。

但是，这将起作用：

(defmethod inc-both2 (an-mn another-mn amount)
(incf (slot-value 'pai an-mn) amount)
(incf (slot-value 'pai another-mn) amount))

因为slot-value是 CLOS 的基元访问器，并且两个类都有一个名为pai的插槽。但是，这样你就不能调用访问器函数了。相反，您直接设置插槽。可能不是你想要的。当然，这些名字是巧合。除了相似的名称和共享的槽名称外，类之间没有任何关系。

但是，您可以这样做：

(defmethod inc-both ((mn an-mn) (mn2 another-mn) amount)
(incf (mn-pai an-mn) amount)
(incf (mn-pai2 another-mn) amount))

这是有效的，因为运行时将根据参数的类型进行调度。我们"知道"another-mn是mn2的实例，因为我们告诉系统，当我们限定论点时，一定是这样。

但是，同样，您可以看到在基于类的系统中，这种方法没有"位置"。我们通常只是创建一个某种类型的 Utility 类并将其粘贴在那里，或者在全局命名空间中创建一个常规函数。

虽然 CLOS 有类，但它并不是一个真正基于类的系统。

这在多继承方案(CLOS 支持(中也会出现。那么谁是"自我"呢？