最近简单学习下Clojure，网上的资料也不是很多，自己写个小教程。
在Clojure中，很多数据结构都可以通过同一个抽象概念来访问：序列（Seq）。
可被视为序列的容器，被称为可序化的（seq-able，发音“SEEKabull”）。各种各样可序化的容器包括：
- 所有的Clojure容器
- 所有的Java容器
- Java数组和字符串
- 正则表达式的匹配结果
- 目录结构
- 输入/输出流
- XML树
一切皆为序列
每一种聚合的数据结构，在Clojure中都能被视为序列。序列具有三大核心能力：
- 你能够得到序列的第一个元素。
(first aseq)
- 你能够获取第一个元素后面的一切东西，换句话说，就是序列的剩余部分。
(rest aseq)
- 你可以通过向现有序列的前端添加元素，来创建一个新的序列。这就是所谓的cons。
(cons elem aseq)
seq函数会返回一个序列，该序列源自任何一个可序化的其他容器。
(seq coll)
如果coll是空的或者是nil，则seq返回nil。next函数也会返回一个序列，该序列由除第一个元素以外的其他所有元素组成。
(next aseq)
(next aseq)等价于 (seq (rest aseq))。
映射表和集合的遍历顺序是稳定的，但这个顺序取决于具体的实现细节。
sorted-set会依据自然顺序对值进行排序。
(sorted-set& elements)
sorted-map来创建一个有序的映射表。
(sorted-map& elements)
conj 会向容器添加一个或是多个元素，into 则会把容器中的所有元素添加至另一个容器。添加数据时，conj和into都会根据底层数据结构的特点选取最高效的插入点。
对于列表而言，conj和into会在其前端进行添加。
而对于向量，conj和into则会把元素添加至末尾。
绝大多数Clojure序列都是惰性的：只有当确实需要时，它们才真正的把元素生成出来。因此，Clojure序列函数能够处理那些无法驻留在内存中的超大序列。
Clojure序列是不可变的：它们永远都不会发生变化。所以我们可以很容易的就做出推断：Clojure序列在并发访问时是安全的。
序列库
Clojure的序列库包含以下四种函数：
- 创建序列的函数。
- 过滤序列的函数。
- 序列谓词。
- 序列转换函数。
创建序列
ranage会生成一个从start开始到end结束的序列，每次的增量为step。
(range start? end step?)
范围包含了start，但并不包含end。如果你没有指定的话，start默认为0，step默认为1。
user=> (range 10)
(0 1 2 3 4 5 6 7 8 9)
user=> (range 10 20)
(10 11 12 13 14 15 16 17 18 19)
user=> (range 1 10 2)
(1 3 5 7 9)
repeat函数会重复n次元素x。当只传入一个参数时，repeat会返回一个惰性的无限序列。
(repeat n x)
user=> (repeat 5 1)
(1 1 1 1 1)
user=> (repeat 6 "x")
("x" "x" "x" "x" "x" "x")
iterate起始于值x，并持续地对每个值应用函数f，以计算下一个值，直至永远。
(iterate f x)
take会返回一个包含了容器中前n项元素的惰性序列，这就提供了一种在无限序列上创建有限视图的途径。
(take n sequence)
cycle函数接受一个容器，并无限的对其进行循环。
(cycle coll)
interleave函数接受多个容器作为参数，并产生一个新的容器，这个新容器会从每个参数容器中交错地提取元素，直至其中某个容器元素被耗尽。
(interleave& colls)
当其中的某个容器被耗尽时，interleave就会终止。所以，你可以把有限容器与无限容器混合到一块儿。
与interleave密切相关的interpose函数，把输入序列中的每个元素用分隔符隔开，并作为新的序列返回。
(interpose separator coll)
interpose和(apply str ...)的结合，正好可以用来产生输出字符串。
作为一种惯用法，(apply str ...)是如此的常用，以至于Clojure甚至专门把它封装为clojure.string/join。
(join separator sequence)
对应每种Clojure中的容器类型，都有一个可以接受任意数量参数的函数，用来创建该类型的容器。
(list_& elements)
(vector_& elements)
(hash-set_& elements)
(hash-map key-1 val-1 ...)
过滤序列
filter接受一个谓词和一个容器作为参数，并返回一个序列，这个序列的所有元素都经谓词判定为真。
(filter pred coll)
user=> (filter even? '(1, 2, 3, 4, 5))
(2 4)
你还可以使用take-while从序列中截取开头的一段，其每个元素都被谓词判定为真。
(take-while pred coll)
drop-while 从序列的起始位置开始，逐个丢弃元素，直至谓词判定为真，然后返回序列剩余的部分。
(drop-while pred coll)
split-at和split-with能把一个容器一分为二。
(split-at index coll)
(split-with pred coll)
split-at接受一个索引作为参数，而split-with则接受一个谓词。
user=> (split-at 5 (range 10))
[(0 1 2 3 4) (5 6 7 8 9)]
user=> (split-with #(<= % 10) (range 0 20 2))
[(0 2 4 6 8 10) (12 14 16 18)]
所有take-、split-和drop-打头的函数，返回的都是惰性序列。
序列谓词
序列谓词会要求其他谓词应如何判定序列中的每一个元素。例如，every？要求其他谓词对序列中的每个元素都必须判定为真。
(every? pred coll)
user=> (every? odd? [1 3 5])
true
user=> (every? odd? [1 2 5])
false
只要有一个元素被谓词判定为非假，some就会返回这个值，如果没有任何元素符合，则some返回nil。
(some pred coll)
user=> (some even? [1 2 3])
true
user=> (some even? [1 3 5])
nil
注意，some没有以问号结尾。尽管总被当作谓词使用，但some并非谓词。因为 some 返回的是第一个符合项的值，而非 true。
其他谓词从名称就能很明显的表现出其行为。
(not-every? pred coll)
(not-any? pred coll)
序列转换
转换函数用于对序列中的值进行转换。最简单的转换是映射函数map。
(map f coll)
map接受一个源容器coll和一个函数f作为参数，并返回一个新的序列。该序列的所有元素，都是通过对coll中的每个元素调用f得到的。
还可以传入多个容器给map。在这种情况下，f必须是一个多参函数。map会从每个容器分别取出一个值，作为参数来调用f，直到数量最少的那个容器被耗尽为止。
另一个常用的转换是归纳函数reduce。
(reduce f coll)
其中f是一个接受两个参数的函数。reduce首先用coll的前两个元素作为参数来调用f，然后用得到的结果和第三个元素作为参数，继续调用f，以此类推。
user=> (reduce + (range 1 11))
55
你可以使用sort或sort-by对容器进行排序。
(sort comp? coll)
(sort-by a-fn comp? coll)
sort 会依据元素的自然顺序对容器进行排序，sort-by 则会对每个元素调用 a-fn，再依据得到的结果序列来进行排序。
user=> (sort [42 1 6 11])
(1 6 11 42)
user=> (sort-by #(.toString %) [42 1 6 11])
(1 11 42 6)
如果不打算按照自然顺序排序，你可以为sort或sort-by指定一个可选的比较函数comp。
user=> (sort > [42 1 6 11])
(42 11 6 1)
惰性和无限序列
大多数Clojure序列都是惰性的，换句话说，直到真的需要时，元素才会被计算出来。使用惰性序列有很多好处。
- 你可以推迟那些实际上并不需要的昂贵计算。
- 你可以处理超出内存允许范围的庞大数据集。
- 你可以将I/O推迟至确实需要时才进行。
当你在REPL中查看很大的序列时，你可以使用take来阻止REPL对整个序列进行求值。
在另外一些情况下，你遇到的问题可能正好相反。doall迫使Clojure遍历序列中的元素，并把这些元素作为结果返回。
(doall coll)
你还可以使用dorun。
(dorun coll)
dorun 同样会遍历容器中的元素，但它不会把穿过的元素保留在内存中。这样的结果是，dorun可以遍历那些超过了内存容许范围的超大容器。
调用特定于结构的函数
Clojure包含了一些特定目标的函数，面向列表、向量、映射表、结构和集合。
列表函数
Clojure支持peek和pop这两个名称比较传统的函数，分别用于取出列表的第一个元素，和其余的那些元素。
(peek coll)
(pop coll)
user=> (peek '(1 2 3))
1
user=> (pop '(1 2 3))
(2 3)
peek等同于first，但pop则与rest不同。如果是空序列，pop会抛出一个异常。
user=> (rest ())
()
user=> (pop ())
Execution error (IllegalStateException) at user/eval53 (REPL:1).
Can't pop empty list
向量函数
向量也支持peek和pop，但它们是从向量的末尾开始处理元素的。
user=> (peek [1 2 3])
3
user=> (pop [1 2 3])
[1 2]
get返回索引位置的值，倘若索引超出了向量边界，则返回nil。
user=> (get [:a :b :c] 1)
:b
向量自身也是函数。它接受一个索引作为参数并返回对应的值，或是当索引超过边界时，抛出一个异常。
user=> ([:a :b :c] 1)
:b
assoc会在指定的索引位置，关联一个新的值。
user=> (assoc [0 1 2 3 4] 2 :two)
[0 1 :two 3 4]
subvec会返回向量的一个子向量。
(subvec avec start end?)
若未指定end，则默认为向量的末尾。
当然，你也可以通过组合drop和take来模拟subvec。不同之处在于，take和drop非常通用，可用于任何序列。令一方面，对于向量而言，subvec要更快一些。每当你看到subvec这样特定于结构的函数，同时其功能又与序列库中的某个函数产生了重复时，那最有可能的理由就是性能。
映射表
Clojure提供了几个用于从映射表中读取键和值的函数。keys将所有的键作为序列返回，vals则将所有的值作为序列返回。
(keys map)
(vals map)
get会返回键对应的值，或者是返回nil。
(get map key value-if-not-found?)
有一种比用 get 更简单的方法。因为映射表同时也是一个函数，以它自己的键作为参数。
关键字同样也是函数。他接受一个容器作为参数，并在这个容器中查找其自身。
如果在映射表中查找一个键并返回了 nil，你无法确认究竟是键对应的值为nil，还是这个键在映射表中根本就不存在。contains?函数就可以解决这个问题，它只是单纯的检测某个键是否存住。
(contains? map key)
另外一种方法是调用get，它可以传入可选的第三个参数，如果键未能找到，那么就会返回这个参数的值。
Clojure还提供了几个会构建新映射表的函数。
- assoc返回新增了一个键值对的映射表。
- dissoc返回移除了某些键的映射表。
- select-keys返回一个映射表，仅保留了参数传入的那些键。
- merge可以合并映射表。如果多个映射表包含了同一个键，那么最右边的获胜。
最有趣的映射表构建函数是merge-with。
(merge-with merge-fn & maps)
merge-with与merge很类似，除了当两个或以上的映射表中有相同的键时，你能指定一个你自己的函数，来决定如何合并这个键对应的值。
集合函数
clojure.set函数执行由集合论而来的操作。
- union返回的集合，包含了所有输入集合中的元素。
- intersection返回的集合，其所有元素都曾同时出现于多个输入集合中。
- difference 返回的集合，其所有元素都出现于第一个输入集合，但却未出现于第二个中。
- select返回所有元素都能与给定谓词相匹配的一个集合。
rename函数可以用来给键（数据库的列）重新命名，基于一个映射表，把原来的名称改成新的。
(rename relation rename-map)
select 函数返回经谓词计算结果为真的那些映射表，这里的谓词与 SQL 语言中SELECT语句的WHERE部分非常类似。
(select pred relation)
project函数返回的那些映射表中，仅包含与参数匹配的键。
(project relation keys)
project与指定了列的子集的SQL SELECT语句非常类似。