前言
初步深入函數(shù)式編程是在寒假的時候，搞了一本Haskell的書，啃了沒多久就因為我突然的項目任務(wù)被擱置了，不過在學(xué)習(xí)的時候也是各種看不懂，里面的概念略微抽象，再加上當(dāng)時沒有適當(dāng)?shù)貙崙?zhàn)敲Demo，導(dǎo)致沒過多久腦袋就全空了。慶幸的是，Swift是一門高度兼容函數(shù)式編程范式的語言，而我又是一只喜歡敲Swift的程序Dog，在后來我使用Swift編碼時，有意識或無意識地套用函數(shù)式編程范式的一些概念，也漸漸加深我對函數(shù)式編程的理解。這篇文章是我對自己所掌握的函數(shù)式編程的一個小總結(jié)，主要探討的是函數(shù)式編程中的幾個概念: Functor、Applicative、Monad以及它們在Swift中的表現(xiàn)形式。由于本人能力有限，一些概念上的不嚴(yán)謹(jǐn)、編碼上的不全面希望大家多包涵，歡迎留下各位寶貴的意見或問題。
本文為純概念講述，后期或許會有函數(shù)式編程實戰(zhàn)的文章推出（我有空寫再說吧）
概念
Context
在編碼時，我們會遇到各種數(shù)據(jù)類型，基礎(chǔ)的數(shù)據(jù)類型我們稱作值，當(dāng)然這并不是指編程語言中的基本數(shù)據(jù)類型，比如說整形1它可以稱作一個值，一個結(jié)構(gòu)體struct Person { let name: String; let age: Int }的實例也可以成為一個值，那么何為Context(上下文)呢，我們可以將它理解為對值的一個包裝，通過這層包裝，我們可以得知值此時所處在的一個狀態(tài)。在Haskell中，這個包裝就是typeclass(類型類)，而在Swift中，魔性的enum(枚舉)可以充當(dāng)這個角色，一個例子，就是Swift中的Optional(可選類型)，它的定義如下(相關(guān)繼承或協(xié)議關(guān)系在這里不標(biāo)出):
Optional<Wrapped> {
case none
case some(Wrapped)
Optional有兩種狀態(tài)，一種是空狀態(tài)none，也就是和平時我們傳入的nil相等價，一種是存在值的狀態(tài)，泛型Wrapped指代被包入這層上下文的值的類型。通過這個例子，我們可以很直觀地理解Context：描述值在某一階段的狀態(tài)。當(dāng)然，在平時開發(fā)中，我們會見到各種Context，比如Either：
enum Either<L, R> {
case left(L)
case right(R)
}
它代表在某個階段值可能在left或者right中存在。
在一些函數(shù)式響應(yīng)式編程框架如ReactiveCocoa、RxSwift中，Context無處不在：RACSignal、Observable，甚至是Swift的基本類型Array(數(shù)組)它本身也可以看作是一個Context。可見，只要你接觸了函數(shù)式編程，Context即會接觸。
這里，我特別說下這個Context：Result，因為在后面對其他概念以及實戰(zhàn)的講述中我都會以它為基礎(chǔ)：
enum Result<T> {
case success(T)
case failure(MyError)
}
Result上下文存在兩種狀態(tài)，一種是成功的狀態(tài)，當(dāng)處于這個狀態(tài)，Result就會持有一個特定類型的值，另外一種狀態(tài)是失敗狀態(tài)，在這個狀態(tài)中，你可以獲取到一個錯誤的實例（這個實例可以是你自己擬定的）。這么這個Context有什么用呢？想象一下，你正在進行一項網(wǎng)絡(luò)操作，獲取到的數(shù)據(jù)是無法確定的，你或許能如你所愿，從服務(wù)器中獲取到你期望的值，但是也有可能此時服務(wù)器發(fā)生一些未知的錯誤，或者網(wǎng)絡(luò)延時，又或是一些不可抗力的影響，那么，此時你得到的將會是一個錯誤的表示，如HTTP Code 500...而Result可以在這種情況下引入來表示你在網(wǎng)絡(luò)操作中獲取到的最終結(jié)果，是成功還是失敗。除了網(wǎng)絡(luò)請求，諸如數(shù)據(jù)庫操作、數(shù)據(jù)解析等等，Result都可以引入來進行更明確的標(biāo)示。
何為Functor、Applicative、Monad?
你可以把Functor、Applicative、Monad想象成Swift中的Protocol(協(xié)議)，它們可以為某種數(shù)據(jù)結(jié)構(gòu)的抽象，而這種數(shù)據(jù)接口正是剛剛我在上面提到的Context，要將某個Context實現(xiàn)成Functor、Applicative、Monad，你必須實現(xiàn)其中特定的函數(shù)，所以，要了解什么是Functor、Applicative、Monad，你需要知道它們定義了那些協(xié)議函數(shù)。接下來我會一一講解。
Functor
我們對一個值的運算操作使用的是函數(shù)，比如我要對一個整形的值進行翻倍操作，我們可以定義一個函數(shù)：
func double(_ value: Int) -> Int {
return 2 * value
}
然后就可以拿這個函數(shù)對特定的值進行操作：
let a = 2
let b = double(a)
好，問題來了，如果此時這個值被包在一個Context中呢？
一個函數(shù)只能作用于它聲明好的特定類型的值，運算整形的函數(shù)不能用來運算一個非整形的Context，所以這時，我們引入了Functor。它要做的，就是使一個只能運算值的函數(shù)用來運算一個包有這個值類型的Context，最后返回的一個包有運算結(jié)果的Context，為此，我們要實現(xiàn)map這個函數(shù)(在Haskell中為fmap)，它的偽代碼是這樣的：
Context(結(jié)果值) = map(Context(初始值), 運算函數(shù))
現(xiàn)在我們拿Result來實現(xiàn)一下：
extension Result {
func map<O>(_ mapper: (T) -> O) -> Result<O> {
switch self {
case .failure(let error):
return .failure(error)
case .success(let value):
return .success(mapper(value))
}
}
}
我們可以看到，首先我們對Result進行模式匹配，當(dāng)此時狀態(tài)是失敗的話，我們也直接返回失敗，并把錯誤的實例傳遞下去，如果狀態(tài)是成功的，我們就對初始的值進行運算，最后返回包有結(jié)果值的成功狀態(tài)。
為了后面表達式簡便，我在這里定義了map的運算符<^>：
precedencegroup ChainingPrecedence {
associativity: left
higherThan: TernaryPrecedence
}
// Functor
infix operator <^> : ChainingPrecedence
// For Result
func <^><T, O>(lhs: (T) -> O, rhs: Result<T>) -> Result<O> {
return rhs.map(lhs)
}
我們現(xiàn)在就可以測試一下：
let a: Result<Int> = .success(2)
let b = double <^> a
在上面我提到，Swift的數(shù)組也可以當(dāng)成是Context，它是作為一個包有多個值的狀態(tài)存在。想必在日常開發(fā)中我們經(jīng)常也用到了Swift數(shù)組中的map函數(shù)吧：
let arrA = [1, 2, 3, 4, 5]
let arrB = arrA.map(double)
RxSwift中我們也經(jīng)常使用map：
let ob = Observable.just(1).map(double)
Applicative
Applicative其實就是高級的Functor，我們可以調(diào)出上面Functor的map偽代碼：
Context(結(jié)果值) = map(Context(初始值), 運算函數(shù))
在函數(shù)式編程中，函數(shù)也可以作為一個值來看待，若此時這個函數(shù)也是被一個Context包裹的，單純的map是不能接受包裹著函數(shù)的Context，所以我們引入了Applicative：
Context(結(jié)果值) = apply(Context(初始值), Context(運算函數(shù)))
我們將Result實現(xiàn)Applicative：
extension Result {
func apply<O>(_ mapper: Result<(T) -> O>) -> Result<O> {
switch mapper {
case .failure(let error):
return .failure(error)
case .success(let function):
return self.map(function)
}
}
}
// Applicative
infix operator <*> : ChainingPrecedence
// For Result
func <*><T, O>(lhs: Result<(T) -> O>, rhs: Result<T>) -> Result<O> {
return rhs.apply(lhs)
}
使用：
let function: Result<(Int) -> Int> = .success(double)
let a: Result<Int> = .success(2)
let b = function <*> a
Applicative在日常開發(fā)中其實用的不多，很多時候我們并不會將一個函數(shù)塞進一個Context上，但是如果你用了一些略為高階的函數(shù)時，它強勁的能力就能在此時表現(xiàn)出來，這里舉一個略為晦澀的例子，你可以花點時間搞懂它：
這個例子的思路是來自源Swift的函數(shù)式JSON解析庫Argo的基本用法，若大家有興趣可以閱讀下Argo的源碼: thoughtbot/Argo
假設(shè)現(xiàn)在我定義了一個函數(shù)，它能夠接受一個Any的JSON Object，以及一個值在JSON中對應(yīng)的Key(鍵)作為參數(shù)，返回一個從JSON數(shù)據(jù)中解析出來的結(jié)果，由于這個結(jié)果是不確定的，可能JSON中不存在此鍵對應(yīng)的值，所以我們用Result來包裝它，這個函數(shù)的簽名為：
func parse<T>(jsonObject: Any, key: String) -> Result<T>
當(dāng)解析成功時，返回的Result處于成功狀態(tài)，當(dāng)解析失敗時，返回的Result處于失敗狀態(tài)并攜帶錯誤的實體，我們能夠通過錯誤實體得知解析失敗的原因。
現(xiàn)在我們有一個結(jié)構(gòu)體，它里面有多個成員，它實現(xiàn)了默認(rèn)的構(gòu)造器：
struct Person {
let name: String
let age: Int
let from: String
}
我們自己可以編寫一套函數(shù)柯里化的庫，這個庫能夠?qū)Χ鄥?shù)的函數(shù)進行柯里化，你也可以從Github中下載: thoughtbot/Curry
比如，我們有一個函數(shù)，它的基本簽名是: func haha(a: Int, b: Int, c: Int) -> Int，通過函數(shù)柯里化我們可以將其轉(zhuǎn)化為(Int) -> (Int) -> (Int) -> Int類型的函數(shù)。
我們此時將Person的構(gòu)造器進行函數(shù)柯里化：curry(Person.init)，此時我們得到的是類型為(String) -> (Int) -> (String) -> Person的值。
現(xiàn)在奇幻的魔法來了，我定義一個將JSON解析成Person的函數(shù)：
func parseJSONToPerson(json: Any) -> Result<Person> {
return curry(Person.init)
<^> parse(jsonObject: json, key: "name")
<*> parse(jsonObject: json, key: "age")
<*> parse(jsonObject: json, key: "from")
}
通過這個函數(shù)，我能夠?qū)⒁粋€JSON數(shù)據(jù)解析成Person的實例，以一個Result的包裝返回，如果解析失敗，Result處理失敗狀態(tài)會攜帶一個錯誤的實例。
這個函數(shù)為什么可以這么寫呢，我們來分解一下：
首先通過函數(shù)的柯里化我們得到了類型為(String) -> (Int) -> (String) -> Person的值，它也是一個函數(shù)，然后經(jīng)過了<^>map的操作，map的右邊是一個解析了name返回的Result，它的類型為Result<String>，map將函數(shù)(String) -> (Int) -> (String) -> Person應(yīng)用于Result<String>，此時我們得到的是返回的結(jié)果(Int) -> (String) -> Person的Result包裝：Result<(Int) -> (String) -> Person>(因為已經(jīng)消費掉了一個參數(shù))，此時，這個函數(shù)就被一個Context包裹住了，后面我們不能再用map去將這個函數(shù)應(yīng)用在接下來解析出來的數(shù)據(jù)了，所以這是我們就借助于Applicative的<*>，接下來看第二個參數(shù)，parse函數(shù)將JSON解析返回了類型為Result<Int>的結(jié)果，我們通過<*>將Result<(Int) -> (String) -> Person>的函數(shù)取出來，應(yīng)用于Result<Int>，就得到了類型為Result<(String) -> Person>的結(jié)果。以此類推，最終我們就獲取到了經(jīng)JSON解析后的結(jié)果Result<Person>。
Applicative強大的能力能夠讓代碼變得如此優(yōu)雅，這就是函數(shù)式編程的魅力之所在。
Monad
Monad中文稱為單子，網(wǎng)上看到挺多人被Monad的概念所搞暈，其實它也是基于上面所講述的概念而來的。對于使用過函數(shù)式響應(yīng)式編程框架(Rx系列[RxSwift、RxJava]、ReactiveCocoa)的人來說，可能不知道Monad是什么，但是在實戰(zhàn)中肯定用過，它所要求實現(xiàn)的函數(shù)說白了就是flatMap：
let ob = Observable.just(1).flatMap { num in
Observable.just("The number is \(num)")
}
有很多人喜歡用降維來形容flatMap的能力，但是，它能做的，不止如此。
Monad需要實現(xiàn)的函數(shù)我們可以稱為bind，在Haskell中它使用符號>>=，在Swift中我們可以定義運算符>>-來表示bind函數(shù)，或者直接叫做flatMap。我們先來看看他的偽代碼：
首先我們定義一個函數(shù)，他的作用是將一個值進行包裝，這里標(biāo)示出這個函數(shù)的簽名：
function :: 值A(chǔ) -> Context(值B)（值A(chǔ)與值B的類型可相同亦可不同）
我們的bind函數(shù)就可以這么寫了：
Context(結(jié)果值) = Context(初始值) >>- function
這里我們實現(xiàn)一下Result的Monad：
extension Result {
func flatMap<O>(_ mapper: (T) -> Result<O>) -> Result<O> {
switch self {
case .failure(let error):
return .failure(error)
case .success(let value):
return mapper(value)
}
}
}
// Monad
infix operator >>- : ChainingPrecedence
// For Result
func >>-<T, O>(lhs: Result<T>, rhs: (T) -> Result<O>) -> Result<O> {
return lhs.flatMap(rhs)
}
Monad的定義很簡單，但是Monad究竟能幫我們解決什么問題呢？它要怎么使用呢？別急，通過以下這個例子，你就能對Monad有更深一層的理解：
假設(shè)現(xiàn)在我有一系列的操作：
- 通過特定條件進行本地數(shù)據(jù)庫的查詢，找出相關(guān)的數(shù)據(jù)
- 利用上面從數(shù)據(jù)庫得到的數(shù)據(jù)作為參數(shù)，向服務(wù)器發(fā)起請求，獲取響應(yīng)數(shù)據(jù)
- 將從網(wǎng)絡(luò)獲取到的原始數(shù)據(jù)轉(zhuǎn)換成JSON數(shù)據(jù)
- 將JSON數(shù)據(jù)進行解析，返回最終解析完成的有特定類型的實體
對以上操作的分析，我們能得知以上每一個操作它的最終結(jié)果都具有不確定性，意思就是說我們無法保證操作百分百完成，能成功返回我們想要的數(shù)據(jù)，所以我們很容易就會想到利用上面已經(jīng)定義的Context：Reuslt將獲取到的結(jié)果進行包裹，若獲取結(jié)果成功，Result將攜帶結(jié)果值處于成功狀態(tài)，若獲取結(jié)果失敗，Result將攜帶錯誤的信息處于失敗狀態(tài)。
現(xiàn)在，我們針對以上每種操作進行函數(shù)定義：
// A代表從數(shù)據(jù)庫查找數(shù)據(jù)的條件的類型
// B代表期望數(shù)據(jù)庫返回結(jié)果的類型
func fetchFromDatabase(conditions: A) -> Result<B> { ... }
// B類型作為網(wǎng)絡(luò)請求的參數(shù)類型發(fā)起網(wǎng)絡(luò)請求
// 獲取到的數(shù)據(jù)為C類型，可能是原始字符串或者是二進制
func requestNetwork(parameters: B) -> Result<C> { ... }
// 將獲取到的原始數(shù)據(jù)類型轉(zhuǎn)換成JSON數(shù)據(jù)
func dataToJSON(data: C) -> Result<JSON> { ... }
// 將JSON進行解析輸出實體
func parse(json: JSON) -> Result<Entity> { ... }
現(xiàn)在我們假設(shè)所有的操作都是在同一條線程中進行的（非UI線程），如果我們只是純粹地用基本的方法去調(diào)用這些函數(shù)，我們可能要這么來：
var entityResult: Entity?
if case .success(let b) = fetchFromDatabase(conditions: XXX) {
if case .success(let c) = requestNetwork(parameters: b) {
if case .success(let json) = dataToJSON(data: c) {
if case .success(let entity) = parse(json: json) {
entityResult = entity
}
}
}
}
這代碼寫起來也好看起來也好真的是一把辛酸淚啊，而且，這里還有一個缺陷，就是我們無法從中獲取到錯誤的信息，如果我們還想要獲取到錯誤的信息，必須再編寫多一大串代碼了。
此時，Monad出場了：
let entityResult = fetchFromDatabase(conditions: XXX) >>- requestNetwork >>- dataToJSON >>- parse
嚇到了吧，只需一行代碼，即可將所有要做的事情連串起來了，并且，最終我們獲取到的是經(jīng)Result包裝的數(shù)據(jù)，若在操作的過程中發(fā)生錯誤，錯誤的信息也記錄在里面了。
這就是Monad的威力
當(dāng)然，我們可以繼續(xù)對上面的操作進行優(yōu)化，比如說現(xiàn)在我需要在網(wǎng)絡(luò)請求的函數(shù)中加多一個參數(shù)，表示請求的URL，我們可以這樣來定義這個網(wǎng)絡(luò)請求函數(shù)：
// B類型作為網(wǎng)絡(luò)請求的參數(shù)類型發(fā)起網(wǎng)絡(luò)請求
// 獲取到的數(shù)據(jù)為C類型，可能是原始字符串或者是二進制
func requestNetwork(urlString: String) -> (B) -> Result<C> {
return { parameters in
return { ... }
}
}
調(diào)用的時候我們只需要這樣調(diào)用:
let entityResult = fetchFromDatabase(conditions: XXX) >>- requestNetwork(urlString: "XXX.com/XXX/XXX") >>- dataToJSON >>- parse
這主要是高階函數(shù)的使用技巧。
個人對Monad作用的總結(jié)有兩部分：
- 對一系列針對值與Context的操作進行鏈?zhǔn)浇Y(jié)合，代碼極其優(yōu)雅，清晰明了。
- 將值與Context之間的轉(zhuǎn)換、Context內(nèi)部進行的操作對外屏蔽，像上面我用原始的方式進行操作，我們需要手動地分析Context的情況，手動地針對不同的Context狀態(tài)進行相應(yīng)的操作，而如果我們使用
Monad，整一流程下來我們什么都不需要做，坐享其成，取得最終的結(jié)果。
總結(jié)
Swift是一門高度適配函數(shù)式編程范式的語言，你可以在里面到處都能找到函數(shù)式編程思想的身影，通過上面對Functor、Appliactive、Monad相關(guān)概念的講述，在鞏固我對函數(shù)式編程的知識外，希望也能讓你對函數(shù)式編程的理解有幫助，若文章有概念不嚴(yán)謹(jǐn)?shù)牡胤交蛘咤e誤，望見諒，也希望能夠向我提出。
謝謝閱讀。
