format - 如何将参数格式化为函数

Question

很快我就有了一个函数 foo:

(defun foo (a b &key test) 
  (format t "~S is the result of my test ~A" (funcall test a b) test))

那么评估的结果是:

(foo 12 34 :test #'(lambda (a b) (+ a b)))
46 is the result of my test #<Anonymous Function #x30200171D91F>

我要

(foo 12 34 :test #'(lambda (a b) (+ a b)))
46 is the result of my test #'(lambda (a b) (+ a b))

不幸的是，function-lambda-expression 在 CCL 中不显示任何信息。

关键是这取决于实现。
例如在 CCL 中:

(describe #'(lambda (a b) (+ a b)))
#<Anonymous Function #x302000C49E1F>
Name: NIL
Arglist (analysis): (A B)
Bits: -528481792
Plist: (CCL::FUNCTION-SYMBOL-MAP (#(B A) . #(575 18 49 63 18 49)))

---

也许，我可以用不同的方式来表述这个问题。如何将 lambda 函数保存为文件中的槽实例，以便从任何 lisp 实现中检索它。

或者更具体地说，我想将一个插槽设置为非解释函数，以便调用它进行解释并跟踪“源”。

我的临时“解决方案”是显式使用宏函数，例如:

(defmacro src (func) `(read-from-string (format nil "~A" ',func)))
(setf (my-slot my-class-object) (src #'(lambda (a b) (* a b))))
;; this stores the un-interpreted function such as
(my-slot my-class-object)
;; return 
#'(lambda (a b) (* a b))
;; then I can do
(funcall (my-slot my-class-object) 2 3)
6

Answer 1

从函数恢复源代码的能力取决于环境的实现和调试级别。在编译代码的 Common Lisp 实现中，您需要优化调试以跟踪源代码。有时源只是定义函数的文件名和一个偏移量。

命名函数

如果您想跟踪函数，如果您将自己限制在已命名 函数，那么可移植性会更容易。只需使用宏将源代码附加到符号的属性列表中:

;; body should be a single form that returns a name, like "defun"
(defmacro with-source-code (&body body)
  (destructuring-bind (form) body
    (let ((name$ (gensym)))
      `(let ((,name$ ,form))
         (check-type ,name$ symbol)
         (setf (get ,name$ 'source-code) ',form)
         ,name$))))

;; get the code associated with the name
(defun source-code (name)
  (check-type name symbol)
  (get name 'source-code))

例如:

(with-source-code
  (defun my-test-fn (x y)
    (+ x y)))

(source-code 'my-test-fn)
=> (DEFUN MY-TEST-FN (X Y) (+ X Y))

弱哈希表

弱引用也依赖于实现，但您可以使用 trivial-garbage 系统来移植地使用它们，或者在该功能不可用时收到通知。

在这里，您将实际的函数对象附加到它的源代码(或任何对象，但这对数字或字符来说不是很好，因为它们通常是不可识别的):

;; defines package "tg"
(ql:quickload :trivial-garbage)

(defparameter *source-map*
  (tg:make-weak-hash-table :test #'eq :weakness :key)
  "Map objects to their defining forms.")

弱点是 :key，这样如果键(我们要检索其代码的对象)被垃圾回收，垃圾回收器可能会删除该条目。这应该足以避免无限期保留条目。

(defmacro remember (form)
  (let ((value$ (gensym)))
    `(let ((,value$ ,form))
       (setf (gethash ,value$ *source-map*) ',form)
       ,value$)))

(defun source (object)
  (gethash object *source-map*))

例如，您可以定义一个 lambda* 宏来记住所定义的匿名函数:

(defmacro lambda* ((&rest args) &body body)
  `(remember (lambda ,args ,@body)))

例如:

(let ((fn (lambda* (x y) (+ x y))))
  (prog1 (funcall fn 3 4)
    (format t "~&Calling ~a" (source fn))))

上面的代码返回 7 并打印 Calling (LAMBDA (X Y) (+ X Y))

元类

如果您想避免弱哈希表，您还可以使用元对象协议(protocol)将您的函数包装在另一个对象中，该对象可以充当函数(可调用 对象)。

在这种情况下，您可以使用 closer-mop 来获得一个统一的 API 来使用元对象协议(protocol):

(ql:quickload :closer-mop)

您定义了一个 funcallable-standard-object 的子类，用于跟踪源代码和被调用的函数(或闭包):

(defclass fn-with-code (c2mop:funcallable-standard-object)
  ((source :reader source-of :initarg :source))
  (:metaclass c2mop:funcallable-standard-class))

该对象可以像任何其他函数一样被调用，但为此您需要调用 set-funcallable-instance-function。我们可以在初始化对象后通过定义以下方法来做到这一点:

(defmethod initialize-instance :after ((f fn-with-code)
                                       &key function &allow-other-keys)
  (c2mop:set-funcallable-instance-function f function))

我还定义了一个帮助函数来构建这样一个实例，给定一个函数对象及其源代码:

(defun make-fn-with-code (function source)
  (make-instance 'fn-with-code :source source :function function))

然后，我们可以重写lambda*如下:

(defmacro lambda* ((&rest args) &body body)
  (let ((code `(lambda ,args ,@body)))
    `(make-fn-with-code ,code ',code)))

最后，这种方法的有用之处在于，通过为 print-object 定义一个方法，可以在打印函数时自动打印代码:

(defmethod print-object ((o fn-with-code) stream)
  (print-unreadable-object (o stream :type nil :identity nil)
    (format stream "FUN ~a" (source-of o))))

> (lambda* (x y) (* x y))
#<FUN (LAMBDA (X Y) (* X Y))>   ;; << printed as follow