您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

Swift 中的 Functor 與 Monad:用實作而非理論理解它

編輯:iOS 開發基礎

(原文:Functor and Monad in Swift 作者:Javier Soto 譯者:Micheal Geng)

自 2013 年底開始學函數式編程以來,有不少學術概念一直困擾著我,Functor 和 Monad 就是其中之二。

這篇文章想嘗試把這兩個概念講清楚。由於我並非專家,本文偏向實用而非理論。網路上試圖解釋 Monad 的文章不少,有些比喻已經做得太過頭,而本文選擇用示例代碼來描述概念,希望這種方式能讓你更好理解。

直到最近我才真正明白 Monad 意味著什麼,接下來就一起探討 Monad 存在的價值,以及它如何應用到你的 Swift 編程中。

map 函數

先從 2014 年 WWDC 介紹 Swift 時提到的一個強力函數 map 說起,它能實現元素映射:

let numbers = [1, 2, 3]
let doubledNumbers = numbers.map { $0 * 2 }
// doubledNumbers: 2, 4, 6

這種寫法的好處是,我們能非常清楚地表達對元素列表做了什麼轉換(上例中,新列表每個元素都是原列表的兩倍)。看看傳統命令式寫法:

var doubledImperative: [Int] = []
for number in numbers {
    doubledImperative.append(number * 2)
}
// doubledImperative: 2, 4, 6

比較兩段代碼,差別不只是「一行 vs 三行」——前者實現更簡單,卻有更高的信噪比(這裡指更能準確表達意圖)。map 讓我們能表達目標而不必關心背後發生了什麼,降低了理解代碼的負擔。

但 map 並不只對數組有意義,它是一個高級函數,可以在任何類型與方法中實現。我們來看 Optional 的例子(Optional 是一種嵌套具體值或 nil 的類型):

let number = Optional(815)
let transformedNumber = number.map { $0 * 2 }.map { $0 % 2 == 0 }
// transformedNumber: Optional.Some(true)

在 Optional 中使用 map 的好處是它會自動處理空值:若企圖對 nil 做操作,先透過 optional.map 申請轉換,原本為空最終仍為空,就不必用 if let 逐層打開 Optional。

let nilNumber: Int? = .None
let transformedNilNumber = nilNumber.map { $0 * 2 }.map { $0 % 2 == 0 }
// transformedNilNumber: None

由此可推斷,map 在不同類型上會有不同行為,取決於該類型的語義。例如它讓 Optional 在值為空時也能正確完成映射轉換。

下面是一個通用的 Container map 方法,封裝 T 類型的值:

func map< U>(transformFunction: T -> U) -> Container< U>

分析這段代碼:T 是當前元素類型,U 是要返回的元素類型。透過這種方式,我們可以把字串數組的每個字串長度映射成一個整數組。若提供一個傳入 T、輸出 U 的函數,map 就會用它建立另一個 Container 實例,把原始值替換為 transformFunction 的返回值。

用自己寫的類型實現 map

我們來自訂一個類型。如今很多開源 Swift 專案都會看到 Result 枚舉的寫法,用它取代 Objective-C 舊式的 NSError 參數能為 API 帶來不少好處。

class Box< T> {
    let unbox: T
    init(_ value: T) {
        self.unbox = value
    }
}

enum Result< T> {
    case Value(Box< T>)
    case Error(NSError)
}

Box 類是用來繞過當時 Swift 版本的一處限制(non-fixed multi-payload enum layout)。這是一種在部分語言中稱為 Either 的實現模式,此處我們用 NSError 來報告操作結果。

概念上,Result 與 Optional 很相似:都適用於任意類型的值,不同的是 Result 能告訴我們「無意義的值是什麼、為什麼存在」。

看一個讀取文件內容、以 Result 作為返回值的例子:

func dataWithContentsOfFile(file: String, encoding: NSStringEncoding) -> Result< NSData> {
    var error: NSError?
    if let data = NSData(contentsOfFile: file, options: .allZeros, error: &error) {
        return .Value(Box(data))
    } else {
        return .Error(error!)
    }
}

很明顯,這個函數會返回一個 NSData,或一個告知文件無法讀取的 NSError。

以前若要取出這些值並做轉換,得在每一步都檢測是否正確,可能要用繁瑣的 if let 或 switch 嵌套。而在這裡,我們只需提供轉換方法,否則就沿用同一個 error。

假設要讀取字串內容:先得到 NSData,再轉成字串,最後轉大寫:

NSData -> String -> String

用 map 來轉化:

let data: Result< NSData> = dataWithContentsOfFile(path, NSUTF8StringEncoding)
let uppercaseContents: Result< String> = data.map { NSString(data: $0, encoding: NSUTF8StringEncoding)! }.map { $0.uppercaseString }

這與前面處理數組的例子類似,只需描述想完成的目標即可。對照之下,不使用 map 的寫法:

let data: Result< NSData> = dataWithContentsOfFile(path, NSUTF8StringEncoding)
var stringContents: String?
switch data {
    case let .Value(value):
        stringContents = NSString(data: value.unbox, encoding: NSUTF8StringEncoding)
    case let .Error(error):
        break
}
let uppercaseContents: String? = stringContents?.uppercaseString

Result.map 背後做了什麼?來看看:

extension Result {
    func map< U>(f: T -> U) -> Result< U> {
        switch self {
            case let .Value(value):
                return Result< U>.Value(Box(f(value.unbox)))
            case let .Error(error):
                return Result< U>.Error(error)
        }
    }
}

就像之前一樣,變換函數 f 傳入類型 T 的值(上例是 NSData)並返回類型 U 的值(字串),調用 map 後我們得到一個輸入 T、輸出 U 的 Result。每當有新的初始值就調用一次 f,否則會報錯。

Functor(仿函數)

可以看到,map 實際上是為某個類型(如 Optional、Array 或 Result)實現的方法。綜上所述,我們得到一個「使用上像函數的類」,讓這個類有了近似函數的行為——這就是 Functor。一旦你明白 Functor 是什麼,就會意識到 dictionary 之類的東西其實也是 Functor,你也能動手實現自己的 Functor 代碼。

Monad 模式

前面的例子裡,轉換函數返回的是另一個值。但如果我們想讓它返回一個 Result 對象會怎樣?也就是說,轉換操作本身可能失敗或出錯:

func map< U>(f: T -> U) -> Result< U>

在我們的例子中,類型 T 的 NSData 想轉成類型 U。如同:

func map(f: NSData -> Result< String>) -> Result< Result< String>>

注意返回類型的嵌套,這可能不是我們想要的,但卻是正確的。我們可以設計一個函數把它變成想要的結果:

extension Result {
    static func flatten< T>(result: Result< Result< T>>) -> Result< T> {
        switch result {
            case let .Value(innerResult):
                return innerResult.unbox
            case let .Error(error):
                return Result< T>.Error(error)
        }
    }
}

這個 flatten 函數把嵌套類型 T 的返回值攤平,透過提取內部對象返回一個類型 T 的 Result,或返回錯誤。flatten 也可能實現在其他情境,例如把一組數組合併成一維連續數組。

如此一來,我們就能用 map 加 flatten 完成 -><字符串> 的轉換:

let stringResult = Result< String>.flatten(data.map { (data: NSData) -> (Result< String>) in
    if let string = NSString(data: data, encoding: NSUTF8StringEncoding) {
        return Result.Value(Box(string))
    } else {
        return Result< String>.Error(NSError(domain: "com.javisoto.es.error_domain", code: JSErrorCodeInvalidStringData, userInfo: nil))
    }
})

這種模式很常見,很多地方都能看到 flatMap 之類的定義:

extension Result {
    func flatMap< U>(f: T -> Result< U>) -> Result< U> {
        return Result.flatten(map(f))
    }
}

於是我們把這樣的類型定義為 Monad。一個 Monad 就是一個 Functor,用類似上面看到的模式實現功能,有時也被稱為「綁定(bind)」。這裡介紹的是與類型相關的 Monad,但你也會遇到封裝延遲計算的模型,如 Signal 或 Future。

Functor 和 Monad 源自範疇理論,我並不完全熟悉,但我認為對這些名詞做比喻是有價值的。計算機科學家喜歡用一些名詞來命名概念,有了名字,抽象的東西就更容易被理解,透過比喻也能讓大眾更容易親近這些抽象概念。

寫這篇博客花了我很長時間。如果你對這一切還不熟悉,我不希望你讀完就立刻理解它,但我鼓勵你建一份 Xcode 代碼親手試試這些示例。

下次聽到 Functor 或 Monad 時,別害怕——這些名詞只是用來描述我們平常常見的操作模式而已。

(本文為 CocoaChina 組織翻譯,本譯文權利歸譯者所有,未經允許禁止轉載。)

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved