值就是函數(shù)，函數(shù)就是值。所有函數(shù)都消費函數(shù)，所有函數(shù)都生產(chǎn)函數(shù)。
"函數(shù)式編程", 又稱泛函編程, 是一種"編程范式"（programming paradigm），也就是如何編寫程序的方法論。它的基礎是 λ 演算（lambda calculus）。λ演算可以接受函數(shù)當作輸入（參數(shù)）和輸出（返回值）。
和指令式編程相比，函數(shù)式編程的思維方式更加注重函數(shù)的計算。它的主要思想是把問題的解決方案寫成一系列嵌套的函數(shù)調(diào)用。
就像在OOP中，一切皆是對象，編程的是由對象交合創(chuàng)造的世界；在FP中，一切皆是函數(shù)，編程的世界是由函數(shù)交合創(chuàng)造的世界。
函數(shù)式編程中最古老的例子莫過于1958年被創(chuàng)造出來的Lisp了。Lisp由約翰·麥卡錫（John McCarthy，1927-2011）在1958年基于λ演算所創(chuàng)造，采用抽象數(shù)據(jù)列表與遞歸作符號演算來衍生人工智能。較現(xiàn)代的例子包括Haskell、ML、Erlang等?，F(xiàn)代的編程語言對函數(shù)式編程都做了不同程度的支持，例如：JavaScript, Coffee Script，PHP，Perl，Python, Ruby, C# , Java 等等（這將是一個不斷增長的列表）。
函數(shù)式語言在Java 虛擬機（JVM）平臺上也迅速地嶄露頭角，例如Scala 、Clojure ； .NET 平臺也不例外，例如：F# 。
函數(shù)作為Kotlin中的一等公民，可以像其他對象一樣作為函數(shù)的輸入與輸出。關于對函數(shù)式編程的支持，相對于Scala的學院派風格，Kotlin則是純的的工程派：實用性、簡潔性上都要比Scala要好。
本章我們來一起學習函數(shù)式編程以及在Kotlin中使用函數(shù)式編程的相關內(nèi)容。
8.1 函數(shù)式編程概述
函數(shù)式編程思想是一個非常古老的思想。我們簡述如下：
我們就從1900 年 David Hilbert 的第 10 問題（能否通過有限步驟來判定不定方程是否存在有理整數(shù)解？） 開始說起吧。
1920，Sch?nfinkel，組合子邏輯(combinatory logic)。直到 Curry Haskell 1927 在普林斯頓大學當講師時重新發(fā)現(xiàn)了 Moses Sch?nfinkel 關于組合子邏輯的成果。Moses Sch?nfinkel的成果預言了很多 Curry 在做的研究，于是他就跑去哥廷根大學與熟悉Moses Sch?nfinkel工作的Heinrich Behmann、Paul Bernays兩人一起工作，并于 1930 年以一篇組合子邏輯的論文拿到了博士學位。Curry Brooks Haskell 整個職業(yè)生涯都在研究組合子，實際開創(chuàng)了這個研究領域，λ演算中用單參數(shù)函數(shù)來表示多個參數(shù)函數(shù)的方法被稱為 Currying (柯里化)，雖然 Curry 同學多次指出這個其實是 Sch?nfinkel 已經(jīng)搞出來的，不過其他人都是因為他用了才知道，所以這名字就這定下來了；并且有三門編程語言以他的名字命名，分別是：Curry, Brooks, Haskell。Curry 在 1928 開始開發(fā)類型系統(tǒng)，他搞的是基于組合子的 polymorphic，Church 則建立了基于函數(shù)的簡單類型系統(tǒng)。
1929, 哥德爾(Kurt G?del )完備性定理。G?del 首先證明了一個形式系統(tǒng)中的所有公式都可以表示為自然數(shù)，并可以從一自然數(shù)反過來得出相應的公式。這對于今天的程序員都來說，數(shù)字編碼、程序即數(shù)據(jù)計算機原理最核心、最基本的常識，在那個時代卻腦洞大開的創(chuàng)見。
1933，λ 演算。 Church 在 1933 年搞出來一套以純λ演算為基礎的邏輯，以期對數(shù)學進行形式化描述。 λ 演算和遞歸函數(shù)理論就是函數(shù)式編程的基礎。
1936，確定性問題（decision problem，德文 Entscheidungsproblem (發(fā)音 [?nt??a??d??sp?o?ble?m]）。 Alan Turing 和 Alonzo Church，兩人在同在1936年獨立給出了否定答案。
1935-1936這個時間段上，我們有了三個有效計算模型：通用圖靈機、通用遞歸函數(shù)、λ可定義。Rosser 1939 年正式確認這三個模型是等效的。
1953-1957，F(xiàn)ORTRAN (FORmula TRANslating )，John Backus。1952 年 Halcombe Laning 提出了直接輸入數(shù)學公式的設想，并制作了 GEORGE編譯器演示該想法。受這個想法啟發(fā)，1953 年 IBM 的 John Backus 團隊給 IBM 704 主機研發(fā)數(shù)學公式翻譯系統(tǒng)。第一個 FORTRAN (FORmula TRANslating 的縮寫)編譯器 1957.4 正式發(fā)行。FORTRAN 程序的代碼行數(shù)比匯編少20倍。FORTRAN 的成功，讓很多人認識到直接把代數(shù)公式輸入進電腦是可行的，并開始渴望能用某種形式語言直接把自己的研究內(nèi)容輸入到電腦里進行運算。John Backus 在1970年代搞了 FP 語言，1977 年發(fā)表。雖然這門語言并不是最早的函數(shù)式編程語言，但他是 Functional Programming 這個詞兒的創(chuàng)造者， 1977 年他的圖靈獎演講題為[“Can Programming Be Liberated From the von Neumann Style? A Functional Style and its Algebra of Programs”]
1956， LISP， John McCarthy。John McCarthy 1956年在 Dartmouth一臺 IBM 704 上搞人工智能研究時，就想到要一個代數(shù)列表處理(algebraic list processing)語言。他的項目需要用某種形式語言來編寫語句，以記錄關于世界的信息，而他感覺列表結(jié)構(gòu)這種形式挺合適，既方便編寫，也方便推演。于是就創(chuàng)造了LISP。正因為是在 IBM 704 上開搞的，所以 LISP 的表處理函數(shù)才會有奇葩的名字： car/cdr 什么的。其實是取 IBM704 機器字的不同部分，c=content of，r=register number, a=address part, d=decrement part 。
8.1.1 面向?qū)ο缶幊蹋∣OP）與面向函數(shù)編程（FOP）
面向?qū)ο缶幊蹋∣OP）
在OOP中，一切皆是對象。
在面向?qū)ο蟮拿钍剑╥mperative）編程語言里面，構(gòu)建整個世界的基礎是類和類之間溝通用的消息，這些都可以用類圖（class diagram）來表述?！对O計模式：可復用面向?qū)ο筌浖幕A》（Design Patterns: Elements of Reusable Object-Oriented Software，作者ErichGamma、Richard Helm、Ralph Johnson、John Vlissides）一書中，在每一個模式的說明里都附上了至少一幅類圖。
OOP 的世界提倡開發(fā)者針對具體問題建立專門的數(shù)據(jù)結(jié)構(gòu)，相關的專門操作行為以“方法”的形式附加在數(shù)據(jù)結(jié)構(gòu)上，自頂向下地來構(gòu)建其編程世界。
OOP追求的是萬事萬物皆對象的理念，自然地弱化了函數(shù)。例如：函數(shù)無法作為普通數(shù)據(jù)那樣來傳遞（OOP在函數(shù)指針上的約束），所以在OOP中有各種各樣的、五花八門的設計模式。
GoF所著的《設計模式-可復用面向?qū)ο筌浖幕A》從面向?qū)ο笤O計的角度出發(fā)的，通過對封裝、繼承、多態(tài)、組合等技術(shù)的反復使用，提煉出一些可重復使用的面向?qū)ο笤O計技巧。而多態(tài)在其中又是重中之重。
多態(tài)、面向接口編程、依賴反轉(zhuǎn)等術(shù)語，描述的思想其實是相同的。這種反轉(zhuǎn)模式實現(xiàn)了模塊與模塊之間的解耦。這樣的架構(gòu)是健壯的, 而為了實現(xiàn)這樣的健壯系統(tǒng)，在系統(tǒng)架構(gòu)中基本都需要使用多態(tài)性。
絕大部分設計模式的實現(xiàn)都離不開多態(tài)性的思想。換一種說法就是，這些設計模式背后的本質(zhì)其實就是OOP的多態(tài)性，而OOP中的多態(tài)本質(zhì)上又是受約束的函數(shù)指針。
引用Charlie Calverts對多態(tài)的描述: “多態(tài)性是允許你將父對象設置成為和一個或更多的他的子對象相等的技術(shù)，賦值之后，父對象就可以根據(jù)當前賦值給它的子對象的特性以不同的方式運作?！?/p>
簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。而我們在OOP中的那么多的設計模式，其實就是在OOP的多態(tài)性的約束規(guī)則下，對這些函數(shù)指針的調(diào)用模式的總結(jié)。
很多設計模式，在函數(shù)式編程中都可以用高階函數(shù)來代替實現(xiàn)：
面向函數(shù)編程（FOP）
在FP中，一切皆是函數(shù)。
函數(shù)式編程（FP）是關于不變性和函數(shù)組合的一種編程范式。
函數(shù)式編程語言實現(xiàn)重用的思路很不一樣。函數(shù)式語言提倡在有限的幾種關鍵數(shù)據(jù)結(jié)構(gòu)（如list、set、map）上 ， 運用函數(shù)的組合 ( 高階函數(shù)) 操作，自底向上地來構(gòu)建世界。
當然，我們在工程實踐中，是不能極端地追求純函數(shù)式的編程的。一個簡單的原因就是：性能和效率。例如：對于有狀態(tài)的操作，命令式操作通常會比聲明式操作更有效率。純函數(shù)式編程是解決某些問題的偉大工具，但是在另外的一些問題場景中，并不適用。因為副作用總是真實存在。
OOP喜歡自頂向下架構(gòu)層層分解（解構(gòu)），F(xiàn)P喜歡自底向上層層組合（復合）。 而實際上，編程的本質(zhì)就是次化分解與復合的過程。通過這樣的過程，創(chuàng)造一個美妙的邏輯之塔世界。
我們經(jīng)常說一些代碼片段是優(yōu)雅的或美觀的，實際上意味著它們更容易被人類有限的思維所處理。
對于程序的復合而言，好的代碼是它的表面積要比體積增長的慢。
代碼塊的“表面積”是我們復合代碼塊時所需要的信息（接口API協(xié)議定義）。代碼塊的“體積”就是接口內(nèi)部的實現(xiàn)邏輯（API內(nèi)部的實現(xiàn)代碼）。
在OOP中，一個理想的對象應該是只暴露它的抽象接口（純表面， 無體積），其方法則扮演箭頭的角色。如果為了理解一個對象如何與其他對象進行復合，當你發(fā)現(xiàn)不得不深入挖掘?qū)ο蟮膶崿F(xiàn)之時，此時你所用的編程范式的原本優(yōu)勢就蕩然無存了。
FP通過函數(shù)組合來構(gòu)造其邏輯系統(tǒng)。FP傾向于把軟件分解為其需要執(zhí)行的行為或操作,而且通常采用自底向上的方法。函數(shù)式編程也提供了非常強大的對事物進行抽象和組合的能力。
在FP里面，函數(shù)是“一類公民”（first-class）。它們可以像1, 2, "hello"，true，對象…… 之類的“值”一樣，在任意位置誕生，通過變量，參數(shù)和數(shù)據(jù)結(jié)構(gòu)傳遞到其它地方，可以在任何位置被調(diào)用。
而在OOP中，很多所謂面向?qū)ο笤O計模式（design pattern），都是因為面向?qū)ο笳Z言沒有first-class function（對應的是多態(tài)性），所以導致了每個函數(shù)必須被包在一個對象里面（受約束的函數(shù)指針）才能傳遞到其它地方。
勻稱的數(shù)據(jù)結(jié)構(gòu) + 勻稱的算法
在面向?qū)ο笫降木幊讨?，一切皆是對象（偏重?shù)據(jù)結(jié)構(gòu)、數(shù)據(jù)抽象，輕算法）。我們把它叫做：胖數(shù)據(jù)結(jié)構(gòu)-瘦算法（FDS-TA）。
在面向函數(shù)式的編程中，一切皆是函數(shù)（偏重算法，輕數(shù)據(jù)結(jié)構(gòu)）。我們把它叫做：瘦數(shù)據(jù)結(jié)構(gòu)-胖算法（TDS-FA）。
可是，這個世界很復雜，你怎么能說一切皆是啥呢？真實的編程世界，自然是勻稱的數(shù)據(jù)結(jié)構(gòu)結(jié)合勻稱的算法（SDS-SA）來創(chuàng)造的。
我們在編程中，不可能使用純的對象（對象的行為方法其實就是函數(shù)），或者純的函數(shù)（調(diào)用函數(shù)的對象、函數(shù)操作的數(shù)據(jù)其實就是數(shù)據(jù)結(jié)構(gòu)）來創(chuàng)造一個完整的世界。如果數(shù)據(jù)結(jié)構(gòu)是陰，算法是陽，那么在解決實際問題中，往往是陰陽交合而成世界。還是那句經(jīng)典的：
程序 = 勻稱的數(shù)據(jù)結(jié)構(gòu) + 勻稱的算法
我們用一幅圖來簡單說明：
函數(shù)與映射
一切皆是映射。函數(shù)式編程的代碼主要就是“對映射的描述”。我們說組合是編程的本質(zhì)，其實，組合就是建立映射關系。
一個函數(shù)無非就是從輸入到輸出的映射，寫成數(shù)學表達式就是：
f : X -> Y
p : Y -> Z
p(f) : X ->Z
用編程語言表達就是：
fun f(x:X) : Y{}
fun p(y:Y) : Z{}
fun fp(f: (X)->Y, p: (Y)->Z) : Z {
return {x -> p(f(x))}
}
8.1.2 函數(shù)式編程基本特性
在經(jīng)常被引用的論文 “Why Functional Programming Matters” 中，作者 John Hughes 說明了模塊化是成功編程的關鍵，而函數(shù)編程可以極大地改進模塊化。
在函數(shù)編程中，我們有一個內(nèi)置的框架來開發(fā)更小的、更簡單的和更一般化的模塊， 然后將它們組合在一起。
函數(shù)編程的一些基本特點包括：
- 函數(shù)是"第一等公民"。
- 閉包（Closure）和高階函數(shù)（Higher Order Function）。
- Lambda演算與函數(shù)柯里化（Currying）。
- 懶惰計算（lazy evaluation）。
- 使用遞歸作為控制流程的機制。
- 引用透明性。
- 沒有副作用。
8.1.3 組合與范疇
函數(shù)式編程的本質(zhì)是函數(shù)的組合，組合的本質(zhì)是范疇（Category）。
和搞編程的一樣，數(shù)學家喜歡將問題不斷加以抽象從而將本質(zhì)問題抽取出來加以論證解決，范疇論就是這樣一門以抽象的方法來處理數(shù)學概念的學科，主要用于研究一些數(shù)學結(jié)構(gòu)之間的映射關系（函數(shù)）。
在范疇論里，一個范疇(category)由三部分組成：
- 對象(object)
- 態(tài)射(morphism)
- 組合(composition)操作符
范疇的對象
這里的對象可以看成是一類東西，例如數(shù)學上的群，環(huán)，以及有理數(shù)，無理數(shù)等都可以歸為一個對象。對應到編程語言里，可以理解為一個類型，比如說整型，布爾型等。
態(tài)射
態(tài)射指的是一種映射關系，簡單理解，態(tài)射的作用就是把一個對象 A 里的值 a 映射為 另一個對象 B 里的值 b = f(a)，這就是映射的概念。
態(tài)射的存在反映了對象內(nèi)部的結(jié)構(gòu)，這是范疇論用來研究對象的主要手法：對象內(nèi)部的結(jié)構(gòu)特性是通過與別的對象的映射關系反映出來的，動靜是相對的，范疇論通過研究映射關系來達到探知對象的內(nèi)部結(jié)構(gòu)的目的。
組合操作符
組合操作符，用點(.)表示，用于將態(tài)射進行組合。組合操作符的作用是將兩個態(tài)射進行組合，例如，假設存在態(tài)射 f: A -> B, g: B -> C， 則 g.f : A -> C.
一個結(jié)構(gòu)要想成為一個范疇, 除了必須包含上述三樣東西，它還要滿足以下三個限制:
結(jié)合律： f.(g.h) = (f.g).h 。
封閉律：如果存在態(tài)射 f, g，則必然存在 h = f.g 。
同一律：對結(jié)構(gòu)中的每一個對象 A, 必須存在一個單位態(tài)射 Ia: A -> A， 對于單位態(tài)射，顯然，對任意其它態(tài)射 f, 有 f.I = f。
在范疇論里另外研究的重點是范疇與范疇之間的關系，就正如對象與對象之間有態(tài)射一樣，范疇與范疇之間也存在映射關系，從而可以將一個范疇映射為另一個范疇，這種映射在范疇論中叫作函子(functor），具體來說，對于給定的兩個范疇 A 和 B, 函子的作用有兩個:
- 將范疇 A 中的對象映射到范疇 B 中的對象。
- 將范疇 A 中的態(tài)射映射到范疇 B 中的態(tài)射。
顯然，函子反映了不同的范疇之間的內(nèi)在聯(lián)系。跟函數(shù)和泛函數(shù)的思想是相同的。
而我們的函數(shù)式編程探究的問題與思想理念可以說是跟范疇論完全吻合。如果把函數(shù)式編程的整個的世界看做一個對象，那么FP真正搞的事情就是建立通過函數(shù)之間的映射關系，來構(gòu)建這樣一個美麗的編程世界。
很多問題的解決（證明）其實都不涉及具體的（數(shù)據(jù)）結(jié)構(gòu)，而完全可以只依賴映射之間的組合運算(composition)來搞定。這就是函數(shù)式編程的核心思想。
如果我們把程序看做圖論里面的一張圖G，數(shù)據(jù)結(jié)構(gòu)當作是圖G的節(jié)點Node（數(shù)據(jù)結(jié)構(gòu)，存儲狀態(tài)）， 而算法邏輯就是這些節(jié)點Node之間的Edge (數(shù)據(jù)映射，Mapping)， 那么這整幅圖 G(N,E) 就是一幅美妙的抽象邏輯之塔的 映射圖 ， 也就是我們編程創(chuàng)造的世界：
函數(shù)是"第一等公民"
函數(shù)式編程（FP）中，函數(shù)是"第一等公民"。
所謂"第一等公民"（first class），有時稱為 閉包 或者 仿函數(shù)（functor）對象，指的是函數(shù)與其他數(shù)據(jù)類型一樣，處于平等地位，可以賦值給其他變量，也可以作為參數(shù)，傳入另一個函數(shù)，或者作為別的函數(shù)的返回值。這個以函數(shù)為參數(shù)的概念，跟C語言中的函數(shù)指針類似。
舉例來說，下面代碼中的print變量就是一個函數(shù)（沒有函數(shù)名），可以作為另一個函數(shù)的參數(shù):
>>> val print = fun(x:Any){println(x)}
>>> listOf(1,2,3).forEach(print)
1
2
3
高階函數(shù)（Higher order Function）
FP 語言支持高階函數(shù)，高階函數(shù)就是多階映射。高階函數(shù)用另一個函數(shù)作為其輸入?yún)?shù)，也可以返回一個函數(shù)作為輸出。
代碼示例：
fun isOdd(x: Int) = x % 2 != 0
fun length(s: String) = s.length
fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
return { x -> f(g(x)) }
}
測試代碼：
fun main(args: Array<String>) {
val oddLength = compose(::isOdd, ::length)
val strings = listOf("a", "ab", "abc")
println(strings.filter(oddLength)) // [a, abc]
}
這個compose函數(shù)，其實就是數(shù)學中的復合函數(shù)的概念，這是一個高階函數(shù)的例子：傳入的兩個參數(shù)f , g都是函數(shù)，其返回值也是函數(shù)。
圖示如下：
這里的
fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C
中類型參數(shù)對應：
fun <String, Int, Boolean> compose(f: (Int) -> Boolean, g: (String) -> Int): (String) -> Boolean
這里的(Int) -> Boolean 、(String) -> Int、 (String) -> Boolean 都是函數(shù)類型。
其實，從映射的角度看，就是二階映射。對[a, ab, abc] 中每個元素 x 先映射成長度g(x) = 1, 2, 3 ， 再進行第二次映射：f(g(x)) %2 != 0 , 長度是奇數(shù)？返回值是true的被過濾出來。
有了高階函數(shù)，我們可以用優(yōu)雅的方式進行模塊化編程。
另外，高階函數(shù)滿足結(jié)合律：
λ演算 （Lambda calculus 或者 λ-calculus）
?? 演算是函數(shù)式語言的基礎。在λ-演算的基礎上，發(fā)展起來的π-演算、χ-演算，成為近年來的并發(fā)程序的理論工具之一，許多經(jīng)典的并發(fā)程序模型就是以π-演算為框架的。λ 演算神奇之處在于，通過最基本的函數(shù)抽象和函數(shù)應用法則，配套以適當?shù)募记?，便能夠?gòu)造出任意復雜的可計算函數(shù)。
λ演算是一套用于研究函數(shù)定義、函數(shù)應用和遞歸的形式系統(tǒng)。它由 阿隆佐·丘奇（Alonzo Church，1903~1995）和 Stephen Cole Kleene 在 20 世紀三十年代引入。當時的背景是解決函數(shù)可計算的本質(zhì)性問題，初期λ演算成功的解決了在可計算理論中的判定性問題，后來根據(jù)Church–Turing thesis，證明了λ演算與圖靈機是等價的。
λ 演算可以被稱為最小的通用程序設計語言。它包括一條變換規(guī)則 (變量替換) 和一條函數(shù)定義方式，λ演算之通用在于，任何一個可計算函數(shù)都能用這種形式來表達和求值。
λ演算強調(diào)的是變換規(guī)則的運用，這里的變換規(guī)則本質(zhì)上就是函數(shù)映射。
Lambda 表達式（Lambda Expression） 是 λ演算 的一部分。
λ演算中一切皆函數(shù)，全體λ表達式構(gòu)成Λ空間，λ表達式為Λ空間到Λ空間的函數(shù)。
例如，在 lambda 演算中有許多方式都可以定義自然數(shù)，最常見的是Church 整數(shù)，定義如下：
0 = λ f. λ x. x
1 = λ f. λ x. f x
2 = λ f. λ x. f (f x)
3 = λ f. λ x. f (f (f x))
...
數(shù)學家們都崇尚簡潔，只用一個關鍵字 'λ' 來表示對函數(shù)的抽象。
其中的λ f. λ x.，λ f 是抽象出來的函數(shù), λ x是輸入?yún)?shù)， . 語法用來分割參數(shù)表和函數(shù)體。 為了更簡潔，我們簡記為F, 那么上面的Church 整數(shù)定義簡寫為：
0 = F x
1 = F f x
2 = F f (f x)
3 = F f (f (f x))
...
使用λ演算定義布爾值：
TRUE = λ x. λ y. x
FALSE = λ x. λ y. y
用圖示如下：
在λ演算中只有函數(shù)，一門編程語言中的數(shù)據(jù)類型，比如boolean、number、list等，都可以使用純λ演算來實現(xiàn)。我們不用去關心數(shù)據(jù)的值是什么，重點是我們能對這個值做什么操作（apply function）。
使用λ演算定義一個恒等函數(shù)I ：
I = λ x . x
使用Kotlin代碼來寫，如下：
>>> val I = {x:Int -> x}
>>> I(0)
0
>>> I(1)
1
>>> I(100)
100
對 I 而言任何一個 x 都是它的不動點(即對某個函數(shù) f(x) 存在這樣的一個輸入 x，使得函數(shù)的輸出仍舊等于輸入的 x 。形式化的表示即為 f(x) = x )。
再例如，下面的 λ 表達式表示將x映射為 x+1 :
λ x . x + 1
測試代碼：
( λ x . x + 1) 5
將輸出6 。
這樣的表達式，在Kotlin中, 如果使用Lambda表達式我們這樣寫：
>>> val addOneLambda = {
... x: Int ->
... x + 1
... }
>>> addOneLambda(1)
2
如果使用匿名函數(shù)，這樣寫：
>>> val addOneAnonymouse = (fun(x: Int): Int {
... return x + 1
... })
>>> addOneAnonymouse(1)
2
在一些古老的編程語言中，lambda表達式還是比較接近lambda演算的表達式的。在現(xiàn)代程序語言中的lambda表達式，只是取名自lambda演算，已經(jīng)與原始的lambda演算有很大差別了。例如：
在Javascript里沒有任何語法專門代表lambda, 只寫成這樣的嵌套函數(shù)function{ return function{...} }。
函數(shù)柯里化（Currying）
很多基于 lambda calculus 的程序語言，比如 ML 和 Haskell，都習慣用currying 的手法來表示函數(shù)。比如，如果你在 Haskell 里面這樣寫一個函數(shù)：
f x y = x + y
然后你就可以這樣把鏈表里的每個元素加上 2：
map (f 2) [1, 2, 3]
它會輸出 [3, 4, 5]。
Currying 用一元函數(shù)，來組合成多元函數(shù)。比如，上面的函數(shù) f 的定義在 Scheme 里面相當于：
(define f (lambda (x) (lambda (y) (+ x y))))
它是說，函數(shù) f，接受一個參數(shù) x，返回另一個函數(shù)（沒有名字）。這個匿名函數(shù)，如果再接受一個參數(shù) y，就會返回 x + y。所以上面的例子里面，(f 2) 返回的是一個匿名函數(shù)，它會把 2 加到自己的參數(shù)上面返回。所以把它 map 到 [1, 2, 3]，我們就得到了 [3, 4, 5]。
我們再使用Kotlin中的函數(shù)式編程來舉例說明。
首先，我們看下普通的二元函數(shù)的寫法：
fun add(x: Int, y: Int): Int {
return x + y
}
add(1, 2) // 輸出3
這種寫法最簡單，只有一層映射。
柯里化的寫法：
fun curryAdd(x: Int): (Int) -> Int {
return { y -> x + y }
}
curryAdd(1)(2)// 輸出3
我們先傳入?yún)?shù)x = 1， 返回函數(shù) curryAdd(1) = 1 + y；然后傳入?yún)?shù) y = 2, 返回最終的值 curryAdd(1)(2) = 3。
當然，我們也有 λ 表達式的寫法：
val lambdaCurryAdd = {
x: Int ->
{
y: Int ->
x + y
}
}
lambdaCurryAdd(1)(2) // 輸出 3
這個做法其實來源于最早的 lambda calculus 的設計。因為 lambda calculus 的函數(shù)都只有一個參數(shù)，所以為了能夠表示多參數(shù)的函數(shù)， Haskell Curry （數(shù)學家和邏輯學家），發(fā)明了這個方法。
不過在編碼實踐中，Currying 的工程實用性、簡潔性上不是那么的友好。大量使用 Currying，會導致代碼可讀性降低，復雜性增加，并且還可能因此引起意想不到的錯誤。 所以在我們的講求工程實踐性能的Kotlin語言中，
古老而美麗的理論，也許能夠給我?guī)硭枷氲膯⒌希窃诠こ虒嵺`中未必那么理想。
閉包（Closure）
閉包簡單講就是一個代碼塊，用{ }包起來。此時，程序代碼也就成了數(shù)據(jù)，可以被一個變量所引用（與C語言的函數(shù)指針比較類似）。閉包的最典型的應用是實現(xiàn)回調(diào)函數(shù)（callback）。
閉包包含以下兩個組成部分：
- 要執(zhí)行的代碼塊（由于自由變量被包含在代碼塊中，這些自由變量以及它們引用的對象沒有被釋放）
- 自由變量的作用域
在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
Lambda表達式可以表示閉包。
惰性計算
除了高階函數(shù)、閉包、Lambda表達式的概念，F(xiàn)P 還引入了惰性計算的概念。惰性計算（盡可能延遲表達式求值）是許多函數(shù)式編程語言的特性。惰性集合在需要時提供其元素，無需預先計算它們，這帶來了一些好處。首先，您可以將耗時的計算推遲到絕對需要的時候。其次，您可以創(chuàng)造無限個集合，只要它們繼續(xù)收到請求，就會繼續(xù)提供元素。第三，map 和 filter 等函數(shù)的惰性使用讓您能夠得到更高效的代碼（請參閱 參考資料 中的鏈接，加入由 Brian Goetz 組織的相關討論）。
在惰性計算中，表達式不是在綁定到變量時立即計算，而是在求值程序需要產(chǎn)生表達式的值時進行計算。
一個惰性計算的例子是生成無窮 Fibonacci 列表的函數(shù)，但是對 第 n 個Fibonacci 數(shù)的計算相當于只是從可能的無窮列表中提取一項。
遞歸函數(shù)
遞歸指的是一個函數(shù)在其定義中直接或間接調(diào)用自身的一種方法, 它通常把一個大型的復雜的問題轉(zhuǎn)化為一個與原問題相似的規(guī)模較小的問題來解決（復用函數(shù)自身）, 這樣可以極大的減少代碼量。遞歸分為兩個階段:
- 遞推:把復雜的問題的求解推到比原問題簡單一些的問題的求解;
- 回歸:當獲得最簡單的情況后,逐步返回,依次得到復雜的解。
遞歸的能力在于用有限的語句來定義對象的無限集合。
使用遞歸要注意的有兩點:
- 遞歸就是在過程或函數(shù)里面調(diào)用自身;
- 在使用遞歸時,必須有一個明確的遞歸結(jié)束條件,稱為遞歸出口。
下面我們舉例說明。
階乘函數(shù) fact(n) 一般這樣遞歸地定義：
fact(n) = if n=0 then 1 else n * fact(n-1)
我們使用Kotlin代碼實現(xiàn)這個函數(shù)如下：
fun factorial(n: Int): Int {
println("factorial() called! n=$n")
if (n == 0) return 1;
return n * factorial(n - 1);
}
測試代碼：
@Test
fun testFactorial() {
Assert.assertTrue(factorial(0) == 1)
Assert.assertTrue(factorial(1) == 1)
Assert.assertTrue(factorial(3) == 6)
Assert.assertTrue(factorial(10) == 3628800)
}
輸出：
factorial() called! n=0
factorial() called! n=1
factorial() called! n=0
factorial() called! n=3
factorial() called! n=2
factorial() called! n=1
factorial() called! n=0
factorial() called! n=10
factorial() called! n=9
factorial() called! n=8
factorial() called! n=7
factorial() called! n=6
factorial() called! n=5
factorial() called! n=4
factorial() called! n=3
factorial() called! n=2
factorial() called! n=1
factorial() called! n=0
BUILD SUCCESSFUL in 24s
6 actionable tasks: 5 executed, 1 up-to-date
我們可以看到在factorial計算的過程中，函數(shù)不斷的調(diào)用自身，然后不斷的展開，直到最后到達了終止的n==0，這是遞歸的原則之一，就是在遞歸的過程中，傳遞的參數(shù)一定要不斷的接近終止條件，在上面的例子中就是n的值不斷減少，直至最后為0。
再舉個Fibonacci數(shù)列的例子。
Fibonacci數(shù)列用數(shù)學中的數(shù)列的遞歸表達式定義如下：
fibonacci (0) = 0
fibonacci (1) = 1
fibonacci (n) = fibonacci (n - 1) + fibonacci (n - 2)
我們使用Kotlin代碼實現(xiàn)它：
fun fibonacci(n: Int): Int {
if (n == 1 || n == 2) return 1;
return fibonacci(n - 1) + fibonacci(n - 2);
}
測試代碼：
@Test
fun testFibonacci() {
Assert.assertTrue(fibonacci(1) == 1)
Assert.assertTrue(fibonacci(2) == 1)
Assert.assertTrue(fibonacci(3) == 2)
Assert.assertTrue(fibonacci(4) == 3)
Assert.assertTrue(fibonacci(5) == 5)
Assert.assertTrue(fibonacci(6) == 8)
}
外篇： Scheme中的遞歸寫法
因為Scheme 程序中充滿了一對對嵌套的小括號，這些嵌套的符號體現(xiàn)了最基本的數(shù)學思想——遞歸。所以，為了多維度的來理解遞歸，我們給出Scheme中的遞歸寫法：
(define factorial
(lambda (n)
(if (= n 0)
1
(* n (factorial (- n 1))))))
(define fibonacci
(lambda (n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))))
其中關鍵字lambda, 表明我們定義的(即任何封閉的開括號立即離開λ及其相應的關閉括號)是一個函數(shù)。
Lambda演算和函數(shù)式語言的計算模型天生較為接近，Lambda表達式一般是這些語言必備的基本特性。
Scheme是Lisp方言，遵循極簡主義哲學，有著獨特的魅力。Scheme的一個主要特性是可以像操作數(shù)據(jù)一樣操作函數(shù)調(diào)用。
Y組合子(Y - Combinator)
在現(xiàn)代編程語言中，函數(shù)都是具名的，而在傳統(tǒng)的Lambda Calculus中，函數(shù)都是沒有名字的。這樣就出現(xiàn)了一個問題 —— 如何在Lambda Calculus中實現(xiàn)遞歸函數(shù)，即匿名遞歸函數(shù)。Haskell B. Curry （編程語言 Haskell 就是以此人命名的）發(fā)現(xiàn)了一種不動點組合子 —— Y Combinator，用于解決匿名遞歸函數(shù)實現(xiàn)的問題。Y 組合子(Y Combinator)，其定義是：
Y = λf.(λx.f (x x)) (λx.f (x x))
對于任意函數(shù) g，可以通過推導得到Y g = g (Y g) (（高階）函數(shù)的不動點 )，從而證明 λ演算 是 圖靈完備 的。 Y 組合子 的重要性由此可見一斑。
她讓人絞盡腦汁，也琢磨不定！她讓人心力憔悴，又百般回味！
她，看似平淡，卻深藏玄機！她，貌不驚人，卻天下無敵！
她是誰？她就是 Y 組合子：Y = λf.(λx.f (x x)) (λx.f (x x))，不動點組合子中最著名的一個。
Y 組合子讓我們可以定義匿名的遞歸函數(shù)。Y組合子是Lambda演算的一部分，也是函數(shù)式編程的理論基礎。僅僅通過Lambda表達式這個最基本的 原子 實現(xiàn)循環(huán)迭代。Y 組合子本身是函數(shù)，其輸入也是函數(shù)（在 Lisp 中連程序都是函數(shù)）。
頗有道生一、一生二、二生三、三生萬物的韻味。
舉個例子說明： 我們先使用類C語言中較為熟悉的JavaScript來實現(xiàn)一個Y組合子函數(shù)， 因為JavaScript語言的動態(tài)特性，使得該實現(xiàn)相比許多需要聲明各種類型的語言要簡潔許多：
function Y(f) {
return (function (g) {
return g(g);
})(function (g) {
return f(function (x) {
return g(g)(x);
});
});
}
var fact = Y(function (rec) {
return function (n) {
return n == 0 ? 1 : n * rec(n - 1);
};
});
我們使用了Y函數(shù)組合一段匿名函數(shù)代碼，實現(xiàn)了一個匿名的遞歸階乘函數(shù)。
直接將這兩個函數(shù)放到瀏覽器的Console中去執(zhí)行，我們將看到如下輸出：
fact(10)
3628800
這個Y函數(shù)相當繞腦。要是在Clojure（JVM上的Lisp方言）中，這個Y函數(shù)實現(xiàn)如下：
(defn Y [r]
((fn [f] (f f))
(fn [f]
(r (fn [x] ((f f) x))))))
使用Scheme語言來表達：
(define Y
(lambda (f)
((lambda (x) (f (lambda (y) ((x x) y))))
(lambda (x) (f (lambda (y) ((x x) y)))))))
我們可以看出，使用Scheme語言表達的Y組合子跟 原生的 λ演算 表達式基本一樣。
用CoffeeScript實現(xiàn)一個 Y combinator就長這樣：
coffee> Y = (f) -> ((x) -> (x x)) ((x) -> (f ((y) -> ((x x) y))))
[Function]
這個看起就相當簡潔優(yōu)雅了。我們使用這個 Y combinator 實現(xiàn)一個匿名遞歸的Fibonacci函數(shù)：
coffee> fib = Y (f) -> (n) -> if n < 2 then n else f(n-1) + f(n-2)
[Function]
coffee> index = [0..10]
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
coffee> index.map(fib)
[ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]
實現(xiàn)一個匿名遞歸階乘函數(shù)：
coffee> fact = Y (f) ->(n) -> if n==0 then 1 else n*f(n-1)
[Function]
coffee> fact(10)
3628800
上面的Coffee代碼的命令行REPL運行環(huán)境搭建非常簡單：
$ npm install -g coffee-script
$ coffee
coffee>
對CoffeeScript感興趣的讀者，可以參考：http://coffee-script.org/。
但是，這個Y組合子 要是 使用 OOP 語言編程范式， 就要顯得復雜許多。為了更加深刻地認識OOP 與 FP編程范式，我們使用Java 8 以及 Kotlin 的實例來說明。這里使用Java給出示例的原因，是為了給出Kotlin與Java語言上的對比，在下一章節(jié)中，我們將要學習Kotlin與Java的互操作。
首先我們使用Java的匿名內(nèi)部類實現(xiàn)Y組合子 ：
package com.easy.kotlin;
public class YCombinator {
public static Lambda<Lambda> yCombinator(final Lambda<Lambda> f) {
return new Lambda<Lambda>() {
@Override
public Lambda call(Object input) {
final Lambda<Lambda> u = (Lambda<Lambda>)input;
return u.call(u);
}
}.call(new Lambda<Lambda>() {
@Override
public Lambda call(Object input) {
final Lambda<Lambda> x = (Lambda<Lambda>)input;
return f.call(new Lambda<Object>() {
@Override
public Object call(Object input) {
return x.call(x).call(input);
}
});
}
});
}
public static void main(String[] args) {
Lambda<Lambda> y = yCombinator(new Lambda<Lambda>() {
@Override
public Lambda call(Object input) {
final Lambda<Integer> fab = (Lambda<Integer>)input;
return new Lambda<Integer>() {
@Override
public Integer call(Object input) {
Integer n = Integer.parseInt(input.toString());
if (n < 2) {
return Integer.valueOf(1);
} else {
return n * fab.call(n - 1);
}
}
};
}
});
System.out.println(y.call(10));//輸出： 3628800
}
interface Lambda<E> {
E call(Object input);
}
}
這里定義了一個Lambda<E>類型， 然后通過E call(Object input)方法實現(xiàn)自調(diào)用，方法實現(xiàn)里有多處轉(zhuǎn)型以及嵌套調(diào)用。邏輯比較繞，代碼可讀性也比較差。當然，這個問題本身也比較復雜。
我們使用Java 8的Lambda表達式來改寫下匿名內(nèi)部類：
package com.easy.kotlin;
public class YCombinator2 {
public static Lambda<Lambda> yCombinator2(final Lambda<Lambda> f) {
return ((Lambda<Lambda>)(Object input) -> {
final Lambda<Lambda> u = (Lambda<Lambda>)input;
return u.call(u);
}).call(
((Lambda<Lambda>)(Object input) -> {
final Lambda<Lambda> v = (Lambda<Lambda>)input;
return f.call((Lambda<Object>)(Object p) -> {
return v.call(v).call(p);
});
})
);
}
public static void main(String[] args) {
Lambda<Lambda> y2 = yCombinator2(
(Lambda<Lambda>)(Object input) -> {
Lambda<Integer> fab = (Lambda<Integer>)input;
return (Lambda<Integer>)(Object p) -> {
Integer n = Integer.parseInt(p.toString());
if (n < 2) {
return Integer.valueOf(1);
} else {
return n * fab.call(n - 1);
}
};
});
System.out.println(y2.call(10));//輸出： 3628800
}
interface Lambda<E> {
E call(Object input);
}
}
最后，我們使用Kotlin的對象表達式（順便復習回顧一下上一章節(jié)的相關內(nèi)容）實現(xiàn)Y組合子：
package com.easy.kotlin
// lambda f. (lambda x. (f(x x)) lambda x. (f(x x)))
object YCombinatorKt {
fun yCombinator(f: Lambda<Lambda<*>>): Lambda<Lambda<*>> {
return object : Lambda<Lambda<*>> {
override fun call(n: Any): Lambda<*> {
val u = n as Lambda<Lambda<*>>
return u.call(u)
}
}.call(object : Lambda<Lambda<*>> {
override fun call(n: Any): Lambda<*> {
val x = n as Lambda<Lambda<*>>
return f.call(object : Lambda<Any> {
override fun call(n: Any): Any {
return x.call(x).call(n)!!
}
})
}
}) as Lambda<Lambda<*>>
}
@JvmStatic fun main(args: Array<String>) {
val y = yCombinator(object : Lambda<Lambda<*>> {
override fun call(n: Any): Lambda<*> {
val fab = n as Lambda<Int>
return object : Lambda<Int> {
override fun call(n: Any): Int {
val n = Integer.parseInt(n.toString())
if (n < 2) {
return Integer.valueOf(1)
} else {
return n * fab.call(n - 1)
}
}
}
}
})
println(y.call(10)) //輸出： 3628800
}
interface Lambda<E> {
fun call(n: Any): E
}
}
關于Y combinator的更多實現(xiàn)，可以參考：https://gist.github.com/Jason-Chen-2017/88e13b63fa5b7c612fddf999739964b0 ； 另外，關于Y combinator的原理介紹，推薦看《The Little Schemer 》這本書。
從上面的例子，我們可以看出OOP中的對接口以及多態(tài)類型，跟FP中的函數(shù)的思想表達的，本質(zhì)上是一個東西，這個東西到底是什么呢？我們姑且稱之為“編程之道”罷！
Y combinator 給我們提供了一種方法，讓我們在一個只支持first-class函數(shù)，但是沒有內(nèi)建遞歸的編程語言里完成遞歸。所以Y combinator給我們展示了一個語言完全可以定義遞歸函數(shù)，即使這個語言的定義一點也沒提到遞歸。它給我們展示了一件美妙的事：僅僅函數(shù)式編程自己，就可以讓我們做到我們從來不認為可以做到的事（而且還不止這一個例子）。
嚴謹而精巧的lambda演算體系，從最基本的概念“函數(shù)”入手，創(chuàng)造出一個絢爛而宏偉的世界，這不能不說是人類思維的驕傲。
沒有"副作用"
所謂"副作用"（side effect），指的是函數(shù)內(nèi)部與外部互動（最典型的情況，就是修改全局變量的值），產(chǎn)生運算以外的其他結(jié)果。
函數(shù)式編程強調(diào)沒有"副作用"，意味著函數(shù)要保持獨立，所有功能就是返回一個新的值，沒有其他行為，尤其是不得修改外部變量的值。
函數(shù)式編程的動機，一開始就是為了處理運算（computation），不考慮系統(tǒng)的讀寫（I/O）。"語句"屬于對系統(tǒng)的讀寫操作，所以就被排斥在外。
當然，實際應用中，不做I/O是不可能的。因此，編程過程中，函數(shù)式編程只要求把I/O限制到最小，不要有不必要的讀寫行為，保持計算過程的單純性。
函數(shù)式編程只是返回新的值，不修改系統(tǒng)變量。因此，不修改變量，也是它的一個重要特點。
在其他類型的語言中，變量往往用來保存"狀態(tài)"（state）。不修改變量，意味著狀態(tài)不能保存在變量中。函數(shù)式編程使用參數(shù)保存狀態(tài)，最好的例子就是遞歸。
引用透明性
函數(shù)程序通常還加強引用透明性，即如果提供同樣的輸入，那么函數(shù)總是返回同樣的結(jié)果。就是說，表達式的值不依賴于可以改變值的全局狀態(tài)。這樣我們就可以從形式上邏輯推斷程序行為。因為表達式的意義只取決于其子表達式而不是計算順序或者其他表達式的副作用。這有助于我們來驗證代碼正確性、簡化算法，有助于找出優(yōu)化它的方法。
8.2 在Kotlin中使用函數(shù)式編程
好了親，前文中我們在函數(shù)式編程的世界里遨游了一番，現(xiàn)在我們把思緒收回來，放到在Kotlin中的函數(shù)式編程中來。
嚴格的面向?qū)ο蟮挠^點，使得很多問題的解決方案變得較為笨拙。為了將一行有用的代碼包裝到Runnable或者Callable 這兩個Java中最流行的函數(shù)式示例中，我們不得不去寫五六行模板范例代碼。為了讓事情簡單化（在Java 8中，增加Lambda表達式的支持），我們在Kotlin中使用普通的函數(shù)來替代函數(shù)式接口。事實上，函數(shù)式編程中的函數(shù)，比C語言中的函數(shù)或者Java中的方法都要強大的多。
在Kotlin中，支持函數(shù)作為一等公民。它支持高階函數(shù)、Lambda表達式等。我們不僅可以把函數(shù)當做普通變量一樣傳遞、返回，還可以把它分配給變量、放進數(shù)據(jù)結(jié)構(gòu)或者進行一般性的操作。它們可以是未經(jīng)命名的，也就是匿名函數(shù)。我們也可以直接把一段代碼丟到 {}中，這就是閉包。
在前面的章節(jié)中，其實我們已經(jīng)涉及到一些關于函數(shù)的地方，我們將在這里系統(tǒng)地學習一下Kotlin的函數(shù)式編程。
8.2.1 Kotlin中的函數(shù)
首先，我們來看下Kotlin中函數(shù)的概念。
函數(shù)聲明
Kotlin 中的函數(shù)使用 fun 關鍵字聲明
fun double(x: Int): Int {
return 2*x
}
函數(shù)用法
調(diào)用函數(shù)使用傳統(tǒng)的方法
fun test() {
val doubleTwo = double(2)
println("double(2) = $doubleTwo")
}
輸出：double(2) = 4
調(diào)用成員函數(shù)使用點表示法
object FPBasics {
fun double(x: Int): Int {
return 2 * x
}
fun test() {
val doubleTwo = double(2)
println("double(2) = $doubleTwo")
}
}
fun main(args: Array<String>) {
FPBasics.test()
}
我們這里直接用object對象FPBasics來演示。
8.2.2 擴展函數(shù)
通過 擴展 聲明完成一個類的新功能 擴展 ，而無需繼承該類或使用設計模式(例如，裝飾者模式)。
一個擴展String類的swap函數(shù)的例子：
fun String.swap(index1: Int, index2: Int): String {
val charArray = this.toCharArray()
val tmp = charArray[index1]
charArray[index1] = charArray[index2]
charArray[index2] = tmp
return charArrayToString(charArray)
}
fun charArrayToString(charArray: CharArray): String {
var result = ""
charArray.forEach { it -> result = result + it }
return result
}
這個 this 關鍵字在擴展函數(shù)內(nèi)部對應到接收者對象（傳過來的在點符號前的對象）。 現(xiàn)在，我們對任意 String 調(diào)用該函數(shù)了：
val str = "abcd"
val swapStr = str.swap(0, str.lastIndex)
println("str.swap(0, str.lastIndex) = $swapStr")
輸出： str.swap(0, str.lastIndex) = dbca
8.2.3 中綴函數(shù)
在以下場景中，函數(shù)還可以用中綴表示法調(diào)用：
- 成員函數(shù)或擴展函數(shù)
- 只有一個參數(shù)
- 用
infix關鍵字標注
例如，給 Int 定義擴展
infix fun Int.shl(x: Int): Int {
...
}
用中綴表示法調(diào)用擴展函數(shù)：
1 shl 2
等同于這樣
1.shl(2)
8.2.4 函數(shù)參數(shù)
函數(shù)參數(shù)使用 Pascal 表示法定義，即 name: type。參數(shù)用逗號隔開。每個參數(shù)必須顯式指定其類型。
fun powerOf(number: Int, exponent: Int): Int {
return Math.pow(number.toDouble(), exponent.toDouble()).toInt()
}
測試代碼：
val eight = powerOf(2, 3)
println("powerOf(2,3) = $eight")
輸出：powerOf(2,3) = 8
默認參數(shù)
函數(shù)參數(shù)可以有默認值，當省略相應的參數(shù)時使用默認值。這可以減少重載數(shù)量。
fun add(x: Int = 0, y: Int = 0): Int {
return x + y
}
默認值通過類型后面的 = 及給出的值來定義。
測試代碼：
val zero = add()
val one = add(1)
val two = add(1, 1)
println("add() = $zero")
println("add(1) = $one")
println("add(1, 1) = $two")
輸出：
add() = 0
add(1) = 1
add(1, 1) = 2
另外，覆蓋帶默認參數(shù)的函數(shù)時，總是使用與基類型方法相同的默認參數(shù)值。
當覆蓋一個帶有默認參數(shù)值的方法時，簽名中不帶默認參數(shù)值：
open class DefaultParamBase {
open fun add(x: Int = 0, y: Int = 0): Int {
return x + y
}
}
class DefaultParam : DefaultParamBase() {
override fun add(x: Int, y: Int): Int { // 不能有默認值
return super.add(x, y)
}
}
命名參數(shù)
可以在調(diào)用函數(shù)時使用命名的函數(shù)參數(shù)。當一個函數(shù)有大量的參數(shù)或默認參數(shù)時這會非常方便。
給定以下函數(shù)
fun reformat(str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' ') {
}
我們可以使用默認參數(shù)來調(diào)用它
reformat(str)
然而，當使用非默認參數(shù)調(diào)用它時，該調(diào)用看起來就像
reformat(str, true, true, false, '_')
使用命名參數(shù)我們可以使代碼更具有可讀性
reformat(str,
normalizeCase = true,
upperCaseFirstLetter = true,
divideByCamelHumps = false,
wordSeparator = '_'
)
并且如果我們不需要所有的參數(shù)
reformat(str, wordSeparator = '_')
可變數(shù)量的參數(shù)（Varargs）
函數(shù)的參數(shù)（通常是最后一個）可以用 vararg 修飾符標記：
fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts) // ts is an Array
result.add(t)
return result
}
允許將可變數(shù)量的參數(shù)傳遞給函數(shù)：
val list = asList(1, 2, 3)
8.2.5 函數(shù)返回類型
函數(shù)返回類型需要顯式聲明
具有塊代碼體的函數(shù)必須始終顯式指定返回類型，除非他們旨在返回 Unit。
Kotlin 不推斷具有塊代碼體的函數(shù)的返回類型，因為這樣的函數(shù)在代碼體中可能有復雜的控制流，并且返回類型對于讀者（有時對于編譯器）也是不明顯的。
返回 Unit 的函數(shù)
如果一個函數(shù)不返回任何有用的值，它的返回類型是 Unit。Unit 是一種只有一個Unit 值的類型。這個值不需要顯式返回:
fun printHello(name: String?): Unit {
if (name != null)
println("Hello ${name}")
else
println("Hi there!")
// `return Unit` 或者 `return` 是可選的
}
Unit 返回類型聲明也是可選的。上面的代碼等同于
fun printHello(name: String?) {
.....
}
8.2.6 單表達式函數(shù)
當函數(shù)返回單個表達式時，可以省略花括號并且在 = 符號之后指定代碼體即可
fun double(x: Int): Int = x * 2
當返回值類型可由編譯器推斷時，顯式聲明返回類型是可選的:
fun double(x: Int) = x * 2
8.2.7 函數(shù)作用域
在 Kotlin 中函數(shù)可以在文件頂層聲明，這意味著你不需要像一些語言如 Java、C# 或 Scala 那樣創(chuàng)建一個類來保存一個函數(shù)。此外除了頂層函數(shù)，Kotlin 中函數(shù)也可以聲明在局部作用域、作為成員函數(shù)以及擴展函數(shù)。
局部函數(shù)（嵌套函數(shù)）
Kotlin 支持局部函數(shù)，即一個函數(shù)在另一個函數(shù)內(nèi)部
fun sum(x: Int, y: Int, z: Int): Int {
val delta = 0;
fun add(a: Int, b: Int): Int {
return a + b + delta
}
return add(x + add(y, z))
}
局部函數(shù)可以訪問外部函數(shù)（即閉包）中的局部變量delta。
println("sum(1,2,3) = ${sum(0, 1, 2, 3)}")
輸出：sum(1,2,3) = 6
成員函數(shù)
成員函數(shù)是在類或?qū)ο髢?nèi)部定義的函數(shù)
class Sample() {
fun foo() { print("Foo") }
}
成員函數(shù)以點表示法調(diào)用
Sample().foo() // 創(chuàng)建類 Sample 實例并調(diào)用 foo
8.2.8 泛型函數(shù)
函數(shù)可以有泛型參數(shù)，通過在函數(shù)名前使用尖括號指定。
例如Iterable的map函數(shù)：
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}
8.2.9 高階函數(shù)
高階函數(shù)是將函數(shù)用作參數(shù)或返回值的函數(shù)。例如，Iterable的filter函數(shù)：
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
return filterTo(ArrayList<T>(), predicate)
}
它的輸入?yún)?shù)predicate: (T) -> Boolean就是一個函數(shù)。其中，函數(shù)類型聲明的語法是：
(X)->Y
表示這個函數(shù)是從類型X到類型Y的映射。即這個函數(shù)輸入X類型，輸出Y類型。
這個函數(shù)我們這樣調(diào)用：
fun isOdd(x: Int): Boolean {
return x % 2 == 1
}
val list = listOf(1, 2, 3, 4, 5)
list.filter(::isOdd)
其中，::用來引用一個函數(shù)。
8.2.10 匿名函數(shù)
我們也可以使用匿名函數(shù)來實現(xiàn)這個predicate函數(shù)：
list.filter((fun(x: Int): Boolean {
return x % 2 == 1
}))
8.2.11 Lambda 表達式
我們也可以直接使用更簡單的Lambda表達式來實現(xiàn)一個predicate函數(shù)：
list.filter {
it % 2 == 1
}
- lambda 表達式總是被大括號
{}括著 - 其參數(shù)（如果有的話）在
->之前聲明（參數(shù)類型可以省略） - 函數(shù)體（如果存在的話）在
->后面
上面的寫法跟：
list.filter({
it % 2 == 1
})
等價，如果 lambda 是該調(diào)用的唯一參數(shù)，則調(diào)用中的圓括號可以省略。
使用Lambda表達式定義一個函數(shù)字面值：
>>> val sum = { x: Int, y: Int -> x + y }
>>> sum(1,1)
2
我們在使用嵌套的Lambda表達式來定義一個柯里化的sum函數(shù)：
>>> val sum = {x:Int -> {y:Int -> x+y }}
>>> sum
(kotlin.Int) -> (kotlin.Int) -> kotlin.Int
>>> sum(1)(1)
2
8.2.11 it：單個參數(shù)的隱式名稱
Kotlin中另一個有用的約定是，如果函數(shù)字面值只有一個參數(shù)，
那么它的聲明可以省略（連同 ->），其名稱是 it。
代碼示例：
>>> val list = listOf(1,2,3,4,5)
>>> list.map { it * 2 }
[2, 4, 6, 8, 10]
8.2.12 閉包（Closure）
Lambda 表達式或者匿名函數(shù)，以及局部函數(shù)和對象表達式（object declarations）可以訪問其 閉包 ，即在外部作用域中聲明的變量。 與 Java 不同的是可以修改閉包中捕獲的變量：
fun sumGTZero(c: Iterable<Int>): Int {
var sum = 0
c.filter { it > 0 }.forEach {
sum += it
}
return sum
}
val list = listOf(1, 2, 3, 4, 5)
sumGTZero(list) // 輸出 15
我們再使用閉包來寫一個使用Java中的Thread接口的例子：
fun closureDemo() {
Thread({
for (i in 1..10) {
println("I = $i")
Thread.sleep(1000)
}
}).start()
Thread({
for (j in 10..20) {
println("J = $j")
Thread.sleep(2000)
}
Thread.sleep(1000)
}).start()
}
一個輸出：
I = 1
J = 10
I = 2
I = 3
...
J = 20
8.2.13 帶接收者的函數(shù)字面值
Kotlin 提供了使用指定的 接收者對象 調(diào)用函數(shù)字面值的功能。
使用匿名函數(shù)的語法，我們可以直接指定函數(shù)字面值的接收者類型。
下面我們使用帶接收者的函數(shù)類型聲明一個變量，并在之后使用它。代碼示例：
>>> val sum = fun Int.(other: Int): Int = this + other
>>> 1.sum(1)
2
當接收者類型可以從上下文推斷時，lambda 表達式可以用作帶接收者的函數(shù)字面值。
class HTML {
fun body() {
println("HTML BODY")
}
}
fun html(init: HTML.() -> Unit): HTML { // HTML.()中的HTML是接受者類型
val html = HTML() // 創(chuàng)建接收者對象
html.init() // 將該接收者對象傳給該 lambda
return html
}
測試代碼：
html {
body()
}
輸出：HTML BODY
使用這個特性，我們可以構(gòu)建一個HTML的DSL語言。
8.2.14 具體化的類型參數(shù)
有時候我們需要訪問一個參數(shù)類型：
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
var p = parent
while (p != null && !clazz.isInstance(p)) {
p = p.parent
}
@Suppress("UNCHECKED_CAST")
return p as T?
}
在這里我們向上遍歷一棵樹并且檢查每個節(jié)點是不是特定的類型。
這都沒有問題，但是調(diào)用處不是很優(yōu)雅：
treeNode.findParentOfType(MyTreeNode::class.java)
我們真正想要的只是傳一個類型給該函數(shù)，即像這樣調(diào)用它：
treeNode.findParentOfType<MyTreeNode>()
為能夠這么做，內(nèi)聯(lián)函數(shù)支持具體化的類型參數(shù)，于是我們可以這樣寫：
inline fun <reified T> TreeNode.findParentOfType(): T? {
var p = parent
while (p != null && p !is T) {
p = p.parent
}
return p as T?
}
我們使用 reified 修飾符來限定類型參數(shù)，現(xiàn)在可以在函數(shù)內(nèi)部訪問它了，
幾乎就像是一個普通的類一樣。由于函數(shù)是內(nèi)聯(lián)的，不需要反射，正常的操作符如 !is 和 as 現(xiàn)在都能用了。
雖然在許多情況下可能不需要反射，但我們?nèi)匀豢梢詫σ粋€具體化的類型參數(shù)使用它：
inline fun <reified T> membersOf() = T::class.members
fun main(s: Array<String>) {
println(membersOf<StringBuilder>().joinToString("\n"))
}
普通的函數(shù)（未標記為內(nèi)聯(lián)函數(shù)的）沒有具體化參數(shù)。
8.2.10 尾遞歸tailrec
Kotlin 支持一種稱為尾遞歸的函數(shù)式編程風格。 這允許一些通常用循環(huán)寫的算法改用遞歸函數(shù)來寫，而無堆棧溢出的風險。 當一個函數(shù)用 tailrec 修飾符標記并滿足所需的形式時，編譯器會優(yōu)化該遞歸，生成一個快速而高效的基于循環(huán)的版本。
tailrec fun findFixPoint(x: Double = 1.0): Double
= if (x == Math.cos(x)) x else findFixPoint(Math.cos(x)) // 函數(shù)必須將其自身調(diào)用作為它執(zhí)行的最后一個操作
這段代碼計算余弦的不動點（fixpoint of cosine），這是一個數(shù)學常數(shù)。 它只是重復地從 1.0 開始調(diào)用 Math.cos，直到結(jié)果不再改變，產(chǎn)生0.7390851332151607的結(jié)果。最終代碼相當于這種更傳統(tǒng)風格的代碼：
private fun findFixPoint(): Double {
var x = 1.0
while (true) {
val y = Math.cos(x)
if (x == y) return y
x = y
}
}
要符合 tailrec 修飾符的條件的話，函數(shù)必須將其自身調(diào)用作為它執(zhí)行的最后一個操作。在遞歸調(diào)用后有更多代碼時，不能使用尾遞歸，并且不能用在 try/catch/finally 塊中。尾部遞歸在 JVM 后端中支持。
Kotlin 還為集合類引入了許多擴展函數(shù)。例如，使用 map() 和 filter() 函數(shù)可以流暢地操縱數(shù)據(jù)，具體的函數(shù)的使用以及示例我們已經(jīng)在 集合類 章節(jié)中介紹。
本章小結(jié)
本章我們一起學習了函數(shù)式編程的簡史、Lambda演算、Y組合子與遞歸等核心函數(shù)式的編程思想等相關內(nèi)容。然后重點介紹了在Kotlin中如何使用函數(shù)式風格編程，其中重點介紹了Kotlin中函數(shù)的相關知識，以及高階函數(shù)、Lambda表達式、閉包等核心語法，并給出相應的實例說明。
我們將在下一章 中介紹Kotlin的 輕量級線程：協(xié)程（Coroutines）的相關知識，我們將看到在Kotlin中，程序的邏輯可以在協(xié)程中順序地表達，而底層庫會為我們解決其異步性。
