到目前為止，在本系列的每期文章中，我都說明了為什么理解函數(shù)式編程非常重要。但是，有些原因是在多期文章中進行說明的，只有在綜合思路的更大背景中，才可以完全了解這些原因。在本期文章中，我會探討函數(shù)式編程方興未艾的所有原因，并綜合前幾期文章中的一些個人經(jīng)驗教訓。

在計算機科學短短的發(fā)展歷史中，技術(shù)的主流有時會產(chǎn)生分支，包括實用分支和學術(shù)分支。20 世紀 90 年代的 4GL（第四代語言）是一個實用分支，而函數(shù)式編程是來自學術(shù)界的一個示例。每隔一段時間，都會有一些分支加入主流，函數(shù)式編程目前也是這種情況。函數(shù)式語言不僅在 JVM 上剛剛嶄露頭腳（其中兩個最有趣的新語言是 Scala 和 Clojure），在 .NET 平臺上也是才開始得到應(yīng)用，在 .NET 平臺上，F(xiàn)# 是頭等公民。為什么所有平臺都如此歡迎函數(shù)式編程？答案是，隨著時間的推移，隨著運行時都要能夠處理更多的繁忙工作，開發(fā)人員已經(jīng)能夠?qū)⑷粘Ｈ蝿?wù)的更多控制權(quán)割讓給它們。

割讓控制權(quán)

在 20 世紀 80 年代初，在我上大學的時候，我們使用一個被稱為 Pecan Pascal 的開發(fā)環(huán)境。其獨特的特性是，相同的 Pascal 代碼可以在 Apple II 或 IBM PC 上運行。Pecan 工程師使用某個稱為 “字節(jié)碼” 的神秘東西實現(xiàn)了這一壯舉。開發(fā)人員將 Pascal 代碼編譯為 “字節(jié)碼”，它可以在每個平臺本地編寫的 “虛擬機” 上運行。這是一個可怕的體驗！所生成的代碼慢得讓人痛苦，甚至簡單的類賦值也非常緩慢。當時的硬件還沒有準備好迎接這個挑戰(zhàn)。

在發(fā)布 Pecan Pascal 之后的十年，Sun 發(fā)布了 Java，Java 使用了相同的架構(gòu)，對于 20 世紀 90 年代中期的硬件環(huán)境，運行該代碼顯得有些緊張，但最終取得了成功。Java 還增加了其他開發(fā)人員友好的特性，如自動垃圾收集。使用過像 C++ 這樣的語言之后，我再也不想在沒有垃圾收集的語言中編寫代碼。我寧愿花將時間花在更高層次上的抽象上，思考解決復雜業(yè)務(wù)問題的方法，也不愿意在內(nèi)存管理等復雜的管道問題上浪費時間。

Java 緩解了我們與內(nèi)存管理的交互；函數(shù)式編程語言使我們能夠用高層次的抽象取代其他核心構(gòu)建塊，并更注重結(jié)果而不是步驟。

結(jié)果比步驟更重要

函數(shù)式編程的特點之一是存在強大的抽象，它隱藏了許多日常操作的細節(jié)（比如迭代）。我在本系列文章中一直使用的一個示例是數(shù)字分類：確定某個數(shù)字是 perfect、abundant 還是 deficient。清單 1 中顯示的 Java 實現(xiàn)可以解決這個問題：

清單 1. 自帶緩存總數(shù)的 Java 數(shù)字分類器

import static java.lang.Math.sqrt;  
   
public class ImpNumberClassifier {  
    private Set<Integer> _factors;  
    private int _number;  
    private int _sum;  
   
    public ImpNumberClassifier(int number) {  
        _number = number;  
        _factors = new HashSet<Integer>();  
        _factors.add(1);  
        _factors.add(_number);  
        _sum = 0;  
    }  
   
    private boolean isFactor(int factor) {  
        return _number % factor == 0;  
    }  
   
    private void calculateFactors() {  
        for (int i = 1; i <= sqrt(_number) + 1; i++)  
            if (isFactor(i))  
                addFactor(i);  
    }  
   
    private void addFactor(int factor) {  
        _factors.add(factor);  
        _factors.add(_number / factor);  
    }  
   
    private void sumFactors() {  
        calculateFactors();  
        for (int i : _factors)  
            _sum += i;  
    }  
   
    private int getSum() {  
        if (_sum == 0)  
            sumFactors();  
        return _sum;  
    }  
   
    public boolean isPerfect() {  
        return getSum() - _number == _number;  
    }  
   
    public boolean isAbundant() {  
        return getSum() - _number > _number;  
    }  
   
    public boolean isDeficient() {  
        return getSum() - _number < _number;  
    }  
} 

清單 1 中的代碼是典型的 Java 代碼，它使用迭代來確定和匯總系數(shù)。在使用函數(shù)式編程語言時，開發(fā)人員很少關(guān)心細節(jié)（比如迭代，由 calculateFactors() 使用）和轉(zhuǎn)換（比如匯總一個列表，該列表由 sumFactors() 使用），寧愿將這些細節(jié)留給高階函數(shù)和粗粒度抽象。

粗粒度的抽象

用抽象來處理迭代等任務(wù)，使得需要維護的代碼變得更少，因此可能出現(xiàn)錯誤的地方也就更少。清單 2 顯示了一個更簡潔的數(shù)字分類器，用 Groovy 編寫，借用了 Groovy 的函數(shù)風格方法：

清單 2. Groovy 數(shù)字分類器

import static java.lang.Math.sqrt  
   
class Classifier {  
  def static isFactor(number, potential) {  
    number % potential == 0;  
  }  
   
  def static factorsOf(number) {  
    (1..number).findAll { isFactor(number, it) }  
  }  
   
  def static sumOfFactors(number) {  
    factorsOf(number).inject(0, {i, j -> i + j})  
  }  
   
  def static isPerfect(number) {  
    sumOfFactors(number) == 2 * number  
  }  
   
  def static isAbundant(number) {  
    sumOfFactors(number) > 2 * number  
  }  
   
  def static isDeficient(number) {  
    sumOfFactors(number) < 2 * number  
  }  
} 

清單 2 中的代碼使用很少的代碼完成 清單 1 的所有工作（減去緩存總數(shù)，這會重新出現(xiàn)在下面的示例中）。例如，用于確定factorsOf() 中的系數(shù)的迭代消失了，替換為使用 findAll() 方法，它接受一個具有我的篩選器條件的代碼塊（一個高階函數(shù)）。Groovy 甚至允許使用更簡潔的代碼塊，它允許單參數(shù)塊使用 it 作為隱含參數(shù)名稱。同樣，sumOfFactors() 方法使用了 inject()，它（使用 0 作為種子值）將代碼塊應(yīng)用于每個元素，將每個對減少為單一的值。{i, j -> i + j} 代碼塊返回兩個參數(shù)的總和；每次將列表 “折疊” 成一個對時，都會應(yīng)用此塊，產(chǎn)生總和。

Java 開發(fā)人員習慣于框架 級別的重用；在面向?qū)ο蟮恼Z言中進行重用所需的必要構(gòu)件需要非常大的工作量，他們通常會將精力留給更大的問題。函數(shù)式語言在更細化的級別提供重用，在列表和映射等基本數(shù)據(jù)結(jié)構(gòu)之上通過高階函數(shù)提供定制，從而實現(xiàn)重用。

少量數(shù)據(jù)結(jié)構(gòu)，大量操作

在面向?qū)ο蟮拿钍骄幊陶Z言中，重用的單元是類以及與這些類進行通信的消息，這些信息是在類圖中捕獲的。該領(lǐng)域的開創(chuàng)性著作是《設(shè)計模式: 可復用面向?qū)ο筌浖幕A(chǔ)》，至少為每個模式提供一個類圖。在 OOP 的世界中，鼓勵開發(fā)人員創(chuàng)建獨特的數(shù)據(jù)結(jié)構(gòu)，以方法的形式附加特定的操作。函數(shù)式編程語言嘗試采用不同的方式來實現(xiàn)重用。它們更喜歡一些關(guān)鍵的數(shù)據(jù)結(jié)構(gòu)（如列表、集和映射），并且在這些數(shù)據(jù)結(jié)構(gòu)上采用高度優(yōu)化的操作。傳遞數(shù)據(jù)結(jié)構(gòu)和高階函數(shù)，以便 “插入” 這種機制，針對某一特定用途對其進行定制。例如，在 清單 2 中，findAll() 方法接受使用一個代碼塊作為 “插件” 高階函數(shù)（該函數(shù)確定了篩選條件），而該機制以有效方式應(yīng)用了篩選條件，并返回經(jīng)過篩選的列表。

函數(shù)級的封裝支持在比構(gòu)建自定義類結(jié)構(gòu)更細的基礎(chǔ)級別上進行重用。此方法的優(yōu)勢之一已經(jīng)體現(xiàn)在 Clojure 中。最近，庫中的一些巧妙創(chuàng)新重寫了 map 函數(shù)，使它可以自動并行化，這意味著所有映射操作都可以受益于沒有開發(fā)人員干預的性能提升。

例如，考慮一下解析 XML 的情況。大量的框架可用于在 Java 中完成這個任務(wù)，每個框架都有自定義的數(shù)據(jù)結(jié)構(gòu)和方法語義（例如，SAX 與 DOM）。Clojure 將 XML 解析為一個標準的 Map 結(jié)構(gòu)，而不是強迫您使用自定義的數(shù)據(jù)結(jié)構(gòu)。因為 Clojure 中包含大量與映射配合使用的工具，如果使用內(nèi)置的列表理解函數(shù) for，那么執(zhí)行 XPath 樣式的查詢就會很簡單，如清單 3 所示：

清單 3. 將 XML 解釋為 Clojure

(use 'clojure.xml)  
   
(def WEATHER-URI "http://weather.yahooapis.com/forecastrss?w=%d&u=f")  
   
(defn get-location [city-code]  
  (for [x (xml-seq (parse (format WEATHER-URI city-code)))  
        :when (= :yweather:location (:tag x))]  
    (str (:city (:attrs x)) "," (:region (:attrs x)))))  
   
(defn get-temp [city-code]  
  (for [x (xml-seq (parse (format WEATHER-URI city-code)))  
        :when (= :yweather:condition (:tag x))]  
    (:temp (:attrs x))))  
   
(println "weather for " (get-location 12770744) "is " (get-temp 12770744)) 

在 清單 3 中，我訪問雅虎的氣象服務(wù)來獲取某個給定城市的氣象預報。因為 Clojure 是 Lisp 的一個變體，所有從內(nèi)部讀取是最簡單的。對服務(wù)端點的實際調(diào)用發(fā)生在 (parse (format WEATHER-URI city-code)) 上，它使用了 String 的 format() 函數(shù)將 city-code嵌入字符串。列表理解函數(shù) for 放置了解析后的 XML，使用 xml-seq 將它投放到名稱為 x 的可查詢映射中。:when 謂詞確定了匹配條件；在本例中，我要搜索一個標簽（轉(zhuǎn)換成一個 Clojure 關(guān)鍵字） :yweather:condition。

如欲了解從數(shù)據(jù)結(jié)構(gòu)中讀取值所用的語法，那么查看該語法中包含的內(nèi)容會非常有用。在解析的時候，氣象服務(wù)的相關(guān)調(diào)用會返回在此摘錄中顯示的數(shù)據(jù)結(jié)構(gòu)：

({:tag :yweather:condition, :attrs {:text Fair, :code 34, :temp 62, :date Tue,   
   04 Dec 2012 9:51 am EST}, :content nil}) 

因為已經(jīng)為了與映射配合使用而優(yōu)化了 Clojure，所以關(guān)鍵字在包含它們的映射上成為了函數(shù)。在 清單 3 中，對 (:tag x) 的調(diào)用是一個縮寫，它等同于 “從存儲在 x 中的映射檢索與 :tag 鍵對應(yīng)的值”。因此，:yweather:condition 產(chǎn)生與該鍵關(guān)聯(lián)的映射值，其中包括我使用相同語法從中提取 :temp 的 attrs。

最初，Clojure 中令人生畏的細節(jié)之一是：與映射和其他核心數(shù)據(jù)結(jié)構(gòu)進行交互的方法似乎有無限多種。然而，它反映了這樣一個事實：在 Clojure 中，大多數(shù)內(nèi)容都嘗試解決這些核心的、優(yōu)化的數(shù)據(jù)結(jié)構(gòu)。它沒有將解析的 XML 困在一個獨特的框架中，相反，它試圖將其轉(zhuǎn)換為一個已存在相關(guān)工具的現(xiàn)有結(jié)構(gòu)。

對基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)的依賴性的優(yōu)點體現(xiàn)在 Clojure 的 XML 庫中。為了遍歷樹形結(jié)構(gòu)（如 XML 文檔），1997 年創(chuàng)建了一個有用的數(shù)據(jù)結(jié)構(gòu)，名為 zipper（參閱 參考資料）。zipper 通過提供坐標系方向，讓您可以結(jié)構(gòu)性地導航樹。例如，可以從樹的根開始，發(fā)出 (-> z/down z/down z/left) 等命令，導航到第二級的左側(cè)元素。Clojure 中已經(jīng)有現(xiàn)成的函數(shù)可將解析的 XML 轉(zhuǎn)換為 zipper，在整個樹形結(jié)構(gòu)中實現(xiàn)一致的導航。

#p#

新的、不同的工具

函數(shù)式編程提供了新的工具類型，以優(yōu)雅的方式解決棘手的問題。例如，Java 開發(fā)人員不習慣盡能延遲生成其值的惰性 數(shù)據(jù)結(jié)構(gòu)。而未來的函數(shù)式語言將對這種高級特性提供支持，一些框架將此功能加裝到 Java 中。例如，清單 4 所示的數(shù)字分類器版本使用了 Totally Lazy 框架：

清單 4. Java 數(shù)字分類器通過 Totally Lazy 使用惰性和函數(shù)式數(shù)據(jù)結(jié)構(gòu)

import com.googlecode.totallylazy.Predicate;  
import com.googlecode.totallylazy.Sequence;  
   
import static com.googlecode.totallylazy.Predicates.is;  
import static com.googlecode.totallylazy.numbers.Numbers.*;  
import static com.googlecode.totallylazy.predicates.WherePredicate.where;  
   
public class Classifier {  
  public static Predicate<Number> isFactor(Number n) {  
      return where(remainder(n), is(zero));  
  }  
   
  public static Sequence<Number> getFactors(final Number n){  
      return range(1, n).filter(isFactor(n));  
  }  
   
  public static Sequence<Number> factors(final Number n) {  
      return getFactors(n).memorise();  
  }  
   
  public static Number sumFactors(Number n){  
      return factors(n).reduce(sum);  
  }  
   
  public static boolean isPerfect(Number n){  
      return equalTo(n, subtract(sumFactors(n), n));  
  }  
   
  public static boolean isAbundant(Number n) {  
    return greaterThan(subtract(sumFactors(n), n), n);  
  }  
   
  public static boolean isDeficient(Number n) {  
    return lessThan(subtract(sumFactors(n), n), n);  
  }  
   
} 

Totally Lazy 增加了惰性集合和流暢接口方法，大量使用靜態(tài)導入，使代碼具有可讀性。如果您羨慕下一代語言中的某些特性，那么一些研究可能會提供可以解決某個特定問題的特定擴展。

讓語言遷就問題

大多數(shù)開發(fā)人員都將他們的工作誤解為接受一個復雜的業(yè)務(wù)問題，將它轉(zhuǎn)換成 Java 等語言。他們的這種誤解是因為 Java 并不是一種特別靈活的語言，它迫使您讓自己的想法適應(yīng)于已經(jīng)存在的剛性結(jié)構(gòu)。但是，當開發(fā)人員使用可塑語言時，他們看到了讓語言遷就問題，而不是讓問題遷就語言的機會。像 Ruby（它為領(lǐng)域特定語言 (DSL) 提供了比主流更友好的支持）等語言證明了這種潛在可能。現(xiàn)代函數(shù)式語言甚至走得更遠。Scala 旨在協(xié)調(diào)內(nèi)部 DSL 的托管，并且所有 Lisp（包括 Clojure）都可以提供無與倫比的靈活性，使開發(fā)人員能夠讓語言適應(yīng)問題。例如，清單 5 使用了 Scala 中的 XML 基元來實現(xiàn) 清單 3 的天氣示例：

清單 5. Scala 的 XML 語法修飾

import scala.xml._  
import java.net._  
import scala.io.Source  
   
val theUrl = "http://weather.yahooapis.com/forecastrss?w=12770744&u=f" 
   
val xmlString = Source.fromURL(new URL(theUrl)).mkString  
val xml = XML.loadString(xmlString)  
   
val city = xml \\ "location" \\ "@city" 
val state = xml \\ "location" \\ "@region" 
val temperature = xml \\ "condition" \\ "@temp" 
   
println(city + ", " + state + " " + temperature) 

Scala 是為獲得可塑性而設(shè)計的，它支持操作符重載和隱式類型等擴展。在 清單 5 中，Scala 被擴展為可以使用 \\ 操作符支持類似 XPath 的查詢。

與語言的趨勢相一致

函數(shù)式編程的目標之一是最大程度地減少可變狀態(tài)。在 清單 1 中，有兩種類型的共享狀態(tài)清單。_factors 和 _number 都存在，它們使代碼測試變得更容易（編寫原代碼版本是為了說明最大可測試性），并可以折疊成更大的函數(shù)，從而消除它們。但是，_sum 是因為各種原因而存在。我預計，這段代碼的用戶可能需要檢查多個分類。（例如，如果一個完美的檢查失敗，那么下一次我可能會檢查百分比。）合計系數(shù)總數(shù)的操作可能很昂貴，所以我為它創(chuàng)建了一個經(jīng)過惰性初始化的訪問器。在第一次調(diào)用時，它會計算總和，并將它存儲在 _sum 成員變量中，以便優(yōu)化未來的調(diào)用。

像垃圾收集一樣，現(xiàn)在緩存也可以降級用于語言。清單 2 中的 Groovy 數(shù)字分類器忽略了 清單 1 中總數(shù)的惰性初始化。如果想要實現(xiàn)同樣的功能，可以修改分類器，如清單 6 所示：

清單 6. 手動添加一個緩存

class ClassifierCachedSum {  
  private sumCache  
   
  ClassifierCachedSum() {  
    sumCache = [:]  
  }  
   
  def sumOfFactors(number) {  
    if (sumCache.containsKey(number))  
      return sumCache[number]  
    else {  
      def sum = factorsOf(number).inject(0, {i, j -> i + j})  
      sumCache.putAt(number, sum)  
      return sum  
    }  
  }  
  // ... other code omitted 

在最新版的 Groovy 中，清單 6 中的代碼不再是必要的?？紤]使用清單 7 中的改進版的分類器：

清單 7. 備忘數(shù)字分類器

class ClassifierMemoized {  
  def static dividesBy = { number, potential ->  
    number % potential == 0 
  }  
  def static isFactor = dividesBy.memoize()  
   
  def static factorsOf(number) {  
    (1..number).findAll { i -> isFactor.call(number, i) }  
  }  
   
  def static sumFactors = { number ->  
    factorsOf(number).inject(0, {i, j -> i + j})  
  }  
  def static sumOfFactors = sumFactors.memoize()  
   
  def static isPerfect(number) {  
    sumOfFactors(number) == 2 * number  
  }  
   
  def static isAbundant(number) {  
    sumOfFactors(number) > 2 * number  
  }  
   
  def static isDeficient(number) {  
    sumOfFactors(number) < 2 * number  
  }  
} 

任何純函數(shù)（沒有副作用的函數(shù)）都可以備忘，比如 清單 7 中的 sumOfFactors() 方法。備忘函數(shù)允許運行時緩存重復出現(xiàn)的值，從而消除手工編寫緩存的需要。事實上，請注意執(zhí)行實際工作的 getFactors() 和 factors() 方法之間的關(guān)系，該方法是備忘版本的getFactors()。Totally Lazy 還為 Java 增加了備忘功能，這是反饋到主流中的另一個高級函數(shù)特性。

由于運行時獲得了更多的能力并且有多余的開銷，開發(fā)人員可以將繁忙的工作割讓給語言，將我們解放出來，去思考更重要的問題。Groovy 中的備忘功能就是眾多示例中的一個；因為基礎(chǔ)運行時允許這樣做，所有現(xiàn)代語言都添加了函數(shù)式構(gòu)造，包括 Totally Lazy 等框架。

結(jié)束語

因為運行時的能力變得更強，并且語言獲得了更強大的抽象，所以開發(fā)世界變得更加函數(shù)化，這使開發(fā)人員可以花費更多的時間來思考結(jié)果的影響，而不是思考如何生成結(jié)果。由于高階函數(shù)等抽象出現(xiàn)在語言中，它們將成為高度優(yōu)化的操作的自定義機制。您不需要創(chuàng)建框架來處理問題（如 XML），您可以將其轉(zhuǎn)換成您已經(jīng)可以使用工具來處理的數(shù)據(jù)結(jié)構(gòu)。

隨著第 20 期文章的發(fā)布，函數(shù)式思維 將告一段落，我將準備開始一個新的系列，探索下一代的 JVM 語言。Java 下一代 會讓您對不久的將來有一個大致了解，并幫助您對必須投入新語言學習的時間作出明智選擇。

原文鏈接：http://www.ibm.com/developerworks/cn/java/j-ft20/index.html?ca=drs-