clojure.core
Fundamental library of the Clojure language
作为核心命名空间中最大的一个，clojure.core 提供了在构建 Clojure 程序时
你会用到的功能的大部分。
核心函数非常之多，在此无法一一描述，但可以查看
快速参考，按概念分组查看。
clojure.core 中的 Vars
*^%
- *
- 返回 nums 的乘积。(*) 返回 1。不会自动提升长整型，会因溢出而引发异常。另请参阅：*'
- *'
- 返回 nums 的乘积。(*') 返回 1。支持任意的精度。另请参阅：*
- *clojure-version*
- Clojure core 的版本信息，以包含 :major :minor :incremental 和 :qualifier 键的地图形式出现。特性版本可能递增 :minor 和/或 :major，而修复程序版本将递增 :incremental。:qualifier 的可能值包括 "GA"、"SNAPSHOT"、"RC-x"、"BETA-x"
- *compile-path*
- 指定 'compile' 将输出 .class 文件的目录。该目录必须在 classpath 中，以便 'compile' 起作用。默认为 "classes"
- *compiler-options*
- 一个键对选项的地图。注意，在动态绑定时务必与先前的值合并。支持的选项：:elide-meta - 编译期间要省略的元数据键的集合。:disable-locals-clearing - 设置为 true 以禁用清除，这对于使用调试器非常有用 :direct-linking - 设置为 true 以使用函数的直接静态调用，而不是使用 vars。注意，使用直接链接编译的调用位置不会受到 vars 重新定义的影响。在 var 上使用 ^:redef（或 ^:dynamic）可以防止直接链接并允许重新定义。有关详细信息，请参阅 https://clojure.org/reference/compilation。
- *data-readers*
- 映射器标记符号到数据映射器变量。Clojure 启动时，它会搜索类路径根目录处的名为“data_readers.clj”和“data_readers.cljc”的文件。每个此类文件都必须包含一个符号的文字映射，如下所示：{foo/bar my.project.foo/bar foo/baz my.project/baz} 每一对中的第一个符号是 Clojure 映射器将识别的标记。这对中的第二个符号是一个全限定 Var 名称，该名称将由映射器调用，以解析标记后面的表单。例如，给定上面的 data_readers.clj 文件，Clojure 映射器将通过对向量[1 2 3]调用 Var #'my.project.foo/bar 来解析此表单：#foo/bar [1 2 3]。映射器函数在映射器将表单读取为正常的 Clojure 数据结构后被调用。不带命名空间限定符的映射器标签由 Clojure 保留。默认映射器标签在 clojure.core/default-data-readers 中定义，但可以在 data_readers.clj、data_readers.cljc 或通过重新绑定此变量来覆盖它们。
- *default-data-reader-fn*
- 如果没有为标记找到数据映射器，并且 *default-data-reader-fn* 为非空，则它将使用两个参数（标记和值）调用。如果 *default-data-reader-fn* 为空（默认），将为未知标记抛出一个异常。
- *e
- 在 REPL 线程中绑定到 REPL 捕获的最新异常
- *err*
- 一个用作打印操作的标准错误输出的 java.io.Writer 对象。默认为 System/err，封装在一个 PrintWriter 中
- *file*
- 作为字符串，正在评估的文件的路径。当没有文件时（例如，在 REPL 中），该值未定义。
- *in*
- 一个用作读取操作的标准输入的 java.io.Reader 对象。默认为 System/in，封装在一个 LineNumberingPushbackReader 中
- *ns*
- 表示当前命名空间的 clojure.lang.Namespace 对象。
- *out*
- 一个用作打印操作的标准输出的 java.io.Writer 对象。默认为 System/out，封装在一个 OutputStreamWriter 中
- *print-dup*
- 设置为逻辑 true 时，将以一种方式打印对象，以便在以后读取时保留其类型。默认为 false。
- *print-length*
- *print-length* 控制打印机将打印每个集合的多少项。如果将它绑定到逻辑 false，则没有限制。否则，它必须绑定到一个整数，指示要打印的每个集合的最大项数。如果一个集合包含更多项，打印机将打印最多达到此限制的项，后跟“...”以表示剩下的项。根绑定为 null 表示没有限制。
- *print-level*
- *print-level* 控制打印机将打印嵌套对象的层级深度。如果将它绑定到逻辑 false，则没有限制。否则，它必须绑定到一个整数，指示要打印的最大层级。打印的每个参数的层级为 0；如果一个参数是一个集合，则它的项的层级为 1；以此类推。如果一个对象是集合且其层级大于或等于绑定到 *print-level* 的值，则打印机将打印“#”来表示它。根绑定为 null 表示没有限制。
- *print-meta*
- 如果设置为逻辑 true，则在打印对象时，其元数据也将以可由读取器读取回来的形式进行打印。默认为 false。
- *read-eval*
- 默认为 true（或由系统属性指定的 value，请见下文）***此设置暗示读者拥有全部功能，包括可能导致代码执行的语法。此设置永远不应与不受信任的源一起使用。另请参阅：clojure.edn/read.***在 thread-local 绑定中将其设置成逻辑 false 时，eval reader（#=）和 record/type 字面量语法在 read/load 中被禁用。示例（将失败）：(binding [*read-eval* false] (read-string "#=(* 2 21)")) 默认绑定可由系统属性 'clojure.read.eval' 控制，系统属性可在命令行中这样进行设置：java -Dclojure.read.eval=false ... 系统属性还可通过 -Dclojure.read.eval=unknown 设置为 'unknown'，在这种情况下，默认绑定为 :unknown，并且在 *read-eval* 未明确绑定到 true 或 false 的上下文中，所有读取均将失败。此设置可作为一个有用的诊断工具来确保所有读取在周全上下文中进行。还可以通过将 *read-eval* 绑定到 :unknown 在特定范围内完成此操作
- *unchecked-math*
- 当绑定到 true 时，+、-、*、inc、dec 的编译将不经溢出检查完成。当绑定到 :warn-on-boxed 时，其行为与 true 相同，并且会在编译使用 boxed math 时发出一个警告。默认值：false。
- +
- 返回 nums 的总和。(+) 返回 0。不会自动提升 long，在溢出时将抛出异常。另请参阅：+'
- +'
- 返回 nums 的总和。(+') 返回 0。支持任意精度。另请参阅：+
- -
- 如果未提供 ys，则返回 x 的否定值，否则从 x 中减去 ys 并返回结果。不会自动提升 long，在溢出时将抛出异常。另请参阅：-'
- -'
- 如果未提供 ys，则返回 x 的否定值，否则从 x 中减去 ys 并返回结果。支持任意精度。另请参阅：-
- ->
- 将 expr 串联到 forms 中。将 x 插入作为第一个 form 的第二个项目，如果其不是列表，则将 x 制成列表。如果还有更多 form，则将第一个 form 作为第二个 form 的第二个项目进行插入，等等。
- ->>
- 将 expr 串联到 forms 中。将 x 插入作为第一个 form 的最后一个项目，如果其不是列表，则将 x 制成列表。如果还有更多 form，则将第一个 form 作为第二个 form 的最后一个项目进行插入，等等。
- ->Vec
- 类 clojure.core.Vec 的位置工厂函数。
- .
- 特殊形式 '.' 是访问 Java 的基础。可将其视为成员访问运算符和/或读作“作用域内”。有关更多信息，请见 https://clojure.org/special_forms。
- ..
- form => fieldName-symbol 或 (instanceMethodName-symbol args*) 扩展成为第一个参数上的第一个成员的成员访问 (.)，后跟结果上的下一个成员，等等。例如：(.. System (getProperties) (get "os.name")) 扩展为：(. (. System (getProperties)) (get "os.name"))，但比较容易编写、阅读和理解。
- /
- 如果未提供分母，则返回 1/分子，否则返回分子除以所有分母。
- <
- 如果 nums 以单调递增顺序排列，则返回非 nil，否则返回 false。
- <=
- 如果 nums 以单调非递减顺序排列，则返回非 nil，否则返回 false。
- =
- 相等性。如果 x 等于 y，返回 true，否则返回 false。与 Java 中的 x.equals(y) 相同，但它也适用于 nil，并以类型无关的方式比较数字和集合。Clojure 的不可变数据结构将 equals()（因此也包括 =）定义为一个值，而不是标识符，比较。
- ==
- 如果 nums 全部具有相同的等效值（与类型无关），则返回非 nil，否则返回 false
- >
- 如果 nums 按递减顺序排列，则返回非 nil，否则返回 false。
- >=
- 如果 nums 按非递增顺序排列，则返回非 nil，否则返回 false。
a
- abs
- 返回 a 的绝对值。如果 a 是 Long/MIN_VALUE => Long/MIN_VALUE 如果 a 是双精度且为零 => +0.0 如果 a 是双精度且为 ##Inf 或 ##-Inf => ##Inf 如果 a 是双精度且为 ##NaN => ##NaN
- accessor
- 返回一个函数，该函数给定基础 structmap 的一个实例后，返回键下的值。该键必须在基础中。返回的函数比使用 get 效率（略微）高，但此类访问器的使用应限于已知的性能关键领域。
- aclone
- 返回 Java 数组的克隆。适用于已知类型的数组。
- add-classpath
- 已弃用，根据 URLClassLoader.addURL，将 url（字符串或 URL 对象）添加到类路径。
- add-tap
- 向抽取器集添加 f，即一个具有一个参数的函数。此函数将使用通过 tap> 发送的任何内容进行调用。此函数可能（短暂地）阻塞（例如对于流），并且永远不会妨碍调用 tap>，但是无限期地阻塞可能会导致丢弃抽取器值。记住 f 以便执行 remove-tap
- add-watch
- 向中介/原子/变量/引用引用添加监视函数。监视函数必须是 4 个参数的函数：一个键、引用、其旧状态、其新状态。无论何时引用状态可能已经改变，都将对任何已注册的监视器调用其函数。监视函数将在同步模式下调用，如果存在中介，则在中介的线程上调用，在中介或引用存在时，先调用任何待发送的操作。请注意，原子或引用的状态可能会在函数调用之前再次改变，因此使用旧/新状态而不是取消引用引用。另请注意，监视函数可能同时从多个线程进行调用。变量监视器仅由根绑定更改触发，而不是线程局部设置！密钥对每个引用必须是唯一的，并且可以使用 remove-watch 删除监视器，但监视机制将其他方式视为不透明。
- agent
- 创建并返回一个中介，其中状态的初始值为状态和一个或多个选项（按任何顺序）：：元数据元数据映射：验证器验证函数：错误处理程序处理程序函数：错误模式模式关键词如果提供了元数据映射，它将成为中介上的元数据。验证函数必须为 nil 或一个无副作用且具有一个参数的函数，将在任何状态改变时将预期的状态传递给它。如果新状态不可接受，验证函数应返回 false 或抛出异常。如果操作抛出异常或验证函数拒绝新状态，则将调用处理程序函数，有关详细信息，请参见 set-error-handler!。模式关键字可以是：continue（如果提供了错误处理程序则是默认值）或：fail（如果没有提供错误处理程序则是默认值），有关详细信息，请参见 set-error-mode!。
- aget
- 返回索引/索引下的值。适用于所有类型的 Java 数组。
- alias
- 为当前命名空间添加另一个命名空间的别名。参数为两个符号：要使用的别名以及目标命名空间的符号名称。优先在名称空间宏中使用 :as，而无需直接调用此方法。
- alter
- 必须在一个事务中调用。将 ref 的事务中值设置为： (apply fun ref的事务中值 args)，并返回 ref 的事务中值。
- alter-meta!
- 将命名空间/变量/ref/代理/原子的元数据设置为： (apply f 其当前元数据 args)，且 f 必须没有副作用
- amap
- 使用名为 idx 的索引以及名为 ret 的返回值映射一个表达式，该值被初始化为 a 的克隆，然后将 ret 的每个元素设置为 expr 的求值，返回新的数组 ret。
- ancestors
- 返回标记的直接和间接父级，可通过 Java 类型继承关系或通过 derive 建立的关系来获得。如果未提供，h 必须从 make-hierarchy 获得层次结构，则默认为全局层次结构
- and
- 从左到右一次对 expr 求值。如果一个形式返回逻辑 false（nil 或 false），则返回该值并且不再求值任何其他表达式，否则返回最后一个 expr 的值。（and）返回 true。
- apply
- 将 fn f 应用于通过将 intervening 参数前置到 args 形成的参数列表。
- areduce
- 使用名为 idx 的索引以及名为 ret 的返回值对一个数组映射表达式，该值被初始化为 init，然后将 ret 设置为 expr 在每个步骤的求值结果，返回 ret。
- array-map
- 构造一个数组映射。如果任何键相等，则将它们作为 assoc 的重复使用来处理。
- as->
- 将 name 绑定到 expr，在该绑定的词法上下文中求值第一个形式，然后将 name 绑定到该结果，对每个连续形式重复此操作，返回最后一个形式的结果。
- aset
- 设置索引/索引处的值。对引用类型的 Java 数组进行操作。返回 val。
- aset-int
- 设置索引/索引处的值。对 int 型数组进行操作。返回 val。
- assert
- 对 expr 求值，如果求值结果不是逻辑真则抛出异常。
- assoc
- assoc[加入]。应用于一个映射时，返回包含将键 key 映射到值 val 的相同（哈希/排序）类型的新映射。应用于一个向量时，返回包含在该索引上为 val 的新向量。注意：索引必须 <= (count vector)。
- assoc!
- 应用于一个瞬态映射时，添加将键 key 映射到值 val 的映射。应用于一个瞬态向量时，将该索引设置为 val。注意：索引必须 <= (count vector)。返回集合。
- assoc-in
- 将值关联到嵌套关联结构中，其中 ks 是键的序列，v 是新值，并返回嵌套的新结构。如果任何级别不存在，则会创建哈希映射。
- atom
- 创建并返回一个 Atom，其初始值为 x 以及零个或多个选项（按任意顺序）：:meta 元数据映射 :validator 验证函数 如果提供了元数据映射，则它将成为原子上的元数据。validate-fn 必须是无副作用的单参数函数，在任何状态更改时，已旨在将新状态传递给该函数。如果新状态不可接受，则 validate-fn 应返回 false 或引发异常。
- await
- 从当前线程或代理到代理的所有已分派操作都已发生之前，一直（无限期！）阻塞当前线程。将在故障代理上进行阻塞。如果在故障代理上通过 :clear-actions true 重新启动或调用 shutdown-agents，则永远不会返回。
- await-for
- 从当前线程或代理到代理的所有已分派操作都已发生，或者超时（以毫秒为单位）已过，之前，一直阻塞当前线程。如果由于超时而返回，则返回逻辑 false，否则返回逻辑 true。
b
- bases
- 如果存在，则返回 c 的直接超类和直接接口
- bean
- 获取 Java 对象，并基于其 JavaBean 属性返回映射抽象的只读实现。
- binding
- binding => var-symbol init-expr 为（已存在的）var 创建新的绑定，并通过提供初始值，在隐式 do 中执行 expr，然后重新建立之前存在的绑定。新的绑定是并行进行的（不同于 let）；在将 var 绑定到新值之前，将对所有 init-expr 进行评估。
- bound-fn
- 返回一个函数，该函数由给定的 fntail 定义，该函数将在 bound-fn 被调用时安装与该线程中有效绑定相同绑定的函数。这可用于定义一个在不同线程上运行的帮助函数，但需要将相同的绑定就位。
- bound-fn*
- 返回一个函数，该函数将在 bound-fn* 被调用时安装与该线程中有效绑定相同绑定的函数，然后使用任何给定的参数调用 f。这可用于定义一个在不同线程上运行的帮助函数，但需要将相同的绑定就位。
- bound?
- 如果所有作为参数提供的变量有任何绑定值（根或线程局部），则返回 true。这意味着对提供的变量进行 deref 将会成功。如果没有提供变量，则返回 true。
- bounded-count
- 如果 coll 是 counted? 的返回它的计数，否则将使用其 seq 计算 coll 的最多前 n 个元素
- butlast
- 返回 coll 中除了最后一项之外的所有项的 seq，呈线性时间
c
- case
- 采用一个表达式，以及一组条款。每个条款都可采用以下形式： 测试常量结果表达式（测试常量1 . . . 测试常量 N）结果表达式测试常量不受评估。它们必须是编译时文字，并且不需要引用。如果表达式等于测试常量，则返回对应的结果表达式。可以为条款添加一个默认表达式，如果没有任何条款匹配，则返回该表达式的值。如果没有提供默认表达式，也没有任何条款匹配，则抛出 IllegalArgumentException 错误。与 cond 和 condp 不同，case 进行常量级派遣，不会按顺序考虑条款。case 可接受各种常量表达式，包括数字、字符串、符号、关键字及其（Clojure）组合。请注意，由于列表用于将映射到同一表达式的多个常量分组，因此在需要的时候可以使用矢量匹配列表。测试常量不必都属于同一种类型。
- 类型转换
- 如果 x 不是 c，则抛出 ClassCastException 错误；否则返回 x。
- 猫
- 一个将每个输入内容（输入必须是集合）级联到还原中的变换器。
- 捕获
- 评估表达式，如果未出现例外情况，则返回最后一个表达式的值。如果出现例外情况并且提供了 catch 条款，它将依次检查每个条款，第一个被抛出例外视为其命名的类实例的条款被视为匹配的 catch 条款。如果存在匹配的 catch 条款，则在 name 绑定到抛出例外的情况中评估其表达式，并且最后一个表达式的值为函数的返回值。如果没有匹配的 catch 条款，则例外会在函数中传播。无论正常返回还是异常返回，任何 finally 表达式都将被评估其副作用。请访问 https://clojure.org/special_forms 了解更多信息。
- 清除代理程序错误
- 不推荐使用：改用“重启代理程序”。清除代理程序的异步动作期间抛出的任何异常，以允许后续动作的发生。
- 集合？
- 如果 x 实现 IPersistentCollection，则返回真
- 变更
- 必须在事务中调用。将 ref 的事务中值设置为：(apply fun in-transaction-value-of-ref args)，并返回 ref 的事务中值。在事务的提交点设置 ref 的值为：(apply fun most-recently-committed-value-of-ref args)。因此，fun 应为可交换的，或者如不能交换，则你必须接受最后的那个获胜的行为。change 允许更多的并发性多于 ref-set。
- 组合
- 采用一组函数并返回一个 fn，它是这些 fn 的组合。返回的 fn 采用数量可变的参数，将最右边的 fn 应用到参数上，将下一个 fn（从右到左）应用到结果上，以此类推。
- 比较器
- 基于 pred 返回 java.util.Comparator 的一个实现。
- 比较
- Comparator.当 x 逻辑上“小于”、“等于”或“大于” y 时，返回负数、零或正数。它与 Java x.compareTo(y) 相同，但它也适用于 nil，并且以独立于类型的方式比较数字和集合。x 必须实现 Comparable
- compare-and-set!
- 仅当 atom 的当前值与 oldval 相同时，将 atom 的值原子地设置为 newval。如果设置成功，返回 true，否则返回 false
- compile
- 将符号 lib 命名为命名空间编译到一组类文件中。lib 的源文件必须位于适当的 classpath 相对目录中。输出文件将转到由 *compile-path* 指定的目录，该目录也必须位于 classpath 中。
- complement
- 获取一个函数 f，并返回一个函数，该函数采用与 f 相同的参数，具有相同的效果（如果有），并返回相反的真假值。
- completing
- 获取一个包含 2 个参数的简化函数 f，并返回一个适合 transduce 的函数，通过在结果参数上调用 cf（默认为 - identity）来添加一个 arity-1 签名。
- cond
- 获取一组测试/表达式对。它一次评估一个测试。如果测试返回逻辑真，cond 将评估并返回对应 expr 的值，并且不会评估任何其他测试或 expr。（cond）返回 nil。
- cond->
- 获取一个表达式和一组测试/形式对。通过对应测试表达式为真的每个形式（通过 ->）穿透 expr。请注意，与 cond 分支不同，cond -> 穿透在第一个真测试表达式之后不会短路。
- cond->>
- 获取一个表达式和一组测试/形式对。通过对应测试表达式为真的每个形式（通过 ->>）穿透 expr。请注意，与 cond 分支不同，cond ->> 穿透在第一个真测试表达式之后不会短路。
- condp
- 获取一个二元谓词、一个表达式和一组条款。每个子句可以采用以下形式：test-expr result-expr test-expr :>> result-fn 注：>> 是一个普通的关键字。对于每个条款，（pred test-expr expr）被评估。如果它返回逻辑真，则该子句匹配。如果二元子句匹配，则返回 result-expr，如果三元子句匹配，则会调用其 result-fn（它必须是一个一元函数），并以谓词的结果作为其参数，该调用的结果是 condp 的返回值。一个默认表达式可以跟随这些子句，如果没有子句匹配，将返回其值。如果没有提供默认表达式，并且没有子句匹配，则会抛出 IllegalArgumentException。
- conj
- conj[oin]。返回一个添加了 xs 的新集合。（conj nil item）返回（item）。（conj coll）返回 coll。（conj）返回 []。“添加”可能会在不同的“位置”发生，具体取决于具体类型。
- conj!
- 将 x 添加到瞬态集合，并返回 coll。“添加”可能会在不同的“位置”发生，具体取决于具体类型。
- cons
- 返回一个新序列，其中 x 是第一个元素而序列是其余部分。
- contains?
- 如果给定集合中存在 key，则返回 true，否则返回 false。请注意， بالنسبة إلى المجموعات المفهرسة رقميًا مثل المتجهات ومصفوفات Java، تختبر هذه الدالة ما إذا كان المفتاح الرقمي ضمن نطاق الفهارس. تعمل 'contains؟' بوقت ثابت أو لوغاريتمي؛ لن تؤدي بحثًا خطيًا عن قيمة. انظر أيضًا 'بعض'.
- count
- 返回集合中的各项的数目。(count nil) 返回 0。此函数也适用于字符串、数组以及 Java 集合和映射
- create-ns
- 创建一个由符号命名的新命名空间，如果不存在该命名空间就返回或者返回同名的已有命名空间。
- cycle
- 返回对集合中各项的重复项目的懒惰（无限！）序列。
d
- dec
- 返回比 num 小一的一个数字。不会自动提升长整型，将会在发生溢出时抛出错误。另外，参见：dec'
- dec'
- 返回比 num 小一的一个数字。支持任意精度。另外，参见：dec
- dedupe
- 返回一个懒惰序列，其会删除集合中连续出现的重复项目。如果没有提供集合，则返回一个转换器。
- def
- 创建并实习一个全局变量，其名称为 symbol，命名空间为当前命名空间 (*ns*) 的值。有关更多信息，请见 https://clojure.org/special_forms。
- definline
- 实验性 - 就像 defmacro 一样，除了能够定义一个其 body 是扩展的命名函数，其调用可以像宏一样在线扩展。不能与变化参数 (&) 参数一起使用。
- definterface
- 用给定的名称和方法签名创建一个新的 Java 接口。方法返回类型和参数类型可以用类型提示指定，如果省略会默认为 Object。（definterface MyInterface (^int method1 [x]) (^Bar method2 [^Baz b ^Quux q]))
- defmacro
- 与 defn 一样，但结果函数名被声明为一个宏，当调用它时，编译器会将它作为宏使用。
- defmethod
- 创建和安装一个关联着 dispatch-value 的多态方法的新方法。
- defmulti
- 用关联的 dispatch 函数创建一个新的多态方法。docstring 和 attr-map 是可选的。选项都是键值对，并且可以是以下之一：:default 默认的 dispatch 值，默认为 :default :hierarchy 用作层次结构 dispatch 的值（例如，::square is-a ::shape）层次结构是类型类似的关系，它们不取决于类型继承。默认情况下，Clojure 的多态方法在全局层次结构映射之外进行 dispatch。但是，可以通过使用 derive 函数来创建一个层次结构关系来增补用 make-hierarchy 创建的根祖先。多态方法期望层次结构选项的值作为引用类型提供，例如，变量（也就是说，通过 Var 引用 dispatch 宏 #' 或 var 特殊形式提供）。
- defn
- 与 (def name (fn [params* ] exprs*)) 或 (def name (fn ([params* ] exprs*)+)) 相同，任何文档字符串或属性都添加到变量元数据中。prepost-map 定义了一个映射，可选的键为 :pre 和 :post，其中包含预条件或后条件集合。
- defonce
- 仅当已命名变量没有根值时才将 name def 为其 expr 的根值，否则不会评估 expr
- defprotocol
- 协议是一组命名方法及其签名：(defprotocol AProtocolName ;可选的文档字符串“AProtocol 抽象的文档字符串” ;选项：:extend-via-metadata true ;方法签名 (bar [this a b] “bar 文档”) (baz [this a] [this a b] [this a b c] “baz 文档”)) 没有提供任何实现。文档可以为整个协议和每种方法指定。上述将生成一组多态函数和一个协议对象。所有这些都由包含定义的 ns 命名空间限定生成函数在其第一个参数的类型上进行分派，这是必需的并对应于隐式目标对象（在 Java 术语中为“this”）。defprotocol 是动态的，没有特殊编译时效果，并且不定义任何新的类型或类。可以使用 extend 提供协议方法的实现。当 :extend-via-metadata 为 true 时，值可以通过添加元数据来扩展协议，其中键是完全限定的协议函数符号，而值是函数实现。首先检查协议实现是否有直接定义（defrecord、deftype、reify），然后是元数据定义，然后是外部扩展（extend、extend-type、extend-protocol）defprotocol 将自动生成一个相应的接口，其名称与协议相同，即给定一个协议：my.ns/Protocol，一个接口：my.ns.Protocol。接口将具有与协议函数相对应的方法，并且协议将自动与接口的实例一起使用。请注意，您不应将此接口与 deftype 或 reify 一起使用，因为它们直接支持协议：(defprotocol P (foo [this]) (bar-me [this] [this y])) (deftype Foo [a b c] P (foo [this] a) (bar-me [this] b) (bar-me [this y] (+ c y))) (bar-me (Foo. 1 2 3) 42) => 45 (foo (let [x 42] (reify P (foo [this] 17) (bar-me [this] x) (bar-me [this y] x)))) => 17
- defrecord
- 对于名称 [fields*] 选项* 规范* 的记录定义支持依次用作关键字和参数（顺序任意）的选项。支持的选项：：load-ns - 如果为真，导入记录类会加载记录被定义的命名空间。默认值为假。每个规范包括一个协议或接口名称，后跟零个或多个方法主体：协议或接口或对象 (methodName [args*] body)* 动态生成给定名称类的已编译字节代码，在与当前命名空间同名的程序包中，使用给定的字段，还可以选择为协议和/或接口提供方法。该类将具有由 fields 命名的（不可变）字段，它可以有类型提示。协议/接口和方法是可选的。唯一可提供的方法是协议/接口中声明的方法。请注意，方法主体不是闭包，局部环境仅包括已命名的字段，可以直接访问这些字段。方法定义采用如下格式： (methodname [args*] body) 可以提示 arg 和 methodname 符号上的参数和返回类型。如未提供，将推断它们，因此类型提示应保留以消除歧义。对于所需协议和接口的所有方法都应提供方法。还可以定义对象的重写方法。请注意，必须提供与目标对象（在 Java 术语中为“this”）相对应的参数。因此，接口方法比接口声明多一个参数。此外，请注意，指向方法头的 recur 调用*不应*传递目标对象，它将自动提供且无法代替。在方法主体中，可以使用（不合格）名称来命名类（对于对 new、instance? 等的调用）。该类将具有自动生成的几个（clojure.lang）接口的实现：IObj（元数据支持）和 IPersistentMap 以及它们的所有超接口。此外，defrecord 将定义基于类型和值 =，并将定义与 java.util.Map 的契约一致的 Java .hashCode 和 .equals。当 AOT 编译时，生成具有给定名称（一个符号）的类的已编译字节代码，将当前 ns 添加到程序包前面，并将 .class 文件写入 *compile-path* 目录。将定义两个构造函数，一个使用指定的 fields 后接一个元数据映射（无为无）和一个扩展字段映射（无意味着无），另一个仅使用字段（对 meta 和扩展字段使用无）。请注意，字段名 __meta、__extmap、__hash 和 __hasheq 当前为保留字段，定义自己的记录时不应使用。针对 (defrecord TypeName ...)，将定义两个工厂函数：->TypeName，它为字段采用位置参数，map->TypeName，它为字段值采用关键字映射。
- defstruct
- 与 (def name (create-struct keys...)) 相同
- deftype
- （deftype 名称 [字段*] 选项* 专项技术*）选项以连续的关键字和论点（按任意顺序）表达。受支持的选项：:load-ns - 如果为真，导入类型类将导致加载定义类型的命名空间。默认值为假。每个技术规范都由一个协议或接口后面跟着零个或更多个方法体组成：协议或接口或 Object (methodName [args*] 正文)* 动态生成具有给定名称的类的已编译字节码，在与当前名称空间相同的包中，具有给定字段以及可选的协议和/或接口方法。该类将具有由字段命名的（默认情况为不可变）字段，可以具有类型提示。协议/接口和方法是可选的。唯一可以提供的函数是那些在协议/接口中声明的函数。请注意，方法实体不是闭包，本地环境仅包含具名字段，并且可以直接访问这些字段。字段可以用元数据 :volatile-mutable true 或 :unsynchronized-mutable true 限定，此时（set! afield aval）将在方法体中得到支持。请注意，可变字段极其难以正确使用，并且仅用于在 Clojure 自身中构建更高级别的构造（例如 Clojure 的引用类型）。它们仅适用于专家 - 如果 :volatile-mutable 或 :unsynchronized-mutable 的语义和含义不是立即可见的，则不应使用它们。方法定义采用以下形式：(methodname [args*] body) 可以提示参数和返回类型在 arg 和 methodname 符号上。如果没有提供，它们将被推断出来，因此类型提示应保留用于消除歧义。应提供所有所需协议和接口的所有方法。您还可以为 Object 方法定义覆盖项。请注意，必须提供一个参数来对应于目标对象（Java 语言中的“this”）。因此，接口的方法将比接口声明多一个参数。另请注意，方法正文的 recur 调用*不应*传递目标对象，它将自动提供并且无法替换。在方法体中，可以使用（未限定）名称来命名类（用于调用 new、instance? 等）。在 AOT 编译时，为具有给定名称（符号）的类生成编译后的字节码，将当前 ns 添加为包，并将 .class 文件写入 *compile-path* 目录。将定义一个构造函数，取指定字段。请注意，字段名称 __meta、__extmap、__hash 和 __hasheq 目前已被保留，在定义自己的类型时不应使用。给出 (deftype 类型名称 ...)，将定义一个名为 ->TypeName 的工厂函数，它取字段的位置参数
- 延迟
- 取一段表达式并生成一个延迟对象，它只会首次强制时（通过 force 或 deref/@）调用实体，并会高速缓存结果并在所有后续强制调用中返回该结果。另请参见 - realized?
- delay?
- 如果 x 是使用延迟创建的延迟，则返回 true
- 交付
- 将提供的 value 传递给承诺，释放任何待定的 deref。后续对承诺发出的 deliver 调用不会产生任何效果。
- deref
- 也是读取器宏：@ref/@agent/@var/@atom/@delay/@future/@promise。在交易中，返回 ref 的交易中值，否则返回 ref 最近提交的值。应用于变量、代理或原子时，返回其当前状态。应用于延迟时，如果尚未强制执行，则强制执行。应用于未来时，如果计算未完成，则会阻塞。应用于承诺时，在提供值之前会阻塞。采用超时的变体可用于阻塞引用（未来和承诺），如果在提供值之前达到超时（以毫秒为单位），它将返回 timeout-val。另请参见 - realized?。
- 衍生
- 在父项和标记之间建立父/子关系。父项必须是命名空间限定符号或关键字，子项可以是命名空间限定符号或关键字或类。如果未提供，h 必须是从 make-hierarchy 获取的层次结构，否则将默认为全局层次结构并对其进行修改。
- 后代
- 通过通过 derive 建立的关系，返回标记的直接和间接子项。如果未提供，h 必须是从 make-hierarchy 获取的层次结构，否则将默认为全局层次结构。注意：不适用于 Java 类型继承关系。
- disj
- disj[oin]。返回一个不存在键的新集合（哈希或排序类型）。
- disj!
- disj[join]。返回一个不存在键的瞬态集合（哈希或排序类型）。
- dissoc
- dissoc[iate]。返回一个不存在键映射的新映射（哈希或排序类型）。
- 唯一
- 返回 coll 中去除重复元素的序列。如果不提供集合，则返回有状态的转换器。
- 做
- 按顺序计算表达式并返回最后一个的值。如果没有提供表达式，则返回 nil。有关更多信息，请访问 https://clojure.org/special_forms。
- doall
- 当通过具有副作用的函数生成延迟序列时，除了生成序列中第一个元素所需的任何效果外，序列被消耗之前不会发生。doall 可用于强制执行任何效果。浏览序列的连续下一个，保留并返回头，从而导致整个序列一次驻留在内存中。
- dorun
- 当通过具有副作用的函数生成延迟序列时，除了生成序列中第一个元素所需的任何效果外，序列被消耗之前不会发生。dorun 可用于强制执行任何效果。浏览序列的连续下一个，不保留头并返回 nil。
- doseq
- 使用“for”提供的绑定和过滤，重复执行正文（想必是为了产生副作用）。不保留序列的首部。返回 nil。
- dosync
- 在包含表达式和任何嵌套调用的事务中运行表达式（隐式 do 中）。如果此线程上还没有运行任何事务，则启动事务。任何未捕获的异常都会中止事务并流出 dosync。该表达式可能运行多次，但对 Refs 的任何影响都是原子的。
- dotimes
- 绑定 => 名称 n 重复执行正文（想必是为了产生副作用），其中名称绑定到从 0 到 n-1 的整数。
- doto
- 计算 x，然后用在给定参数的前面提供 x 的值来调用所有方法和函数。这些形式按顺序计算。返回 x。（doto (new java.util.HashMap) （.put “a” 1）（.put “b” 2））
- drop
- 返回 coll 中所有项除了前 n 个项的延迟序列。如果不提供集合，则返回有状态的转换器。
- drop-while
- 从第一个 (pred item) 返回逻辑 false 的项开始，返回 coll 中的项的延迟序列。如果不提供集合，则返回有状态的转换器。
e
- 化简
- 返回转换器在 coll 中的项的化简/可迭代应用程序。转换器按顺序应用，就好像使用 comp 组合一样。请注意，每次调用减少/迭代器时都会执行这些应用程序。
- empty
- 返回与 coll 相同类别的一个空集合，或者返回 nil
- empty?
- 如果 coll 没有 item，返回 true - 与 (not (seq coll)) 相同。请使用惯用语 (seq x) 而非 (not (empty? x))
- ensure
- 必须在事务中调用。保护 ref 免受其他事务的修改。返回 ref 的事务中值。允许的并发性高于 (ref-set ref @ref)
- error-handler
- 返回代理 a 的 error-handler 或者是 nil，如果没有该 error-handler。参见 set-error-handler!
- eval
- 计算形式数据结构（而不是文本！）并返回结果。
- even?
- 如果 n 为偶数，返回 true。如果 n 不是整数，抛出一个异常
- every-pred
- 获取一组谓词并返回一个函数 f，如果其所有组成谓词针对其所有参数返回逻辑真，则该函数返回 true，否则返回 false。请注意 f 是短路的，因为它将对针对原始谓词触发逻辑假结果的第一个参数停止执行。
- every?
- 如果 (pred x) 对于 coll 中的每个 x 均为逻辑真，返回 true，否则返回 false。
- ex-cause
- 如果 ex 是一个 Throwable，返回 ex 的原因。否则返回 nil。
- ex-data
- 如果 ex 是一个 IExceptionInfo，返回异常数据（一个映射）。否则返回 nil。
- ex-info
- 创建一个 ExceptionInfo 实例，这是一个携带附加数据映射的 RuntimeException 子类。
- ex-message
- 如果 ex 是一个 Throwable，返回附加到 ex 的消息。否则返回 nil。
- extend
- 可以使用 extend 构造来实现协议方法： (extend AType AProtocol {:foo an-existing-fn :bar (fn [a b] ...) :baz (fn ([a]...) ([a b] ...)...)} BProtocol {...} ...) extend 获取一个类型/类（或界面，参见下文）和一个或多个协议 + 方法映射对。当 AType 作为第一个参数提供时，它将扩展协议方法的多态性以调用所提供的这些方法。方法映射是关键字化的方法名到普通 fn 的映射。这有助于方便重用现有的 fn 和 fn 映射，以便在代码重用/混合过程中无需派生或组合。你可以将一个接口扩展到一个协议。这主要是为了促进与主体的互操作（例如，Java），但会打开实现的多重继承的意外之门，因为一个类可以从多个继承接口，而这些接口都可以扩展该协议。如何指定要使用的实现尚未确定。你可以将一个协议扩展到 nil。如果你明确提供定义（即不重新使用现有的函数或混合映射），你可能会发现使用 extend-type 或 extend-protocol 宏更加方便。请注意，对于同类型，可以存在多个独立的 extend 子句，并非所有协议都必须在单个 extend 调用中定义。另请参见： extends?、satisfies?、extenders
- extend-protocol
- 当你希望同时提供同一协议的几个实现时，很有用。获取单个协议和该协议针对一到多种类型的实现。展开成对 extend-type 的调用： (extend-protocol Protocol AType (foo [x] ...) (bar [x y] ...) BType (foo [x] ...) (bar [x y] ...) AClass (foo [x] ...) (bar [x y] ...) nil (foo [x] ...) (bar [x y] ...)) 展开成： (do (clojure.core/extend-type AType Protocol (foo [x] ...) (bar [x y] ...)) (clojure.core/extend-type BType Protocol (foo [x] ...) (bar [x y] ...)) (clojure.core/extend-type AClass Protocol (foo [x] ...) (bar [x y] ...)) (clojure.core/extend-type nil Protocol (foo [x] ...) (bar [x y] ...)))
- extend-type
- 扩展调用的宏展开。在你明确提供内联定义时有用，扩展类型自动创建扩展所需的映射。在所有 fn 的第一个参数中将类作为类型提示进行传播。（扩展类型 MyType 可数（cnt [c] ...）Foo（bar [x y] ...）（baz ([x] ...）（[x y & zs] ...））展开为：（扩展 MyType 可数 {:cnt（fn [c] ...）} Foo {:baz（fn ([x] ...）（[x y & zs] ...））:bar（fn [x y] ...）})
f
- 筛选器
- 对于（pred 项）返回逻辑真值的 coll 中的项，返回一个惰性序列。pred 必须没有副作用。如果没有提供集合，则返回一个转换器。
- filterv
- 对于（pred 项）返回逻辑真值的 coll 中的项，返回一个向量。pred 必须没有副作用。
- 最后
- 评估表达式，如果未出现例外情况，则返回最后一个表达式的值。如果出现例外情况并且提供了 catch 条款，它将依次检查每个条款，第一个被抛出例外视为其命名的类实例的条款被视为匹配的 catch 条款。如果存在匹配的 catch 条款，则在 name 绑定到抛出例外的情况中评估其表达式，并且最后一个表达式的值为函数的返回值。如果没有匹配的 catch 条款，则例外会在函数中传播。无论正常返回还是异常返回，任何 finally 表达式都将被评估其副作用。请访问 https://clojure.org/special_forms 了解更多信息。
- 查找关键字
- 如果已存在具有给定命名空间和名称的关键字，则返回该关键字。此函数不会对新关键字进行转换。如果关键字尚未被转换，则它将返回 nil。请不要在关键字字符串中使用：“：”，它将自动添加。
- 查找命名空间
- 返回符号命名的命名空间，如果不存在，则返回空值。
- 查找变量
- 返回命名空间限定符号命名的全局变量，如果没有该名称的变量，则返回空值。
- 第一个
- 返回集合中的第一个项目。在参数上调用 seq。如果 coll 为空值，则返回空值。
- 扁平化
- 接受顺序数据的任何嵌套组合（列表、向量等），并将它们的内容作为单个平面惰性序列返回。（flatten nil）返回一个空序列。
- fn
- params => positional-params*, or positional-params* & rest-param positional-param => binding-form rest-param => binding-form binding-form => name, or destructuring-form 定义一个函数。有关更多信息，请访问 https://clojure.org/reference/special_forms#fn
- fn?
- 如果 x 实现 Fn，即通过 fn 创建的对象，则返回真。
- fnil
- 采用函数 f，并返回一个调用 f 的函数，用提供的 x 值替换 f 的第一个 nil 参数。更高的元组版本可以在第二个和第三个位置（y，z）替换参数。请注意，函数 f 可以接受任意数量的参数，而不仅仅是那些非空修补的参数。
- for
- 列表推导。采用一个或多个 binding-form/collection-expr 对的向量，每个对后跟零个或多个修饰符，并生成一个 expr 求值惰性序列。以嵌套方式迭代集合，最右侧最快，并且嵌套 coll-expr 可以引用之前 binding-form 中创建的绑定。支持的修饰符为：：let [binding-form expr ...],：while test,：when test。（take 100 (for [x（range 100000000）y（range 1000000）:while (< y x)] [x y]))
- force
- 如果 x 是延时，则返回其表达式的值（可能缓存在内存中），否则返回 x
- format
- 使用 java.lang.String.format 格式化字符串，有关格式字符串语法的概念，请参见 java.util.Formatter
- future
- 采用一个表达式序列，并生成一个 future 对象，该对象将在另一个线程中调用序列，并将缓存结果，然后在对 deref/@ 的所有后续调用中返回该结果。如果计算尚未完成，对 deref/@ 的调用将阻塞，除非使用带有 timeout 的 deref 变体。另请参阅 - realized?。
- future-call
- 采用一个无参数函数，并生成一个 future 对象，该对象将在另一个线程中调用该函数，并将缓存结果，然后在对 deref/@ 的所有后续调用中返回该结果。如果计算尚未完成，对 deref/@ 的调用将阻塞，除非使用带有 timeout 的 deref 变体。另请参阅 - realized?。
g
- gen-class
- When compiling, generates compiled bytecode for a class with the given package-qualified :name (which, as all names in these parameters, can be a string or symbol), and writes the .class file to the *compile-path* directory. When not compiling, does nothing. The gen-class construct contains no implementation, as the implementation will be dynamically sought by the generated class in functions in an implementing Clojure namespace. Given a generated class org.mydomain.MyClass with a method named mymethod, gen-class will generate an implementation that looks for a function named by (str prefix mymethod) (default prefix: "-") in a Clojure namespace specified by :impl-ns (defaults to the current namespace). All inherited methods, generated methods, and init and main functions (see :methods, :init, and :main below) will be found similarly prefixed. By default, the static initializer for the generated class will attempt to load the Clojure support code for the class as a resource from the classpath, e.g. in the example case, ``org/mydomain/MyClass__init.class``. This behavior can be controlled by :load-impl-ns Note that methods with a maximum of 18 parameters are supported. In all subsequent sections taking types, the primitive types can be referred to by their Java names (int, float etc), and classes in the java.lang package can be used without a package qualifier. All other classes must be fully qualified. Options should be a set of key/value pairs, all except for :name are optional: :name aname The package-qualified name of the class to be generated :extends aclass Specifies the superclass, the non-private methods of which will be overridden by the class. If not provided, defaults to Object. :implements [interface ...] One or more interfaces, the methods of which will be implemented by the class. :init name If supplied, names a function that will be called with the arguments to the constructor. Must return [ [superclass-constructor-args] state] If not supplied, the constructor args are passed directly to the superclass constructor and the state will be nil :constructors {[param-types] [super-param-types], ...} By default, constructors are created for the generated class which match the signature(s) of the constructors for the superclass. This parameter may be used to explicitly specify constructors, each entry providing a mapping from a constructor signature to a superclass constructor signature. When you supply this, you must supply an :init specifier. :post-init name If supplied, names a function that will be called with the object as the first argument, followed by the arguments to the constructor. It will be called every time an object of this class is created, immediately after all the inherited constructors have completed. Its return value is ignored. :methods [ [name [param-types] return-type], ...] The generated class automatically defines all of the non-private methods of its superclasses/interfaces. This parameter can be used to specify the signatures of additional methods of the generated class. Static methods can be specified with ^{:static true} in the signature's metadata. Do not repeat superclass/interface signatures here. :main boolean If supplied and true, a static public main function will be generated. It will pass each string of the String[] argument as a separate argument to a function called (str prefix main). :factory name If supplied, a (set of) public static factory function(s) will be created with the given name, and the same signature(s) as the constructor(s). :state name If supplied, a public final instance field with the given name will be created. You must supply an :init function in order to provide a value for the state. Note that, though final, the state can be a ref or agent, supporting the creation of Java objects with transactional or asynchronous mutation semantics. :exposes {protected-field-name {:get name :set name}, ...} Since the implementations of the methods of the generated class occur in Clojure functions, they have no access to the inherited protected fields of the superclass. This parameter can be used to generate public getter/setter methods exposing the protected field(s) for use in the implementation. :exposes-methods {super-method-name exposed-name, ...} It is sometimes necessary to call the superclass' implementation of an overridden method. Those methods may be exposed and referred in the new method implementation by a local name. :prefix string Default: "-" Methods called e.g. Foo will be looked up in vars called prefixFoo in the implementing ns. :impl-ns name Default: the name of the current ns. Implementations of methods will be looked up in this namespace. :load-impl-ns boolean Default: true. Causes the static initializer for the generated class to reference the load code for the implementing namespace. Should be true when implementing-ns is the default, false if you intend to load the code via some other method.
- gen-interface
- 在编译时，为具有给定包限定的 :name 的接口生成已编译字节码（在这些参数中，所有名称都可以是字符串或符号），并将 .class 文件写入 *compile-path* 目录。在不编译时，则什么也不执行。在需要类型的后续所有章节中，可以用基本类型的 Java 名称（int、float 等）引用它们，并且可以使用 java.lang 包中的类而不使用包限定符。必须对其他所有类进行完全限定。选项应为一组键/值对，除 :name 外，所有选项均为可选：:name aname 要生成的类的包限定名称：:extends [接口 …] 该接口将扩展的一个或多个接口。:methods [ [name [param-types] return-type]，…] 此参数用于指定已生成接口的方法签名。不要在此处重复超接口签名。
- gensym
- 返回一个具有唯一名称的新符号。如果提供前缀字符串，则该名称为 prefix#，其中 # 是某个唯一数字。如果未提供前缀，则前缀为 'G__'。
- get
- 返回映射到 key 的值，如果 key 不存在于关联集合、集合、字符串、数组或 ILookup 实例中，则返回 not-found 或 nil。
- get-in
- 返回嵌套关联结构中的值，其中 ks 是键序列。如果键不存在，则返回 nil；如果已提供，则返回 not-found 值。
- get-method
- 给定一个多态方法和一个调度值，返回将应用于该值的调度 fn，如果没有应用值且没有默认值，则返回 nil
- get-proxy-class
- 采用一个可选单一类，后跟零个或多个接口。如果没有提供类，则默认值为 Object。创建并返回一个从提供的类派生的代理类的实例。缓存结果值，并将其用于对同一类集的所有后续请求。返回一个 Class 对象。
- group-by
- 返回一个 coll 元素的映射，其键为 f 在每个元素上的结果。每个键的值将是对应元素的向量，按照这些元素在 coll 中出现的顺序排列。
h
- halt-when
- 返回一个转换器，当 pred 为某个输入返回 true 时，该转换器将结束转换。提供 retf 时，它必须是 2 个参数的 fn - 它将被传递到目前为止的（已完成的）结果和触发谓词的输入，并且它的返回值（如果没有引发异常）将是转换器的返回值。如果没有提供 retf，则将返回触发谓词的输入。如果谓词从不返回 true，则转换不受影响。
- hash
- 返回其参数的哈希码。请注意，这是与等号一致的哈希码，因此不同于 Integer、Short、Byte 和 Clojure 集合的 .hashCode 。
- hash-map
- keyval => key val 返回包含已提供映射的新哈希映射。如果任一密钥相等，则处理它们就如同通过 assoc 重复使用一样。
- hash-ordered-coll
- 返回与外部实现 Iterable 的有序集合一致的哈希码。请参阅 https://clojure.org/data_structures#hash 了解完整的算法。
- hash-set
- 返回包含已提供密钥的新哈希集合。任何相等密钥的处理就如同通过 conj 重复使用一样。
- hash-unordered-coll
- 返回与外部实现 Iterable 的无序集合一致的哈希码。对于映射，迭代器应返回其哈希计算为 (hash-ordered-coll [k v]) 的映射条目。请参阅 https://clojure.org/data_structures#hash 了解完整的算法。
i
- if-let
- bindings => binding-form test 如果测试为 true，则用绑定至测试值的 binding-form 评估 then，如果不是，则返回 else
- if-not
- 评估测试。如果逻辑假，则评估并返回 then 表达式，否则（如果已提供）返回 else 表达式，否则返回 nil。
- if-some
- bindings => binding-form test 如果测试不为 nil，则用绑定至测试值的 binding-form 评估 then，如果不是，则返回 else
- ifn?
- 如果 x 实现 IFn，则返回 true。请注意，许多数据结构（例如集合和映射）实现 IFn
- import
- import-list => (package-symbol class-name-symbols*) 对于 class-name-symbols 中的每个名称，将一个从名称映射到由 package.name 命名且属于当前命名空间的类的映射添加到该名称。优先在 ns 宏中使用 :import，而不是直接调用此宏。
- in-ns
- 将 *ns* 设置为由符号命名的命名空间，必要时创建命名空间。
- inc
- 返回比 num 大 1 的数字。不会自动提升长整数，将引发溢出。另请参阅：inc'
- inc'
- 返回比 num 大 1 的数字。支持任意精度。另请参阅：inc
- indexed?
- 如果 coll 实现 Indexed，指示可以根据索引有效查找，则返回 true
- infinite?
- 如果 num 为负无穷大或正无穷大，则返回 true，否则返回 false
- init-proxy
- 获取代理实例以及一个包含字符串（必须对应于代理超类/超级接口的方法）到 fns （必须采取与对应方法匹配的参数，再加上一个显式的第一个参数，对应于 this）的映射，并设置代理的 fn 映射。返回代理。
- inst-ms
- 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来经过的毫秒数
- inst?
- 如果 x 满足 Inst，则返回 true
- instance?
- 对 x 求值，并测试它是否是类 c 的实例。返回 true 或 false
- intern
- 在命名空间 ns（可以是符号或命名空间）中的符号名称找到或创建 var，如果提供，将它的根绑定设置为 val。命名空间必须存在。该 var 将采用来自名称符号的任何元数据。返回该 var。
- interpose
- 返回已由 sep 分隔的 coll 元素的惰性序列。在未提供任何集合时，返回一个有状态的变换器。
- into
- 返回由所有来自 coll 的项连接而成的新的 coll。可以提供转换器。
- into-array
- 返回一个数组，其中的组件设置为 aseq 中的值。如果提供数组的组件类型，则为该组件类型；如果 aseq 中存在第一个值，则为该值的类型；否则为 Object。aseq 中的所有值都必须与组件类型兼容。可以通过使用 Integer/TYPE 等方式获取用于基本类型的类对象。
- io!
- 如果在事务中出现 io! 块，则抛出 IllegalStateException，否则使用隐式 do 运行 body。如果 body 中的第一个表达式是文字字符串，则将其用作异常消息。
- isa?
- 如果 (= child parent)，或者直接或间接地从 parent 导出 child，无论是通过 Java 类型继承关系还是通过使用 derive 建立的关系，则返回 true。如果 h 未提供，它必须是从 make-hierarchy 获取的层级，否则默认使用全局层级
- iterate
- 返回 x、(f x)、(f (f x)) 等的延迟序列。f 必须没有副作用
- iteration
- 通过反复调用某个（延续标记）'k' 的函数 step，创建可 seqable/可 reducible 的项：step 的第一次调用将传递 initk，返回'ret'。如果 (somef ret) 为 true，(vf ret) 将包含在迭代中，否则迭代将终止且不会调用 vf/kf。如果 (kf ret) 为非 null，则将把它传递到下一个 step 调用，否则迭代将终止。例如，这可用于使用返回分页或批次数据 API。step - 'k' 的（可能不纯）fn -> 'ret' :somef - 'ret' 的 fn -> 逻辑 true/false，默认值为 'some?' :vf - 'ret' 的 fn -> 'v'，迭代产生的值，默认值为 'identity' :kf - 'ret' 的 fn -> 'next-k' 或 null（表示“不继续”），默认值为 'identity' :initk - 传递到 step 的第一个值，默认值为 'nil' 假设使用非 initk 的 step 不可复用/不可幂等。如果使用 initk 的 step 不可复用，则由使用者保证不重复使用。
- iterator-seq
- 在 java.util.Iterator 上返回一个 seq。请注意，提供迭代器的多数集合都实现了 Iterable，因此直接支持 seq。Seq 会缓存值，因此不能对反复返回同一可变对象的任何迭代器使用 iterator-seq。
j
- juxt
- 接受一组函数，返回一个 fn，即那些 fn 的并置。返回的 fn 接受数量可变的参数，并返回一个包含应用每个 fn 到参数（从左至右）的结果的向量。((juxt a b c) x) => [(a x) (b x) (c x)]
k
- keep
- 返回一个 (f 项目) 的非 nil 结果的延迟序列。请注意，这意味着将包括返回 false 值。f 必须没有副作用。如果未提供集合，则返回一个转换器。
- keep-indexed
- 返回 (f 索引项目) 的非 nil 结果的延迟序列。请注意，这意味着将包括返回 false 值。f 必须没有副作用。如果未提供集合，则返回一个有状态转换器。
- keys
- 返回映射的键的序列，顺序与 (seq map) 相同。
- keyword
- 返回具有给定名称空间和名称的 Keyword。不要在关键词字符串中使用 :，系统会自动添加。
l
- lazy-cat
- 展开为产生所提供 coll 连接的延迟序列的代码。只有在需要时才会计算每个 coll 表达式。(lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))
- lazy-seq
- 采用返回 ISeq 或 nil 的表达式主体，并且产生一个 Seqable 对象，该对象仅在第一次调用 seq 时调用主体，并且缓存结果并在所有后续 seq 调用中返回该结果。另请参见 - realized?
- let
- binding => binding-form init-expr binding-form => name, or destructuring-form destructuring-form => map-destructure-form, or seq-destructure-form 在词法上下文中计算 exprs，其中 binding-form 中的符号绑定到各自的 init-expr 或其部分。有关解构的更多信息，请参阅 https://clojure.org/reference/special_forms#binding-forms。
- letfn
- fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+) 采用一个函数规范向量和一个主体，并且生成一组函数绑定到其名称的绑定。在所有函数定义以及主体中，所有名称均可用。
- line-seq
- 将来自 rdr 的文本行作为字符串惰性序列返回。rdr 必须实现 java.io.BufferedReader。
- list*
- 创建一个包含前置于 rest 的项的新 seq，其中最后一个将被视为序列。
- list?
- 如果 x 实现 IPersistentList，则返回 true
- load
- 从类路径中的资源加载 Clojure 代码。如果路径以斜杠开头，则会被解释为类路径相关；否则，会被解释为当前名称空间的根目录相关。
- locking
- 在隐式 do 中计算 exprs，同时持有时 x 的监视器。在所有情况下，均会释放 x 的监视器。
- loop
- 在词法上下文中计算 exprs，其中 binding-form 中的符号绑定到各自的 init-expr 或其部分。充当 recur 目标。
m
- macroexpand
- 不断对表单调用 macroexpand-1，直到它不再表示宏表单，然后返回该表单。请注意，macroexpand-1 或 macroexpand 均不在子表单中扩展宏。
- make-array
- 创建并返回一个指定类指定维度（维度）的实例数组。请注意，需要类对象。可以通过使用其导入的或完全限定的名称获取类对象。可以使用 Integer/TYPE 获取原始类型的类对象。
- map
- 返回一个惰性序列，其中包含将 f 应用于每个 coll 的第一个项的集合的结果，接着将 f 应用于每个 coll 的第二个项的集合，直至其中任何一个 coll 耗尽。其他 coll 中的任何剩余项都将被忽略。函数 f 应接受 number-of-colls 个参数。如果没有提供任何集合，则返回一个转换器。
- map-indexed
- 返回一个惰性序列，其中包含将 f 应用于 0 和 coll 的第一个项的结果，接着将 f 应用于 1 和 coll 中的第二个项等，直至 coll 耗尽。因此，函数 f 应接受 2 个参数：索引和项。如果没有提供任何集合，则返回一个有状态转换器。
- map?
- 如果 x 实现 IPersistentMap，则返回 true
- mapcat
- 返回将 concat 应用于将 map 应用于 f 和 colls 的结果的结果。因此，函数 f 应返回一个集合。如果没有提供任何集合，则返回一个转换器
- mapv
- 返回一个向量，该向量包含对每个 coll 中的第一项应用 f 的结果，其次是将 f 应用于每个 coll 中的第二项，直到任何一个 coll 耗尽。忽略其他 coll 中的任何剩余项。函数 f 应接受 coll 数参数。
- max-key
- 返回 (k x) 为最大数字的 x。如果存在多个这样的 x，则返回最后一个 x。
- memfn
- 扩展到创建 fn 的代码，该 fn 期望传递对象和任何 arg，并在对象上调用具名实例方法，传递 arg。当您想将 Java 方法视为一等 fn 时使用。name 可以通过方法接收者的类型进行类型提示，以避免反射调用。
- memoize
- 返回引用透明函数的记忆化版本。该函数的记忆化版本将 arg 与结果的映射缓存起来，当重复调用相同 arg 时，该函数以增加内存使用为代价提高性能。
- merge
- 返回一个 map，该 map 由第一个 map 上联接的其余 map 组成。如果一个键出现在多个 map 中，那么结果中的映射将是后者的映射（从左到右）。
- merge-with
- 返回一个 map，该 map 由第一个 map 上联接的其余 map 组成。如果一个键出现在多个 map 中，则通过调用 (f val-in-result val-in-latter) 将后者（从左到右）的映射与结果中的映射结合起来。
- meta
- 返回 obj 的元信息，如果没有元信息则返回 nil。
- min-key
- 返回 (k x) 为最小数字的 x。如果存在多个这样的 x，则返回最后一个 x。
- mix-collection-hash
- 对有序或无序集合进行最终集合哈希混合。hash-basis 是组合后的集合哈希，count 是包含在基本中的元素数量。请注意，这是与 = 一致的哈希代码，不同于 .hashCode。有关完整算法，请参阅 https://clojure.org/data_structures#hash。
- mod
- num 和 div 的模数。朝负无穷大截断。
- monitor-enter
- 一种同步基元，在用户代码中应避免使用。使用锁定宏。有关更多信息，请参阅 https://clojure.org/special_forms。
- monitor-exit
- 一种同步基元，在用户代码中应避免使用。使用锁定宏。有关更多信息，请参阅 https://clojure.org/special_forms。
n
- name
- 返回字符串、符号或关键字的 name String。
- namespace
- 返回符号或关键字的 namespace String，或者如果不存在，则返回 nil。
- NaN?
- 如果 num 是 NaN，则返回 true，否则返回 false
- neg?
- 如果 num 小于零，则返回 true，否则返回 false
- new
- 实例化一个类。有关更多信息，请参阅 https://clojure.org/java_interop#new。
- next
- 返回第一个之后的项的 seq。对其参数调用 seq。如果没有更多项，则返回 nil。
- nil?
- 如果 x 为 nil，则返回 true，否则返回 false。
- not
- 如果 x 为逻辑 false，则返回 true，否则返回 false。
- not-any?
- 如果 (pred x) 对 coll 中的任何 x 为逻辑 true，则返回 false，否则返回 true。
- not-every?
- 如果 coll 中每个 x 的 (pred x) 逻辑值为真，则返回假，否则返回真。
- not=
- 与 (not (= obj1 obj2)) 相同
- ns
- 将 *ns* 设置为 name 命名的命名空间（未求值），必要时创建它。引用可以是以下一个或多个：(:refer-clojure ...) (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class) 分别采用 refer-clojure/require/use/import/load/gen-class 的语法，除了参数未求值且无需引用外。(:gen-class ...)（如果提供）默认值为与 ns 名称对应的 :name、:main true、与 ns 相同的 :impl-ns 和 :init-impl-ns true。支持 gen-class 的所有选项。未编译时将忽略 :gen-class 指令。如果未提供 :gen-class，则编译时仅生成一个 nsname__init.class。如果未使用 :refer-clojure，则使用默认值 (refer 'clojure.core)。建议将 ns 用于针对 in-ns/require/use/import 的各个调用：(ns foo.bar (:refer-clojure :exclude [ancestors printf]) (:require (clojure.contrib sql combinatorics)) (:use (my.lib this that)) (:import (java.util Date Timer Random) (java.sql Connection Statement)))
- ns-resolve
- 返回一个 var 或 Class，该符号将在命名空间中求值（除非在环境中找到），否则为 nil。请注意，如果符号是完全限定的，则它求值的 var/Class 不必存在于命名空间中。
- nth
- 返回索引处的值。如果索引超出范围，get 返回 nil，nth 抛出异常，除非提供了 not-found。nth 还适用于字符串、Java 数组、regex Matcher 和列表，并且适用于 O(n) 时间内的序列。
- nthnext
- 返回 coll 的第 n 个下一个元素，当 n 为 0 时返回 (seq coll)。
- nthrest
- 返回 coll 的第 n 个剩余元素，当 n 为 0 时返回 coll。
o
- odd?
- 如果 n 是奇数，则返回真，如果 n 不是整数，则抛出异常
- or
- 从左到右一次评估一个 expr。如果一个表单返回逻辑真值，则返回该值并且不会评估任何其他表达式，否则返回最后一个表达式的值。（or）返回 nil。
p
- parents
- 返回 tag 的直接父级，可以通过 Java 类型继承关系或通过 derive 建立的关系。必须从 make-hierarchy 获取 h，如果没有提供，则默认为全局层次结构
- parse-double
- 解析具有浮点分量的字符串并返回一个 Double 值，或在解析失败时返回 nil。语法：https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-
- parse-long
- 解析十进制数字的字符串，前面可以带 +/-，并返回 Long 值，或在解析失败时返回 nil
- parse-uuid
- 解析表示 UUID 的字符串并返回 java.util.UUID 实例，或在解析失败时返回 nil。语法：https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--
- partial
- 获取一个函数 f 和小于 f 所需参数数量的参数，并返回一个获取可变数量的附加参数的函数。当调用时，返回的函数用 args + additional args 调用 f。
- partition
- 返回一个 lazy 序列，其中包含每一项 n 个列表，偏移步进分开。如果未提供步进，则默认为 n，即分区不重叠。如果提供填充集合，则在必要时使用其元素来将最后一个分区填充到 n 项。如果没有足够的填充元素，则返回一个项少于 n 的分区。
- partition-all
- 返回一个类似于 partition 的 lazy 序列列表，但可能在最后包含项少于 n 的分区。在未提供集合时，返回一个有状态的转换器。
- partition-by
- 将 f 应用于 coll 中的每一项，在 f 返回新值时将每一项拆分。返回一个分区的 lazy seq。在未提供集合时，返回一个有状态的转换器。
- peek
- 对于列表或队列，与 first 相同，对于向量，与 last 相同，但效率更高。如果集合为空，则返回 nil。
- persistent!
- 以常量时间返回瞬态集合的新持久版本。在此调用之后不能再使用瞬态集合，任何此类使用都会引发异常。
- pmap
- 与 map 相似，但 f 是并行应用的。半懒惰，因为并行计算领先于消耗，但除非需要，否则不会实现整个结果。仅适用于计算密集型函数，其中 f 的时间支配着协调开销。
- pop
- 对于一个列表或队列，返回一个没有第一项的新列表/队列；对于向量，返回一个没有最后一项的新向量。如果集合为空，则抛出异常。注意——与 next/butlast 不同。
- pop!
- 从瞬态向量中删除最后一项。如果集合为空，则抛出异常。返回 coll
- pos?
- 如果 num 大于零，则返回 true，否则返回 false
- pr
- 将对象打印到输出流，这是 *out* 的当前值。打印对象（如果有两个以上，则用空格分隔）。默认情况下，pr 和 prn 以对象可由阅读器读取的方式进行打印
- print
- 将对象打印到输出流，这是 *out* 的当前值。print 和 println 生成供人类消费的输出。
- PrintWriter-on
- 实现 java.io.PrintWriter（给定 flush-fn，它将在调用 .flush() 时使用 .flush() 来调用，自上次对 .flush() 的调用以来，一个字符串已构建）。如果不是 nil，将在调用 .close 时使用 close-fn 不带参数
- prn
- 与在 (newline) 之后打印相同。观察 *flush-on-newline*
- promise
- 返回一个 promise 对象，可以通过 deref/@ 读取，并且只能使用 deliver 设置一次。在递送之前，对 deref/@ 的调用会阻塞，除非使用带有超时功能的 deref 变量。所有后续的 deref 都会返回相同的已递送值，而不会阻塞。另请参见 - realized?。
- proxy
- class-and-interfaces - 类名向量 args - 超类构造函数的参数向量（可能为空）。f => (name [params*] body) 或 (name ([params*] body) ([params+] body) ...) 扩展为用于创建代理类实例的代码，该类通过调用提供的 fns 来实现命名的类/接口。如果提供了单个类，则必须位于首位。如果没有提供，它将默认为 Object。接口名称必须是有效的接口类型。如果未为类方法提供方法 fn，则将调用超类方法。如果未为接口方法提供方法 fn，则在调用该方法时将引发 UnsupportedOperationException。方法 fns 为闭包，可以捕获调用 proxy 时所在的环境。每个方法 fn 都有一个附加的隐式第一个参数，它绑定到 'this'。请注意，虽然可以提供方法 fns 来覆盖受保护的方法，但它们不能访问其他受保护成员或像 super，因为这些功能不能被代理。
- push-thread-bindings
- 警告：这是一个底层函数。在任何可能的情况下，优先使用诸如 binding 之类的顶层宏。获取一个 Var/value 对的映射。为当前线程将每个 Var 绑定到关联的值。每个调用 *必须* 伴随一个匹配的 pop-thread-bindings 调用，该调用包装在 try-finally！中 (push-thread-bindings bindings) (try ... (finally (pop-thread-bindings)))
q
- quote
- 生成未求值的形式。有关详细信息，请参阅 https://clojure.org/special_forms。
r
- rand
- 返回 0（包括）和 n（默认 1）（排除）之间的随机浮点数。
- rand-nth
- 返回（顺序）集合的随机元素。将具有与给定集合的 nth 相同的性能特征。
- random-sample
- 在具有随机概率 prob（0.0 - 1.0）的情况下返回 coll 中的项。在不提供集合的情况下返回一个转换器。
- random-uuid
- 返回一个伪随机生成的 java.util.UUID 实例（即类型 4）。参见：https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#randomUUID--
- range
- 从 start（包括）到 end（排除），按 step 返回 nums 的惰性 seq，其中 start 默认为 0，step 默认为 1，end 默认为无穷大。当 step 等于 0 时，返回一个 start 的无穷序列。当 start 等于 end 时，返回空列表。
- re-find
- 使用 java.util.regex.Matcher.find() 返回（如果存在）字符串与 pattern 的下一个正则表达式匹配。使用再分组来返回分组。
- re-groups
- 返回最近匹配/查找中的分组。如果没有嵌套分组，则返回整个匹配项的字符串。如果有嵌套分组，则返回分组的向量，第一个元素是整个匹配项。
- re-matcher
- 返回 java.util.regex.Matcher 的一个实例，用于（例如）re-find。
- re-matches
- 返回 string 与 pattern 的匹配（如果存在），使用 java.util.regex.Matcher.matches()。使用 re-groups 返回这些组。
- re-pattern
- 返回 java.util.regex.Pattern 的一个实例，用于（例如）re-matcher。
- re-seq
- 返回一个惰性序列，包含使用 java.util.regex.Matcher.find() 在 string 中找到的相继匹配，每个匹配都使用 re-groups 进行处理。
- read
- 从流中读取下一个对象，它必须是 java.io.PushbackReader 或某个派生类的实例。stream 默认为 *in* 的当前值。opts 是一个持久映射，具有有效键：:read-cond - :allow 以处理 reader 条件语句，或 :preserve 以保留所有分支 :features - reader 条件语句的持久功能关键字集 :eof - 在 eof 时，返回值（除非 :eofthrow，则抛出）。如果不指定，则将抛出。请注意，read 可以执行代码（受 *read-eval* 控制），因此仅应与受信任的源一起使用。对于数据结构互操作，请使用 clojure.edn/read
- read+string
- 与 read 类似，接收相同的参数。stream 必须是 LineNumberingPushbackReader。返回一个包含所读取对象和读取的（已修剪空格的）字符串向量的向量。
- read-string
- 从 string s 读取一个对象。也可以包含 reader 选项，如 read 中所指定。请注意，read-string 可以执行代码（受 *read-eval* 控制），因此仅应与受信任的源一起使用。对于数据结构互操作，请使用 clojure.edn/read-string
- realized?
- 如果已针对 promise、delay、future 或惰性序列生成值，则返回真。
- recur
- 按顺序计算 expr，然后并行地将递归点的绑定重新绑定到 expr 的值。有关更多信息，请参阅 https://clojure.org/special_forms。
- reduce
- f 应为 2 个参数的函数。如果未提供 val，则返回将 f 应用于 coll 中前两项的结果，然后将 f 应用于该结果和第三项，依此类推。如果 coll 不包含任何项，f 也必须不接受任何参数，reduce 返回调用 f 时不提供任何参数的结果。如果 coll 仅包含 1 个项目，则返回该项并且不会调用 f。如果提供了 val，则返回将 f 应用于 val 和 coll 中的第一项的结果，然后将 f 应用于该结果和第二项，依此类推。如果 coll 不包含任何项，则返回 val 并且不会调用 f。
- reduce-kv
- 归约关联集合。f 应为 3 个参数的函数。返回将 f 应用于 init、coll 中的第一个键以及第一个值的结果，然后将 f 应用于该结果和第二个键与值，依此类推。如果 coll 不包含任何条目，则返回 init 并且不会调用 f。注意，reduce-kv 支持向量，其中键将是序数。
- reduced
- 以一种方式包装 x，使得 reduce 将以值 x 终止
- reductions
- 返回 coll 的归约（根据 reduce）的中间值的一个惰性序列，从 init 开始。
- ref
- 创建并返回一个 Ref，其初始值为 x，并具有零个或多个选项（任意顺序）： :meta 元数据映射 :validator 验证函数 :min-history （默认值 0）:max-history （默认值 10）如果提供了 metadata-map，它将成为 ref 上的元数据。validate-fn 必须是 nil 或一个不产生副作用的函数，它将在任何状态更改时传递预期的新状态。如果新状态不可接受，则 validate-fn 应返回 false 或抛出异常。validate-fn 将在事务提交时调用，此时所有 ref 均为最终值。通常情况下，ref 根据需要动态累积历史记录以满足读取需求。如果您提前知道需要历史记录，则可以将 :min-history 设置为确保它在首次需要时可用（而不是在读取故障之后）。历史记录是有限的，并且可以将限制设置为 :max-history。
- refer
- 根据过滤器，引用 ns 的所有公共变量。过滤器最多包含每个过滤器之一： :exclude 符号列表 :only 符号列表 :rename 从符号到符号的映射对于由符号命名的命名空间中的每个公共内部变量，都会向当前命名空间添加一个从变量的名称到变量的映射。如果当前命名空间中名称已映射到其他内容，则抛出异常。可以使用过滤器通过包含或排除来选择子集，或者提供与变量名称不同的符号的映射，以防止冲突。优先在 ns 宏中使用 :use，而不是直接调用此宏。
- reify
- reify 创建实现协议或接口的对象。reify 是一个具有以下结构的宏： (reify 选项* 规格*) 当前没有选项。每个规范由协议或接口名称后跟零个或多个方法主体组成： 协议或接口或对象（methodName [args+] 主体） * 应为所需协议和接口提供所有方法。您还可以为 Object 的方法定义覆盖项。请注意，必须提供第一个参数与目标对象相对应（用 Java 术语来说是“this”）。因此，接口的方法将比接口声明多一个参数。另请注意，不应将 recur 调用传递给方法头，它将自动提供且不可替代。可以通过方法名称上的类型提示指示返回类型，可以通过 arg 名称上的类型提示指示 arg 类型。如果您省略所有提示，reify 将尝试匹配协议/接口中同名/ar 的方法 - 这是首选。如果您提供任何提示，则不会进行任何推断，因此所有提示（或 Object 的默认值）都必须正确，对于参数和返回类型都是如此。如果在协议/接口中使方法重载，则必须提供多个独立的方法定义。如果在接口中以相同的 ar 进行重载，则必须指定完整提示以消除歧义 - 缺少的提示表示 Object。recur 作用于方法头 reify 的方法主体是词法闭包，并且可以引用周围的局部作用域： (str (let [f "foo"] (reify Object (toString [this] f)))) == "foo" (seq (let [f "foo"] (reify clojure.lang.Seqable (seq [this] (seq f))))) == (\f \o \o)) reify 始终实现 clojure.lang.IObj并将形式为 to 的元数据转移到创建的对象。（meta ^{:k :v} (reify Object (toString [this] "foo"))) == {:k :v}
- release-pending-sends
- 通常，在另一个操作期间直接或间接发送的操作会保留，直到操作完成（更改代理的状态）。该函数可用于立即发送任何挂起的已发送操作。这对在事务期间发送的操作没有影响，它们仍保留到提交为止。如果没有操作正在发生，则什么也不做。返回已发送的操作数。
- 删除
- 返回一个惰性序列，其中的项目是 coll 中返回逻辑 false 的 (pred 项目) 项。pred 必须没有副作用。如果没有提供集合，则返回一个传感器。
- remove-ns
- 删除符号命名的命名空间。谨慎使用。不能用于删除 clojure 命名空间。
- repeat
- 返回 xs 的惰性序列（无限！，如果提供了，则长 n）。
- repeatedly
- 获取一个不带参数的函数，大概有副作用，并返回一个对其的调用无限（或提供长度 n 的话为长度 n）惰性序列
- replace
- 在给定一个替换对映射和一个向量/集合后，返回一个向量/序列，其中任何元素 = smap 中的键都替换为 smap 中的相应 val。如果没有提供集合，则返回一个传感器。
- require
- 加载库，跳过所有已经加载的库。每个参数都是标识库的 libspec、标识多个名称包含相同前缀的库的前缀列表或修改所有已识别库加载方式的标志。优先在 ns 宏中使用 :require，而不是直接调用它。库“库”是类路径中的一组已命名资源，其内容定义了一组 Clojure 代码。库名称是符号，并且每个库与一个同名的 Clojure 命名空间和 Java 包相关联。库的名称还使用 Java 的包名称到类路径相对路径映射来定位类路径中它的根目录。库中的所有资源应包含在其根目录下的目录结构中。库做出的所有定义都应在其关联的命名空间中。“require 通过加载根资源来加载库。根资源路径由以下方式从库名称派生：考虑一个由符号“x.y.z”命名的库；它有根目录/x/y/，它的根资源是/x/y/z.clj，或者/x/y/z.cljc if/x/y/z.clj 不存在。根资源应包含用于创建库的命名空间（通常通过使用 ns 宏）和加载任何其他库资源的代码。库规范库规范是库名称或一个向量，其中包含库名称后跟表示为顺序关键字和参数的选项。识别的选项： 使用其参数作为符号并使该符号成为当前命名空间中库的命名空间别名。 使用其参数作为符号并作为别名（如 :as），但是库不会被加载。如果尚未加载库，将会创建新的空命名空间（如 create-ns）。 获取从命名空间引用的符号列表或 :all 关键字以引入所有公共变量。前缀列表对于 Clojure 代码来说，依赖于几个名称具有相同前缀的库是很常见的。指定库时，可以使用前缀列表来减少重复。前缀列表包含共享前缀，后跟库规范，其中共享前缀已从库名称中删除。删除前缀后，剩下的名称不得包含任何句点。标志标志是关键字。识别的标志： :reload，:reload-all，:verbose :reload 强制加载所有已识别的库，即使它们已经加载（对使用 :as-alias 的库规范无效） :reload-all 暗示 :reload，并且强制加载所有库，即标识的库通过 require 或 use 直接或间接加载的库（对使用 :as-alias 的库规范无效） :verbose 触发打印有关每个加载、别名和引用的信息示例：以下将加载库 clojure.zip 和 clojure.set，缩写为“s”。(require '(clojure zip [set :as s]))
- reset!
- 设置 atom 的值为 newval，不考虑当前值。返回 newval。
- reset-vals!
- 设置 atom 的值为 newval。返回 [old new]，即重置之前和之后的 atom 值。
- resolve
- 与 (ns-resolve *ns* symbol) 或 (ns-resolve *ns* &env symbol) 相同
- rest
- 返回第一个项目之后的项的可能为空序列。对它的 argument 调用 seq。
- restart-agent
- 当一个代理失败时，将代理状态更改为 new-state，然后取消代理的失败，以便再次允许发送。如果给出了 :clear-actions true 选项，则在代理失败时对其保留的任何动作队列都会被丢弃，否则这些保留的动作将继续进行。新的状态必须通过验证器（如果有），否则，restart 将抛出一个异常，代理将保持失败状态，并带有其旧状态和错误。观察者（如果有）不会收到新状态的通知。如果该代理未失败，则抛出异常。
- resultset-seq
- 创建并返回一个惰性序列，其中的 structmaps 对应于 java.sql.ResultSet rs 中的行
- rseq
- 以恒定时间返回 rev（可以是向量或排序映射）中按相反顺序排列的序列。如果 rev 为空，则返回 nil
- rsubseq
- sc 必须是有序集合，test(s) 是 <、<=、> 或 >= 之一。返回具有键 ek 的那些条目的反向序列，对于这些条目，(test (.. sc 比较器 (比较 ek 键)) 0) 为 true
- run!
- 运行提供的过程（通过 reduce），用于对集合中的连续项目产生副作用。返回 nil
s
- send
- 向代理发送一个动作。立即返回代理。随后，在来自线程池的线程中，代理的状态将被设置为以下值：(apply action-fn state-of-agent args)
- send-off
- 向代理发送一个可能阻塞的动作。立即返回代理。随后，在单独的线程中，代理的状态将被设置为以下值：(apply action-fn state-of-agent args)
- send-via
- 向代理发送一个动作。立即返回代理。随后，在 executor 提供的线程中，代理的状态将被设置为以下值：(apply action-fn state-of-agent args)
- seq
- 在集合上返回一个序列。如果集合为空，则返回 nil。(seq nil) 返回 nil。seq 也适用于字符串、本机 Java 数组（引用类型）和任何实现 Iterable 的对象。请注意，seq 缓存值，因此不应该在任何反复返回相同可变对象的 Iterable 上使用 seq。
- seq?
- 如果 x 实现 ISeq，则返回 true
- seque
- 在另一个（可能是延迟的）序列 s 上创建一个队列序列。该队列序列将在后台生成一个具体的序列，并且可以提前最多 n 个项目给消费者。n-or-q 可以是整数 n 缓冲区大小，或 java.util.concurrent BlockingQueue 的实例。请注意，如果读者抢在生产者之前，则读取一个序列可能会阻塞。
- 序列
- 如果 coll 不是一个序列，则强制其成为一个（可能是空的）序列。将不会强制执行延迟序列。（序列 nil）生成 ()。当提供转换器时，返回转换在 coll(s) 中项目上的应用的延迟序列，即转换为每个 coll 的第一个项目集合，接着是每个 coll 中的第二个项目集合，直到任何一个 coll 耗尽为止。其他 coll 中的任何剩余项目将被忽略。转换应接受 number-of-colls 的参数
- 可顺序？
- 如果 coll 实现顺序，则返回 true
- set！
- 赋值特殊形式。当第一个操作数是字段成员访问表单时，赋值对应于字段。如果是实例字段，则将求值实例 expr，然后是 expr。在所有情况下，都返回 expr 的值。注意 - 你不能赋值给函数参数或局部绑定。只有 Java 字段、变量、引用和代理在 Clojure 中是可变的。有关更多信息，请参见 https://clojure.org/special_forms。
- set-error-handler！
- 将代理 a 的 error-handler 设置为 handler-fn。如果代理运行的操作抛出异常或未通过验证器 fn，则会使用两个参数调用 handler-fn：代理和异常。
- set-error-mode！
- 将代理 a 的 error-mode 设置为 mode-keyword，它必须是 :fail 或 :continue。如果代理运行的操作抛出异常或未通过验证器 fn，可能会调用 error-handler （请参见 set-error-handler！），之后，如果模式为 :continue，则代理将继续，就好像导致该错误的操作和错误本身从未发生过一样。如果模式为 :fail，则代理将变为失败状态并且将停止接受新“send”和“send-off”操作，并且任何先前排队的操作都将保留，直到“restart-agent”为止。Deref 仍将起作用，返回该错误之前的代理状态。
- set-validator！
- 为变量/引用/代理/原子设置 validator-fn。validator-fn 必须为 nil 或一个不产生副作用并且仅有一个参数的函数，并且在任何状态更改时将向其传递预期的新状态。如果新状态不可接受，则 validator-fn 应返回 false 或抛出异常。如果当前状态（如果是变量，则为根值）对新验证器不可接受，则会抛出异常，并且不会更改验证器。
- set？
- 如果 x 实现 IPersistentSet，则返回 true
- 关闭代理
- 启动对代理系统后端线程池的关闭。正在运行的操作将完成，但不会接受任何新操作
- 简单标识符？
- 如果 x 是没有命名空间符号或关键字，则返回 true
- 简单关键字？
- 如果 x 是没有命名空间的关键字，则返回 true
- 简单符号？
- 如果 x 是没有命名空间的符号，则返回 true
- slurp
- 在 f 上打开一个读取器并读取其所有内容，返回一个字符串。有关受支持的参数的完整列表，请参见 clojure.java.io/reader。
- some
- 返回 (pred x) 的第一个逻辑 true 值（对于 coll 中的任何 x），否则返回 nil。一种常见的习惯用法是使用一个集合作为 pred，例如，如果 :fred 在序列中，则这将返回 :fred，否则返回 nil： (some #{:fred} coll)
- some->
- 当 expr 不为 nil 时，将其通过 -> 线程编入第一个表单中，并且当该结果不为 nil 时，再将其线程编入下一个表单中，依次类推
- some->>
- 当 expr 不为 nil 时，将其通过 ->> 传入第一种形式，并且当该结果不为 nil 时，继续传入下一种形式，以此类推。
- some-fn
- 获取一组谓词并返回一个函数 f，该函数返回由其中任何一个谓词针对任何参数返回的第一个逻辑真值，否则返回逻辑假值。请注意，f 会短路，即如果第一个参数针对原始谓词触发逻辑真值，则 f 将停止执行。
- some?
- 如果 x 不为 nil，则返回 true，否则返回 false。
- sort
- 返回 coll 中项目的有序序列。如果未提供比较器，则使用比较。比较器必须实现 java.util.Comparator。保证稳定：相等元素不会被重新排序。如果 coll 是 Java 数组，则它将被修改。要避免这种情况，请对数组的副本进行排序。
- sort-by
- 返回 coll 中项目的有序序列，其中排序顺序由比较 (keyfn item) 决定。如果未提供比较器，则使用比较。比较器必须实现 java.util.Comparator。保证稳定：相等元素不会被重新排序。如果 coll 是 Java 数组，则它将被修改。要避免这种情况，请对数组的副本进行排序。
- sorted-map
- keyval => key val 返回一个新的有序映射，其中包含提供的映射。如果任何键相等，则它们将被处理为使用 assoc 的重复次数。
- sorted-map-by
- keyval => key val 使用提供的比较器返回一个新的有序映射，其中包含提供的映射。如果任何键相等，则它们将被处理为使用 assoc 的重复次数。
- sorted-set
- 返回一个新的有序集合，其中包含提供的键。所有相等键的处理方式与重复使用 conj 相同。
- sorted-set-by
- 使用提供的比较器返回一个新的有序集合，其中包含提供的键。所有相等键的处理方式与重复使用 conj 相同。
- spit
- slurp 的反义词。使用写入器打开 f，写入内容，然后关闭 f。选项传递到 clojure.java.io/writer。
- split-at
- 返回一个向量 [(take n coll) (drop n coll)]
- split-with
- 返回一个向量 [(take-while pred coll) (drop-while pred coll)]
- str
- 如果不带参数，则返回空字符串。如果带一个参数 x，则返回 x.toString()。（str nil）返回空字符串。如果带有多个参数，则返回参数 str 值的连接。
- struct
- 返回一个新的结构映射实例，其中包含结构基础的键。必须按顺序提供 vals 用于基础键 - 对于未提供值的键，它们将默认为 nil。
- struct-map
- 返回一个新的结构映射实例，其中包含结构基础的键。键值可以包含基础键的所有、部分或全部 - 对于未提供值的键，它们将默认为 nil。键值还可以包含基础中没有的键。
- subs
- 返回从 start（包括）开始到 end（默认为字符串的长度，不包括）的 s 子字符串。
- subseq
- sc 必须是一个排序的集合，test(s) 是 <、<=、> 或 >= 中的一个。返回那些键为 ek 且 (test (.. sc comparator (compare ek key)) 0) 为 true 的项目的 seq
- subvec
- 返回 vector 中从 start（包括）到 end（不包括）的项目的持久向量。如果未提供 end，则默认为 (count vector)。此操作为 O(1)，非常快，因为结果向量与原始向量共享结构且不执行任何修剪。
- swap!
- 原子性交换 atom 的值为：(apply f atom 的当前值 args)。请注意，可能会多次调用 f，因此应使其无副作用。返回交换的值。
- swap-vals!
- 原子性交换 atom 的值为：(apply f atom 的当前值 args)。请注意，可能会多次调用 f，因此应使其无副作用。返回 [old new]，即交换前后 atom 的值。
- 符号
- 使用给定的命名空间和名称返回一个符号。1 元功能在字符串、关键字和变量上工作。
- 同步
- 处理事务中 exprs (在隐式 do 中) => TBD，目前传 nil 运行 exprs 和任何嵌套调用。如果此线程上还没有运行的事务，则启动事务。任何未捕获的异常都将中止事务并退出同步。exprs 可能运行好多次，但对 Ref 的任何影响都将是原子的。
t
- 标签文字
- 从标签符号和形式构造标签文字的数据表示形式。
- 标签文字？
- 如果值是标签文字的数据表示形式，则返回 true
- take
- 返回 coll 中前 n 个项的懒惰序列，如果项少于 n，则返回所有项。如果没有提供集合，则返回有状态的变换器。
- take-last
- 返回 coll 中最后 n 个项的 seq。根据 coll 的类型，可能没有比线性时间更好的方法。对于向量，另请参见子向量。
- take-nth
- 返回 coll 中每第 n 个项的懒惰 seq。如果没有提供集合，则返回有状态的变换器。
- take-while
- 返回 coll 中连续项的懒惰序列，同时 (pred 项) 返回逻辑 true。pred 必须没有副作用。如果没有提供集合，则返回变换器。
- tap>
- 将 x 发送到任何 tap。不会阻塞。如果有队列中还有空间，则返回 true，如果没有（已删除），则返回 false。
- test
- 测试 [v] 根据键 :test 在 var 元数据中查找 fn 并调用它，假设失败将引发异常
- namespace
- 如果传入命名空间，则返回该命名空间。否则，在传入符号的情况下，返回由该符号命名的命名空间，如果找不到该符号，则引发异常。
- thread-bound?
- 如果作为参数提供的所有 var 都有线程本地绑定，则返回 true。这意味着 set!'ing 提供的 var 将成功。如果没有提供 var，则返回 true。
- 抛出
- 评估 expr 并抛出，因此它应产生 Throwable 的某个派生的实例。请参见 https://clojure.org/special_forms#throw
- Throwable->map
- 为 Throwable 构造数据表示形式，其中包含键：：cause - 根源消息：：phase - 错误阶段：：via - 原因链，原因键：：type - 异常类符号：：message - 异常消息：：data - ex-data：：at - 顶部堆栈元素：：trace - 根源堆栈元素
- 时间
- 评估 expr 并打印它花费的时间。返回 expr 的值。
- to-array
- 返回一个包含 coll 内容的对象数组，其中 coll 可以是任何集合。映射到 java.util.Collection.toArray()。
- to-array-2d
- 返回一个包含 coll 内容的对象的（可能参差不齐的）二维数组，其中 coll 也可以是任何集合的集合。
- 弹簧床
- trampoline 可用于转换需要相互递归且无需使用堆栈的算法。使用提供的参数调用 f，如果有参数。如果 f 返回一个 fn，则不带参数调用该 fn，并持续重复，直到返回值不是 fn，然后返回该非 fn 值。请注意，如果你想返回一个 fn 作为最终值，必须使用某些数据结构对其进行包装，并在返回 trampoline 之后解压该值。
- transduce
- 使用 f (xf) 的转换来进行 reduce。如果没有提供 init，将调用 (f) 来生成该值。f 应该是一个接受 1 个或 2 个参数的 reducing step 函数，如果仅接受 2 个参数，你可以使用 'completing' 添加 arity-1。返回应用 (已转换的) xf 到 init 和 coll 中的第一个项的结果，然后应用 xf 到该结果和第二个项，以此类推。如果 coll 没有包含任何项，则返回 init 并且没有调用 f。请注意，某些转换可能会注入或跳过项。
- tree-seq
- 通过深度优先遍历返回树中节点的惰性序列。branch？必须是一个 1 个参数的 fn，如果传入一个可能包含子项（但可能不包含子项）的节点时，则返回 true。children 必须是一个 1 个参数的 fn，返回子项的序列。仅在 branch？返回 true 的节点上调用该函数。Root 是树的根节点。
- true?
- 如果 x 是 true 值，则返回 true，否则返回 false。
- try
- 评估表达式，如果未出现例外情况，则返回最后一个表达式的值。如果出现例外情况并且提供了 catch 条款，它将依次检查每个条款，第一个被抛出例外视为其命名的类实例的条款被视为匹配的 catch 条款。如果存在匹配的 catch 条款，则在 name 绑定到抛出例外的情况中评估其表达式，并且最后一个表达式的值为函数的返回值。如果没有匹配的 catch 条款，则例外会在函数中传播。无论正常返回还是异常返回，任何 finally 表达式都将被评估其副作用。请访问 https://clojure.org/special_forms 了解更多信息。
- type
- 返回 x 的 :type 元数据，如果没有，则返回其 Class
u
- underive
- 移除父项和标签之间的父项/子项关系。如果未提供 h，则必须是从 make-hierarchy 获取的层次结构，默认情况下会修改全局层次结构。
- unreduced
- 如果 x 是 reduced？，则返回 (deref x)，否则返回 x
- update
- 'Updates' updates 联想结构中的值，其中 k 是键，f 是一个函数，该函数接受旧值和任何提供参数，然后返回新值，并返回一个新结构。如果键不存在，则 nil 作为旧值传递。
- update-in
- 'Updates' updates 嵌套联想结构中的值，其中 ks 是键序列，f 是一个函数，该函数接受旧值和任何提供参数，然后返回新值，并返回一个新的嵌套结构。如果任何级别不存在，则创建 hash 映射。
- update-keys
- m f => {(f k) v ...} 给定一个映射 m 和一个 1 个参数的函数 f，返回一个新映射，该映射的键是将 f 应用于 m 的键的结果，映射到 m 的相应值。f 必须为 m 的每个键返回一个唯一键，否则行为是未定义的。
- update-proxy
- 接受一个代理实例和一个字符串映射（必须对应于代理超类/超接口的方法）到 fns（必须采用与相应方法匹配的参数，外加一个与 this 相对应的附加（显式）第一个参数），并（通过 assoc）更新代理的 fn 映射。可以传递 nil 而不是 fn，在这种情况下，相应方法将恢复为默认行为。请注意，此函数可用于更新现有实例的行为，而无需更改其标识。返回代理。
- update-vals
- m f => {k (f v) ...} 给定一个映射 m 和一个 1 个参数的函数 f，返回一个新映射，其中 m 的键映射到将 f 应用于 m 的相应值的结果。
- uri?
- 如果 x 是 java.net.URI，则返回 true
- use
- 就像'require，但还使用 clojure.core/refer 引用每个库的命名空间。优先在 ns 宏中使用 :use，而不是直接调用它。'use 接受 libspec 中的其他选项：:exclude、:only、:rename。:exclude、:only 和 :rename 的参数和语义与 clojure.core/refer 中记录的相同。
- uuid?
- 如果 x 是 java.util.UUID，则返回 true
v
- vals
- 返回映射值的序列，与 (seq map) 中的顺序相同。
- var
- 符号必须解析为 var，返回 Var 对象本身（而不是其值）。读取宏 #'x 扩展为 (var x)。有关更多信息，请参阅 https://clojure.org/special_forms。
- var-set
- 将 var 对象中的值设置为 val。var 必须是线程局部绑定的。
- var?
- 如果 v 是 clojure.lang.Var 类型，则返回 true
- vary-meta
- 返回一个 obj 同类型同值的 obj，其元数据为 (apply f (meta obj) args)。
- vec
- 创建包含 coll 内容的新矢量。Java 数组将被引用，不应修改。
- vector-of
- 创建一个包含单个基本类型 t 的新矢量，其中 t 是 :int、:long、:float、:double、:byte、:short、:char 或 :boolean 之一。结果矢量遵循一般矢量的接口，但内部存储的是未装箱的值。还可以选择一个或多个元素填充矢量。
- vector?
- 如果 x 实现 IPersistentVector，则返回 true
- vreset！
- 将 volatile 的值重置为 newval 而不用顾及当前值。返回 newval。
- vswap！
- 以非原子方式交换 volatile 的值，仿佛进行了：(apply f current-value-of-vol args)。返回交换进来的值。
w
- when
- 评估 test。如果逻辑为真，在隐式 do 中评估 body。
- when-first
- bindings => x xs 与 (when (seq xs) (let [x (first xs)] body)) 大致相同，但 xs 仅评估一次
- when-let
- bindings => binding-form test 当 test 为真时，在将 binding-form 绑定到 test 的值的隐式 do 中评估 body
- when-some
- bindings => binding-form test 当 test 不为 nil 时，在将 binding-form 绑定到 test 的值的隐式 do 中评估 body
- while
- 在 test 表达式为真时，反复执行 body。通常某种副作用会使 test 变为 false/nil。返回 nil
- with-bindings
- 采用 Var/value 对的映射。对于给定的 Var，将关联的值安装为线程局部绑定。然后执行 body。在评估 body 之后弹出已安装的绑定。返回 body 的值。
- with-bindings*
- 采用 Var/value 对的映射。对于给定的 Var，将关联的值安装为线程局部绑定。然后使用提供参数调用 f。在 f 返回后弹出已安装的绑定。返回 f 所返回的任何内容。
- with-in-str
- 在其中 *in* 绑定到用字符串 s 初始化的新 StringReader 的上下文中评估 body。
- with-local-vars
- varbinding=> symbol init-expr 在其中符号绑定到对具有 init-exprs 的每个线程的绑定的 vars 的上下文中执行 exprs。符号引用 var 对象本身，务必通过 var-get 和 var-set 进行访问
- with-open
- bindings => [name init ...] 在 try 表达式中评估 body，其中名称绑定到 inits 的值，并在 finally 子句中按相反顺序对每个名称调用 (.close name)。
- with-out-str
- 在其中 *out* 绑定到新 StringWriter 的上下文中评估 exprs。返回任何嵌套打印调用创建的字符串。
- with-precision
- 为 BigDecimal 操作设置精度和舍入模式。用法：(with-precision 10 (/ 1M 3)) 或：(with-precision 10 :rounding HALF_DOWN (/ 1M 3)) 舍入模式之一为 CEILING、FLOOR、HALF_UP、HALF_DOWN、HALF_EVEN、UP、DOWN 和 UNNECESSARY；默认为 HALF_UP。
- with-redefs
- binding => var-symbol temp-value-expr 在执行 body 时临时重新定义 Vars。将评估 temp-value-exprs，且每个结果值将同时替换其 Var 的根值。在执行 body 后，所有 Vars 的根值将重新设置为其旧值。此临时更改将在所有线程中可见。在测试期间，这对于模拟函数非常有用。
- with-redefs-fn
- 在对 func 进行调用期间，临时重新定义 Vars。binding-map 的每个 val 将替换其键的根值（该键必须为 Var）。在使用无参调用 func 之后，所有 Vars 的根值将重新设置为其旧值。此临时更改将在所有线程中可见。在测试期间，这对于模拟函数非常有用。
z
- zero？
- 如果 num 为零，则返回真，否则返回假