common-lisp - 在 REPL 中自动加载依赖文件

Question

我是 Common Lisp 的新手，来自 Clojure，并且习惯了这样的事情:

(ns x.core
  (:require [x.util :as u]))

当我启动 REPL 并评估该文件时，x.util 会自动编译并在 x.core 中可供我使用。

在 Common Lisp 中，我正在尝试做类似的事情。在 main.lisp 中:

(defpackage x.main
  (:use :x.util))

(in-package :x.main)

(comment
 (load "util.lisp"))

在 util.lisp 中:

(defpackage x.util
  (:use :common-lisp)
  (:export :foo))

(in-package :cl-blog.util)

(defun foo () 3)

我知道从 main 中的 util 访问 foo 的唯一方法是评估 comment< 中的表单 宏(我定义的类似于 Clojure 的注释，忽略它的主体)。

我也试过这个x.asd文件:

(defsystem "x"
  :version "0.1.0"
  :author ""
  :license ""
  :components ((:module "src"
                        :components
                        ((:file "util")
                         (:file "main" :depends-on ("util")))))
  :description ""
  :in-order-to ((test-op (test-op "x/tests"))))

但这似乎并不能帮助我解决这个问题。

当我在 REPL 中编译 main.lisp 时，是否有更简单、更标准的方法来自动加载(或重新编译)util.lisp？在 REPL 中处理多个文件的标准工作流程是什么？

Answer 1

只有当所需的命名空间位于类路径上的文件中时，您为 Clojure 显示的内容才有效，文件和目录的名称按照约定与命名空间匹配。为了管理类路径(除其他外)，您可以使用 deps、boot 或 leiningen 之类的东西。

用 Common Lisp 的说法，这称为系统定义，它的工作方式有点不同。

事实上的标准工具是 ASDF(另一个系统定义工具)。在 Clojure 中，您首先确定类路径，然后使用它立即启动整个应用程序，而在 Common Lisp 中，您首先启动镜像，然后将系统加载到其中(有点类似于 Clojure 中的石榴)。系统在 .asd 文件中定义。 ASDF 知道几个寻找此类文件的标准位置，您可以通过配置文件甚至在运行时添加更多。

重要的是要认识到系统和包对于 Common Lisp 来说是完全正交的概念。一个系统可以定义多个包，但一个包中的东西也可能在不同的系统中定义。此外，包与文件无关。

所以，简而言之，您的x.asd 绝对没问题。如果您的系统定义中有

:components ((:file "util")
             (:file "main")))

那么你的 util.lisp 可能是:

(defpackage #:x.util
  (:use #:cl))

(in-package #:x.util)

(defun foo ()
  'whatever)

还有你的main.lisp:

(defpackage #:x.main
  (:use #:cl))

(in-package #:x.main)

(defun bar ()
  (x.util:foo))

为了加载此系统，您在 REPL 中调用 (asdf:load-system "x")。

然后您无需执行任何操作即可启用对其他包的引用。另一个包已经存在，因为 ASDF 加载了系统定义中声明为 components 的所有文件。

概括地说:不是启动具有完整类路径定义的图像，然后加载特定文件以使 Clojure 首先递归地加载依赖项，而是启动一个基本图像，然后以正确的顺序完全加载一个或多个已定义的系统依赖性。

在 Common Lisp 中不为每个文件定义一个包是很常见的。相反，一个包在一个单独的文件中定义，然后其他文件的顶部只有 in-package 形式。

foo.asd:

(defsystem "foo"
  :serial t
  :components ((:file "package")
               (:file "utils)
               (:file "foo")))

package.lisp:

(in-package #:cl-user)

(defpackage #:foo
  (:use #:cl))

实用程序.lisp:

(in-package #:foo)

(defun frobnicate (bar)
  #| … |#)

foo.lisp:

(in-package #:foo)

(defun handle-vie (r)
  (wurble (frobnicate r)))

许多小型库只有一个包，而较大的系统通常有更多包，然后还使用某种伪层次结构(foo.bar、foo.baz)。

ASDF 中还有一个较新的补充，称为包推断系统，它在某些方面更类似于 Clojure/Java 机制，但就我个人而言，我不认为这是一个普遍的有用的东西。