Clojure 核心快速引用
改编自 Johannes Friestad 出色的快速引用。
- +
- 返回 nums 之和。(+) 返回 0。不会自动提升 long，溢出时会引发异常。另请参见：+'
- -
- 如果未提供 y，则返回 x 的负值，否则从 x 中减去 y 并返回结果。执行以下操作
- *
- 返回 num 的乘积。(*) 返回 1。不会自动提升 long，溢出时会引发异常。另请参见：*
- /
- 如果没有提供分母，则返回 1/分子，否则返回分子除以所有分母
- 增量
- 返回比 num 大 1 的数字。不会自动提升 long，溢出时会引发异常。另请参见：inc'
- 减量
- 返回比 num 小 1 的数字。不会自动提升 long，溢出时会引发异常。另请参见：dec'
- 指定精度
- 设置 BigDecimal 操作要使用的精度和舍入模式。用法：(with-precision 10 (/ 1M
- 随机
- 返回 0（包括）和 n（默认为 1）（不包括）之间的随机浮点数。
- 随机整数
- 返回 0（包括）和 n（不包括）之间的随机整数。
- =
- 相等性。如果 x 等于 y，则返回 true，否则返回 false。与 Java x.equals(y) 相同，但它也适用于 nil、a
- ==
- 如果所有 num 都具有相等的值（与类型无关），则返回不为 nil，否则返回 false
- 不等
- 与 (not (= obj1 obj2)) 相同
- <
- 如果 num 按单调递增顺序排列，则返回不为 nil，否则返回 false。
- >
- 如果 num 按单调递减顺序排列，则返回不为 nil，否则返回 false。
- <=
- 如果 num 按单调非递减顺序排列，则返回不为 nil，否则返回 false。
- >=
- 如果 num 按单调非递增顺序排列，则返回不为 nil，否则返回 false。
- 零？
- 如果 num 是零，则返回 true，否则返回 false
- 正？
- 如果 num 大于零，则返回 true，否则返回 false
- 负？
- 如果 num 小于零，则返回 true，否则返回 false
- 偶？
- 如果 n 是偶数，则返回 true，如果 n 不是整数，则引发异常
- 奇？
- 如果 n 是奇数，则返回 true，如果 n 不是整数，则引发异常
- 十进制数？
- 如果 n 是大十进制数，则返回 true
- nil？
- 如果 x 是 nil，则返回 true，否则返回 false。
- true？
- 如果 x 的值为 true，则返回 true，否则返回 false。
- false？
- 如果 x 的值为 false，则返回 true，否则返回 false。
- 关键字
- 使用给定的命名空间和名称返回一个关键字。请勿在关键字字符串中使用 :，系统会自动添加
- 符号
- 使用给定的命名空间和名称返回一个符号。元级 1 在字符串、关键字和变量上起作用。
- 插入
- 在命名空间 ns（可以是符号或命名空间）中查找或创建由符号名称命名的变量，
- 命名空间
- 返回符号或关键字的命名空间字符串，如果没有存在则返回 nil。
- 标识符？
- 如果 x 是符号或关键字，则返回 true
- 简单关键字？
- 如果 x 是没有命名空间的关键字，则返回 true
- 简单符号？
- 如果 x 是没有命名空间的符号，则返回 true
- 简单标识符？
- 如果 x 是没有命名空间的符号或关键字，则返回 true
- 合格关键字？
- 如果 x 是有命名空间的关键字，则返回 true
- 合格符号？
- 如果 x 是有命名空间的符号，则返回 true
- 合格标识符？
- 如果 x 是有命名空间的符号或关键字，则返回 true
- 字符串
- 没有参数时，返回空字符串。有一个参数 x 时，返回 x.toString()。(str nil) 返回空字符串
- with-out-str
- 在 *out* 被绑定至一个新的 StringWriter 的上下文中评估 expr。返回由以下内容创建的字符串：
- count
- 返回集合中的项数。(count nil) 返回 0。它还对字符串、数组和 Ja 数组有效
- get
- 返回映射到 key 的值，如果 key 不存在于关联集合，集合，字符串中则返回找不到或 nil，
- subs
- 返回 s 从 start 起始（包括）到 end 结束（默认为字符串的长度）的子字符串，
- format
- 使用 java.lang.String.format 格式化字符串，请参阅 java.util.Formatter 了解格式字符串语法
- char?
- 如果 x 是一个 Character，则返回 true
- re-pattern
- 返回 java.util.regex.Pattern 的实例，用于例如在 re-matcher 中。
- re-matcher
- 返回 java.util.regex.Matcher 的实例，用于例如在 re-find 中。
- re-find
- 如果存在，返回 string 到 pattern 的下一个 regex 匹配，使用 java.util.regex.Matcher.find()。使用 re-g
- re-matches
- 返回 string 到 pattern 的匹配（如果存在），使用 java.util.regex.Matcher.matches()。使用 re-groups 来
- re-seq
- 使用 java.util.regex.Matcher.find() 返回 pattern 在 string 中连续匹配的延迟序列，例如
- re-groups
- 返回最近的匹配/查找结果中的分组。如果没有嵌套分组，则返回 e 的字符串
- not
- 如果 x 是逻辑 false，则返回 true，否则返回 false。
- and
- 从左到右逐个评估 expr。如果一个表单返回逻辑 false（nil 或 false），and 返回
- or
- 从左到右逐个评估 expr。如果一个表单返回逻辑 true 值，or 返回该值
- let
- binding => binding-form init-expr binding-form => name, 或 destructuring-form destructuring-form => map-de
- if-not
- 评估 test。如果为逻辑 false，则评估并返回 then expr，否则（如果已提供）则返回 else expr，否则返回 n
- if-let
- bindings => binding-form test 如果 test 为 true，则用 binding-form 绑定至 te 的值来评估 then
- if-some
- bindings => binding-form test 如果 test 不为 nil，则用 binding-form 绑定至 o 的值来评估 then
- when
- 评估 test。如果为逻辑 true，则在隐式的 do 中评估 body。
- when-not
- 评估 test。如果为逻辑 false，则在隐式的 do 中评估 body。
- when-let
- bindings => binding-form test 当 test 为 true 时，评估 body，其中 binding-form 绑定至 tes 的值
- when-first
- bindings => x xs 大致与 (when (seq xs) (let [x (first xs)] body)) 相同，但 xs 仅被评估一
- when-some
- bindings => binding-form test 当 test 不为 nil 时，用与值绑定 binding-form 评估 body
- cond
- 获取一组测试/expr 对。它逐个评估每个测试。如果一个测试返回逻辑 true，cond
- condp
- 获取一个二进制谓词、一个表达式和一组子句。每个子句都可以采用以下形式：t
- cond->
- 获取一个表达式和一组测试/表单对。通过 -> 线程 expr 完成每个表单，条件是相应的
- cond->>
- 获取一个表达式和一组测试/形式对。通过各自形式（通过 ->>）传递 expr，每个 cor
- some->
- 当 expr 非空时，通过第一个形式（通过 ->）传递，并且当该结果非空时，通过
- some->>
- 当 expr 非空时，通过第一个形式（通过 ->>）传递，并且当该结果非空时，通过
- as->
- 将名称绑定到 expr，在该绑定的词法上下文中评估第一个形式，然后将该名称绑定到该
- case
- 获取一个表达式和一组子句。每个子句都可以采用以下任一形式：测试常量结果
- do
- 按顺序评估表达式并返回最后表达式的值。如果没有提供表达式，返回
- eval
- 评估形式数据结构（不是文本！）并返回结果。
- loop
- 在词法上下文中评估 expr，在这种上下文中，绑定形式中的符号绑定到它们各自的
- recur
- 按顺序评估 exprs，然后并行重新将递归点的绑定重新绑定到
- while
- 在测试表达式为真的情况下重复执行主体。假定某个副作用会导致测试变成
- try
- 评估 exprs，并且如果没有发生异常，则返回最后一个 exprs 的值。如果发生异常
- catch
- 评估 exprs，并且如果没有发生异常，则返回最后一个 exprs 的值。如果发生异常
- finally
- 评估 exprs，并且如果没有发生异常，则返回最后一个 exprs 的值。如果发生异常
- throw
- 评估 expr 并抛出它，因此它应生成某些 Throwable 派生类的实例。请 s
- assert
- 评估 expr，如果它没有评估为逻辑真，则抛出异常。
- delay
- 获取一组表达式并生成一个延迟对象，该对象仅在首次 fo 时调用该组表达式
- delay?
- 如果 x 是使用 delay 创建的延迟，则返回 true
- deref
- 也作为读程序宏：@ref/@agent/@var/@atom/@delay/@future/@promise。在事务中，返回事务中的
- force
- 如果 x 是延迟，则返回其表达式的（可能已缓存的）值，否则返回 x
- iterate
- 返回一个 x、(f x)、(f (f x)) 等等的惰性序列。f 必须不产生副作用
- dotimes
- bindings => name n 重复执行主体（可能产生副作用），并将名称绑定到 fro 的整数
- doseq
- 重复执行主体（可能产生副作用），绑定为“for”提供的绑定和过滤。执行
- for
- 列表解析。获取一个或多个绑定形式/collection-expr 对的向量，每个对后面跟一个零
- lazy-seq
- 获取一个返回 ISeq 或 nil 的表达式主体，并生成一个将调用 bo 的可序列对象
- lazy-cat
- 展开为生成所提供 coll 的连接的惰性序列的代码。每个 coll expr
- doall
- 当通过具有副作用的函数生成惰性序列时，除了 t 所需之外的任何其他影响
- dorun
- 当通过具有副作用的函数生成惰性序列时，除了 t 所需之外的任何其他影响
- type
- 返回 x 的 :type 元数据，或其 Class（如果没有元数据）。
- bases
- 如果存在，返回 c 的直接超类和直接接口
- class?
- 如果 x 是 Class 的一个实例，则返回 true
- instance?
- 对 x 求值并测试它是否是类 c 的实例。返回 true 或 false
- isa?
- 如果 (= child parent)，或 child 直接或间接派生自 parent（通过 Java 进行转换），则返回 true
- cast
- 如果 x 不是 c，则抛出 ClassCastException；否则返回 x。
- deref
- 也作为读程序宏：@ref/@agent/@var/@atom/@delay/@future/@promise。在事务中，返回事务中的
- set-validator!
- 设置 var/ref/agent/atom 的校验器-fn。校验器-fn 必须为 nil 或一个无副作用、一个参数的 fn
- atom
- 创建一个 Atom 并返回，该 Atom 带有一个 x 的初始值和零个或多个选项（按任意顺序）：:meta met
- swap!
- 原子性地交换 atom 的值，以变为：(apply f current-value-of-atom args)。请注意，f 可能会被调用
- reset!
- 设置 atom 的值，新值为 newval，而不管当前值是什么。返回 newval。
- ref
- 创建一个 Ref 并返回，该 Ref 带有一个 x 的初始值和零个或多个选项（按任意顺序）：:meta metad
- sync
- transaction-flags => TBD，现在为 nil 通过运行一个隐式 do 中的 exprs，在一个包含 exprs 的事务中并涵盖
- dosync
- 在一个包含 exprs 和任何嵌套调用的事务中运行一个隐式 do 中的 exprs。启动一个 t
- ref-set
- 必须在一个事务中调用。设置 ref 的值。返回 val。
- alter
- 必须在一个事务中调用。将 ref 的事务内值设置为：(apply fun in-transaction-value
- commute
- 必须在一个事务中调用。将 ref 的事务内值设置为：(apply fun in-transaction-value
- ensure
- 必须在一个事务中调用。保护 ref 不受其他事务的修改。返回事务中的
- io!
- 如果一个 io! 块出现在一个事务中，则抛出一个 IllegalStateException；否则，在一个隐式 do 中运行 body。
- agent
- 创建一个 agent 并返回，该 agent 带有一个 state 的初始值和零个或多个选项（按任意顺序）：:met
- send
- 向一个 agent 发送一个动作。立即返回该 agent。随后，在一个线程池中的一个线程中，
- send-off
- 向一个 agent 发送一个可能阻塞的动作。立即返回该 agent。随后，在一个分离
- await
- 阻塞当前线程（无限期！），直到由此线程或 agent 派发至此为止的所有动作，
- await-for
- 阻塞当前线程，直至发往 agents 的所有动作（由此线程或 agent 派发）至此为止（具有
- agent-error
- 如果 agent 失败，则返回在 agent 的一个异步动作期间抛出的异常。如果 agent 没有失败，则返回 nil
- restart-agent
- 当一个 agent 失败时，将 agent 状态更改为 new-state，然后取消 agent 的失败，以便 send
- *agent*
- 当前在此线程上运行一个动作的 agent，否则为 nil
- error-handler
- 返回 agent a 的错误处理程序，如果没有，则返回 nil。请参阅 set-error-handler！
- set-error-mode!
- 设置 agent a 的 error-mode 为 mode-keyword，且必须为 :fail 或 :continue。如果在另一操作期间直接或间接发送操作
- future
- 采用表示式文本并产生 future 对象，该对象将在另一线程中调用文本，并将在
- vswap!
- 非原子地交换易失变量的值，仿佛：(apply f current-value-of-vol args)。返回该值
- vreset!
- 设置易失变量的值为 newval，而不考虑当前值。返回 newval。
- bound-fn
- 返回由给定的 fntail 定义的函数，该函数将在与 thr 相同的有效绑定中安装相同的绑定
- bound-fn*
- 返回一个函数，该函数将在 bound-fn* wa 时在该线程有效绑定中安装相同的绑定
- locking
- 在隐式 do 中执行 exprs，同时持有 x 的监视器。在所有情况下都会释放 x 的监视器
- pmap
- 如同 map，但 f 以并行方式应用。半延迟，因为并行计算领先于 con
- seque
- 在另外（可能是延迟的）序列 s 上创建一个队列化序列。队列化序列将在 b
- promise
- 返回可通过 deref/@ 读和仅设置一次的 promise 对象，通过 deliver 进行设置。对 p 的 deref/@ 调
- deliver
- 将提供的值传递给 promise，释放任何待处理的 derefs。对 a 的后续 deliver 调用
- add-watch
- 向 agent/atom/var/ref 引用添加一个观察函数。观察函数必须是具有 4 个参数的 fn：一个键，重新
- fn
- params => positional-params*, or positional-params* & rest-param positional-param => binding-form rest-par
- defn
- 与 (def name (fn [params* ] exprs*)) 或 (def name (fn ([params* ] exprs*)+)) 相同，带有任意文档字符串或 a
- definline
- 试验性 - 与 defmacro 相同，但定义一个命名函数，其文本为扩展，对其进行调用 ma
- memfn
- 扩展到创建 fn 的代码中，该 fn 期望传递一个对象和任何参数，并调用命名的 ins
- comp
- 获取一组函数并返回一个表示那些函数组合的 fn。返回的 fn 接受一个 var
- complement
- 获取一个 fn f 并返回一个接受与 f 相同参数的 fn，具有相同的功能（如果有），并返回
- fnil
- 获取函数 f，并返回一个调用 f、用提供的 suppli 替换 f 中的 nil 首参数的函数
- partial
- 获取一个函数 f 和少于 f 的正常参数，并返回一个接受可变数量的
- juxt
- 获取一组函数并返回一个表示那些函数并列的 fn。返回的 fn 接受一个 v
- memoize
- 返回引用透明函数的 memoized 版本。函数的 memoized 版本让
- some-fn
- 获取一组谓词并返回一个函数 f，该函数返回一个谓词返回的第一个逻辑真值
- ->
- 在 form 中穿插 expr。将 x 作为第一个 form 中的第二个项插入，如果需要，则创建一个它的列表
- ->>
- 在 form 中穿插 expr。将 x 作为第一个 form 中的最后一个项插入，如果需要，则创建一个它的列表
- apply
- 将 fn f 应用到通过将中间参数添加 args 前缀而形成的参数列表。
- fn?
- 如果 x 实现了 Fn，即是一个通过 fn 创建的对象，则返回真。
- ifn?
- 如果 x 实现了 IFn，则返回真。请注意，许多数据结构（例如集合和映射）实现了 IFn
- compare
- Comparator。当 x 在逻辑上“小于”、“等于或小于“时，返回一个负数、零或一个正数
- hash
- 返回参数的哈希代码。请注意，这是与 = 一致的哈希代码，因此与
- defmulti
- 使用关联的调度函数创建一个新的多方法。docstring 和 attr-map 是可选的。
- get-method
- 给定一个多方法和一个调度值，返回将应用于该值的调度 fn，如果无需，则返回 nil
- methods
- 给定一个多方法，返回一个调度值 -> 调度 fn 的映射
- defmacro
- 类似于 defn，但将结果函数名声明为宏，并且编译器会使用它作为宏
- macroexpand
- 在 form 上反复调用 macroexpand-1，直到它不再表示宏表单，然后返回它。注意
- gensym
- 返回一个具有唯一名称的新符号。如果提供了前缀字符串，则名称为前缀#，其中#是一些
- doto
- 计算 x，然后调用所有方法和函数，其中 x 的值位于给定参数前面的
- ..
- form => fieldName-symbol 或 (instanceMethodName-symbol args*) 扩展到对第一个的成员访问 (.)
- set!
- 赋值特殊形式。当第一个操作数为字段成员访问形式时，赋值至对应的
- aclone
- 返回 Java 数组的克隆。对已知类型的数组进行操作。
- to-array
- 返回包含 coll 内容的对象数组，其中 coll 可以是任何集合。映射到 java.util
- into-array
- 返回一个数组，其组件设置为 aseq 中的值。如果已提供，则数组的组件类型为 type，
- aget
- 返回索引/索引处的值。对所有类型的 Java 数组进行操作。
- aset
- 设置索引/索引处的值。对引用类型 Java 数组进行操作。返回 val。
- amap
- 使用名为 idx 的索引和名为 ret 的返回值（已初始化为 a）对着一个数组 a 映射表达式，并返回值
- areduce
- 使用名为 idx 的索引和名为 ret 的返回值（已初始化为 t）对着一个数组 a 简化表达式，并返回值
- proxy
- class-and-interfaces - 类名称向量 args - 超级的参数（可能是空）向量
- count
- 返回集合中的项数。(count nil) 返回 0。它还对字符串、数组和 Ja 数组有效
- empty
- 返回与 coll 相同类别的空集合，或 nil
- into
- 返回一个新的 coll，包括 to-coll 和所有 from-coll 项结合的部分。转换器可能是 s
- conj
- conj[oin] 返回一个添加 xs' 的新集合。（conj nil item）返回(item)。（conj coll）r
- contains?
- 如果 key 在给定的集合中，则返回 true，否则返回 false。请注意，对于数字
- empty?
- 如果 coll 没有项，则返回 true - 与 (not (seq coll)) 相同。请使用惯用语 (seq x) 而不是 (not
- every?
- 如果 coll 中的每个 x 的 (pred x) 为逻辑真值，则返回 true，否则返回 false。
- not-every?
- 如果 coll 中的每个 x 的 (pred x) 为真值，则返回 false，否则返回 true。
- some
- 返回 coll 中任何 x 的 (pred x) 的第一个逻辑真值，否则返回 nil。一种常见的惯用语是使用 a
- not-any?
- 如果 coll 中的任何 x 的 (pred x) 为真值，则返回 false，否则返回 true。
- coll?
- 如果 x 实现 IPersistentCollection，则返回 true
- seq?
- 如果 x 实现 ISeq，则返回 true
- vector?
- 如果 x 实现 IPersistentVector，则返回 true
- list?
- 如果 x 实现 IPersistentList，则返回 true
- map?
- 如果 x 实现 IPersistentMap，则返回 true
- set?
- 如果 x 实现 IPersistentSet，则返回 true
- vec
- 创建包含 coll 内容的新向量。Java 数组将成为别名，不应修改
- vector-of
- 创建一个包含单个基本类型 t 的新向量，其中 t 是 :int :long :float :double :byte :short 之一
- conj
- conj[oin] 返回一个添加 xs' 的新集合。（conj nil item）返回(item)。（conj coll）r
- peek
- 对于列表或队列，与第一项相同，对于向量，与最后一项相同，但效率更高。如果集合
- pop
- 对于列表或队列，返回不包含第一项的新列表/队列，对于向量，返回包含新向量的 wit
- get
- 返回映射到 key 的值，如果 key 不存在于关联集合，集合，字符串中则返回找不到或 nil，
- assoc
- assoc[iate]。应用于映射时，返回类型相同的新映射（已哈希/已排序），其中包含
- subvec
- 返回从 start（包括）到 end（不包括）的向量中项的持久向量。如果 end 不是
- rseq
- 在常量时间内返回 rev 中的项（可以是向量或排序映射）的 seq，按相反的顺序排列
- list*
- 创建一个包含前置于其余内容的新 seq，最后一个将被视为序列
- cons
- 返回一个新 seq，其中 x 是第一项，seq 是其余部分。
- conj
- conj[oin] 返回一个添加 xs' 的新集合。（conj nil item）返回(item)。（conj coll）r
- peek
- 对于列表或队列，与第一项相同，对于向量，与最后一项相同，但效率更高。如果集合
- pop
- 对于列表或队列，返回不包含第一项的新列表/队列，对于向量，返回包含新向量的 wit
- first
- 返回集合中的第一项。对其参数调用 seq。如果 coll 为 nil，则返回 nil。
- 其余
- 返回第一个之后的项目，可能是一个空序号。对其参数调用序号。
- hash-map
- keyval => key val 返回具有给定映射的新哈希映射。如果任何键相等，则处理它们
- array-map
- 构造数组映射。如果任何键相等，则处理它们，如同通过重复使用 assoc 的方式一样。
- sorted-map
- keyval => key val 返回具有给定映射的新排序映射。如果任何键相等，则处理它们
- bean
- 使用 Java 对象并基于 JavaBean pr 返回映射抽离的只读实现
- assoc
- assoc[iate]。应用于映射时，返回类型相同的新映射（已哈希/已排序），其中包含
- dissoc
- dissoc[iate]。返回相同（哈希/排序）类型的映射的新映射，它不包含键 (key) 的映射
- find
- 返回键的映射条目，如果没有键则返回 nil。
- keys
- 返回与 (seq map) 中的顺序相同的映射键的序列。
- vals
- 返回与 (seq map) 中的顺序相同的映射值的序列。
- get
- 返回映射到 key 的值，如果 key 不存在于关联集合，集合，字符串中则返回找不到或 nil，
- get-in
- 返回嵌套关联结构中的值，其中 ks 是键的序列。如果键
- update
- 在关联结构中“更新”值，其中 k 是键且 f 是一个将使用旧 v
- merge
- 返回一个映射，它由 conj-ed 在第一个映射上的其他映射组成。如果键出现于多个 on
- merge-with
- 返回一个映射，它由 conj-ed 在第一个映射上的其他映射组成。如果键出现于多个 on
- rseq
- 在常量时间内返回 rev 中的项（可以是向量或排序映射）的 seq，按相反的顺序排列
- subseq
- sc 必须是已排序的集合，test(s) 之一<、<=、> 或>=。返回键 ek f 的那些条目的序号
- rsubseq
- sc 必须是已排序的集合，test(s) 之一<、<=、> 或>=。返回键 k 的那些条目的反向序号
- hash-set
- 返回一个新的哈希集，其中包含提供的键。通过重复使用 conj 处理所有相等键。
- sorted-set
- 返回一个新的已排序的集合，其中包含提供的键。通过重复使用 conj 处理所有相等键。
- conj
- conj[oin] 返回一个添加 xs' 的新集合。（conj nil item）返回(item)。（conj coll）r
- disj
- disj[oin]。返回一个相同（哈希/排序）类型的集合的新集合，不包含键（key）。
- get
- 返回映射到 key 的值，如果 key 不存在于关联集合，集合，字符串中则返回找不到或 nil，
- defstruct
- 与 (def name (create-struct keys...)) 相同
- struct
- 返回一个带有结构基础键的新 structmap 实例。必须为基础键提供 vals
- struct-map
- 返回一个带有结构基础键的新 structmap 实例。keyvals 可能包含全部、一部分或不包含
- accessor
- 返回一个 fn，给定通过基础的 structmap 实例返回键的值。key m
- get
- 返回映射到 key 的值，如果 key 不存在于关联集合，集合，字符串中则返回找不到或 nil，
- assoc
- assoc[iate]。应用于映射时，返回类型相同的新映射（已哈希/已排序），其中包含
- seq
- 是否在集合中返回序号。当集合为空时，返回 nil。（seq nil）返回 nil。seq 也
- sequence
- 将 coll 强制转换到（可能是空的）序列中，如果它不是序列。不会强制延迟序列。（sequence
- repeat
- 返回 xs 的延迟（无限！如果提供的话，长度为 n）序列。
- range
- 返回从 start（含）到 end（不含）的 num 延迟序列，按 step 为步长，start 默认为 0，st
- iterate
- 返回一个 x、(f x)、(f (f x)) 等等的惰性序列。f 必须不产生副作用
- lazy-seq
- 获取一个返回 ISeq 或 nil 的表达式主体，并生成一个将调用 bo 的可序列对象
- lazy-cat
- 展开为生成所提供 coll 的连接的惰性序列的代码。每个 coll expr
- cycle
- 返回 coll 中项目重复的延迟（无限！）序列。
- tree-seq
- 通过深度优先遍历返回树中节点的延迟序列。branch？必须是单 arg 函数
- iterator-seq
- 在 java.util.Iterator 中返回序列。请注意，提供迭代器的大多数集合都实现 Iterable 和
- line-seq
- 将 rdr 中的文本行作为字符串的延迟序列返回。rdr 必须实现 java.io.BufferedReader。
- first
- 返回集合中的第一项。对其参数调用 seq。如果 coll 为 nil，则返回 nil。
- 其余
- 返回第一个之后的项目，可能是一个空序号。对其参数调用序号。
- next
- 返回第一个之后的项目序列。对其自变量调用 seq。如果没有更多项目，则返回
- fnext
- 与 (first (next x)) 相同
- nnext
- 与 (next (next x)) 相同
- nth
- 返回索引处的数。如果索引超出边界，则 get 返回 nil，除非 not-f
- nthnext
- 返回 coll 的第 n 个 next，当 n 为 0 时，返回 (seq coll)。
- nthrest
- 返回 coll 的第 n 个 rest，当 n 为 0 时，返回 coll。
- butlast
- 返回 coll 中除最后一项之外的所有项目的序列，以线性时间
- take
- 返回 coll 中前 n 项的延迟序列，如果少于 n 项，则返回所有项。返回 sta
- take-last
- 返回 coll 中最后 n 项的序列。根据 coll 的类型，可能不会优于线性时间。
- take-nth
- 返回 coll 中每个第 n 项的延迟序列。当未提供集合时，返回状态转换器。
- take-while
- 返回 coll 中的连续项延迟序列，同时 (pred item) 返回逻辑真值。pred 必须是
- drop
- 返回 coll 中除前 n 项之外的所有项的延迟序列。当未提供集合时，返回状态转换器
- conj
- conj[oin] 返回一个添加 xs' 的新集合。（conj nil item）返回(item)。（conj coll）r
- concat
- 返回表示提供的 coll 中元素连接的延迟序列。
- group-by
- 返回以每个元素的 f 结果为键的 coll 元素映射。每个键值处的值将 b
- partition
- 返回一个延迟序列，每个序列由 n 个项组成，偏移量相差一步。如果不提供步骤，则默认为 t
- partition-by
- 将 f 应用于 coll 中的每个值，每次 f 返回一个新值时将其分割。返回一个 parti 的延迟序列
- split-at
- 返回 [(take n coll) (drop n coll)] 的向量
- split-with
- 返回 [(take-while pred coll) (drop-while pred coll)] 的向量
- filter
- 返回 coll 中 (pred item) 返回逻辑真值的项的延迟序列。pred 必须不含 o
- filterv
- 返回 coll 中 (pred item) 返回逻辑真值的项的向量。pred 必须不含侧-
- remove
- 返回 coll 中 (pred item) 返回逻辑假值的项的延迟序列。pred 必须不含
- replace
- 给定一个替换对映射和一个向量/集合，返回一个具有 = 映射中密钥的任何元素的向量/序列
- flatten
- 采用嵌套组合的任何顺序对象（列表、向量等），并作为 sin 返回其内容
- sort
- 返回 coll 中项的已排序序列。如果不提供比较器，则使用比较。比较器必须
- sort-by
- 返回 coll 中项的已排序序列，其中排序顺序由比较 (keyfn item) 决定
- dedupe
- 返回去除 coll 中相邻重复项的延迟序列。在没有集合时返回一个转换器
- for
- 列表解析。获取一个或多个绑定形式/collection-expr 对的向量，每个对后面跟一个零
- doseq
- 重复执行主体（可能产生副作用），绑定为“for”提供的绑定和过滤。执行
- map
- 返回一个延迟序列，该序列包含将 f 应用于每个 coll 的第一项的结果，其次是
- mapv
- 返回一个向量，该向量包含将 f 应用于每个 coll 的第一项的结果，后跟
- keep
- 返回 (f item) 的非 nil 结果的延迟序列。注意，这意味着将包含 false 返回值
- keep-indexed
- 返回 (f index item) 的非 nil 结果的延迟序列。注意，这意味着将包含 false 返回值
- mapcat
- 返回将连接应用于将映射应用于 f 和 coll 的结果的结果。因此函数 f 应
- reduce
- f 应该是 2 个参数的函数。如果未提供 val，则返回将 f 应用于第一个结果
- reductions
- 返回 coll 通过 f 的还原的中间值的延迟序列（根据 reduce），从 i 开始
- transduce
- 通过 f (xf) 的变换进行还原。如果未提供 init，则将调用 (f) 来生成它。f 应
- max-key
- 返回 (k x) 为最大数的 x。如果有多个这样的 x，则返回最后一个
- min-key
- 返回 (k x) 为最小数的 x。如果有多个这样的 x，则返回最后一个。
- doall
- 当通过具有副作用的函数生成惰性序列时，除了 t 所需之外的任何其他影响
- dorun
- 当通过具有副作用的函数生成惰性序列时，除了 t 所需之外的任何其他影响
- conj!
- 将 x 添加到瞬态集合，并返回 coll。‘添加’可能发生在不同的‘位置’中，具体取决于
- pop!
- 从瞬态向量中移除最后一个元素。如果集合为空，则抛出异常。返回 coll
- assoc!
- 当应用于瞬态图时，将映射添加到键 (key) 到值 (val) 。当应用于瞬态向量时，将设置
- disj!
- disj[oin]。返回同种类型 (散列/已排序) 的瞬态集合，其中不包含键 (key)。
- def
- 创建并使用符号名称和当前名称空间值的命名空间插入或查找全局变量
- defonce
- defs 名称拥有 expr 的根值（如果 named var 没有根值），否则 expr 未评估
- 插入
- 在命名空间 ns（可以是符号或命名空间）中查找或创建由符号名称命名的变量，
- declare
- defs 提供的 var 名称没有绑定，可用于进行前向声明。
- set!
- 赋值特殊形式。当第一个操作数为字段成员访问形式时，赋值至对应的
- binding
- binding => var-symbol init-expr 使用提供的 i 为（已存在的）vars 创建新的绑定
- letfn
- fnspec ==> (fname [params*] exprs) 或 (fname ([params*] exprs)+) 采用函数规范向量和 bod
- gensym
- 返回一个具有唯一名称的新符号。如果提供了前缀字符串，则名称为前缀#，其中#是一些
- var
- 符号必须解析为变量，变量对象本身（不是其值）将被返回。读者宏 #'x
- find-var
- 返回由命名空间限定的符号命名的全局变量，如果不存在该名称的 var 则返回 nil 。
- var?
- 如果 v 属于 clojure.lang.Var 类型则返回 true
- bound?
- 如果作为参数提供的所有 var 具有任何已绑定值（根或线程本地）则返回 true。暗示 t
- resolve
- 与 (ns-resolve *ns* symbol) 或 (ns-resolve *ns* &env symbol) 相同
- ns
- 将 *ns* 设置为 name 命名的命名空间（未评估），如果需要，则创建它。引用可以为零或多个
- remove-ns
- 删除由符号命名的命名空间。请谨慎使用。不能用来删除 clojure 命名空间。
- *ns*
- 表示当前命名空间的 clojure.lang.Namespace 对象。
- the-ns
- 如果传递命名空间，则返回它。否则，当传递符号时，返回由它命名的命名空间，抛出 a
- in-ns
- 将 *ns* 设置为使用符号命名的命名空间，需要时创建它。
- alias
- 在当前命名空间添加其他命名空间的别名。参数为两个符号：要使用的别名，
- derive
- 在父项和标记之间建立父子关系。父项必须是命名空间限定符号
- underive
- 删除父项和标记之间的父子关系。h 必须是从 make-hierarc 获取的层次
- parents
- 返回标记的直接父项，通过 Java 类型继承关系或建立的
- isa?
- 如果 (= child parent)，或 child 直接或间接派生自 parent（通过 Java 进行转换），则返回 true
- defprotocol
- 协议是一组命名的命名方法和它们的签名：(defprotocol AProtocolName ;可选 d
- defrecord
- (defrecord name [fields*] options* specs*) 选项表示为顺序关键字和参数（in
- deftype
- (deftype name [fields*] options* specs*) 选项表示为顺序关键字和参数（an
- reify
- reify 创建一个实现协议或接口的对象。reify 是一个宏，结构如下
- extend
- 可以使用 extend 结构提供协议方法的实现：(extend AType AProtocol
- meta
- 返回 obj 的元数据，如果没有元数据则返回 nil。
- vary-meta
- 返回一个与 obj 类型和值相同，元数据为其元数据的（apply f (meta obj) args）的对象。
- alter-meta!
- 原子设置元数据命名空间/var/ref/agent/atom 为：(apply f its-current-meta args) f
- use
- 如“require”，但在 ns 宏中也使用 clojure.core/refer 引用每个库的命名空间。
- require
- 加载库，跳过任何已加载的库。每个参数要么是识别库的 libspec，要么是
- import
- import-list => (package-symbol class-name-symbols*) 对于 class-name-symbols 中的每个名称，添加从
- refer
- 引用 ns 的所有公共 var，受过滤器控制。过滤器最多可以包含以下内容之一：:exclude li
- *file*
- 正在评估的文件的路径，作为字符串。当没有文件时，例如在 REPL 中，值不存在
- 编译
- 将由符号 lib 命名的命名空间编译到一组类文件中。该 lib 的源必须位于
- load
- 从类路径中的资源加载 Clojure 代码。如果一个路径以 wit 起始，则它被解释为类路径相对的
- read
- 从流中读取下一个对象，它必须是 java.io.PushbackReader 的一个实例或某个派生类。str
- read-string
- 从字符串 s 中读取一个对象。根据需要，包括 read 中指定的 reader 选项。请注意 re
- gen-class
- 编译时，生成具有给定的包限定名 :name（它作为 al）的类的编译字节码
- test
- test [v] 在 var 元数据中查找键 :test 处的 fn 并调用它，假设失败将抛出异常
- *in*
- 一个 java.io.Reader 对象，表示读取操作的标准输入。默认为 System/in，包装在
- *out*
- 一个 java.io.Writer 对象，表示打印操作的标准输出。默认为 System/out，包装在
- *err*
- 一个 java.io.Writer 对象，表示打印操作的标准错误。默认为 System/err，包装在 i
- print
- 将对象打印到输出流，该流是 *out* 的当前值。print 和 println 产生 out
- pr
- 将对象打印到输出流，该流是 *out* 的当前值。打印对象，分隔
- prn
- 与 pr 相同，后跟 (newline)。遵守 *flush-on-newline*
- flush
- 刷新输出流，该流是 *out* 的当前值
- slurp
- 在 f 上打开一个读取器并读取其所有内容，返回一个字符串。有关完整
- spit
- 与 slurp 相反。用编写器打开 f，写入内容，然后关闭 f。选项传递给 clojure.java.io/wr
- with-in-str
- 在上下文中评估 body，其中 *in* 绑定到使用字符串 s 初始化的新 StringReader。
- with-out-str
- 在 *out* 被绑定至一个新的 StringWriter 的上下文中评估 expr。返回由以下内容创建的字符串：
- with-open
- bindings => [name init ...] 在 try 表达式中评估 body，其中名称绑定到 init
- *3
- 在 repl 线程中绑定到最近的第三个打印的值
- *e
- 在 repl 线程中绑定到 repl 捕获的最新异常
- *clojure-version*
- 以映射形式表示的 Clojure 核心版本信息，其中包含按键值：:major :minor :incremental 和 :qualifier。可实现
- time
- 评审 expr 并打印所花费的时间。返回 expr 的值。