Clojure学习笔记（三）—

函数式编程的理念

函数式编程使得代码的编写、阅读、测试和重用都更容易了。

纯函数

函数式程序构建于纯函数之上。纯函数没有副作用，也就是说，它不依赖于除参数以外的其他任何东西。此外，它影响外部世界的唯一途径，就是它的返回值。

持久性数据结构

不可变数据是Clojure通向FP和处理状态的关键所在。站在FP的这一面，纯函数不能出现诸如更新可变对象状态这样的副作用。站在状态处理这一面，Clojure的引用类型也需要借助不可变数据结构，来实现其并发保证。

Clojure数据结构并没有采用直接复制这种影响性能的修改方式。相反，所有的Clojure数据结构都是持久的（persistent）。在这里，所谓持久性，意味着新旧版本之间能高效的共享结构，通过这种方式，持久性数据结构能很好地维持其自身的旧副本。

惰性和递归

函数式程序大量地使用了递归和惰性。函数对其自身进行调用时，无论是直接还是间接的，就会形成递归。有了惰性，对表达式的求值会被推迟至实际需要时才真正进行。对一个惰性表达式进行求值，也被称作表达式的变现（realizing）。

在Clojure中，函数和表达式都不是惰性化的。然而，序列则一般来说都是惰性的。

引用透明性

惰性依赖于这样一种能力：在任何时刻，都可以用函数的结果来取代对其的调用。具备这种能力的函数之所以被称为是引用透明（Referential transparency）的，是因为对该函数的调用可被替换，却不会影响程序的行为。

除了惰性之外，引用透明的函数还可以在下述两个方面受益。

快存（Memoization），自动缓存结果。
自动并行化，将函数移至另外一个处理器，甚至另外一台机器进行求值。

纯函数的定义就是引用透明的。然而其他的大部分函数都不是引用透明的，它们只能通过细致的代码审查，方能证明其安全性。

6条规则

Clojure中FP的6条规则：

避免直接递归。Java 虚拟机无法优化递归调用，Clojure 的递归程序会撑爆它们的栈空间。
当产生的是标量（scalar values），或者是体积小还数量固定的序列时，你可以使用recur。Clojure会对显式的recur进行调用优化。
当产生大量，或是大小可变的序列时，让它成为惰性的，而不要用递归。
小心不要让一个惰性序列变现的太多，多的超出你的需要。
熟悉序列库。这样你就总能写出完全用不着recur或者惰性API的代码了。
细分。把看似简单的问题也尽可能划分为更小的块。这样你就能发现蕴藏于序列库中的解决方案。

递归

函数式程序大量的使用了递归定义。递归定义由两个部分组成。

基础（basis），明确地列举出序列的部分成员。
归纳（induction），提供一些规则，规定了如何通过组合序列的成员，来产生更多的成员。

要把递归定义转换为可以工作的代码，通常采用下面这几种方式。

简单的递归，让函数以某种方式来调用其自身，从而进行归纳。
尾递归，仅当函数执行到末尾时，才去调用其自身。
惰性序列，实实在在地消除了递归，并且只有当需要时，才会去计算值。

下面看个斐波那契数列的例子，用简单递归实现：

(defn stack-consuming-fibo [n]
  (cond
    (= n 0) 0
    (= n 1) 1
    :else (+ (stack-consuming-fibo (- n 1))
             (stack-consuming-fibo (- n 2)))))

它的性能很糟糕。因为Clojure函数调用是消耗栈空间（stack-consuming）的，因为它们使用了栈空间来分配栈帧。在Clojure中，你应该尽量避免采stack-consumingfibo这种消耗栈空间型的递归。

尾递归

函数式程序可以借助尾递归技术解决栈空间的使用问题。尾递归函数依然被定义为是递归的，但递归点必须位于尾部，即函数中返回某个值的那个表达式。语言随后即可进行尾部调用优化（tail-call optimization，TCO），把尾递归转换为迭代，于是就不再消耗栈空间了。

将斐波那契数列的例子转换为尾递归。

(defn tail-fibo [n]
  (letfn [(fib
           [current next n]
           (if (zero? n)
             current
             (fib next (+ current next) (dec n))))]
        (fib 0N 1N n)))

第2行引入了letfn宏。

(letfn fnspecs & body) ; fnspecs ==> [(fname [params*] exprs)+]

letfn与let很像，只不过它是专门用来指定局部函数的。每个声明于letfn中的函数，都可以调用自身或是其他属于同一个letfn块的函数。

第3行声明的fib有三个参数：当前斐波那契数current、下一个斐波那契数next和代表剩余步数的数字n。当不再有剩余步数时，会在第5行返回current，反之，则在第6行继续进行计算，并且把剩余步数减1。最后，在第7行开启了递归，这里使用了基础值0和1，再加上我们正要求解的斐波那契数的序号n。

自递归与recur

递归在 Java 虚拟机上有一种可以被优化的特殊情况，就是自递归。

在Clojure中，你可以借助recure把那种在尾部调用其自身的函数，转换为显式自递归。下面采用了这种方法，tail-fibo转换为recur-fibo。

(defn recur-fibo [n]
  (letfn [(fib
            [current next n]
            (if (zero? n)
              current
              (recur next (+ current next) (dec n))))]
    (fib 0N 1N n)))

recur-fibo和tail-fibo之间的关键区别是第7行，在那儿用recur替代了对fib的调用。

惰性序列

惰性序列是用lazy-seq宏创建出来的。

(lazy-seq& body)

仅当需要时，lazy-seq 才会去调用它的 body，也就是说，当 seq 被直接或是间接的调用时，lazy-seq会为后续的调用缓存结果。

你可以像下面这样，用lazy-seq来定义惰性的斐波那契数列。

(defn lazy-seq-fibo
  ([]
   (concat [0 1] (lazy-seq-fibo 0N 1N)))
  ([a b]
   (let [n (+ a b)]
     (lazy-seq
       (cons n (lazy-seq-fibo b n))))))

在第 3 行，无参版本的那个函数主体，把基础值[0 1]和随后将要计算得到的剩余部分连接起来并返回，而这些剩余部分的值，是通过调用那个有两个参数的版本来计算得到的。在第 5 行，两个参数版本的函数体计算出数列的下一个值 n，然后在第 7行，把n和剩余部分的值进行连接。最关键的是第 6 行，这使得它的主体惰性化了。

Clojure学习笔记（三）——函数式编程