函數語言程式設計 - Swift中的Functor(函子)、Monad(單子)、Applicative

TangentW發表於2017-10-18
函數程式設計SwiftAPP

函數語言程式設計-Swift中的Functor(函子)、Monad(單子)、Applicative

前言

初步深入函數語言程式設計是在寒假的時候，搞了一本Haskell的書，啃了沒多久就因為我突然的專案任務被擱置了，不過在學習的時候也是各種看不懂，裡面的概念略微抽象，再加上當時沒有適當地實戰敲Demo，導致沒過多久腦袋就全空了。慶幸的是，Swift是一門高度相容函數語言程式設計正規化的語言，而我又是一隻喜歡敲Swift的程式Dog，在後來我使用Swift編碼時，有意識或無意識地套用函數語言程式設計正規化的一些概念，也漸漸加深我對函數語言程式設計的理解。這篇文章是我對自己所掌握的函數語言程式設計的一個小總結，主要探討的是函數語言程式設計中的幾個概念: Functor、Applicative、Monad以及它們在Swift中的表現形式。由於本人能力有限，一些概念上的不嚴謹、編碼上的不全面希望大家多包涵，歡迎留下各位寶貴的意見或問題。

本文為純概念講述，後期或許會有函數語言程式設計實戰的文章推出（我有空寫再說吧?）

概念

Context

在編碼時，我們會遇到各種資料型別，基礎的資料型別我們稱作值，當然這並不是指程式語言中的基本資料型別，比如說整形1它可以稱作一個值，一個結構體struct Person { let name: String; let age: Int }的例項也可以成為一個值，那麼何為Context(上下文)呢，我們可以將它理解為對值的一個包裝，通過這層包裝，我們可以得知值此時所處在的一個狀態。在Haskell中，這個包裝就是typeclass(型別類)，而在Swift中，魔性的enum(列舉)可以充當這個角色，一個例子，就是Swift中的Optional(可選型別)，它的定義如下(相關繼承或協議關係在這裡不標出):

Optional<Wrapped> {
    case none
    case some(Wrapped)複製程式碼

Optional有兩種狀態，一種是空狀態none，也就是和平時我們傳入的nil相等價，一種是存在值的狀態，泛型Wrapped指代被包入這層上下文的值的型別。通過這個例子，我們可以很直觀地理解Context：描述值在某一階段的狀態。當然，在平時開發中，我們會見到各種Context，比如Either：

enum Either<L, R> {
    case left(L)
    case right(R)
}複製程式碼

它代表在某個階段值可能在left或者right中存在。
在一些函式式響應式程式設計框架如ReactiveCocoa、RxSwift中，Context無處不在：RACSignal、Observable，甚至是Swift的基本型別Array(陣列)它本身也可以看作是一個Context。可見，只要你接觸了函數語言程式設計，Context即會接觸。

這裡，我特別說下這個Context：Result，因為在後面對其他概念以及實戰的講述中我都會以它為基礎：

enum Result<T> {
    case success(T)
    case failure(MyError)
}複製程式碼

Result上下文存在兩種狀態，一種是成功的狀態，當處於這個狀態，Result就會持有一個特定型別的值，另外一種狀態是失敗狀態，在這個狀態中，你可以獲取到一個錯誤的例項（這個例項可以是你自己擬定的）。這麼這個Context有什麼用呢？想象一下，你正在進行一項網路操作，獲取到的資料是無法確定的，你或許能如你所願，從伺服器中獲取到你期望的值，但是也有可能此時伺服器發生一些未知的錯誤，或者網路延時，又或是一些不可抗力的影響，那麼，此時你得到的將會是一個錯誤的表示，如HTTP Code 500...而Result可以在這種情況下引入來表示你在網路操作中獲取到的最終結果，是成功還是失敗。除了網路請求，諸如資料庫操作、資料解析等等，Result都可以引入來進行更明確的標示。

何為Functor、Applicative、Monad?

你可以把Functor、Applicative、Monad想象成Swift中的Protocol(協議)，它們可以為某種資料結構的抽象，而這種資料介面正是剛剛我在上面提到的Context，要將某個Context實現成Functor、Applicative、Monad，你必須實現其中特定的函式，所以，要了解什麼是Functor、Applicative、Monad，你需要知道它們定義了那些協議函式。接下來我會一一講解。

Functor

我們對一個值的運算操作使用的是函式，比如我要對一個整形的值進行翻倍操作，我們可以定義一個函式：

func double(_ value: Int) -> Int {
    return 2 * value
}複製程式碼

然後就可以拿這個函式對特定的值進行操作：

let a = 2
let b = double(a)複製程式碼

好，問題來了，如果此時這個值被包在一個Context中呢？
一個函式只能作用於它宣告好的特定型別的值，運算整形的函式不能用來運算一個非整形的Context，所以這時，我們引入了Functor。它要做的，就是使一個只能運算值的函式用來運算一個包有這個值型別的Context，最後返回的一個包有運算結果的Context，為此，我們要實現map這個函式(在Haskell中為fmap)，它的虛擬碼是這樣的：
Context(結果值) = map(Context(初始值), 運算函式)

現在我們拿Result來實現一下：

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進行模式匹配，當此時狀態是失敗的話，我們也直接返回失敗，並把錯誤的例項傳遞下去，如果狀態是成功的，我們就對初始的值進行運算，最後返回包有結果值的成功狀態。
為了後面表示式簡便，我在這裡定義了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)
}複製程式碼

我們現在就可以測試一下：

let a: Result<Int> = .success(2)
let b = double <^> a複製程式碼

在上面我提到，Swift的陣列也可以當成是Context，它是作為一個包有多個值的狀態存在。想必在日常開發中我們經常也用到了Swift陣列中的map函式吧：

let arrA = [1, 2, 3, 4, 5]
let arrB = arrA.map(double)複製程式碼

RxSwift中我們也經常使用map：

let ob = Observable.just(1).map(double)複製程式碼

Applicative

Applicative其實就是高階的Functor，我們可以調出上面Functor的map虛擬碼：
Context(結果值) = map(Context(初始值), 運算函式)
在函數語言程式設計中，函式也可以作為一個值來看待，若此時這個函式也是被一個Context包裹的，單純的map是不能接受包裹著函式的Context，所以我們引入了Applicative：
Context(結果值) = apply(Context(初始值), Context(運算函式))

我們將Result實現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在日常開發中其實用的不多，很多時候我們並不會將一個函式塞進一個Context上，但是如果你用了一些略為高階的函式時，它強勁的能力就能在此時表現出來，這裡舉一個略為晦澀的例子，你可以花點時間搞懂它：
這個例子的思路是來自源Swift的函式式JSON解析庫Argo的基本用法，若大家有興趣可以閱讀下Argo的原始碼: thoughtbot/Argo
假設現在我定義了一個函式，它能夠接受一個Any的JSON Object，以及一個值在JSON中對應的Key(鍵)作為引數，返回一個從JSON資料中解析出來的結果，由於這個結果是不確定的，可能JSON中不存在此鍵對應的值，所以我們用Result來包裝它，這個函式的簽名為：

func parse<T>(jsonObject: Any, key: String) -> Result<T>複製程式碼

當解析成功時，返回的Result處於成功狀態，當解析失敗時，返回的Result處於失敗狀態並攜帶錯誤的實體，我們能夠通過錯誤實體得知解析失敗的原因。

現在我們有一個結構體，它裡面有多個成員，它實現了預設的構造器：

struct Person {
    let name: String
    let age: Int
    let from: String
}複製程式碼

我們自己可以編寫一套函式柯里化的庫，這個庫能夠對多引數的函式進行柯里化，你也可以從Github中下載: thoughtbot/Curry
比如，我們有一個函式，它的基本簽名是: func haha(a: Int, b: Int, c: Int) -> Int，通過函式柯里化我們可以將其轉化為(Int) -> (Int) -> (Int) -> Int型別的函式。
我們此時將Person的構造器進行函式柯里化：curry(Person.init)，此時我們得到的是型別為(String) -> (Int) -> (String) -> Person的值。
現在奇幻的魔法來了，我定義一個將JSON解析成Person的函式：

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")
}複製程式碼

通過這個函式，我能夠將一個JSON資料解析成Person的例項，以一個Result的包裝返回，如果解析失敗，Result處理失敗狀態會攜帶一個錯誤的例項。

這個函式為什麼可以這麼寫呢，我們來分解一下：
首先通過函式的柯里化我們得到了型別為(String) -> (Int) -> (String) -> Person的值，它也是一個函式，然後經過了<^>map的操作，map的右邊是一個解析了name返回的Result，它的型別為Result<String>，map將函式(String) -> (Int) -> (String) -> Person應用於Result<String>，此時我們得到的是返回的結果(Int) -> (String) -> Person的Result包裝：Result<(Int) -> (String) -> Person>(因為已經消費掉了一個引數)，此時，這個函式就被一個Context包裹住了，後面我們不能再用map去將這個函式應用在接下來解析出來的資料了，所以這是我們就藉助於Applicative的<*>，接下來看第二個引數，parse函式將JSON解析返回了型別為Result<Int>的結果，我們通過<*>將Result<(Int) -> (String) -> Person>的函式取出來，應用於Result<Int>，就得到了型別為Result<(String) -> Person>的結果。以此類推，最終我們就獲取到了經JSON解析後的結果Result<Person>。
Applicative強大的能力能夠讓程式碼變得如此優雅，這就是函數語言程式設計的魅力之所在。

Monad

Monad中文稱為單子，網上看到挺多人被Monad的概念所暈倒，其實它也是基於上面所講述的概念而來的。對於使用過函式式響應式程式設計框架(Rx系列[RxSwift、RxJava]、ReactiveCocoa)的人來說，可能不知道Monad是什麼，但是在實戰中肯定用過，它所要求實現的函式說白了就是flatMap：

let ob = Observable.just(1).flatMap { num in
    Observable.just("The number is \(num)")
}複製程式碼

有很多人喜歡用降維來形容flatMap的能力，但是，它能做的，不止如此。
Monad需要實現的函式我們可以稱為bind，在Haskell中它使用符號>>=，在Swift中我們可以定義運算子>>-來表示bind函式，或者直接叫做flatMap。我們先來看看他的虛擬碼：
首先我們定義一個函式，他的作用是將一個值進行包裝，這裡標示出這個函式的簽名：
function :: 值A -> Context(值B)（值A與值B的型別可相同亦可不同）
我們的bind函式就可以這麼寫了：
Context(結果值) = Context(初始值) >>- function
這裡我們實現一下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有更深一層的理解：
假設現在我有一系列的操作：

  1. 通過特定條件進行本地資料庫的查詢，找出相關的資料
  2. 利用上面從資料庫得到的資料作為引數，向伺服器發起請求，獲取響應資料
  3. 將從網路獲取到的原始資料轉換成JSON資料
  4. 將JSON資料進行解析，返回最終解析完成的有特定型別的實體

對以上操作的分析，我們能得知以上每一個操作它的最終結果都具有不確定性，意思就是說我們無法保證操作百分百完成，能成功返回我們想要的資料，所以我們很容易就會想到利用上面已經定義的Context：Reuslt將獲取到的結果進行包裹，若獲取結果成功，Result將攜帶結果值處於成功狀態，若獲取結果失敗，Result將攜帶錯誤的資訊處於失敗狀態。
現在，我們針對以上每種操作進行函式定義：

// A代表從資料庫查詢資料的條件的型別
// B代表期望資料庫返回結果的型別
func fetchFromDatabase(conditions: A) -> Result<B> { ... }

// B型別作為網路請求的引數型別發起網路請求
// 獲取到的資料為C型別，可能是原始字串或者是二進位制
func requestNetwork(parameters: B) -> Result<C> { ... }

// 將獲取到的原始資料型別轉換成JSON資料
func dataToJSON(data: C) -> Result<JSON> { ... }

// 將JSON進行解析輸出實體
func parse(json: JSON) -> Result<Entity> { ... }複製程式碼

現在我們假設所有的操作都是在同一條執行緒中進行的（非UI執行緒），如果我們只是純粹地用基本的方法去呼叫這些函式，我們可能要這麼來：

var entityResult: Entity?
if let .success(let b) = fetchFromDatabase(conditions: XXX) {
    if let .success(let c) = requestNetwork(parameters: b) {
        if let .success(let json) = dataToJSON(data: c) {
            if let .success(let entity) = parse(json: json) {
                entityResult = entity
            }
        }
    }
}複製程式碼

這程式碼寫起來也好看起來也好真的是一把辛酸淚啊，而且，這裡還有一個缺陷，就是我們無法從中獲取到錯誤的資訊，如果我們還想要獲取到錯誤的資訊，必須再編寫多一大串程式碼了。

此時，Monad出場了：

let entityResult = fetchFromDatabase(conditions: XXX) >>- requestNetwork >>- dataToJSON >>- parse複製程式碼

嚇到了吧，只需一行程式碼，即可將所有要做的事情連串起來了，並且，最終我們獲取到的是經Result包裝的資料，若在操作的過程中發生錯誤，錯誤的資訊也記錄在裡面了。
這就是Monad的威力?

當然，我們可以繼續對上面的操作進行優化，比如說現在我需要在網路請求的函式中加多一個引數，表示請求的URL，我們可以這樣來定義這個網路請求函式：

// B型別作為網路請求的引數型別發起網路請求
// 獲取到的資料為C型別，可能是原始字串或者是二進位制
func requestNetwork(urlString: String) -> (B) -> Result<C> {
    return { parameters in
        return { ... }
    }
}複製程式碼

呼叫的時候我們只需要這樣呼叫:

let entityResult = fetchFromDatabase(conditions: XXX) >>- requestNetwork(urlString: "XXX.com/XXX/XXX") >>- dataToJSON >>- parse複製程式碼

這主要是高階函式的使用技巧。

個人對Monad作用的總結有兩部分：

  1. 對一系列針對值與Context的操作進行鏈式結合，程式碼極其優雅，清晰明瞭。
  2. 將值與Context之間的轉換、Context內部進行的操作對外遮蔽，像上面我用原始的方式進行操作，我們需要手動地分析Context的情況，手動地針對不同的Context狀態進行相應的操作，而如果我們使用Monad，整一流程下來我們什麼都不需要做，坐享其成，取得最終的結果。

總結

Swift是一門高度適配函數語言程式設計正規化的語言，你可以在裡面到處都能找到函數語言程式設計思想的身影，通過上面對Functor、Appliactive、Monad相關概念的講述，在鞏固我對函數語言程式設計的知識外，希望也能讓你對函數語言程式設計的理解有幫助，若文章有概念不嚴謹的地方或者錯誤，望見諒，也希望能夠向我提出。
謝謝閱讀。

參考連結

阮一峰的網路日誌 - 圖解 Monad

相關文章