[draft] rename clojure tutorials

1 files changed, 372 insertions, 0 deletions

diff --git a/content/article/clj2.md b/content/article/clj2.md
new file mode 100644
index 00000000..a5d6207c
--- /dev/null
+++ b/content/article/clj2.md
@@ -0,0 +1,372 @@
++++
+title = 'Coffee Break Clojure, Vol.2'
+subtitle = "Forms O' Plenty"
+slug = 'clj2'
+aliases = '/article/tutorial-clj-2/'
+tags = ["Lisp","编程"]
+categories = '茶歇蔻芥'
+date = 2026-09-25 18:43:53
+draft = true
+toc = true
++++
+
+[上一篇](http://localhost:1313/article/tutorial-clj-1/)我们配置好了 REPL，可以随时开始编写 Clojure 代码并执行。[第零篇](/article/tutorial-clj-0/)提到，被求值（Eval）的列表叫作形式（form），形式的第一个元素是操作符，剩余的是参数。根据操作符的不同，形式被分为函数形式、Lambda 形式、宏形式和特殊形式。今天的文章就来介绍这几种形式。
+
+## 函数形式
+
+不难理解，函数形式就是操作符为函数的形式，比如这个 `println` 形式： 
+
+```clojure 
+(println "Hello World")
+```
+
+我们知道 `"Hello World"` 是字符串，那 `println` 是什么类型？在其他语言里我们可能很少考虑函数名本身的类型，但别忘了 Lisp 的「代码即数据」本质。要把待求值的形式当作数据而非形式处理，只需要把它 `quote` 起来。
+
+这里要引入 Clojure 的 `type` 函数，它返回输入值的类型。我们不妨把刚才的形式 `quote` 起来，然后获取他的第一个元素 `println`，看看它是什么类型。
+
+```clojure 
+(type (first '(println "Hello World")))
+;; => clojure.lang.Symbol
+```
+
+类型是 `Symbol`（符号）！这是 Lisp 中的一种特殊数据类型，和其他的原子不同，符号不是自求值（self-evaluating）的。意思是说，对 `"string"` 求值得到的是 `"string"` 本身，但对符号求值得到的是符号指向的其他值。
+
+要定义一个符号很简单，只需要用到 `def`。
+
+```clojure 
+(def my-symbol 123)
+;; => #'user/my-symbol
+
+123
+;; => 123
+
+my-symbol 
+;; => 123 
+```
+
+可见符号和它指向的数据本身是等价的，对 `123` 求值和对 `my-symbol` 求值得到的结果都是 `123`。
+
+接下来试试让符号指向函数：
+
+```clojure 
+(def my-fn 
+  (fn [a b] (+ a b)))
+;; => #'user/my-fn
+
+(fn [a b] (+ a b))
+;; => #object[user$eval170$fn__171 0x6f8e0cee "user$eval170$fn__171@6f8e0cee"]
+
+my-fn
+;; => #object[user$my_fn 0x3df978b9 "user$my_fn@3df978b9"]
+
+(my-fn 1 2)
+;; => 3
+```
+
+`fn` 是个宏（macro），稍后我会讲到它为什么必须是个宏而不能是函数。你可以把它理解为其他语言里的匿名函数，或者 Lambda 表达式。实际上 `fn` 就是 Common Lisp 和 Scheme 里的 `lambda`，不过换了个名字。
+
+直接对 `fn` 形式求值得到的是形如 `#object[...]` 的字符串，这个字符串是 JVM 上某个数据的文字表示。像函数这种数据没办法像字符串和数字那样直接表示出来，于是就用这种标记表示。
+
+输出这种标记对程序而言没有意义，使用函数的正确方式当然是调用它。上述例子中的 `(my-fn 1 2)` 就是个函数形式，第一个元素是指向函数的符号，剩下的数据作为参数传递给符号指向的函数。
+
+既然符号本身也是数据，那么如果形式的第一个元素不是符号，而是返回符号的函数调用，能否正常调用函数呢？还记得 `eval` 本身也是个函数吗？
+
+```clojure 
+((eval 'my-fn) 1 2)
+;; => 3
+```
+
+之前我们提到对 `(eval (quote x))` 求值和对 `x` 本身求值是等价的，这里也成立。对 `my-fn` 求值返回的是个符号，对 `(eval 'my-fn)` 求值得到的也是个符号。只要形式的第一个元素是指向函数的符号，就能完成函数调用。
+
+根据条件返回不同类型的符号也是可以的：
+
+```clojure 
+(def a 1)
+;; => #'user/a
+((if (> a 1) + -) 2 1)
+;; => 1
+```
+
+好了好了，没人会这么写程序的。你现在知道，==函数形式就是操作符为指向函数的符号的形式==，对函数形式求值就是调用函数。还记得刚才让一个符号指向一个值的 `def` 吗？如果要用来声明函数，还有更简便的写法：
+
+```clojure 
+(def my-fn 
+  (fn [a b] (+ a b)))
+
+;; 等价于 
+(defn my-fn [a b]
+  (+ a b))
+```
+
+写 Clojure 函数的时候你多半只会用到 `defn`，但不要忘了函数名和变量名一样，都只是符号而已。
+
+记住这个原理你能做到很多有趣的事情。比方说，在其他语言里我们经常对值做一些操作，然后赋值给变量，就像这样：
+
+```clojure 
+(def a (reduce + '(1 2 3)))
+;; => #'user/a 
+
+a 
+;; => 6
+```
+
+我们对列表 `(1 2 3)` 做了累加操作，变成了 `6`，然后赋值给 `a`。函数也可以这么干，比如 `partial` 就是对函数的操作，可以让我们提前填充函数的某些参数，然后返回新的函数：
+
+```clojure 
+(def plus-one (partial + 1))
+;; => #'user/plus-one 
+
+(plus-one 3)
+;; => 4
+
+((partial + 1) 3)
+;; => 4
+```
+
+我们对函数 `+` 做了 `partial` 操作，给它提前填上了一个参数 `1`。调用得到的新函数就相当于调用 `(+ 1 ...)`。在其他语言里，要做到类似的事情，你可能要这么写：
+
+```clojure 
+(defn plus-one [num]
+  (+ 1 num))
+```
+
+你可能注意到了 Clojure 函数和非 Lisp 语言的另一个区别：没有 `return` 语句。函数如果有多个并列的形式，就会以最后一个形式的值作为函数的返回值。
+
+做个习题，下面这段函数调用为什么返回了 `nil`？
+
+```clojure 
+(defn chatty-add [a b]
+  (let [result (+ a b)]
+    result 
+    (println result)))
+
+(chatty-add 1 2) ;; => nil
+```
+
+## Lambda 形式
+
+Lambda 形式类似 JavaScript 里的立即执行函数，也就是定义一个匿名函数，然后立马执行它，这样就可以限定变量的作用域。
+
+```js 
+(function (a, b) {
+    let c = a + b 
+    return c
+})(1, 2)
+// => 3
+```
+
+如果是 Clojure，就要这么写：
+
+```clojure 
+((fn [a b] (+ a b)) 1 2)
+;; => 3
+```
+
+Lambda 形式的操作符不是指向函数的符号，就是函数本身。
+
+在 Scheme（另一门 Lisp 方言）里要这么写：
+
+```scheme 
+((lambda (a b) (+ a b)) 1 2)
+;; => 3 
+```
+
+在 Scheme 里，这种写法有个语法糖，叫 `let`：
+
+```scheme 
+(let ((a 1) (b 2)) 
+  (+ a b))
+```
+
+没错，这和 JavaScript 和 Rust 等语言用于声明变量的 `let` 很类似，但 Scheme 中 `let` 仅仅是立即执行函数的语法糖。不过，在 Clojure 中，`let` 是个特殊形式，有专门的[解析器](https://github.com/clojure/clojure/blob/07adae6d24a0efcb4e6b39577c473b61df9d5f5b/src/jvm/clojure/lang/Compiler.java#L6902)，我会在后文展开。
+
+## 宏形式 
+
+前面我一直在用加减法做例子，现在不妨来看看逻辑运算。Clojure 中表示与、或、非运算的操作符分别是 `and`、`or` 和 `not`。其中 `not` 是个非常简单的函数：
+
+```clojure 
+(defn not [x] 
+  (if x false true))
+;; 如果 x 为真，返回 false
+;; 如果 x 为假，返回 true
+```
+
+但 `and` 和 `or` 不可以是函数，必须是宏。为什么？我们不妨假设他们是函数，看看会发生什么。
+
+```clojure 
+(let [a 1 b 2]
+  (or (> b 1)
+      (> a 1)))
+```
+
+首先要对 `or` 函数的所有参数求值，得到值之后才能调用函数。`(> b 1)` 为 `true`，`(> a 1)` 为 `false`，然后得到 `(or true false)`，最后算出值为 `true`。
+
+你发现了吗？我们做了一步完全多余的运算。根本不需要计算 `(> a 1)` 为 `false`，只要算出 `(> b 1)` 为 `true`，就可以算出整个 `or` 形式的值为 `true`，因为逻辑运算或只要求其中一个值为真。
+
+如果 `or` 是函数，就必须做那一步多余的运算，否而得不到值，无法调用函数。然而，有些运算是有副作用的，比如从消息队列中取出一条消息，会导致其他人无法再次从队列中取到它，若 `or` 运算丢弃了这条消息，数据就丢失了。
+
+那怎么办呢？有什么办法可以让参数不被预先求值吗？
+
+答案就是宏（macro）。宏这个机制被不少语言借鉴，比如 Rust 和 Haskell（在 Haskell 里叫 Template，模板），其实本质就是对还没求值的列表做预处理。
+
+定义宏就是定义一系列对列表做变换的规则，宏作为形式的操作符时，会先进行宏展开（macroexpand），然后对展开的结果求值。宏展开之前，所有的列表都不会被求值。
+
+我们来看看 `or` 这个宏的定义：
+
+```clojure 
+(defmacro or
+  ([] nil)
+  ([x] x)
+  ([x & next]
+      `(let [or# ~x]
+         (if or# or# (or ~@next)))))
+```
+
+没有参数时n展开为 `nil`，只有一个参数时展开为这个参数本身，有多个参数时会被展开为嵌套在 `let` 里的 `if`，我们看到宏还能像函数一样递归，因为 `or` 的定义包含了 `or` 本身。
+
+这看起来有点难以理解，我们不妨手动展开一下：
+
+```clojure 
+(macroexpand '(or (> b 1) (> a 1)))
+;; => (let* [or__5600__auto__ (> b 1)] (if or__5600__auto__ or__5600__auto__ (clojure.core/or (> a 1))))
+
+;; 整理得到：
+(let* [or__5600__auto__ (> b 1)] 
+  (if or__5600__auto__ 
+    or__5600__auto__ 
+    (clojure.core/or (> a 1))))
+
+;; clojure.core/or 就是包含命名空间的 or，指向同一个宏 
+;; 由于单参数的 or 展开为参数本身，所以可以得到： 
+(let* [or__5600__auto__ (> b 1)] 
+  (if or__5600__auto__ 
+    or__5600__auto__ 
+    (> a 1)))
+
+;; 为了方便理解，我们再把 let 删掉： 
+(if (> b 1) (> b 1) (> a 1))
+```
+
+`if` 是个特殊形式，和 `let` 一样有自己的解析器。当 `if` 计算 `(> b 1)` 得到 `true` 时，就会选择第二个参数求值，第二参数是 `(> b 1)`，得到 `true`，于是返回 `true`；第三个参数 `(> a 1)` 没有被求值，我们不知道他是 `true` 还是 `false`。
+
+还记得一开始的 `fn` 吗？如果 `fn` 是个函数，下面这段表达式会变成什么样子？
+
+```clojure 
+(fn [a b c]
+  (println a b c)
+  (+ a b c))
+```
+
+<details>
+    <summary>如果 <code>fn</code> 是函数的解释</summary>
+
+首先对 `[a b c]` 求值，解释器会发现 `a` 这个符号不存在，然后报错。
+
+</details>
+
+关于怎么自定义宏，就放在之后的文章再讲了。
+
+## 特殊形式
+
+前面提到 `if` 和 `let` 都是特殊形式，可以理解为其他语言里的保留字。这些符号有特殊的解释规则，或者编译规则。==特殊形式就是由编译器和解释器实现的形式==。函数和宏都是用户定义的，只不过有的定义在标准库里。
+
+有趣的是，Clojure 的 `let` 最外层其实是个宏，而 `let*` 才是特殊形式，只不过 `let` 最终会被展开为 `let*`。
+
+```clojure 
+(macroexpand '(let [a 1 b 1] (+ a b)))
+;; => (let* [a 1 b 1] (+ a b))
+```
+
+看起来 `let` 被展开之后仅仅是把 `let` 替换成了 `let*`，为什么要套一层宏呢？
+
+这次我们故意把 `let` 写错，看看会发生什么。
+
+```clojure 
+(macroexpand '(let [a 1 b] (+ a b)))
+;; Syntax error macroexpanding clojure.core/let at (REPL:1:1).
+;; [a 1 b] - failed: even-number-of-forms? at: [:bindings] 
+;; spec: :clojure.core.specs.alpha/bindings
+```
+
+报错了，错误在 `[a 1 b]`，失败原因是 `let` 里写的符号绑定应该是偶数个。这个语法检查并不是编译器实现的，而是宏定义的：
+
+```clojure 
+(defmacro let
+  [bindings & body]
+  (assert-args
+     (vector? bindings) "a vector for its binding"
+     (even? (count bindings)) "an even number of forms in binding vector")
+  `(let* ~(destructure bindings) ~@body))
+```
+
+`assert-args` 是标准库内部的宏，用来断言（assert）参数是否符合规范（spec）。在 `let` 的宏定义中，它要求 `bindings`（符号绑定）是向量（也就是包裹在 `[]` 里的数据结构），并且是偶数个。断言失败就不会继续展开宏，而是会报错。
+
+如果没有问题，`let` 就会被展开为 `let*`，展开之前还对 `bindings` 执行了 `destructure` 操作。这是解构，解构是 Clojure 的语法特性，Python 和 JavaScript 也有解构：
+
+```js
+let anObject = { a: 1, b: 2, c: 3 }
+const {a, b, c} = anObject 
+console.log(a, b, c) // 1 2 3
+```
+
+上述代码用 `{a, b, c}` 代替了变量名，用来从 `anObject` 这个对象里提取和变量名同名的属性。这就是解构操作。
+
+Clojure 没有用编译器实现解构，而是用 `destructure` 函数实现的，这个解构函数在 `let` 宏展开时调用。以下是用 `let` 解构的例子：
+
+```clojure 
+(def a-map {:a 1 :b 2 :c 3})
+(let [{:keys [a b c]} a-map]
+  (println a b c))
+;; (out) 1 2 3 
+;; => nil
+```
+
+如果对上面的 `let` 形式做宏展开，就会得到：
+
+```clojure 
+(let* [map__147 a-map 
+       map__147 (if (seq? map__147) (if (next map__147) (clojure.lang.PersistentArrayMap/createAsIfByAssoc (to-array map__147)) (if (seq map__147) (first map__147) clojure.lang.PersistentArrayMap/EMPTY)) map__147) 
+       a (get map__147 :a) 
+       b (get map__147 :b) 
+       c (get map__147 :c)] 
+  (println a b c))
+```
+
+正因为 `let` 本身是宏，而非单独的编译器实现，Clojure 的 `let` 和其他 Lisp 的 `let` 比起来才好用不少。在 Common Lisp 和 Scheme 中，`let` 和 `let*` 的作用不同，比方说下面这段代码是有问题的：
+
+```lisp 
+(let ((a 1) (b 2) (c (+ a b))) 
+  (+ a b c))
+; in: LET ((A 1) (B 2) (C (+ A B)))
+;     (+ A B)
+;
+; caught WARNING:
+;   undefined variable: COMMON-LISP-USER::A
+;
+; caught WARNING:
+;   undefined variable: COMMON-LISP-USER::B
+; ...
+```
+
+求值 `(+ a b)` 的时候，Common Lisp 解释器会认为 `a` 和 `b` 没有被绑定，因为 `(c (+ a b))` 和 `a`、`b` 的绑定在同一个 `let` 里。如果要使用在同一个 `let` 定义的其他符号，就要用 `let*`：
+
+```lisp 
+(let* ((a 1) (b 2) (c (+ a b))) 
+  (+ a b c))
+; 6
+```
+
+《[A Scheme Primer](https://files.spritely.institute/papers/scheme-primer.html#fn.more-lets)》里写到，如果 Scheme 的规范要从头开始指定，最好要把 `let`、`let*` 还有 `letrec`（允许递归引用符号自己的 `let`）都合成同一个。Clojure 作为较新的一门 Lisp 方言，少了很多历史遗留问题。
+
+--- 
+
+## 最后 
+
+现在你应该知道求值 Clojure 形式时，解释器底下大概都发生了什么，你应该也熟悉了一些基本的函数、宏和特殊形式，比如 `let` `if` 和 `fn`，可以写一些简单的 Clojure 程序了。
+
+其实除了本文提到的四种形式，Clojure 还可以用特定类型的数据作为操作符（比如用一个集合做操作符，用于查看参数是否存在于集合内），也可以当作一种类型的形式。这要留到下篇讲了。
+
+下一篇我们要了解 Clojure 里的集合数据类型，分别是我们已经见过的列表（list）和向量（vector），此外还有集合（set）和映射（map）。我们还会讲到如何操作这些集合，包括遍历和筛选等等。我们还会了解到惰性序列（Lazy sequence），然后你就可以写程序处理相对复杂的数据，并且能够到同时做到语法简洁和高性能。这些都是后话了。
+
+回见！
+