clojure参考手册

1.1.1. 1.1 为什么我应该关心标准库?

1.1.2. 1.2 规范不就是很无聊吗?

1.1.3. 1.3 Clojure 的不同版本

1.1.4. 1.4 Clojure 标准库

1.1.5. 1.5 让你的开发生活更轻松

(def balance "<balance> <accountId>3764882</accountId> <lastAccess>20120121</lastAccess> <currentBalance>80.12389</currentBalance> </balance>")

(require '[clojure.java.io :as io])
(require '[clojure.xml :as xml])

(defn- to-double [k m]
  (update-in m [k] #(Double/valueOf %)))

(defn parse [xml] ; ❶
  (let [xml-in (java.io.ByteArrayInputStream. (.getBytes xml))
        results (to-double :currentBalance
                           (apply merge
                                  (map #(hash-map (:tag %) (first (:content %)))
                                       (:content (xml/parse xml-in)))))]
    (.close xml-in)
    results))

(defn clean-key [k] ; ❷
  (let [kstr (str k)]
    (if (= \: (first kstr))
      (apply str (rest kstr))
      kstr)))

(defn- up-first [[head & others]]
  (apply str (conj others (.toUpperCase (str head)))))

(defn separate-words [k] ; ❸
  (let [letters (map str k)]
    (up-first (reduce #(str %1 (if (= %2 (.toLowerCase %2))
                                 %2
                                 (str " " %2)))
                      ""
                      letters))))

(defn format-decimals [v] ; ❹
  (if (float? v)
    (let [[_ nat dec] (re-find #"(\d+)\.(\d+)" (str v))]
      (cond
        (= (count dec) 1) (str v "0")
        (> (count dec) 2) (apply str nat "." (take 2 dec))
        :default (str v)))
    v))

(defn print-balance [xml] ; ❺
  (let [balance (parse xml)]
    (letfn [(transform [acc item]
              (assoc acc (separate-words (clean-key item))
                     (format-decimals (item balance))))]
      (reduce transform {} (keys balance)))))

(print-balance balance)
;; {"Account Id" 3764882, "Last Access" "20120121", "Current Balance" "80.12"}

(require '[clojure.java.io :as io])
(require '[clojure.xml :as xml])
(require '[clojure.string :refer [split capitalize join]])
(require '[clojure.pprint :refer [cl-format]])

(defn- to-double [k m]
  (update-in m [k] #(Double/valueOf %)))

(defn parse [xml] ; ❶
  (with-open [xml-in (io/input-stream (.getBytes xml))]
    (->> (xml/parse xml-in)
         :content
         (map #(hash-map (:tag %) (first (:content %))))
         (into {})
         (to-double :currentBalance))))

(defn separate-words [s]
  (->> (split s #"(?=[A-Z])") ; ❷
       (map capitalize) ; ❸
       (join " ")))

(defn format-decimals [v]
  (if (float? v)
    (cl-format nil "~$" v) ; ❹
    v))

(defn print-balance [xml]
  (let [balance (parse xml)
        ks (map (comp separate-words name) (keys balance))
        vs (map format-decimals (vals balance))]
    (zipmap ks vs))) ; ❺

(print-balance balance)
;; {"Account Id" 3764882, "Last Access" "20120121", "Current Balance" "80.12"}

1.1.6. 1.6 信息碎片化的问题

user=> (doc interleave)
-------------------------
clojure.core/interleave
([] [c1] [c1 c2] [c1 c2 & colls])
  Returns a lazy seq of the first item in each coll, then the second etc.
nil

1.1.7. 1.7 Clojure 忍者的秘诀

1.1.8. 1.8 完美的伴侣书籍

1.1.9. 1.9 总结

2.1.1. 2.1 函数定义

1. 2.1.1 defn 和 defn-
   

   自 1.0 起为宏

   Listing 1: → 函数定义

   (defn [name & fdecl])
   

   defn (及其私有版本 defn- ) 是 Clojure 中函数创建的基本构件和主要入口点之一. 它支持丰富的功能集, 如解构, 多重元数, 类型提示, :pre 和 :post 条件等 (通过与其密切相关的 fn 实现). 其调用约定本身就像一门小语言, 而 defn 就是专门用来解析这个小语法的. defn 最常用的形式可能是简单的单参数情况:

   (defn hello [person] ; ❶
     (str "hello " person))
   

   ❶ 一个简单的函数定义. 函数 hello 接收一个字符串并返回一个字符串.

   defn 与 def (用于在当前命名空间中绑定其名称) 和 fn (用于前置/后置条件和解构) 协同工作. 由于 defn 是一个宏, 我们可以对其调用 macroexpand 来理解其工作原理:

   (macroexpand ; ❶
     '(defn hello [person]
        (str "hello " person)))
   ;; (def hello
   ;;   (clojure.core/fn ; ❷
   ;;     ([person] (str "hello " person))))
   
   (hello "people") ; ❸
   ;; "hello people"
   

   ❶ 我们可以对之前的函数定义调用 macroexpand, 看看 Clojure 如何将匿名函数的创建与当前命名空间中的 var 定义组合在一起.

   ❷ 通过 fn 创建的 lambda 被赋给一个新的 Var 对象 "hello".

   ❸ "hello" 符号在当前命名空间中可用于执行, 使用环绕的括号.

   1. 约定
      

      defn 的约定相当复杂, 本着保持本书实用性的精神, 我们不打算使用严格的语法来描述这个或书中的其他函数. 我们将使用一种非正式的语法 , 希望它比相应的函数文档更具表达力, 但并不旨在涵盖所有可能情况的全部范围 (也不是 100% 一致). 读者应使用该语法来大致了解函数的作用, 然后参考下面的示例来涵盖其余情况.

      以下是本书中使用的语法词汇表 (同样的词汇表也已添加到附录中):

      • "<term>": 尖括号中的术语是终结符, 不会产生任何进一步的展开.
      • "[]": 方括号中的术语是函数定义中的实际向量.
      • "()": 圆括号中的术语是函数定义中的实际列表.
      • "OR": 表示在可能的选项中进行选择.
      • ":=>": 显示一个可以进一步展开为其他术语的术语.
      • "..": 意思是" …的多次重复" .
      • "?": 在一个术语之后表示该术语是可选的.

      有了这个小语法, 我们可以这样表达 defn 的用法:

      (defn ^<metamap>? <name> fdecl)
      
      fdecl :=> <docstring>? <metamap>? arities
      
      <metamap>?
      arities :=> ^<metamap>? [arity] body
                 OR
                 (^<metamap>? [arity1] body)
                 (^<metamap>? [arity2] body) ..
                 (^<metamap>? [arityN] body)
      
      arity :=> <ret-typehint>? [<arg1-typehint>? <arg1> .. <argN-typehint>? <argN>]
      
      body :=> <metamap> <forms>
      

      • "<metamap>" 是一个可选的键值对 map (例如 ^{:a true}) . "<metamap>" 也接受一种简洁的语法, 只使用键 ^:tagname1 ^:tagname2, 其中值隐式为 true. 请注意, 这种替代语法仅在允许 "<metamap>" 的某些位置可用. 标签与函数定义创建的 var 一起存储. 此外, 根据位置, <metamap> 可能需要 ^ 前缀出现在左花括号之前.
      • "<name>" 是强制性的, 必须是有效的符号 ¹⁷.
      • "<docstring>" 是一个可选的字符串, 用于描述函数. 文档字符串也存储在函数定义产生的 var 对象中. 你可以使用 doc 函数查看文档字符串.
      • ([arity1]) ([arity2]) .. ([arityN]) 是不同长度的参数向量. 在只有一个 [arity] 的情况下, 外围的括号是可选的.
      • "<ret-typehint>" 是一个可选的类型提示, 适用于该元数的返回值. "<ret-typehint>" 也可以出现在该元数的 "<metamap>" 中, 形式为 {:tag <typehint>}, 行为等效.
      • "<arg-typehint>" 是参数向量中一个参数的可选类型提示. 这也可以表示为 "<metamap>".
      • "body" 包含调用函数时求值的表达式. 它被隐式地包裹在一个 do 块中. 当没有 body 时, 假定为 nil. 在 body 中的其他表达式之前, 允许有一个额外的 "<metamap>" (没有前缀 ^). 当参数向量和 body 都包含 "<metamap>" 时, 如果键发生冲突, body 中的那个优先. 注意, 前置和后置条件 (见下文) 只允许在参数向量之后的 "<metamap>" 中使用.

      defn 返回一个引用刚创建的函数对象的 clojure.lang.Var. 函数名在当前命名空间中无需任何额外前缀即可使用. 值得注意的是, 元数据 map 可以出现在多个位置.

   2. 示例
      

      defn 的用法当然是广泛的. 以下示例说明了一些最重要的方面.

      1. 元数据放置
         

         从约定中我们可以看到, defn 接受元数据定义, 在多个位置具有略微不同的语法和含义. 一些元数据作为生成的 var 定义的一部分可用, 其他的则在表达式解析期间通知编译器 , 还有一些在函数求值期间的运行时使用. 我们可以在以下 (公认是人为构造的) 示例中一次性看到它们:

         (defn ^{:t1 1} foo ; ❶
           "docstring"
           {:t2 2}
           (^{:t3 3} [a b] {:t4 4} (+ a b)) ; ❷
           {:t5 5}) ; ❸
         (meta #'foo) ; ❹
         ;; {:ns #object[clojure.lang.Namespace 0x33f17f86 "user"],
         ;;  :name foo,
         ;;  :t2 2,
         ;;  :file
         ;;  "/private/var/form-init5372276344059831979.clj",
         ;;  :column 1,
         ;;  :line 1,
         ;;  :arglists ([a b]),
         ;;  :doc "docstring",
         ;;  :t1 1,
         ;;  :t5 5}
         (meta (first (:arglists (meta #'foo)))) ; ❺
         ;; {:t3 3, :t4 4}
         

         ❶ 元数据的第一个位置是在 defn 声明之后. 在这个位置, 它需要前缀 ^.

         ❷ 元数据 map 在这一行中出现了 3 次: 在第一个元数声明之前, 在第一个元数声明内部, 以及在函数体之前.

         ❸ 最后的元数据 map 在所有定义之后可用.

         ❹ 我们可以看到 :t1, :t2, :t5 出现在 var 元数据中. 其他上下文相关的信息 (如命名空间对象或列/行信息) 在从另一个 REPL 打印时可能会有所不同.

         ❺ 元数定义内的两个元数据 map 已合并为一个附加到 ":arglists" 值的元数据 map.

         值得注意的是, 函数末尾的元数据只有在元数 (参数向量后跟函数体) 被括号包裹时才可用. 当函数只有一个元数时, 记住这一点很重要, 因为这通常是在没有外围括号的情况下编写的.

         例如, 上面的例子之所以有效, 是因为 ([a b] (+ a b)) 被括号包裹着.

         除了像 :doc, :tag, :pre 或 :post 这样的保留键之外, 我们可以使用元数据来用任何类型的上下文信息注释函数. 注释可以稍后被库或工具分析和处理.

         例如, 元数据在 core.test 命名空间中被广泛使用, 以将函数标记为" test" 并相应地运行它. 元数据中的键值对可以是任何类型, 例如字符串, 数字或其他结构化数据.

         然而, 布尔值非常频繁, 以至于它们通常被称为" 标签" . 标签提供了一个额外的前缀语法, 使用脱字符号 "^:".

         以下示例展示了一个性能分析功能, 它扫描一个命名空间以查找标记为 ^:bench 的函数. 当存在这样的标签时, 相应的函数将被重新定义以检查执行时间:

         (ns profilable)
         
         (defn ^:bench profile-me [ms] ; ❶
           (println "Crunching bits for" ms "ms")
           (Thread/sleep ms))
         
         (defn dont-profile-me [ms]
           (println "not expecting profiling"))
         
         (ns user)
         
         (defn- wrap [f]
           (fn [& args] (time (apply f args))))
         
         (defn- make-profilable [v]
           (alter-var-root v (constantly (wrap @v))))
         
         (defn- tagged-by [tag nsname]
           (->> (ns-publics nsname)
                vals
                (filter #(get (meta %) tag))))
         
         (defn prepare-bench [nsname] ; ❷
           (->> (tagged-by :bench nsname)
                (map make-profilable)
                dorun))
         
         (profilable/profile-me 500) ; ❸
         ;; Crunching bits for 500 ms
         
         (prepare-bench 'profilable)
         
         (profilable/profile-me 500) ; ❹
         ;; Crunching bits for 500 ms
         ;; "Elapsed time: 502.422309 msecs"
         
         (profilable/dont-profile-me 0) ; ❺
         ;; not expecting profiling
         

         ❶ "profilable" 命名空间中的函数 profile-me 有一个 :bench 注释, 它会进入元数据 map.

         ❷ prepare-bench 在给定的命名空间中搜索所有标记为 :bench 的函数, 并将它们包装到一个新的函数中, 该函数进行性能分析.

         ❸ 在调用 prepare-bench 之前, profile-me 打印预期的消息.

         ❹ 但在调用 prepare-bench 之后, profile-me 还会打印经过的时间以及消息.

         ❺ 其他未标记的函数不受影响.

      2. 文档化
         

         为一个函数附加一个简短的文档字符串来描述其用途是一种很好的做法. Clojure 为文档字符串提供了一个特定的位置, 以便编译器可以适当地存储此信息. 然后, 您可以使用 clojure.repl/doc 函数来打印有关该函数的有用信息, 包括文档字符串:

         (defn hello "A function to say hello" ; ❶
           [person]
           (str "Hello " person))
         
         (clojure.repl/doc hello) ; ❷
         ;; -------------------------
         ;; user/hello
         ;; ([person])
         ;;   A function to say hello
         ;; ([person])
         ;;   A function to say hello ; ❸
         ;; nil
         
         (:doc (meta #'hello)) ; ❹
         ;; "A function to say hello"
         

         ❶ 文档字符串出现在函数名之后.

         ❷ 我们使用函数 doc 并将 var "hello" 作为参数传递.

         ❸ 文档字符串与函数签名一起打印在屏幕上.

         ❹ 或者, 我们可以从元数据中提取键 :doc.

      3. 前置/后置条件
         

         下一个例子展示了如何使用前置和后置条件. 条件是函数, 可以访问参数和返回值 (仅限后置条件). Clojure 会检查参数向量后的元数据 map 中是否存在 :pre 或 :post 键.

         当存在 :pre 或 :post 键时, 它们的值必须是谓词的集合. 谓词分别在函数执行之前或之后被调用.

         下面的 save! 函数, 将一个项目保存到某个存储. 在将其推送到存储之前, 它使用前置条件检查有关输入的一些事实. 保存到存储后, 它用后置条件验证该项目是否具有正确的 ":id":

         (require '[clojure.test :refer [are]])
         
         (defn save! [item]
           {:pre [(are [x] x ; ❶
                    (map? item) ; ❷
                    (integer? (:mult item)) ; ❸
                    (#{:double :triple} (:width item)))] ; ❹
            :post [(clojure.test/is (= 10 (:id %)))]} ; ❺
           (assoc item :id (* (:mult item) 2)))
         
         (save! {:mult "4" :width :single})
         ;; FAIL in () (form-init828.clj:2) ; ❻
         ;; expected: (integer? (:mult item))
         ;;   actual: (not (integer? "4"))
         ;;
         ;; FAIL in () (form-init828.clj:2)
         ;; expected: (#{:double :triple} (:width item))
         ;;   actual: nil
         ;;
         ;; AssertionError Assert failed:
         ;; (clojure.test/are [x] x (map? item) (integer? (:mult item))
         ;; (#{:double :triple} (:width item))) user/save!
         
         (save! {:mult 4 :width :double}) ; ❼
         ;; FAIL in () (form-init8288562343337105678.clj:6)
         ;; expected: (= 10 (:id %))
         ;;   actual: (not (= 10 8))
         ;;
         ;; AssertionError Assert failed:
         ;; (clojure.test/is (= 10 (:id %)))
         
         (save! {:mult 5 :width :double}) ; ❽
         ;; {:mult 5, :width :double, :id 10}
         

         ❶ "clojure.test/are" 将多个断言组合在一起. 本例中的断言如果失败, 都预期返回逻辑假 (包括 nil).

         ❷ 这个谓词检查 item 是否为 map 类型. 注意参数 "item" 在前置和后置条件中都可用.

         ❸ 类似地, 这个谓词检查键 :mult 的值是否为整数类型.

         ❹ 使用集合包含来验证 :width 键的值是否属于一小组允许的值.

         ❺ 后置条件的工作方式类似, 增加了占位符 % 百分号来访问函数的返回值. 在这种情况下, 我们检查返回的 map 是否包含一个等于 10 的 id.

         ❻ 由于 clojure.test 函数, 失败的断言被很好地打印出来. clojure.test 是标准库的一部分.

         ❼ 在下一次尝试中, 我们修复了前置条件, 但后置条件有问题.

         ❽ 我们终于看到了对 save! 的成功调用.

         注意

         该示例演示了一个有用的技巧, 即用 clojure.test/is 或 clojure.test/are 宏包装前置和后置条件. 条件仍然会因 java.lang.AssertionError 而失败, 但 clojure.test 包装器会显示一个更 友好的消息.

      4. 类型提示
         

         类型提示是连接 Clojure 动态类型世界 (几乎所有东西都被视为通用的 java.lang.Object) 和 Java 静态类型世界的桥梁. 在大多数情况下, Clojure 中的类型提示是可选的, 但当速度很重要时, 它们是必需的 (其他常见的技巧包括禁用检查数学, 使用原始未装箱类型, 使用瞬态等, 具体取决于具体情况).

         当 Clojure 函数调用 Java 方法时, 通常需要类型提示. Clojure 编译器使用类型信息来避免在生成的 Java 字节码中进行反射. 反射是一个非常有用 (但很慢) 的 Java API, 用于发现和调用 Clojure 运行时所需的 Java 方法.

         为了说明这一点, 以下示例是关于使用密钥对请求进行签名. Java 标准库包含了我们完成此任务所需的一切, 因此不需要外部库. 对请求进行签名的想法如下:

         • 有一些我们想要签名的事件的唯一字符串表示. 在本例中, 我们将使用一个 URL.
         • 两方想要交换信息, 但他们想确保信息在中间没有被篡改. 因此, 他们生成并存储一个用于签署消息的密钥, 别人无法访问.
         • 当 "A" 想向 "B" 发送消息时, 它通过附加一个签名来签署消息. "B" 接收到消息, 应用相同的过程, 并验证生成的签名与接收到的签名相同.

         这里是一些实现该协议的代码:

         (ns crypto
           (:import java.io.ByteArrayOutputStream
                    javax.crypto.spec.SecretKeySpec
                    javax.crypto.Mac
                    java.util.Base64
                    java.net.URLEncoder
                    java.nio.charset.StandardCharsets))
         
         (set! *warn-on-reflection* true) ; ❶
         
         (defn get-bytes [s]
           (.getBytes s (StandardCharsets/UTF_8)))
         
         (defn create-spec [secret]
           (SecretKeySpec. (get-bytes secret) "HmacSHA256"))
         
         (defn init-mac [spec]
           (doto (Mac/getInstance "HmacSHA256")
             (.init spec)))
         
         (defn compute-hmac [mac canonical]
           (.doFinal mac (get-bytes canonical)))
         
         (defn encode [hmac]
           (URLEncoder/encode (.encodeToString (Base64/getEncoder) hmac)))
         
         (defn sign [canonical secret] ; ❷
           (-> secret
               create-spec
               init-mac
               (compute-hmac canonical)
               encode))
         
         (defn sign-request [url] ; ❸
           (let [signature (sign url "secret-password")]
             (format "%s?signature=%s" url signature)))
         
         (sign-request "http://example.com/tx/1")
         ;; "http://example.com/tx/1?signature=EtUPpQpumBqQ5c6aCclS8xDIItfP6cINNkKJXtlP1pc%3D"
         

         ❶ Clojure 提供了 *warn-on-reflection* 动态 var, 以显示编译器无法推断类型的位置.

         ❷ sign 函数显示了签名所需的步骤. 我们不需要深入了解算法的细节, 但创建一个 sha256 hmac 是很常见的程序 ¹⁸.

         ❸ sign-request 接受一个代表交易的 url. 该函数返回相同的 URL, 并将签名作为请求参数之一附加, 准备通过网络发送.

         当我们在编译期间查看输出时, Clojure 会打印类似以下内容:

         Reflection warning, crypto.clj:12:3 - call to method getBytes can't be resolved (target class is unknown).
         Reflection warning, crypto.clj:21:3 - call to method doFinal can't be resolved (target class is unknown).
         

         源代码行/列引用可能不同, 但消息表明至少有两个地方编译器无法推断类型并正在使用反射. 如果在我们的示例中, 我们假设每秒有 100k 笔交易的峰值, 我们可能需要审查 sign-request 的性能. 像 Criterium 这样的高级工具是基准测试的最佳选择, 但在这个具体案例中, 我们可以仅通过使用 time 清楚地看到发生了什么:

         (time (dotimes [i 100000] ; ❶
                 (sign-request (str "http://example.com/tx/" i))))
         ;; "Elapsed time: 1054.507977 msecs"
         

         ❶ time 是一个小宏, 它用时间测量来包装一个表达式.

         注意

         此处 (以及本书其他部分) 显示的经过时间取决于执行基准测试的硬件, 因此在其他机器上可能会显示不同的数字. 重要的是基准测试实例之间的相对差异, 这应该与硬件无关.

         现在让我们为编译器警告突出显示的函数定义添加类型提示:

         (defn get-bytes [^String s] ; ❶
           (.getBytes s (StandardCharsets/UTF_8)))
         
         (defn compute-hmac [^Mac mac canonical] ; ❷
           (.doFinal mac (get-bytes canonical)))
         
         (time (dotimes [i 100000]
                 (sign-request (str "http://example.com/tx/" i))))
         ;; "Elapsed time: 449.417098 msecs" ; ❸
         

         ❶ 参数 "s" 被标记为 ^String, 因此接下来的 .getBytes 是完全限定的.

         ❷ 参数 "mac" 被标记为类型 ^Mac. 编译器的其他警告也消失了, 因为 .doFinal 也通过推断变得完全限定.

         ❸ 添加了两个类型提示后, 我们能够将处理时间减少 50%.

         正如新的测量时间所示, 当移除反射调用后, 我们可以获得更好的性能.

      5. 不超过 20 个!
         

         Clojure 中的函数定义限制为最多 20 个非可变参数:

         (defn a [a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17 a18 a19 a20 a21])
         ;; CompilerException java.lang.RuntimeException: Can't specify more than 20 params [...]
         

         以上代码会导致编译时异常. 这个限制可能看起来是任意的或限制性的, 但选择背后的理由很简单: Clojure 非常注重速度, 并且有一些编译器优化, 这些优化从为每个参数数量都有一个特定的 Java 方法中获益匪浅. 在 Clojure 代码库中有几个地方可以看到这一点 ¹⁹, 当然, 这并不容易阅读, 维护或演进.

         除了编译器实现细节外, 任何超过三或四个参数的函数都应该看起来可疑. 参数太多应该引发一个问题, 即是否缺少一个将它们组合在一起的抽象.

   3. 另请参阅
      

      fn 在 defn 的底层被用来生成函数体并实现解构. 与 defn 不同, fn 不会创建 var 对象, 也不会作为副作用改变当前命名空间. 因此, fn 是在不需要外部名称的情况下在本地使用函数的更好选择. fn 经常与序列操作如 reduce 一起使用, 以创建一个两个参数的匿名函数.

      definline 创建一个 defn 定义, 但也包含一个内联版本的函数体以提高 Java 互操作性. 如果函数体除了包装一个 Java 方法调用外没有做太多其他事情, 考虑为性能敏感的函数使用 definline.

      letfn 是与 let 绑定关联的匿名函数定义的语法糖. 优先使用 letfn 来创建一个或多个命名的本地函数.

   4. 性能考虑和实现细节
      

      defn 是一个宏, 主要影响 Clojure 的编译时间. defn 的常见用法在程序运行时不应产生顾虑. defn 的定义在标准库引导的早期发生, 当时大多数常见的 Clojure 设施尚未定义. 这一方面, 加上与内联和类型提示相关的复杂性, 使得 defn 的源码不易理解.

2. 2.1.2 fn
   

   自 1.0 版本以来的宏

   Listing 2: → 匿名函数定义, lambda

   (fn [params] exprs)
   

   fn 创建一个新函数, 并支持重要功能, 如解构, 类型提示, 前置和后置条件 (在 defn 中已说明) 以及基于参数数量 (或 Clojure 文档中常说的" 元数" ) 的多个签名. fn 函数是 Clojure 中的一等公民: 你可以将它们作为参数传递或在本地绑定.

   函数对象 (也称为 lambdas) 在函数式编程中非常普遍, 以至于 Clojure 为它们提供了一种特殊的读取器语法 (读取器宏 #()). 以下示例展示了用 fn 和更短的读取器语法创建的相同函数:

   ((fn [x] (* (Math/random) x)) ; ❶
     (System/currentTimeMillis)) ; ❷
   ;; 1.314465483718698E12
   
   (#(* (Math/random) %) ; ❸
     (System/currentTimeMillis))
   ;; 1.2215726280027874E12
   

   ❶ fn 用于声明一个单参数的匿名函数.

   ❷ 创建的函数立即可供调用, 并需要一个参数. 在这种情况下, 我们传递当前的毫秒时间, 该时间乘以 0 到 1 之间的一个随机数. 结果, 它返回过去的一个随机瞬间 (但在 1970 年 1 月 1 日之后, 即纪元时间的开始 ²⁰).

   ❸ 相同的函数使用 #() 函数字面量语法表示. 函数内部的百分号 (%) 是所需参数的占位符 (替换了前一个示例中的 "x"). 如果函数字面量接受多个参数, 也可以使用带编号的参数: %1, %2 等. 还有一个可变参数的 catch-all 版本 %&, 意思是" 在此处使用函数字面量的所有参数" .

   1. 约定
      

      与标准库中的其他一些函数和宏一样, fn 有一个相当复杂的签名, 类似于一个小型语法. 以下非正式约定展示了 fn 的最重要特性 (请检查下面的示例以明确它们的工作方式).

      (fn <name>? arities)
      
      arities :=> ^<metamap>? [arity] body
                 OR
                 (^<metamap>? [arity1] body)
                 (^<metamap>? [arity2] body) ..
                 (^<metamap>? [arityN] body)
      
      arity :=> [<arg1-typehint>? <arg1> .. <argN-typehint>? <argN>]
      
      body :=> <metamap>? <forms>
      

      • "<name>?" 是一个可选的符号, 它将生成的函数绑定到函数本身的局部作用域. 该名称允许函数是递归的 (参见下面的示例).
      • "arities" 是一个或多个元数声明的列表 (例如, 函数 (fn ([] "a") ([x] "x")) 包含两个元数, 分别是零个和一个参数). 每个元数允许一个可选的以 "^" 为前缀的元数据 map, 后面跟着一个强制性的参数向量和一个可选的函数体. 在单参数的情况下, 外围的括号可以省略. 每个向量的内容可以是纯符号或更复杂的解构表达式.
      • "^<metamap>" 是一个可选的关键字-值对的 map. 它可能包含类型提示或自定义元数据. 当它出现在参数向量之前时, 该 map 需要使用前缀 "^". 当 "<metamap>" 出现在参数向量之后时, 它不需要前缀.
      • "arity" 是参数向量的内容. 除了名称, 每个参数都可以单独进行类型提示.
      • <body>, 当存在时, 包含实际的函数表达式. 它被隐式地包裹在一个 do 块中. 当没有函数体时, 假定为 nil. 当函数体包含一个顶层 map 并且后面跟着一个表达式时, 那么该 map 将被用作元数据. 当 "<metamap>" 同时出现在参数向量之前和之后时, 如果键发生冲突, 后面的那个优先.
      • 返回: 刚创建的函数对象.
   2. 示例
      

      fn 是所有声明函数和宏的最小公分母. 例如, 在用 defn 声明的函数中为参数给出的类型提示是由 fn 在底层处理的. 尽管在 fn 中实现, 类型提示或前置和后置条件通常出现在 defn 声明中. 对于本节中未出现的内容, 邀请读者也查看 defn 的示例.

      1. 命名递归
         

         第一个例子演示了可选名称的一种可能用法, 它使函数在最内层作用域内被绑定. 例如, 它可以用于基本斐波那契数列 ²¹ 的递归定义中:

         ((fn fibo [n] ; ❶
            (if (< n 2)
              n
              (+ (fibo (- n 1)) (fibo (- n 2)))))
          10)
         ;; 55
         

         ❶ 一个查找第 n 个斐波那契数的函数实现.

         通过增加一个带有 3 个参数的元数, 我们现在可以提供一个尾调用优化的斐波那契函数, 而无需改变之前的定义:

         ((fn fibo ; ❶
            ([n] (fibo 1 0 n))
            ([a b cnt]
             (if (zero? cnt)
               b
               (recur (+ a b) a (dec cnt)))))
          10)
         ;; 55
         

         ❶ 一个包含两个" 元数" 的 fn 命名 lambda 声明的示例.

      2. fn 和解构
         

         函数字面量语法 #() 在 Clojure 中非常惯用, 但在某些情况下, 它提供的功能不足: 例如, 函数字面量语法不支持解构. 以下示例展示了一个 map 通过应用键和值的混合更改来转换为另一个 map. 我们没有使用简洁但功能有限的 #() 读取器字面量, 而是用 fn 显式地定义了 lambda 并引入了解构:

         (def sample-person
           {:person_id 1234567
            :person_name "John Doe"
            :image {:url "http://focus.on/me.jpg"
                    :preview "http://corporate.com/me.png"}
            :person_short_name "John"})
         
         (def cleanup ; ❶
           {:person_id [:id str]
            :person_name [:name (memfn toLowerCase)]
            :image [:avatar :url]})
         
         (defn transform [orig mapping]
           (apply merge
                  (map (fn [[k [k' f]]] {k' (f (k orig))}) ; ❷
                       mapping)))
         
         (transform sample-person cleanup)
         ;; {:id "1234567", :name "john doe", :avatar "http://focus.on/me.jpg"}
         

         ❶ cleanup 是输入键名和向量对之间的映射. 该对包含输出 map 中键的新名称和用于转换值的函数. 例如, 第一个键表示 :person_id 应重命名为 :id, 并且应将 str 函数应用于该值.

         ❷ transform 函数接受一个输入 map orig 和映射规则作为参数 (sample-person 和 cleanup 是示例中使用的实例). 这里使用 map 函数来应用所有的转换规则. 通过使用 fn, 我们可以解构 cleanup 的内容, 如果我们使用特殊的读取器形式 #(), 这将是不可能的.

         如果不使用解构, fn lambda 会被 first 或 second 的调用污染, 以访问向量元素, 如下面的 transform 函数重写所示:

         (defn transform [orig mapping] ; ❶
           (apply merge
                  ;; prefer destructuring instead of this
                  (map (fn [rules]
                         (let [k (first rules)
                               k' (first (second rules))
                               f (second (second rules))]
                           {k' (f (k orig))}))
                       mapping)))
         

         ❶ 重写 transform 函数, 以说明在不使用解构时需要多少次 first 和 second 的重复.

      3. fn 是 Clojure 的函数式 lambda
         

         函数式语言通常具有两个主要特点:

         • 它们支持高阶函数
         • 它们倾向于引用透明 ²²

         高阶函数是可以接受其他函数作为参数或向其调用者返回函数的函数. 一种语言需要支持函数作为语言中的一等公民对象, 这样它们就可以作为" 数据" 传递给其他函数. 创建函数对象的方式因语言而异, 但历史上它们一直被称为 lambdas (源自 Lambda 演算, 这是 Alonzo Church 在 1930 年左右引入的第一个广泛采用的数学函数形式化表示法 ²³). 一些语言甚至使用 lambda 作为关键字来强调这种联系. Clojure 没有 lambda 关键字, 但 fn 无疑是 Clojure 的 lambda 实现.

         引用透明保证了函数的返回值仅依赖于其参数, 而不依赖于其他任何东西. 强制执行引用透明的函数式语言, 通常会因此获得许多其他特性: 惰性, 不可变值, 无限序列等等. Clojure 无疑是支持以上所有功能的主流函数式语言之一.

   3. 另请参阅
      

      fn* 是 fn 的一个轻微变体, 它在首次调用后还执行" 局部变量清理" . 有关更多信息, 请参阅 fn* 的文档.

      defn 显然与 fn 相关. 主要区别在于, defn 旨在通过 var 对象将函数对象" 绑定" 到封闭的命名空间. 每当有被其他函数重用的机会时, 你可能应该考虑将 fn 定义重构为 defn.

      identity 是一个返回一个参数的匿名函数的示例函数.

   4. 性能考虑和实现细节
      

      与 defn 类似, fn 的处理主要在编译时发生, 因此在运行时性能方面通常不是一个问题. 与 defn 不同, fn 不会产生副作用, 即不会创建一个 var 定义, 然后将其添加到当前命名空间的映射中.

3. 2.1.3 fn*
   

   (感谢 Nicola Mometto 贡献本节)

   自 1.0 版本以来的特殊形式

   Listing 3: → 匿名函数定义, 优化, 局部变量清理

   (fn* [& fdecl]) ; ❶
   

   ❶ 在声明新函数时, 请参考 defn 以获取支持功能的扩展版本.

   fn* 是 fn 宏底层的特殊形式. 它支持的功能较少, 例如缺少对前置和后置条件 (或解构) 的支持. fn* 的主要目标是内存优化. fn* 独家支持创建具有仅运行一次保证的闭包对象.

   由 fn 创建的普通 lambda 可以在多个地方引用 (这在大型应用程序中通常是这种情况) 并根据需要重用. Clojure 编译器无法跟踪对 lambda 的所有引用, 因此在一次执行后, lambda (及其在相关生成的 Java 类中的内部状态) 需要为潜在的新执行保留下来. 但是有一类 lambda, 我们事先知道它们只会运行一次: 例如, delay 或 future 宏, 它们在外部线程中运行.

   这些线程通常保留在线程池中, 与它们一起的还有它们运行的函数对象. 函数对象反过来可能持有一个对任意大数据的引用, 即使函数已经返回了它的结果. fn* 确保函数持有的引用在结果返回后被设置为 nil. 当编写委托给包装函数的宏时, 这也是一个重要的特性, 这是一种相当常见的惯用模式, 以避免内存保留时间超过实际需要.

   1. 约定
      

      参考 fn 的约定, 请记住仅有的两个区别:

      • 它不支持 fn 接受的各种元数据 map.
      • 它将为 fn* 符号具有 ^:once 元数据的形式赋予特殊的编译时含义, (而 fn 不支持此功能).
   2. 示例
      

      我们将只展示 fn* 独有的" 仅一次" 功能, 对于所有其他示例和用法, 请参考 fn 并避免直接使用 fn*.

      通过将未求值的函数体包装在匿名函数中, 将宏的实现委托给它们的函数版本, 是一种常见的模式, 也是一种良好的实践 ²⁴. 这有几个优点:

      • 它使得理解宏的实现更容易
      • 通过提供函数版本, 它提高了其可组合性和功能, 因为它使得该功能不仅可用于编译时特性, 也可用于运行时使用.

      这个确切的模式在 clojure.core 本身中出现过几次: future 是一个宏, 它使用刚才描述的相同技术委托给 future-call 函数:

      (defmacro future [& body] ; ❶
        `(future-call (^{:once true} fn* [] ~@body))) ; ❷
      

      ❶ future 宏的定义, 如 clojure.core 命名空间中所示.

      ❷ 注意在调用 fn* 之前使用了 :once true 元数据键.

      future 将在稍后的某个时间点在单独的线程中执行函数体. 关于 future 设计的另一个重要方面是, 函数体旨在仅执行一次 (也就是说, 该线程应该运行一次并且永不重新调度). 因此, 作为像 future 这样的宏的作者, 我们已经知道函数使用的资源, 一旦执行, 就可以被 JVM 回收. 我们基本上有能力告诉 Clojure 编译器, 一旦函数体执行完毕, 编译代码中对 lambda 的每个引用都可以设置为 null, 从而允许 JVM 尽快回收资源. 这是 Clojure 编译器完成的一项重要的内存优化, 称为" 局部变量清理" ²⁵.

      通过简单地将 fn 替换为 ^:once fn* (从而向编译器承诺函数体将永远不会被执行超过一次), 编译器现在能够执行局部变量清理优化, 并避免潜在的内存泄漏 ²⁶.

      邀请读者回顾 future-call, 书中探讨了一个显示局部变量清理效果的示例.

   3. 另请参阅
      

      fn 是应该总是优先于 fn* 使用的宏, 除非你需要 ^:once 特性.

      future 将一个表达式包装在一个无参数的 fn* 函数中, 具有仅一次的语义.

   4. 性能考虑和实现细节
      

      与 defn 或 fn 类似, fn* 在运行时影响很小, 因为函数的实际生成发生在编译时. 因此, 当寻找性能改进时, 用户不应关心 fn*.

      fn* 是一种特殊形式, 这意味着它的实现是编译器执行时的" 既定事实" . 特别对于 Clojure 而言, 这意味着 fn* 的实现仅以 Java 代码存在.

2.1.2. 2.2 高阶函数

1. 2.2.1 fnil
   

   自 1.2 版本以来的函数

   Listing 4: -> 函数生成, 参数处理, 默认参数值

   (fnil ([f default1]) ([f default1 default2]) ([f default1 default2 default3]))
   

   fnil 从另一个输入函数 "f" 开始生成一个新函数. fnil 的主要用例是装饰 "f", 以便在输入为 nil 的情况下它可以默认为可选值. fnil 按位置操作: "default1" 将用于作为第一个参数传递的 nil, "default2" 用于作为第二个参数传递的 nil, "default3" 用于作为第三个参数传递的 nil. fnil 不支持超过 3 个默认值, 因此 (fnil + 1 2 3 4) 会导致抛出异常.

   1. 约定
      
      • "f" 可以是任意数量参数的函数, 返回任意类型.
      • "default1,default2,default3" 是当生成的函数分别接收到 nil 作为其第一, 第二或第三个参数时应使用的默认值.
   2. 示例
      

      fnil 的主要用例是包装一个现有的函数, 该函数不按我们期望的方式处理 nil 参数 (例如, 它甚至可能抛出异常). fnil 将 nil 输入替换为给定的默认值, 并且该默认值又被传递给原始函数.

      在存在 nil 的情况下, inc (递增数字的简单函数) 是一个异常行为的例子. 如果我们出于任何原因给 inc 输入 nil, 我们可以使用 fnil 来定义一个替代行为. 在下面的例子中, 我们想用 update ²⁷ 来更新 map 中的数值:

      (update {:a 1 :b 2} :c inc) ; ❶
      ;; NullPointerException
      
      (update {:a 1 :b 2} :c (fnil inc 0)) ; ❷
      ;; {:a 1 :b 2 :c 1}
      

      ❶ 我们尝试更新 map 中的 ":c" 键, 但事先不知道内容是什么, 我们不知道 map 是否包含该键. 如果输入是 nil, inc 会严重失败, 这就是这种情况.

      ❷ 我们可以使用 fnil 来包装 inc 的 nil 参数情况. 如果 inc 得到一个 nil, fnil 会将 nil 替换为 0, 然后将 0 传递给 inc.

      一个典型的不可预测值 (特别是对于 web 应用程序) 是来自输入表单的字符串. 在这种情况下, fnil 会很方便. 在这个例子中, 一个输入表单被转换为 request-params map:

      (require '[clojure.string :refer [split]])
      
      (def request-params ; ❶
        {:name "Jack"
         :selection nil})
      
      (defn as-nums [selection] ; ❷
        (let [nums (split selection #",")]
          (map #(Integer/valueOf %) nums)))
      
      (as-nums (:selection request-params)) ; ❸
      ;; NullPointerException
      

      ❶ request-params 模拟了一个已经转换为 Clojure 数据结构的 web 表单的内容. 一些参数是结构化的, 比如 ":selection", 它是一个逗号分隔的字符串.

      ❷ as-nums 被设计为接收 ":selection" 参数, 将其分割成一个字符串列表, 并将这些字符串转换为数字.

      ❸ 不幸的是, 网页上的用户没有按预期填写 ":selection" (或者发生了其他错误), 导致了一个 nil 的选择.

      :selection 键通常是一个逗号分隔的数字列表, 但如果用户没有填写相关的输入字段, 它可能会导致一个 nil. 在 nil 选择的情况下, as-nums 会抛出异常, 因为它在 null 字符串上调用了 split. 我们可以用 fnil 包装 as-nums 来解决这个问题:

      (def as-nums+ (fnil as-nums "0,1,2")) ; ❶
      
      (as-nums+ (:selection request-params)) ; ❷
      ;; (0 1 2)
      

      ❶ fnil 现在包装了 as-nums. 默认的 ":selection" 是 0,1,2.

      ❷ 现在使用 as-nums+ 而不是旧的函数, 正确地处理了 nil 的 ":selection" 键.

      新函数 as-nums+ 通过将 nil (从参数中检索 :selection 键的结果) 替换为字符串 "0,1,2" 来处理这种情况 (对于这个特定的例子, 我们假设 "0,1,2" 等同于" 无选择" ). 一旦定义, 新的 as-nums+ 可以安全地替换任何旧的, 会抛出异常的普通 as-nums 的用法. fnil 也可以类似地对第 2 和第 3 个参数进行操作, 例如:

      (require '[clojure.string :as string])
      
      (def greetings
        (fnil string/replace "Nothing to replace" "Morning" "Evening"))
      
      (greetings "Good Morning!" "Morning" "Evening") ; ❶
      ;; "Good Evening!"
      
      (greetings nil "Morning" "Evening")
      ;; "Nothing to replace"
      
      (greetings "Good Morning!" nil "Evening")
      ;; "Good Evening!"
      
      (greetings "Good Morning!" "Morning" nil)
      ;; "Good Evening!"
      

      ❶ 该示例展示了 fnil 处理 replace 的 nil 参数和 3 个可能抛出异常的 nil 调用.

      1. 超越第 3 个参数: 一个扩展的 fnil
         

         fnil 最多可以处理给定输入函数的 3 个位置默认值. 将 fnil 扩展到可以处理任意数量的默认选项相对容易:

         (defn fnil+ [f & defaults]
           (fn [& args] ; ❶
             (apply f
                    (map (fn [value default] ; ❷
                           (if (nil? value)
                             default
                             value))
                         args
                         (concat defaults (repeat nil))))))
         
         (+ 1 2 nil 4 5 nil) ; ❸
         ;; NullPointerException
         
         (def zero-defaulting-sum ; ❹
           (apply fnil+ + (repeat 0)))
         
         (zero-defaulting-sum 1 2 nil 4 5 nil)
         ;; 12
         

         ❶ fnil+ 返回一个接受任意数量参数的函数.

         ❷ map 可以接受 2 个或更多个序列参数. 我们利用这个特性来组合实际参数和可能的默认值.

         ❸ 如果我们尝试将 nil 作为 5 个数字之和的一部分传递, 它会抛出错误.

         ❹ 假设当一个数字为 nil 时 "0" 是一个好的默认值, 我们可以使用 apply 和 repeat 来增强 + 以接受任意位置的 nil 参数.

         新函数 fnil+ 接受任意位置的 nil 默认值. map 可以遍历任意数量的序列集合, 这在许多情况下非常方便. 第一个序列 "args" 是函数的实际参数列表. 传递给 map 的第二个序列是传递给 fnil 的给定 "defaults" 和任意数量的额外 nil 参数的串联, 以便遍历 "args".

         我们还利用 map 的惰性来覆盖潜在的无限数量的默认参数, 如 zero-defaulting-sum 所示. 由 (repeat 0) 创建的无限零序列覆盖了 + 的所有 (潜在无限) 参数的 nil 值.

         对于这种 map 的用法, 需要考虑的另一个重要方面是, 当到达最短序列的末尾时, 它会自动停止映射. 这仅仅用 3 行代码就展示了 Clojure 中可用的大部分功能的一个很好的例子. ²⁸

   3. 另请参阅
      

      some-> 可以用来达到与 fnil 类似的效果. 例如, 考虑 (some-> nil clojure.string/upper-case): 这个形式正确地返回了 nil 而没有抛出异常. 如果你需要阻止一个单参数的函数抛出异常, some-> 可能是一个更好的选择. 然而, some-> 的默认值是固定的, 不能更改 (它总是返回 nil).

   4. 性能考虑和实现细节
      

      → O(1) 函数生成

      → O(1) 生成的函数

      fnil 的使用没有相关的性能影响. 输出函数是在常数时间内产生的. 调用生成的函数也是常数时间, 考虑到它受限于它可以处理的参数数量 (仅 3 个).

2. 2.2.2 comp
   
   Listing 5: → 函数生成, 函数组合, 变换器

   (comp ([]) ([f]) ([f g]) ([f g & fs]))
   

   comp 接受零个或多个函数并返回另一个函数. 这个新函数是输入的组合. 例如, 给定函数 f1, f2, f3, comp 创建一个新函数, 使得: ((comp f1 f2 f3) x) 等同于 (f1 (f2 (f3 x))). 这种等价性是 comp 看起来是反向读取的原因, 例如:

   ((comp inc +) 2 2) ; ❶
   ;; 5
   

   ❶ + 和 inc 之间函数组合的一个简单例子.

   在上面的例子中, + 出现在参数列表的最后, 但却是第一个应用的.

   注意

   当没有参数调用时, comp 返回恒等函数. 这在要组合的函数列表是在运行时动态生成且可能为空的情况下很有帮助. comp 会欣然接受一个空的参数列表, 而不是处理错误情况.

   1. 约定
      
      1. 输入
         

         除了最右边的函数 (可以接受任意数量的参数) 外, 所有其他参数函数都必须接受一个参数. 例如, 在 (comp f g h) 的情况下, "h" 是唯一可以接受多个参数的函数, 而 "f & g" 接收一个参数.

      2. 值得注意的异常
         

         当任何输入函数 (除了最后一个) 不支持单参数调用时, 抛出 IllegalArgumentException.

      3. 输出
         

         comp 返回一个函数, 该函数的参数数量与最右边的输入参数相同, 代表所有输入函数的函数式组合.

   2. 示例
      

      函数串联是 comp 的主要用例. 考虑以下例子, 我们要计算需要购买多少邮票来寄送不同目的地的信件:

      (require '[clojure.string :refer [split-lines]])
      
      (def mailing ; ❶
        [{:name "Mark", :label "12 High St\nAnchorage\n99501"}
         {:name "John", :label "1 Low ln\nWales\n99783"}
         {:name "Jack", :label "4 The Plaza\nAntioch\n43793"}
         {:name "Mike", :label "30 Garden pl\nDallas\n75395"}
         {:name "Anna", :label "1 Blind Alley\nDallas\n75395"}])
      
      (defn postcodes [mailing] ; ❷
        (map #(last (split-lines (:label %))) mailing))
      
      (postcodes mailing)
      ;; ("99501" "99783" "43793" "75395" "75395")
      
      (frequencies (postcodes mailing)) ; ❸
      ;; {"99501" 1, "99783" 1, "43793" 1, "75395" 2}
      

      ❶ 输入是 map 组成的向量形式, 这是一种传输结构相似但值不同的数据的常用格式.

      ❷ 函数 postcodes 在解析 :label 值的内容后, 返回一个 (可能重复的) 邮政编码列表. 请注意, 函数体包含 4 个对其他函数的嵌套调用 (map, last, split-lines 和用作函数的键 ":label").

      ❸ 我们可以使用 frequencies 来计算每个邮政编码的出现次数.

      函数 postcodes 包含一个映射函数, 该函数对每个邮件项应用 3 个转换. 我们可以使用 comp 通过组合来构建相同的表达式 ²⁹:

      (defn postcodes [mailing] ; ❶
        (map (comp last split-lines :label) mailing))
      
      (frequencies (postcodes mailing)) ; ❷
      ;; {"99501" 1, "99783" 1, "43793" 1, "75395" 2}
      

      ❶ 我们用 comp 重写了 postcodes.

      ❷ 更改后, 我们确保结果与之前相同.

      通过使用 comp, 我们增加了对转换序列的强调. 这是移除括号的效果, 这反过来又允许自然的垂直对齐. 请注意, 在这种情况下使用 comp 是可能的, 因为所有函数都接受 1 个参数.

      comp 也是组合变换器的主要结构. 这里是之前看到的同样用变换器编写的 postcodes:

      (defn postcodes [mailing] ; ❶
        (sequence (comp ; ❷
                    (map :label)
                    (map split-lines)
                    (map last))
                  mailing))
      
      (frequencies (postcodes mailing)) ; ❸
      ;; {"99501" 1, "99783" 1, "43793" 1, "75395" 2}
      

      ❶ 我们重写了 postcodes 以使用变换器.

      ❷ map 现在用于生成变换器, 我们需要使用 sequence 来应用它们.

      ❸ 结果仍然与前一个例子相同.

      请注意, 与之前使用 map 而不是 sequence 的 postcodes 版本相比, 变换函数的顺序是相反的. 这是变换器实现方式的影响, 但结果是相同的.

      在下面的例子中, 我们在转换中增加了一个步骤, 以从邮政编码列表中移除阿拉斯加, 并在最终输出中防止重复. 请注意, 由于组合, 我们可以使用更吸引人的垂直对齐方式来添加转换:

      (require '[clojure.string :refer [starts-with? split-lines]])
      
      (defn alaska? [postcode]
        (starts-with? postcode "99"))
      
      (defn unique-postcodes [mailing]
        (sequence (comp
                    (map :label)
                    (map split-lines)
                    (map last)
                    (remove alaska?) ; ❶
                    (distinct))
                  mailing))
      
      (unique-postcodes mailing)
      ;; ("43793" "75395")
      

      ❶ 新的 unique-postcodes 函数从列表中移除了阿拉斯加并移除了重复项.

   3. 另请参阅
      

      juxt 是另一个函数生成器. 它不像 comp 那样组合函数, 而是独立地执行它们并收集结果. 当输入函数在输入上独立操作时, 使用 juxt.

      sequence 接受变换器的组合, 如示例所示.

      transduce 是另一个经常与 comp 一起出现的变换函数.

   4. 性能考虑和实现细节
      

      → O(1) 函数生成

      调用 comp 在常数时间内生成一个新函数, 对性能分析几乎没有兴趣.

3. 2.2.3 complement
   

   自 1.0 版本以来的函数

   Listing 6: → 布尔逻辑, 函数生成

   (complement [f])
   

   complement 是一个简单的函数包装器. 它接受一个输入函数 f 并输出另一个函数. 新创建的函数接受任意数量的参数, 并调用包装的函数 f, 用 not 对其输出取反:

   ((complement true?) (integer? 1)) ; ❶
   ;; false
   

   ❶ 使用 complement 来反转检查一个值是否为整数的含义的一个简单例子.

   1. 约定
      
      1. 输入
         
         • "f" 是一个接受任意数量参数并返回任意类型的函数.
      2. 输出
         
         • 返回: 一个接受任意数量参数并返回布尔值 true 或 false 的函数.
   2. 示例
      

      complement 利用了 Clojure 中所有东西都有扩展布尔含义的特点, 并且总是返回 true 或 false:

      ((complement {:a 1 :b 2}) :c) ; ❶
      ;; true
      
      ((complement {:a 1 :b nil}) :b) ; ❷
      ;; true
      

      ❶ 这个例子展示了如何反转验证 map 中是否存在某个键的含义. 如果 :c 不在 map 中, 它返回 true.

      ❷ 然而, 在存在 nil 值的情况下, 我们应该小心使用 complement. 在第二种情况下, :b 在 map 中, 但它的值为 nil.

      如上例所示, 在存在 nil 的情况下应谨慎使用 complement. 然而, 如果 nil 的存在是可控的, 我们可以以一种非常简洁的方式检查一个项是否不属于一个集合:

      (filter (complement #{:a :b :c}) [:d 2 :a 4 5 :c]) ; ❶
      ;; (:d 2 4 5)
      
      (filter (complement #{nil :a 2}) [:a 2 nil nil]) ; ❷
      ;; (nil nil)
      

      ❶ 一种过滤所有不匹配一组值的所有项的简洁方法.

      ❷ 这种方法假设被补充的集合不包含 nil 作为要移除的值之一. 在这种情况下, 它将无法从输入中移除 nil.

      complement 提供了从否定函数中提取函数的能力. 我们无法用 not 做同样的事情, 因为它是一个布尔运算符. 例如, 这里有一种用彼此来表达典型对立面如" 左" 和" 右" 的方法:

      (defn turning-left? [wheel]
        (= :left (:turn wheel)))
      
      (def turning-right? (complement turning-left?)) ; ❶
      
      (defn turn-left [wheel]
        (if (turning-left? wheel)
          (println "already turning left")
          (println "turning left")))
      
      (defn turn-right [wheel]
        (if (turning-right? wheel) ; ❷
          (println "already turning right")
          (println "turning right")))
      

      ❶ 我们使用 complement 来定义 turning-right?. 注意我们不能用 not 来否定一个函数, 因为 not 只接受布尔输入.

      ❷ 我们也可以写成: (if-not (turning-left? wheel)), 代价是在语句中有一个否定.

      调用 (turning-right? wheel) 和 (not (turning-left? wheel)) 的结果是相同的, 但 not 的存在产生了一种稍微不那么可读的形式. 当用已有的名称建模相反的概念时 (例如左和右, 上和下, 北和南等等), 这一点尤其明显. Clojure 本身就包含这样一个例子. 这里是 remove 的定义:

      (defn remove [pred coll] ; ❶
        (filter (complement pred) coll))
      

      ❶ 从标准库中出现的 remove 的实现中移除了一些实现细节.

   3. 另请参阅
      

      not 不产生函数, 只是反转其参数的布尔含义.

   4. 性能考虑和实现细节
      

      → O(1) 函数生成

      complement 在性能分析中不是特别有趣: 它在常数时间内生成所请求的函数. 生成的函数在被调用时, 使用 apply 应用其参数 (最多 20 个).

4. 2.2.4 constantly
   

   自 1.0 版本以来的函数

   Listing 7: → 函数生成, 扩展布尔逻辑

   (constantly [x])
   

   constantly 生成一个函数, 该函数无论以何种数量和类型的参数调用, 都始终返回相同的结果. 输出函数总是返回初始参数作为唯一答案.

   1. 约定
      
      1. 输入
         
         • "x" 是一个任何类型的强制性参数, 用作生成的函数返回的结果.
      2. 输出
         
         • 返回: 一个新的函数, 接受 0 个或多个任何类型的参数.
   2. 示例
      

      constantly 可以用于所有需要更新函数的情况, 但新值不依赖于旧值. 例如, update 接受一个 map, 一个键和一个函数. 该函数接收该键的旧值, 并期望使用该值来计算新值.

      以下示例实现了一个 quantize-volume 函数, 用于计算一组音符的平均音量. 声音的表现力由 :volume 和 :expr 键共同表示:

      (def notes
        [{:name "f" :volume 60 :duration 118 :expr ">"}
         {:name "f" :volume 63 :duration 120 :expr "<"}
         {:name "a" :volume 64 :duration 123 :expr "-"}])
      
      (defn- expressiveness [average exp]
        (case exp
          ">" (+ average 5)
          "<" (- average 5)
          average))
      
      (defn- process-note [note fns] ; ❶
        (letfn [(update-note [note [k f]]
                  (update note k f))] ; ❷
          (reduce update-note note fns))) ; ❸
      
      (defn quantize-volume [notes] ; ❹
        (let [avg (quot (reduce + (map :volume notes)) (count notes))
              fns {:volume (constantly avg) ; ❺
                   :expr (partial expressiveness avg)}] ; ❻
          (map #(process-note % fns) notes)))
      
      (quantize-volume notes) ; ❼
      ;; ({:name "f", :volume 62, :duration 118, :expr 67}
      ;;  {:name "f", :volume 62, :duration 120, :expr 57}
      ;;  {:name "a", :volume 62, :duration 123, :expr 62})
      

      ❶ process-note 接受一个音符和一个函数 map. Clojure map 支持顺序访问, 可以用作 reduce 的输入.

      ❷ update-note 用 letfn 在本地绑定. 它定义了下一行中 reduce 使用的 reducing 函数. 除了解构第二个参数外, 它还用给定的键和函数对音符应用 update.

      ❸ process-note 多次应用 update (每次都用一个作为参数传入的更新函数, 位于 "fns" map 中). 由于 Clojure hash-map 是持久化数据结构, 我们需要确保每个函数产生的更新后的音符是下一个更新函数的输入. reduce 实现了我们正在寻找的更新语义, 确保每个中间步骤都作为输入传递给下一个步骤. 我们对 reduce 的" 初始值" 变成了" 音符" , 我们从那里开始更新链.

      ❹ quantize-volume 的主要目标是为 update 准备输入函数, 并将它们应用于所有音符.

      ❺ 每个音符都有一个 :volume 键, 我们希望所有音量都是平均值. constantly 在这里是一个很好的选择: 我们需要所有音符都使用相同的" 平均" 值, 以及一个返回该值的函数包装器.

      ❻ :expr 键需要旧值来确定新值, 所以我们传入一个从旧表现力到新表现力的函数.

      ❼ 当我们最终处理音符时, 我们可以看到 map 按预期更新, :volume 更新为平均值, :expr 更新为相对于音量高于或低于平均值的关系.

      constantly 的另一个用途是在测试中" 打桩" 函数调用. 一个好的测试设置会将待测函数与不太可预测的行为 (如网络请求) 隔离开来, 提供打桩的响应. 打桩的响应也用于控制待测函数的特定方面, 以便可以验证其行为. with-redefs 经常与 constantly 结合使用:

      (ns book.unit
        (:require [clojure.test :refer [deftest testing is]]))
      
      (defn- third-party-service [url p1 p2] ; ❶
        "Simulation of expensive call"
        (Thread/sleep 1000)
        {:a "a" :b "b"})
      
      (defn fn-depending-on-service [s] ; ❷
        (let [result (third-party-service "url" "p1" "p2")]
          (if (= "b" (:b result))
            (str s "1")
            (str s "2"))))
      
      (deftest test-logic
        (with-redefs [third-party-service (constantly {:b "x"})] ; ❸
          (testing "should concatenate 2"
            (is (= "s2" (fn-depending-on-service "s"))))))
      

      ❶ third-party-service 是一个模拟对我们无法控制的服务进行昂贵调用的函数. 它需要 3 个参数.

      ❷ fn-depending-on-service 是一个依赖于第三方服务调用的函数.

      ❸ 单元测试用 with-redefs 创建了一个本地的重定义绑定, 将第三方调用替换为一个打桩的版本. 由于我们对传递给函数的参数不感兴趣, 我们可以使用 constantly 来打桩返回值.

      开启直接链接后, with-redefs 将停止工作. with-redefs 依赖于 var 的间接性来临时交换函数实现. 当 Clojure 编译时开启直接链接, var 的内容会被直接内联, 无法更改.

      1. 静态类型语言中的多变函数
         

         像 constantly 这样的高阶函数在动态语言中很容易实现, 并且非常惯用. 在静态类型语言中也可以做到同样的事情, 但会更棘手. 复杂程度因语言而异. 例如, Hindley-Milner 语言家族 (ML 及其后代, 如 Haskell 或 OCaml) 支持" 多变" 函数, 但需要一些努力才能使类型正确 (例如, 见这篇论文). 考虑到它们的类型复杂性, " 多变" 函数在像 Haskell 这样的静态类型语言中并不常用, 但像模式匹配这样同样强大的替代方案却很常用.

   3. 另请参阅
      

      identity 也返回作为参数传入的参数. 但 identity 不返回函数, 仅返回其自身的值. identity 经常用于与 constantly 类似的目标, 唯一的限制是 identity 只接受一个参数而不是多个.

      with-redefs 在测试时经常与 constantly 结合使用以生成打桩的响应.

   4. 性能考虑和实现细节
      

      → O(1) 函数生成

      → O(1) 生成的函数

      constantly 只是在每次调用时返回相同的结果. 函数生成和使用生成的函数都是常数时间操作.

5. 2.2.5 identity
   

   自 1.0 版本以来的函数

   Listing 8: → 实用函数, 高阶函数

   (identity [x])
   

   identity 是标准库中的一个小函数. 它只是将其单个参数作为输出返回:

   (identity 1)
   ;; 1
   

   尽管看起来很简单, 但在许多情况下 identity 都能派上用场 (参见示例部分). identity 的名字来源于等价的数学概念 (也称为恒等变换或关系 ³⁰).

   Listing 9: 约定

   (identity x)
   

   1. 输入
      
      • "x" 是唯一的强制性参数, 可以是任何类型.
   2. 输出
      
      • 返回: 作为输入传入的参数.
6. 示例
   

   第一个例子说明了一种将 map 转换为键值对的扁平序列的惯用方法. 它是一行代码和一个函数调用. 所有其他选项都将包含第二个函数调用:

   (mapcat identity {:a 1 :b 2 :c 3}) ; ❶
   ;; (:a 1 :b 2 :c 3)
   

   ❶ 一种惯用的用法, 使用 mapcat 和 identity 将 map 转换为序列.

   mapcat 同时进行迭代和连接. 由于迭代一个 hash-map 会产生一个包含键值对的向量序列, 我们只需要在将所有向量连接在一起之前进行 identity 变换.

   identity 也可以用作" noop" (无操作的缩写), 在需要函数但又不应产生任何效果时提供一个函数. 一个有用的情况是, 当我们需要从序列中过滤掉所有逻辑假元素时 (任何为 nil 或 false 的元素):

   (defn custom-filter [x] ; ❶
     (if (or (nil? x) (false? x))
       false
       true))
   
   (filter custom-filter [0 1 2 false 3 4 nil 5]) ; ❷
   ;; (0 1 2 3 4 5)
   
   (filter identity [0 1 2 false 3 4 nil 5]) ; ❸
   ;; (0 1 2 3 4 5)
   

   ❶ custom-filter 以一种非常冗长的方式实现了我们想要达到的目标: 我们没有考虑到 Clojure 接受任何值为逻辑真/假的事实, 所以这被认为是不惯用的.

   ❷ 显示 custom-filter 按预期工作, 从序列中过滤掉所有不需要的 nil 和 false.

   ❸ 使用 identity 可以在没有自定义函数的情况下达到相同的结果. 其工作原理是像 false 或 nil 这样的值是 Clojure 逻辑假定义的一部分. filter 使用 nil 或 false 作为标记, 决定哪些项应该或不应该出现在最终结果中. identity 按原样传递值, 所以 filter 可以直接使用它们.

   以下示例展示了如何使用 identity 和 some 从集合中检索下一个逻辑真元素. 超市中的收银员列表通过在其对应索引的向量中添加一个数字来标记为可用. 一旦客户选择了一个通道, 收银员就会变忙, 我们需要更新该索引处的值, 以便没有其他客户可以选择同一个通道. 为避免对收银员队列进行并发读/写, 我们使用 ref, 这是 Clojure 中的一种并发原语. 通过使用 ref, 我们可以在单个事务中检查可用性并预订通道:

   (def cashiers (ref [1 2 3 4 5])) ; ❶
   
   (defn next-available [] ; ❷
     (some identity @cashiers))
   
   (defn make-available! [n] ; ❸
     (alter cashiers assoc (dec n) n)
     n)
   
   (defn make-unavailable! [n]
     (alter cashiers assoc (dec n) false)
     n)
   
   (defn book-lane [] ; ❹
     (dosync
       (if-let [lane (next-available)]
         (make-unavailable! lane)
         (throw (Exception. "All cashiers busy!")))))
   
   (book-lane) ; ❺
   ;; 1
   
   (book-lane)
   ;; 2
   
   (dosync (make-available! 2))
   ;; 2
   @cashiers
   ;; [false 2 3 4 5]
   

   ❶ cashiers 包含一个用数字初始化的向量 (代表空闲的收银通道). 该向量被 ref 包装.

   ❷ next-available 在收银员向量上使用 identity 和 some. 它返回第一个真结果, 或者在到达向量末尾后返回 nil. 注意, next-available 是对 ref 的只读操作, 不需要显式的事务上下文.

   ❸ make-available! 和 make-unavailable! 接受一个数字作为参数, 并在该索引处添加或删除元素. 这有效地将收银员标记为可用或不可用, 因为标记为" 不可用" 会在向量的该索引处添加一个 false, 导致 next-available 继续搜索.

   ❹ book-lane 协调查找下一个可用收银员和预订通道. dosync 需要包装读/写操作才能生效, 因为其他客户可能同时试图使用同一个通道. 如果再没有可用通道, book-lane 会抛出异常.

   ❺ 我们可以通过预订和释放几个通道来快速模拟该系统.

   当我们需要对序列中的连续元素进行分组时, 可以使用 identity 和 partition-by. 以下示例展示了如何搜索单词中的强调部分, 假设重复的字母表示强调:

   (def they-say ; ❶
     [{:user "mark" :sentence "hmmm this cake looks delicious"}
      {:user "john" :sentence "Sunday was warm outside."}
      {:user "steve" :sentence "The movie was sooo cool!"}
      {:user "ella" :sentence "Candies are bad for your health"}])
   
   (defn- enthusiast? [s]
     (> (->> (:sentence s)
             (partition-by identity) ; ❷
             (map count)
             (apply max))
        2))
   
   (defn enthusiatic-people [sentences]
     (->> sentences
          (filter enthusiast?)
          (map :user)))
   
   (enthusiatic-people they-say) ; ❸
   ;; ("mark" "steve")
   

   ❶ they-say 包含句子及其作者的样本.

   ❷ 我们使用 partition-by 和 identity 作为判别函数, 因此字母只有在序列中相同时才会一起出现. 创建组后, 我们可以对它们进行计数, 并查看是否有大于 2 个字母的组.

   ❸ 我们可以看到样本中谁在使用" 丰富多彩" 的语言.

7. 另请参阅
   

   nil? 是一个更好的选项, 可用作 filter 的谓词, 用于处理序列中的 nil 元素. 正如我们在示例中所见, identity 与 filter 一起使用时也会移除 false 元素, 而 nil? 不会:

   (remove nil? [0 1 2 false 3 4 nil 5])
   ;; (0 1 2 false 3 4 5)
   

   constantly 返回一个接受任意数量参数但总是返回相同给定结果的函数. 如果你需要可变数量的参数并返回相同的结果, 请使用 constantly 而不是 identity.

8. 性能考虑和实现细节
   

   => O(1) 函数生成

   identity, 标准库中最简单的函数之一, 在性能分析中不是特别有趣.

(juxt ([f]) ([f g]) ([f g h]) ([f g h & fs]))

((juxt first second last) (range 10)) ; ❶
;; [0 1 9]

(memfn [name & args])

(map (memfn toUpperCase) ["keep" "calm" "and" "drink" "tea"]) ; ❶
;; ("KEEP" "CALM" "AND" "DRINK" "TEA")

(map toUpperCase ["keep" "calm" "and" "drink" "tea"]) ; ❷
;; RuntimeException: Unable to resolve symbol: toUpperCase

(memfn [<tags> name & <args>])

(import '[java.time Instant Duration])

(def instants
  (repeatedly (fn [] ; ❶
                (Thread/sleep (rand-int 100))
                (Instant/now))))

(defn durations [instants & [t0]]
  (let [start (or t0 (Instant/now))]
    (->> instants
         (map #(Duration/between % start)) ; ❷
         (map (memfn toMillis))))) ; ❸

(let [two (doall (take 2 instants))]
  (durations two)) ; ❹
;; (67 0)

(let [t1 (Instant/now) ; ❺
      times (doall (take 2 instants))]
  (Thread/sleep 200)
  (first (durations times t1)))
;; 21144

(macroexpand '(memfn toMillis))
;; (fn* ([target24222] (. target24222 (toMillis)))) ; ❶

(map (memfn indexOf ch) ["abba" "trailer" "dakar"] ["a" "a" "a"])
;; (0 2 1)

(map (memfn indexOf "a") ["abba" "trailer" "dakar"])
;; CompilerException java.lang.Exception: Unsupported binding form: a

(macroexpand '(memfn indexOf "a"))
;; (fn* ([target12358 p__12359]
;;      (clojure.core/let ["a" p__12359]
;;        (. target12358 (indexOf "a"))))) ; ❶

(defmacro memfn [name & args]
  (let [t (with-meta (gensym "target") (meta name))] ; ❶
    `(fn [~t ~@args]
       (. ~t (~name ~@args))))) ; ❷

(set! *warn-on-reflection* true)

(time
  (dotimes [n 100000] ; ❶
    (map (memfn toLowerCase) ["A" "B"])))
;; Reflection warning, form-init41.clj:1:6 call to toLowerCase can't be resolved
;; "Elapsed time: 11.294886 msecs"
;; nil

(time
  (dotimes [n 100000]
    (map (memfn ^String toLowerCase) ["A" "B"]))) ; ❶
;; "Elapsed time: 5.701509 msecs"
;; nil

(partial ([f]) ([f arg1]) ([f arg1 arg2]) ([f arg1 arg2 arg3]) ([f arg1 arg2 arg3 & more]))

(def incrementer (partial + 1)) ; ❶
(incrementer 1 1) ; ❷
;; 3

(every-pred ([p]) ([p1 p2]) ([p1 p2 p3]) ([p1 p2 p3 & ps]))
(some-fn ([p]) ([p1 p2]) ([p1 p2 p3]) ([p1 p2 p3 & ps]))

2.1.3. 2.3 线程宏

1. 2.3.1 ->
   

   自 1.0 版本以来的宏

   Listing 15: → 函数组合, 线程宏, 函数应用

   (-> [x & forms])
   

   -> (也称为线程优先宏或画眉鸟运算符) 可用于组合或分组一系列操作. -> 宏的参数包括一个表达式 (强制) 和一系列形式 (可选).

   其思想是将表达式定位为后续形式的第一个参数. 例如, 以下是求值 (-> {:a 2} :a inc) 时发生的情况的逐步解释. 虽然这并非严格意义上宏的实现方式, 但它是一个很好的思维模型:

   • 关键字 :a 是初始表达式 {:a 2} 后的第一个可选形式. 在内部, 该形式被添加到一个列表中 (除非它已经是). 由于 :a 还不是一个列表, 它被转换为 (:a).
   • 表达式 {:a 2} 被放置为先前创建列表中的第二项, 结果为 (:a {:a 2}). 生成的形式被求值并传递下去. 在这种情况下, (:a { :a 2}) 等于 2, 2 被传递给下一个形式.
   • inc 是形式列表中的下一项. 和以前一样, 它不是一个列表, 所以需要被转换为 (inc).
   • 先前的结果, 2, 然后被放置为前一个列表中的第二项: (inc 2).
   • 我们终于到达了结尾. 最终的形式被求值并返回.

   在宏展开期间, Clojure 编译器将 (-> {:a 2} :a inc) 转换为 (inc (:a {:a 2})). 在求值期间, 该形式求值为数字 3. macroexpand 证实了我们的理论:

   (macroexpand '(-> {:a 2} :a inc))
   ;; (inc (:a {:a 2}))
   

   -> 倾向于提高某类序列操作的可读性, 否则这些操作会反向阅读 (或从内到外). 转换管道 (其中第一个操作的结果需要传递给下一个操作) 通常是使用 -> 进行" 线程化" 的良好候选者.

   1. 约定
      
      1. 输入
         
         • "x" 可以是任何有效的 Clojure 表达式. 将 "x" 记为 "eXpression" 中的 "x" 会很有用, 这就是 → 线程穿过后续 "forms" 的内容.
         • "forms" 是一个可选的参数列表. 如果任何可选的形式还不是一个列表, 它将通过在其上调用 list 来使其成为列表. 每个形式的第一个元素必须是一个可调用的函数 (使得 (ifn? (first form)) 求值为 true).
      2. 值得注意的异常
         
         • 如果在没有参数的情况下调用, 会抛出 ArityException.
         • 如果任何形式不可调用, 则会抛出 ClassCastException, 例如 (→ 1 2 []).
      3. 输出
         

         -> 产生最后一个形式的求值结果, 使用先前求值形式的结果, 遵循上面揭示的线程优先规则. 如果没有提供形式, 它返回第一个参数 "x" 的求值结果.

   2. 示例
      

      -> 对于处理管道特别有用, 其中初始输入在每个步骤中都被转换. 对于 map 处理的常见情况也是如此. 以下示例展示了一种将 HTTP 请求解析为哈希映射的方法:

      (def req
        {:host "http://mysite.com" ; ❶
         :path "/a/123"
         :x "15.1"
         :y "84.2"
         :trace [:received]
         :x-forward-to "AFG45HD32BCC"})
      
      (defn prepare [req] ; ❷
        (update
          (dissoc
            (assoc req
                   :url (str (:host req) (:path req))
                   :coord [(Double/valueOf (:x req))
                           (Double/valueOf (:y req))])
            :x-forward-to :x :y)
          :trace conj :prepared))
      
      (pprint (prepare req)) ; ❸
      ;; {:host "http://mysite.com",
      ;;  :path "/a/123",
      ;;  :trace [:received :prepared]
      ;;  :url "http://mysite.com/a/123",
      ;;  :coord [15.1 84.2]}
      

      ❶ req 是一个示例请求. 某个 web 框架负责将请求转换为 map.

      ❷ prepare 接收请求并 assoc 几个额外的键. 然后它移除不再需要的键, 最后更新 :trace.

      ❸ 我们可以使用 clojure.pprint/pprint 来更好地格式化输出. pprint 在 REPL 中直接可用, 但在其他情况下需要显式 require.

      为了准备上述请求, 我们需要进行几次转换: 将主机和路径连接在一起形成 :url, 从坐标中创建一个向量, 移除坐标和转发头, 最后更新跟踪以包括已完成的准备步骤. 在实际应用中, 请求处理可能是任意长和复杂的. 我们可以利用 -> 来增加转换的可读性:

      (defn prepare [req] ; ❶
        (-> req
            (assoc :url (str (:host req) (:path req))
                   :coord [(Double/valueOf (:x req))
                           (Double/valueOf (:y req))])
            (dissoc :x-forward-to :x :y)
            (update :trace conj :prepared)))
      

      ❶ prepare 函数已被重构以利用 ->.

      在 prepare 函数中引入 -> 创建了一个从上到下的视觉流程, 更易于阅读: req 输入被" 向下传递" 到第一个 assoc 操作, 然后是 dissoc, 最后是 update.

      -> 的另一个有趣用法是与匿名 lambda 形式 #() 结合使用. 当应用于单个参数时, -> 的行为类似于 identity 函数, 因此 (-> 1) 等价于 (identity 1). 为了理解这如何有用, 让我们看一下以下失败的示例:

      (def items [:a :a :b :c :d :d :e])
      
      (map #({:count 1 :item %}) items) ; ❶
      ;; ArityException Wrong number of args (0) passed to: PersistentArrayMap
      

      ❶ 我们希望从 items 中的每个元素创建一个 map, 但这不是正确的方式.

      我们在上述示例中希望实现的是, 从 items 向量中的每个元素创建一个 map, 该 map 包含一个键 :count (其值始终为 1) 和一个键 :item (其值为原始元素). 上述代码的问题在于, 匿名函数 #({:count 1 :item %}) 试图在没有参数的情况下调用该 map. 我们需要对该形式进行宏展开才能看到发生了什么:

      (macroexpand '#({:count 1 :item %})) ; ❶
      ;; (fn* [p1] ({:count 1, :item p1}))
      

      ❶ macroexpand 是一个有用的调试工具, 用于可视化宏转换.

      macroexpand 显示了尝试在没有参数的情况下将数组映射作为函数调用 (这会失败). 现在有几种方法可以解决这个问题. 以下形式都产生预期的结果:

      (map #(hash-map :count 1 :item %) items) ; ❶
      (map #(identity {:count 1 :item %}) items) ; ❷
      (map #(do {:count 1 :item %}) items) ; ❸
      (map #(-> {:count 1 :item %}) items) ; ❹
      

      ❶ 一组 4 种形式, 在相同的项目向量上都产生相同的结果. 第一种使用 hash-map, 这是一种惯用的选择.

      ❷ 我们可以使用 identity 并继续使用带有花括号 {} 的 map 字面量语法, 但对 identity 的需求很难理解.

      ❸ identity 的一个更短的替代方案是 do. 然而, do 的存在通常与副作用相关联, 而这种形式中没有任何副作用. 总的来说, 这个选项和第二个选项一样令人困惑.

      ❹ 最终的形式使用 ->, 简短而切中要点.

      使用 -> 的最后一个选项有效地传达了操作的信息: 它简短易读, 没有引入 identity 或 do 的语义混乱. 使用 hash-map 和 -> 的选项都是惯用的, 但它们产生的结果略有不同:

      (map type (map #(hash-map :count 1 :item %) [1])) ; ❶
      ;; (clojure.lang.PersistentHashMap)
      
      (map type (map #(-> {:count 1 :item %}) [1])) ; ❷
      ;; (clojure.lang.PersistentArrayMap)
      

      ❶ 使用 hash-map 创建 map 会产生 clojure.lang.PersistentHashMap 类型. ❷ 使用带有最少键集的 map 字面量语法 {} 会产生一个 clojue.lang.PersistentArrayMap 类型.

      请参考 array-map 和 hash-map 来理解这种类型差异. 大多数时候, Clojure 会透明地处理从一种 map 类型到另一种 map 类型的转换, 用户无需知道.

      1. 线程宏和 T-组合子
         

         组合逻辑是一种表示法 (如 lambda 演算), 它消除了数学逻辑中对自由变量的需求 ³². 它在编程中引起了关注, 因为组合子在函数组合中可以用来增强表达能力. 特别是 T-组合子, 允许函数应用" 反向" 发生. Clojure 线程运算符产生的效果与 T-组合子类似, 但作为一个宏, 它的应用受到限制:

         (/ (Math/abs (- (* (inc 1) 5) 1)) 3) ; ❶
         (-> 1 ; ❷
             inc
             (* 5)
             (- 1)
             (Math/abs)
             (/ 3))
         

         ❶ 一个写成嵌套函数应用的简单数学表达式

         ❷ 使用 -> 宏垂直书写的相同表达式

         上面示例中的两个表达式返回相同的结果, 但第二个表达式更清楚地揭示了流程. 然而, -> 作为 T-组合子受到限制, 因为它不支持带参数的嵌套函数, 例如:

         (-> 1 (fn [x] (inc x)))
         ;; IllegalArgumentException Parameter declaration 1 should be a vector
         

         以上结果会导致编译错误. 宏展开清楚地显示了问题所在:

         (macroexpand-1 '(-> 1 (fn [x] (inc x))))
         ;; (fn 1 [x] (inc x))
         

         这就是为什么有时 Clojure 中的线程运算符被比作一个受限的 T-组合子 ³³.

   3. 另请参阅
      

      -> 只是 Clojure 提供的几种线程宏之一. 最初只有 ->, 随后在 1.1 中有了 ->>, 并在 Clojure 1.5 版本中有了更大的扩展, 增加了 as->, some->, some->>, cond-> 和 cond->>. 其他相关的线程宏是:

      • ->> 被称为" 线程末尾" 宏, 与 -> 非常相似, 但它将元素放在下一个形式的末尾, 而不是作为第二个元素. 它对于序列处理特别有用, 其中输入序列通常出现在参数列表的最后.
      • "as->" 启用占位符的选择, 明确元素在下一个形式中的位置. 当需要精细控制元素在下一个形式中的位置时, 使用 as->. 这个线程宏的缺点是更冗长, 因为占位符在每个形式中都重复.
      • some-> 负责处理任何初始或中间的 nil 值, 立即停止而不是将其传递给下一个形式. 当一个形式求值为 nil 导致异常时, some-> 很有用.
      • cond-> 启用一个自定义条件来决定处理是否应该继续. 这是唯一允许完全跳过一个步骤的线程宏.
      • get-in 获取任意嵌套的关联数据结构 (如 Clojure map) 的值. 例如: (-> {:a 1 :b {:c "c"}} :b :c) 等价于 (get-in {:a 1 :b {:c "c"}} [:b :c]). 如果你需要访问深度嵌套 map 中的值, 考虑使用 get-in 而不是 ->.
   4. 性能考虑和实现细节
      

      → O(n) n 个形式的数量 (展开时间)

      -> 宏展开与运行时性能分析无关, 因为表达式的成本仅适用于编译. 在编译时, 反转函数参数的应用顺序与形式的数量成线性关系.

2. 2.3.2 ->>
   

   自 1.1 版本以来的宏

   Listing 16: → 函数组合, 线程宏, 函数应用

   (->> [x & forms])
   

   ->> (也称为线程末尾宏) 可用于组合或分组一系列操作, 方法是将第一个表达式定位为后续形式的最后一个参数 (类似于 "->", 它将其放在第一个位置). ->> 倾向于提高某类序列操作的可读性, 否则这些操作会反向阅读 (或从内到外). 转换管道 (其中第一个操作的结果需要传递给下一个操作) 通常是使用 ->> 进行" 线程化" 的良好候选者.

   ->> 宏的参数包括一个表达式 (强制) 和一系列形式 (可选). 其思想是第一个表达式被" 管道化" 通过其他形式, 这些形式有机会在返回最终输出之前在每个步骤中处理该表达式.

   1. 约定
      
      1. 输入
         
         • "x" 是一个强制性表达式. 该表达式被求值并放置在后续形式的最后 (如果有).
         • "forms" 是一个可选的形式列表. 如果任何形式还不是一个列表, 它将被一个列表包装. 每个形式的第一个元素必须是一个可调用对象 (使得 (ifn? (first form)) 为真). 每个求值的形式被放置在后续形式的最后, 然后求值, 直到没有更多的形式.
      2. 值得注意的异常
         
         • 如果在没有参数的情况下调用, 会抛出 ArityException.
         • 如果任何形式不可调用, 则会抛出 ClassCastException. 例如, 在 (->> "a" "b" []) 中, 字符串 "a" 被视为一个函数.
      3. 返回
         
         • 返回: 最后一个形式 (如果有) 的求值结果, 通过将先前求值的形式作为下一个形式的最后一个参数. 如果没有提供形式, 它返回表达式 "x" 的求值结果.
   2. 示例
      

      ->> 非常适合于序列处理管道, 其中初始输入通过每个步骤转换为最终输出. 以下示例展示了我们如何使用 ->> 重写几个 filter 操作的嵌套. 我们想要过滤所有由相同重复数字组成, 能被 3 整除的偶数正数:

      (filter pos? ; ❶
              (filter #(apply = (str %))
                      (filter #(zero? (mod % 3))
                              (filter even? (range 1000)))))
      ;; (6 66 222 444 666 888)
      
      (->> (range 1000) ; ❷
           (filter even?)
           (filter #(zero? (mod % 3)))
           (filter #(apply = (str %)))
           (filter pos?))
      ;; (6 66 222 444 666 888)
      

      ❶ 这组嵌套的过滤器相当容易理解, 但我们仍然需要费力地寻找最内层的形式并向外移动来理解它.

      ❷ ->> 反转了之前的流程, 首先是输入序列, 然后是按实际应用顺序排列的操作集.

      以下示例说明了 ->> 是多么灵活, 例如, 当涉及不同的序列操作时, 就像解析 web 请求的查询字符串一样. 这里是第一个选项, 它嵌套了每个处理步骤, 而没有使用线程末尾宏:

      (require '[clojure.string :refer [split]])
      
      (def sample-query "guidx=123&flip=true")
      
      (defn params [query] ; ❶
        (apply merge ; ❷
               (map #(apply hash-map %) ; ❸
                    (map #(split % #"=") ; ❹
                         (split query #"&"))))) ; ❺
      
      (params sample-query)
      ;; {"guidx" "123", "flip" "true"}
      

      ❶ params 是一个对字符串输入应用一系列转换的函数.

      ❷ 这个 merge 操作是最后执行的, 但它出现在最前面.

      ❸ 在这一步, 我们取每一对分割后的字符串, 并用它们构建一个 map.

      ❹ 这一步在 "=" 符号出现的地方分割每个字符串.

      ❺ 初始的字符串输入按 "&" 符号分割.

      处理参数的函数不易理解, 因为它是反向阅读的. 这里是利用 ->> 的新版 params:

      (defn params [query] ; ❶
        (->> (split query #"&")
             (map #(split % #"="))
             (map #(apply hash-map %))
             (apply merge)))
      

      ❶ 重写 params 函数以利用线程末尾宏.

      新的 params 函数包含与之前完全相同数量的步骤, 只是排列顺序不同. 值得注意的是, 这次相同的操作如何自然地按顺序流动, 所以我们可以从顶部开始阅读第一个操作, 并沿着垂直流程到底部.

   3. 另请参阅
      

      ->> 是最常用和最通用的线程末尾宏之一. 还有其他线程末尾的变体, 它们与处理管道的交互更具体:

      • some->> 是一个 nil 感知的线程末尾宏, 它在求值链中第一次出现 nil 时停止处理.
      • cond->> 允许在每个步骤中都有一个条件来决定是否继续. 这个版本的线程末尾宏允许完全跳过一个或多个步骤.
   4. 性能考虑和实现细节
      

      → O(n) n 个形式的数量 (宏展开)

      在使用 ->> 宏之前, 没有特别的性能考虑. 反转函数参数的应用顺序与函数的数量成线性关系, 但这发生在宏展开时, 通常列表不会超过几个项目. 总的来说, 所有线程宏在性能分析中都不被认为特别重要.

3. 2.3.3 cond-> 和 cond->>
   

   自 1.5 版本以来的宏

   Listing 17: → 函数组合, 线程宏, 条件函数应用

   (cond-> [expr & clauses])
   (cond->> [expr & clauses])
   

   cond-> 和 cond->> 分别是基本线程宏 -> 和 ->> 的专门版本. cond-> 接受一个表达式, 并在一个子句为真时将该表达式" 线程优先" 地传入后续形式中 (作为形成函数的第一参数). 类似地, 当条件为 true 时, cond->> 将表达式" 线程末尾" 地传入. 每个形式都由一个子句前导, 该子句用于决定先前的求值是否应该通过该形式.

   关于条件线程宏的一个重要事实是它们不是短路的. 如果子句为假, 相关的形式只是被跳过, 计算从下一个继续. 另外值得注意的是, 子句不能访问其他形式的求值结果, 只能访问周围的局部绑定, 就像代码中任何其他非宏求值部分一样. 具体来说, 子句不能引用前一个形式的结果 (即" 被线程穿过" 的内容). 这种行为可以用来重复检查一个初始表达式 (或某些其他给定的选项), 而与之前发生的转换无关.

   这里有一个逐步解释来阐明 (cond->) 的逻辑:

   (let [x \c] ; ❶
     (cond-> x ; ❷
       (char? x) int ; ❸
       (char? x) inc ; ❹
       (string? x) reverse ; ❺
       (= \c x) (/ 2))) ; ❻
   ;; 50
   

   ❶ 一个局部绑定 "x" 被建立为字符 \c.

   ❷ "x" 被线程穿过 cond->.

   ❸ 子句 (char? x) 被求值. 由于 "x" 是一个字符类型, 相关的形式被求值. 由于 int 函数不是一个序列, 它在宏展开时被转换为一个列表 (list int). 然后 "x" 被用作 (int x) 的第二个参数, 求值为数字 99 (\c 的 ascii 等价物).

   ❹ 子句 (char? x) 再次被求值, 它仍然是 "true", 因为它被绑定到没有改变的 "x". 但这一次, 前一个形式的结果被用作 inc 的参数, 结果为数字 100.

   ❺ 子句 (string? x) 被求值. x 不是一个字符串 (它是一个字符), 所以 reverse 不会发生.

   ❻ (= \c x) 为真, 所以下面的形式被求值. 前一个求值形式的结果 (100) 被用作形式的第二个参数, 如 (/ 100 2), 结果为数字 50.

   类似地, 这里有一个关于 cond->> 如何对其参数进行操作的逐步示例:

   (let [x [\a 1 2 3 nil 5]] ; ❶
     (cond->> x ; ❷
       (char? (first x)) rest ; ❸
       true (remove nil?) ; ❹
       (> (count x) 5) (reduce +))) ; ❺
   ;; 11
   

   ❶ 一个局部绑定 "x" 为向量 [\a 1 2 3 nil 5] 建立.

   ❷ "x" 被线程穿过 cond->> 宏.

   ❸ 子句 (char? (first x)) 被求值. 由于 \a 是一个字符类型, 该形式被求值. 由于 rest 函数不是一个序列, 它在内部被转换为一个列表 (list rest). x 被用作 (rest x) 的第二个参数, 求值为列表 (1 2 3 nil 5).

   ❹ 当 true 用作子句时, 形式总是被求值. 先前的求值被添加为 (remove nil?) 的最后一个参数, 结果为 (remove nil? (1 2 3 nil 5)), 求值为新列表 (1 2 3 5).

   ❺ 最后一个子句 (> (count x) 5) 对 "x" 中的元素进行计数 (这是原始表达式, 而不是先前求值的列表). 由于有超过 5 个项, 先前求值的列表被用作当前形式的最后一个参数: (reduce + (1 2 3 5)). 最终结果是 11.

   1. 约定
      
      1. 输入
         
         • "expr" 是一个强制性表达式. "expr" 被求值并放置在后续形式的第二个位置, 如果子句条件求值为真.
         • "clauses" 是一个可选的子句-形式对的列表. 在每个对中, 一个" 子句" 是一个求值为逻辑真/假的表达式. 每个子句都必须有一个" 形式" . 如果该形式还不是一个列表, 则会创建一个新的包装列表. 每个形式的第一个元素必须是一个可调用对象 (因此 (ifn? (first form)) 为真).
      2. 输出
         

         最后一个形式 (如果提供) 的求值结果, 使用先前求值形式的结果. 如果没有提供形式 (或者所有条件都求值为假), 它返回 "expr" 的求值结果.

   2. 示例
      

      cond-> 的一个惯用法是在条件形式中, "true" 分支应该转换输入, 而 "false" 分支则保持不变. 例如, 以下形式是等效的:

      (let [x "123"] (if (string? x) (Integer. x) x)) ; ❶
      (let [x "123"] (cond-> x (string? x) Integer.)) ; ❷
      

      ❶ 变量 "x" 可以是字符串或数字. 如果它是字符串, 我们想将它转换为数字, 否则我们什么都不做. 条件形式需要在最后重复 "x" 一次, 只是为了保持原样.

      ❷ 在 cond-> 版本中, 我们避免了第三次重复 "x", 因为它仅在条件为真时才通过 Integer 构造函数进行线程化.

      cond-> 可以用于处理异构数据, 使它们最终以相同的" 形状" 出现. 这种情况可能发生, 例如, 当一个应用程序接收到同一实体的 XML 或 JSON, 但在结构或值上存在细微差异时 (树状数据结构可以直接在 Clojure 中表示和处理为哈希映射). 下面的 shape-up 函数检查传入的哈希映射是否符合一组规则, 并相应地进行更改:

      (defn same-initial? [m]
        (apply = (map (comp first name) (keys m))))
      
      (defn shape-up [m]
        (cond-> m
          :always (assoc-in [:k3 :j1] "default") ; ❶
          (same-initial? m) (assoc :same true) ; ❷
          (map? (:k2 m)) (assoc :k2 (apply str (vals (:k2 m)))))) ; ❸
      
      (map shape-up
           [{:k1 "k1" :k2 {:h1 "h1" :h2 "h2"} :k3 {:j2 "j2"}}
            {:k1 "k1" :k2 "k2"}
            {:k1 "k1" :k2 {:h1 "h1" :h3 "h3"} :k3 {:j1 "j1"}}])
      ;; ({:k1 "k1", :k2 "h1h2", :k3 {:j2 "j2", :j1 "default"}, :same true}
      ;;  {:k1 "k1", :k2 "k2", :k3 {:j1 "default"}, :same true}
      ;;  {:k1 "k1", :k2 "h1h3", :k3 {:j1 "default"}, :same true})
      

      ❶ 第一个形式强制要求存在一个 :k3 键, 指向 map {:j1 "default"} (如果该键已存在, 它将被替换). 在这第一步之后, 我们确信 :k3 :j1 键组合存在, 可能带有一个 "default" 值. 为了强制该条件始终被应用, 使用了 ":always" 作为子句. ":always" 是逻辑真, 因此相关的表达式总是被求值.

      ❷ 第二个子句检查所有键是否以相同的字母开头. 如果是这种情况, 我们添加一个键 :same true.

      ❸ 在最后一步, 如果键 :k2 的值是另一个哈希映射, 那么我们取该内部哈希映射的所有值, 并将它们连接成一个字符串. 我们最终用新字符串替换相同的 :k2 键.

      一个有趣的 cond->> 用法类似于非条件的 ->> 线程末尾宏, 但带有可选的步骤. 序列非常适合类似管道的处理, 因为它们在末尾接收输入数据. cond->> 增加了条件以增强灵活性. 例如, 这里是一个用于假设的音频信号处理应用的函数:

      (def signals [111 214 311 413 107 221 316 421 112 222 317 471 115 223 308 482])
      
      (defn process [signals opts]
        (let [{:keys [boost? bypass? interpolate? noise? cutoff?]} opts] ; ❶
          (cond->> signals
            (< (count signals) 10) (map inc) ; ❷
            interpolate? (mapcat range) ; ❸
            bypass? (filter bypass?) ; ❹
            noise? (random-sample noise?) ; ❺
            cutoff? (take-while #(< % cutoff?))))) ; ❻
      
      (process signals {:bypass? even? :interpolate? true :noise? 0.5 :cutoff? 200})
      ;; (0 4 12 14 16 ...
      

      ❶ 使用解构, 我们可以从输入 map 中提取相关的键.

      ❷ 信号处理首先检查我们收到了多少采样事件. 如果少于某个数量, 每个信号都会递增. 在我们的例子中, 这个操作没有被求值.

      ❸ 为了模拟新数据的引入 (插值), 对序列中的每个信号调用 range, 生成一个不同大小的嵌套序列列表. mapcat 负责将所有内容重新连接在一起. 在我们的例子中, map 中设置了该选项, 插值发生在原始信号列表上, 因为上一步没有执行.

      ❹ 这一步根据 bypass? 键过滤信号. 如果 bypass? 是 nil, 那么就没有过滤. 当 bypass? 包含除 nil 以外的内容时, 它假设 bypass? 是 filter 的谓词. 在我们的例子中, 使用 even? 作为谓词进行过滤操作.

      ❺ 这一步通过使用 random-sample 对列表进行随机采样, 可选地向信号添加噪声. 由于设置了 noise? 键, 这一步也使用 50% (0.5) 的概率进行.

      ❻ 最后, 截止步骤移除所有超过某个阈值的信号. 该步骤以 200 的阈值执行.

      1. 可视化垂直流
         

         Clojure 的函数和宏在功能上可以非常丰富. 它们越富有表达力和功能, 就需要越多的文档来理解它们. cond-> 和 cond->> 这样的线程宏就是这种情况. 幸运的是, 它们的自然垂直流有助于更好地理解它们.

         在 cond->> 的情况下, 借助一些格式化, 更容易看到在执行过程中垂直流动的两列: 一列是条件 (左侧), 另一列是形式 (右侧). 这是引言中使用的相同示例:

         (let [x [\a 1 2 3 nil 5]]
           (cond->> x
             (char? (first x)) rest
             true (remove nil?)
             (> (count x) 5) (reduce +)))
         

         条件列可以访问局部和全局绑定 (就像代码的任何其他部分一样), 但它对右侧列一无所知. 类似地, 右侧的处理列对左侧的条件没有任何影响 (假设没有副作用).

         请记住, 上述缩进风格在此处用于强调 cond->> 的垂直流, 通常不使用. 应将通过缩进 (或列) 进行强调视为一种 sparingly 使用的特殊文档情况. 当对如何为函数或宏使用正确的缩进风格有疑问时, 用户贡献的 Clojure 风格指南是权威参考 ³⁴.

   3. 另请参阅
      
      • "->" 是" 线程优先" 宏. 与 cond-> 不同, 它不为下一个形式的执行应用任何子句.
      • ->> 是" 线程末尾" 宏. 与 cond->> 不同, 它不为下一个形式的执行检查条件.
      • "some->" 大致可以与 cond-> 进行比较, 其中所有条件都只检查 nil. 然而, "some->" 在 nil 的情况下会短路并立即返回.
      • some->> 大致与 cond->> 比较, 其中所有条件都检查 nil. 然而, 如果某些形式求值为 nil, some->> 会短路并立即返回.
   4. 性能考虑和实现细节
      

      → O(n) n 个形式的数量 (编译时间)

      cond-> 和 cond->> 通常与运行时性能分析无关, 因为处理形式的成本在编译时应用. 在编译时, 反转函数参数的应用顺序与形式的数量成线性关系.

4. 2.3.4 some-> 和 some->>
   

   自 1.5 版本以来的宏

   Listing 18: → 函数组合, 线程宏, 条件函数应用

   (some-> [expr & forms])
   (some->> [expr & forms])
   

   some-> 和 some->> 是线程优先宏 -> 和线程末尾宏 "->>" 的变体, 如果任何形式求值为 nil, 它们会立即返回. 这对于那些在存在 nil 的情况下会抛出 NullPointerException 的函数特别有用 (这是 Java 互操作中的常见情况, 但不仅限于此):

   (-> {:a 1 :b 2} :c inc) ; ❶
   ;; NullPointerException
   
   (some-> {:a 1 :b 2} :c inc) ; ❷
   ;; nil
   

   ❶ 尝试递增 map 中键 :c 的值. 该键不存在, 返回 nil. 在 nil 的情况下, inc 会抛出异常.

   ❷ 同样的例子使用 some-> 返回 nil.

   1. 约定
      
      1. 输入
         
         • "expr" 是强制性参数, 可以是任何有效的 Clojure 表达式.
         • "forms" 是额外的可选参数. 如果任何可选的形式不是一个列表, 则会创建一个新列表来包装该形式. 每个形式的第一个元素必须是一个可调用对象 (因此 (ifn? (first form)) 为真).
      2. 输出
         

         some-> 通过将前一个形式的结果作为下一个形式的第二个参数来返回最后一个形式的求值结果, 而 some->> 则将求值的形式作为最后一个参数. 如果任何形式求值为 nil, 它返回 nil.

   2. 示例
      

      some-> 的一个惯用法是在使用 Java 互操作时, 例如将字符串转换为数字. 这在从环境变量中读取时经常发生, 这在系统启动时很常见:

      (defn system-port []
        (or (some-> (System/getenv "PORT") Integer.) ; ❶
            4444))
      
      (system-port) ; ❷
      ;; 4444
      

      ❶ some-> 在这里防止了当 "PORT" 变量不存在时出现 NumberFormatException.

      ❷ 调用 (system-port) 不论是否存在 "PORT" 环境变量都能正常工作. 当 "PORT" 存在时, 它会覆盖默认值, 当 "PORT" 不存在时则使用默认值.

      re-seq 是与 some->> 进行条件处理的一个很好的候选者: re-seq 接收目标字符串作为最后一个参数, 并且它不容忍 nil 参数. 这里有一个函数, 用于从某个 HTML 文档中提取 <title></title> 标签之间的内容:

      (defn titles [doc] ; ❶
        (some->> doc ; ❷
                 (re-seq #"<title>(.+?)</title>") ; ❸
                 (map peek))) ; ❹
      
      (titles nil)
      ;; nil
      (titles "<html><head>Document without a title</head></html>")
      ;; nil
      (titles "<html><head>
                <title>Once upon a time</title>
                <title>Kingston upon Thames</title>
              </head></html>")
      ;; ("Once upon a time" "Kingston upon Thames")
      

      ❶ match-title 是一个简单的函数, 它在 HTML 文档中搜索一对 <title></title> 标签, 然后验证标题是否包含给定的正则表达式.

      ❷ some->> 省去了对可能为 nil 值的保护.

      ❸ 如果整个文档为 nil, 我们不希望 re-seq 生成 NullPointerException.

      ❹ re-seq 以向量对的形式返回匹配结果. peek 是访问向量中最后一项的最佳方式.

      使用正则表达式来匹配大型 HTML 文档是可能的, 但效率不高. 对于密集的 HTML 处理, 最好使用许多可用的 HTML 解析库之一 (例如 Enlive ³⁵).

      1. 宏家族的故事
         

         你可能会认为 Clojure 已经用现有的线程宏覆盖了管道处理的所有细微差别. 但线程宏非常有用, 以至于有几个库扩展了它们. 两个值得注意的例子是: LonoCloud Synthread ³⁶ 和 Pallet Ops thread-expr ³⁷.

         这里有几个来自这些库的线程宏的例子:

         Listing 19: 带有解构的 as→ 宏

         (->/as {:a 2 :b 2} {:keys [b]}
                (assoc :large-b (> b 10)))
         ;; {:a 2 :b 2 :large-b false}
         

         Synthread 包含一个支持普通 Clojure 解构的增强版 as-> 宏. 键 :b 从 map 中提取并分配为后续形式的局部绑定.

         Listing 20: for-> 重复

         (-> 1 (for-> [x [1 2 3]] (+ x)))
         ;; 7
         

         来自 Pallet Ops 的 thread-expr for-> 允许在一个已有的 -> 线程优先宏中重复形式. 这里显示的例子展开为: (-> 1 (+ 1) (+ 2) (+ 3)).

         Listing 21: binding->

         (def ^:dynamic *a* 0)
         (-> 1 (binding-> [*a* 1] (+ *a*)))
         ;; 2
         

         binding-> (同样来自 Pallet Ops) 允许在线程化的形式中直接进行绑定. 正如你在这里看到的, *a* 的值在每个线程的基础上变为 1.

         Listing 22: 更新宏

         (-> {:a 1 :b {:c 2}}
             (->/update :a inc -)
             (->/in [:b :c]))
         ;; 2
         

         这些是来自 Synthread 库的两个例子. ->/update 和 ->/in 是两个专门用于 map 的线程宏, 类似于 update 和 get-in, 但支持在一次调用中线程化多个更新, 如 (->/update :a inc -) 所示, 它递增并改变键 :a 指向的值的符号.

   3. 另请参阅
      

      fnil 是一个通过包装另一个函数来工作的函数生成器. 当围绕 nil 值的检查与参数相关时, fnil 是首选.

   4. 性能考虑和实现细节
      

      → O(n) n 个形式的数量 (编译时间)

      在使用 some-> 宏之前, 没有特别的性能考虑. 它基本上委托给 ->, 它在编译时处理形式 (通常没有太大的性能影响, 考虑到通常在线程宏中使用的形式数量很少).

5. 2.3.5 as->
   

   自 1.5 版本以来的宏

   Listing 23: → 函数组合, 线程宏, 参数化函数应用

   (as-> [expr name & forms])
   

   as-> 通过添加一个新参数来专门化两个基本的线程宏 -> 和 ->>, 该参数用作占位符, 将前一个形式的求值结果定位到下一个形式中. 使用 -> 和 ->>, 顶部的表达式求值结果分别被放置在下一个形式的第二个位置或末尾. 链中的所有形式都需要遵循相同的定位. as-> 可以精确地放置下一个形式的求值结果:

   (as-> {:a 1 :b 2 :c 3} x ; ❶
     (assoc x :d 4) ; ❷
     (vals x) ; ❸
     (filter even? x) ; ❹
     (apply + x))
   ;; 6
   

   ❶ as-> 链以 2 个元素开始, 即要传入的表达式和局部绑定 "x".

   ❷ "x" 在下一个形式中用作占位符来驱动其定位, 在这种情况下, 紧跟在 <assoc,assoc>> 之后.

   ❸ 请注意, 即使没有歧义, "x" 也需要在形式中明确.

   ❹ 这是一个作为最后一个参数放置的例子, 等同于 ->> 的定位.

   对形式进行宏展开显示了这是如何轻松完成的:

   (macroexpand-1 ; ❶
     '(as-> {:a 1 :b 2 :c 3} x
        (assoc x :d 4)
        (vals x)
        (filter even? x)
        (apply + x)))
   
   (let [x {:a 1, :b 2, :c 3}
         x (assoc x :d 4)
         x (vals x)
         x (filter even? x)
         x (apply + x)]
     x)
   

   ❶ 使用 macroexpand-1 可以防止展开超出 as→ 本身.

   由于 as-> 基于 let, 它也支持解构 (尽管这仅从 Clojure 1.8 开始启用).

   1. 约定
      
      1. 输入
         
         • "expr" 是任何有效的 Clojure 表达式. 表达式的求值结果被绑定到占位符.
         • "name" 可以是符号或解构形式. 如果 "name" 是符号, 它可以在后续形式中用作占位符. 如果使用解构形式, 链中的后续求值必须与解构形式兼容.
         • "forms" 是一个可选的形式列表, 可能会使用之前定义的占位符.
      2. 值得注意的异常
         

         如果绑定占位符不是符号或解构表达式, 则抛出一个通用的 Exception.

      3. 输出
         

         as-> 返回最后一个形式的求值结果, 使用占位符来引用先前求值的形式. 如果没有提供形式, 它返回表达式的求值结果.

   2. 示例
      

      as-> 在线程化值在每个形式中位置不同的情况下很有用. 这里有一个例子, 序列处理 (通常是线程末尾操作) 与 map 处理 (线程优先操作) 混合在一起. 该示例模拟从某个 URL 端点获取数据, 该端点包含 id, name, count 三元组:

      (defn fetch-data [url] ; ❶
        [{:id "aa1" :name "reg-a" :count 2}
         {:id "aa2" :name "reg-b" :count 6}
         {:id "aa7" :name "reg-d" :count 1}
         {:id "aa7" :name nil :count 1}])
      
      (defn url-from [path] ; ❷
        (str "http://localhost" "/" path))
      
      (defn process [path] ; ❸
        (as-> path <$>
          (url-from <$>)
          (fetch-data <$>)
          (remove #(nil? (:name %)) <$>)
          (reduce + (map :count <$>))))
      
      (process "home/index.html") ; 9
      

      ❶ fetch-data 模拟从远程服务获取数据后的响应. 本例中未使用 url 参数.

      ❷ url-from 从简单路径创建有效 URL.

      ❸ 我们可以看到 as-> 在起作用. 前 3 个形式要求线程化值出现在最后, 而最后一个形式则将占位符置于嵌套位置.

      在上面的例子中, process 使用了 as-> 线程宏. 为了对相关项的 :count 键求和, 所需的操作链需要混合函数调用和序列操作, 因此前一个形式的求值需要在不同的位置. 占位符符号 <$> 的选择是任意的, 但这个符号在形式中更显眼.

      以下示例说明了与 as-> 一起使用解构. 要理解的一个重要方面是, 尽管只在顶部出现一次, 但在每次求值期间都会应用相同的解构. 这允许每个形式根据先前的求值看到局部绑定的新更新:

      (let [point {:x "15.1" :y "84.2"}]
        (as-> point {:keys [x y] :as <$>} ; ❶
          (update <$> :x #(Double/valueOf %))
          (update <$> :y #(Double/valueOf %))
          (assoc <$> :sum (+ x y)) ; ❷
          (assoc <$> :keys (keys <$>)))) ; ❸
      ;; {:x 15.1, :y 84.2, :sum 99.3, :keys (:x :y :sum)}
      

      ❶ 一个 map 包含点的坐标 x,y 作为字符串. 我们在声明 as-> 的占位符时解构了该 map.

      ❷ 在计算的这一步, x 和 y 的值是对前一个形式应用解构的结果, 在 x 和 y 都从字符串转换为双精度浮点数之后.

      ❸ 注意, 占位符 <$> 可以在表达式的任何位置使用, 不仅仅是在开头.

   3. 另请参阅
      

      基本的线程宏 -> 和 ->> 可以被视为 as-> 的专门形式, 其中结果在下一个形式中的位置是固定的 (要么是下一个形式中的第一个参数, 要么是最后一个).

   4. 性能考虑和实现细节
      

      → O(n) n 个形式的数量 (编译时间)

      as-> 通常与运行时性能分析无关, 因为处理形式的成本在编译时应用. 在编译时, 反转函数参数的应用顺序与形式的数量成线性关系.