lambda - 如何制作一个可以序列化包括 lambda 函数在内的所有数据的解释器？

Question

在 lisp/scheme 中，函数 WRITE 和 READ 可以输出语言中的任何数据并将其读回，lambdas/闭包除外。

我希望能够做的一个例子是:

(define f (lambda (x) (lambda (y) (+ x y))))
(write (f 2))

应该输出一些可以读回并像这样使用的东西

((read) 7)

得到结果9。

这将如何实现？是否有任何教科书或文件解释制作具有此功能的解释器的细节？谢谢

Answer 1

事实上 Lisp 系统不能读写任意对象:只能是足够简单的对象。作为 Common Lisp 的示例，给定

(defclass foo ()
  ((x :reader foo-x :initarg :x)))

然后:

> (make-instance 'foo :x 2)
#<foo 40200A9813>

那不是可以阅读的东西。

一般问题

要让 Lisp/Scheme 能够将一般对象写入(下面的“存储”)文件并从您需要的文件中读取(下面的“取消存储”)它们，至少，足够的内省(introspection)能够知道哪些部分的对象是。为了能够可靠地存储和取消存储对象，您还需要能够知道该对象依赖于什么。对于任何可移植的方式的函数或闭包来说，这根本不存在，而且依赖性问题很严重。

例如，考虑这个(现在在 Scheme 中):

(define y 3)

(define (bar x)
  (+ x y))

(define (foo x)
  (cons (bar x) x))

如果我说 (stash foo "/tmp/foo") 会发生什么？

• 作为最低限度，系统必须能够充分理解 foo 以某种形式存储它，以便在加载时重建它。
• 但是 foo 有依赖关系:它依赖于 bar 而 bar 又依赖于 y，作为对 cons 和 + 的依赖，这可能会被忽略(但只是可能)。我也需要把那些东西藏起来吗？因为如果我不这样做，那么如果我在这些东西没有定义的上下文中这样做，那么尝试从我隐藏的文件中取消隐藏定义将会失败。

因此，将一般对象(尤其是函数)存储到外部存储并正确执行是一个巨大的问题。特别是我认为这甚至不是一个定义明确的问题。例如，在许多实现中，诸如 + 或 cons 之类的东西实际上可能不是您所假设的，并且函数应用程序之类的隐式操作可能不会按照您的想法进行:应该 < em>那个和你正在保存的对象一起保存？

正确和一般解决这些问题非常困难，事实上，这些问题的适定性不够好，甚至没有明确定义的解决方案。 p>

具体问题

但是，这并不意味着对于您根本不关心其中部分或全部问题的特定情况，该问题无法解决。

例如，这里是 Racket 中的一些代码，用于处理一些简单的情况。

注意事项:

• 此代码不安全:它调用了 load，这等同于调用 eval 并具有所有的危险；
• define/stashing 的定义可能遗漏了 define 语法中的一些重要情况；
• define/stashing 将无法正常工作，除非在顶层(因为词法环境根本没有被处理)；
• 没有尝试处理依赖关系或任何难题；
• 上述情况的一个特例是，除非仔细编写，否则递归函数将无法工作；
• 我还没有检查这是否是可移植的 Scheme，但可能不是。

总的来说，这只是一个 hacky 演示，它很容易处理一些在实践中可能很有趣的特殊情况。

(define definition-map (make-hasheqv))

(define (save-definition! thing source-form)
  (hash-set! definition-map thing source-form)
  thing)

(define (get-definition thing)
  (hash-ref definition-map thing))

(define (clear-definitions!)
  (hash-clear! definition-map))

(define-syntax define/stashing
  ;; This is probably missing cases
  (syntax-rules ()
    [(_ (name) form ...)
     (define name (save-definition! (lambda () form ...)
                                   '(lambda () form ...)))]
    [(_ (name arg ...) form ...)
     (define name (save-definition!
                   (lambda (arg ...) form ...)
                   '(lambda (arg ...) form ...)))]
    [(_ (name arg ... . rest) form ...)
     (define name (save-definition!
                   (lambda (arg ... . rest) form ...)
                   '(lambda (arg ... . rest) form ...)))]
    [(_ name value)
     (define name (save-definition! value 'value))]))

(define (stash thing file)
  (call-with-output-file
      file
    (λ (o)
      (write (get-definition thing) o)
      thing)
    #:mode 'text
    #:exists 'truncate/replace))

(define (unstash file)
  (load file))

要使用它，您需要使用 define/stashing 而不是 define(一个模块可以使 define 成为 当然是 define/stashing)，然后是 stash & unstash:

> (define/stashing (cons-1 x) (cons x 1))
> (stash cons-1 "/tmp/x")
#<procedure>
> (cons-1 2)
'(2 . 1)
> ((unstash "/tmp/x") 2)
'(2 . 1)

如果你想隐藏递归函数，你需要用局部定义来编写它们:

(define/stashing (fact n)
  (let floop ([m 1] [t 1])
    (if (= m n)
        (* t m)
        (floop (+ m 1) (* t m)))))

会工作，而

(define/stashing (fact n)
  (if (= n 1)
      n
      (* n (fact (- n 1)))))

不会，尽管如果您unstash它到您定义它的同一个 REPL 中它会出现工作。