函數語言程式設計-將Monad（單子）融入Swift

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

前言

近期又開始折騰起Haskell，掉進這個深坑恐怕很難再爬上來了。在不斷深入瞭解Haskell的各種概念以及使用它們去解決實際問題的時候，我會試想著將這些概念移植到Swift中。函數語言程式設計正規化的很多概念在Swift等主打物件導向正規化的語言中就像各種設計模式一樣，優雅地幫助我們構建好整個專案，促使我們的程式碼更加的美觀優雅、安全可靠。
本篇文章為”函數語言程式設計”系列中的第二篇，我主要說下Monad的一些小概念，以及試圖將Monad融入Swift中來讓其為我們的實際工程專案作出貢獻。

關於Monad、在Swift中實現Monad的一些見解

Monad回顧

在上一篇文章《函數語言程式設計-一篇文章概述Functor(函子)、Monad(單子)、Applicative》中提到過，我們可以將一個值用Context（上下文）包裹起來，使得它不僅可以純粹地表示自己，還含有一些額外的資訊，Monad我理解為參與某種計算過程的、被上下文包含起來的值，說到計算過程，就需要提及Monad中一個重要的函式bind（>>=），它的作用，就是進行Monad的計算過程，並且，它讓我們在計算過程中只需專注於值的運算，而不需要花另外的精力去處理計算過程中Context（上下文）的變化轉換。說白了，就是我們只管值的運算，Context（上下文）就放心交給bind的內部實現去處理吧。
這裡列舉一個Swift中的Optional monad:

// 擴充套件Optional，實現bind方法
extension Optional {
    func bind<O>(_ f: (Wrapped) -> Optional<O>) -> Optional<O> {
        switch self {
        case .none:
            return .none
        case .some(let v):
            return f(v)
        }
    }
}

// 定義bind運算子`>>-`
precedencegroup Bind {
    associativity: left
    higherThan: DefaultPrecedence
}

infix operator >>- : Bind

func >>- <L, R>(lhs: L?, rhs: (L) -> R?) -> R? {
    return lhs.bind(rhs)
}

// 除法，若除數為0，返回nil
// 方法型別:
//    A           B          C
// (Double) -> (Double) -> Double?
// 用B除以A
func divide(_ num: Double) -> (Double) -> Double? {
    return {
        guard num != 0 else { return nil }
        return $0 / num
    }
}

let ret = divide(2)(16) >>- divide(3) >>- divide(2) // 1.33333333...
// 可以寫成
// let ret = Optional.some(16) >>- divide(2) >>- divide(3) >>- divide(2)

let ret2 = Optional.some(16) >>- divide(2) >>- divide(0) >>- divide(2) // nil複製程式碼

如上，我將Swift中的Optional型別實現為Monad，所以對於一個可選的資料型別，它的上下文為資料是否為空。定義的除法方法divide將兩個數相除，如果除數為0，則返回nil，用於保證運算的安全。在最後，我進行了兩個連續運算，結果為ret和ret2，可以看到，若運算過程中所有除數都不為0，則最終返回連續除法運算後的結果，若運算過程中某除數如果是0，那麼返回的結果就會是nil。
我們可以發現，整個運算過程中我們只專注於運算的方法以及參與運算的資料，我們並沒有花其他的精力用於檢測除數是否為0，並且如果為零則終止運算，返回nil，因為這部分關於上下文的考慮，bind已經為我們打理好了。

Swift中實現Monad

Haskell的型別系統強大，加上其對Monad的高度支援（如提供了do語法糖），我們可以很容易地在裡面創造和使用Monad。但是對於Swift語言，由於其泛型系統以及語法的限制，我們不能夠像Haskell那樣非常優雅地實現Monad，個人總結出有兩點原因：

Swift中的協議無法定義出Monad

Haskell中，Monad的定義為:

class Applicative m => Monad (m :: * -> *) where
  (>>=) :: m a -> (a -> m b) -> m b
  (>>) :: m a -> m b -> m b
  return :: a -> m a
  fail :: String -> m a複製程式碼

Haskell的型別類與Swift中的協議類似，我們可以看到第一行宣告瞭Monad，而m可以看做是需要實現Monad的型別，下面就是一些需要實現的函式。事實上，m在上面其實是一個型別構造器，它的型別為(* -> *)，我們可以直接把它看成是Swift中具有一個泛型引數的泛型，相應的，如果是(* -> * -> *)型別的Haskell型別構造器，就型別於Swift中具有兩個泛型引數的泛型，而(*)型別的型別構造器其實就是一個具體的型別。
現在問題來了，對於Haskell，我們可以讓一個非具體的型別（具有一個或多個型別引數的型別構造器）去實現某些型別類，但是對於Swift，若要實現一個協議，我們必須得提供一個具體的型別。所以在Swift中Monad無法用協議來實現。

protocol Monad {
    associatedtype MT
    func bind(_ f: (MT) -> Self) -> Self
}複製程式碼

像上面定義的Monad協議，泛型引數為MT。這個Monad協議的bind函式是存在問題的，因為它接收一個返回Self型別的函式，並且返回一個Self型別，Self指待現在實現了這個協議的型別，它的泛型引數依舊是保持不變，這並不滿足Monad的要求。
（以上為個人觀點，個人嘗試過是寫不出來，若各位能使用Swift的協議實現了Monad，還望教授）
要在Swift實現Monad，只能由我們自己保證每個Monad的實現類中實現了指定的Monad函式。

Swift中無法優雅地解決Monad中的lambda巢狀

Haskell的do語法能夠避免多重的lambda巢狀，從而使得Monad的語法更加優雅可觀：

main = do
  first <- getLine
  second <- getLine
  putStr $ first ++ second複製程式碼

對於Swift來說，若我們在使用Monad的時候涉及到了lambda的巢狀，可能寫起來就會有點憂傷，這裡拿上面提到的Optional monad舉例：

let one: Int? = 4
let two: Int? = nil
let three: Int? = 7

let result1 = one >>- { o in two >>- { t in o + t } }
let result2 = one >>- { o in two >>- { t in three >>- { th in o * t * th } } }複製程式碼

如果Swift支援do語法（不是指異常處理的do語法），那麼這樣子就會簡潔很多：

let result1 = do {
  o <- one
  t <- two
  th <- three
  return o * t * th
}複製程式碼

上面的語法純屬腦補。

所以一般來說應該不會用Swift去實現某些需要多重巢狀lambda的Monad。

Either Monad

在上一篇函數語言程式設計的文章中有提到Result Monad，它表示某個運算可能會存在成功與失敗的情況，若運算成功，則能獲取到結果值，若運算失敗，則可以獲取到失敗的原因（錯誤資訊）。使用Either Monad也可以做這件事。

enum Either<L, R> {
    case left(L)
    case right(R)
}

extension Either {
    static func ret(_ data: R) -> Either<L, R> {
        return .right(data)
    }

    func bind<O>(_ f: (R) -> Either<L, O>) -> Either<L, O> {
        switch self {
        case .left(let l):
            return .left(l)
        case .right(let r):
            return f(r)
        }
    }
}

func >>- <L, R, O> (lhs: Either<L, R>, f: (R) -> Either<L, O>) -> Either<L, O> {
    return lhs.bind(f)
}複製程式碼

Either為列舉型別，接收兩個泛型引數，它表示在某個狀態時，資料要麼是在left中，要麼是在right中。
由於Monad要求所實現的型別需要具備一個泛型引數，因為在進行bind操作時可能會對資料型別進行轉換，但是上下文所包含的資料型別是不會改變的，所以這裡我們將泛型引數L用於上下文所包含的資料型別，R則作為值的型別。

什麼是上下文所包含的資料型別，什麼是值的型別？
Result monad中有一個資料泛型，代表裡面的資料型別。某次運算成功是，則返回這個型別的資料，若運算失敗，則會返回一個Error型別。我們可以把Error型別看成是上下文中包含的資料型別，它在一系列運算中是不可變的，因為Result需要靠它來記錄失敗的資訊，若某次運算這個型別突然變成Int，那麼整個上下文將失去原本的意義。所以，若Either monad作為Result monad般地工作，我們必須固定好一個上下文包含的型別，這個型別在一系列的運算中都不會改變，而值的型別是可以改變的。
運算子>>-的簽名可以很清晰地看到這種型別約束：接收的Either引數跟後面返回的Either它們的左邊泛型引數都為L，而右邊泛型引數可以隨著接收的函式而相應進行改變(R -> O)。

用Either monad來作為Result monad般工作，可以細化錯誤資訊的型別。在Result monad中，錯誤資訊都是用Error型別的例項來攜帶，而我們使用Either monad，可以根據我們的需要擬定不同的錯誤型別。如我們有兩個模組，模組一表示錯誤的型別為ErrorOne，模組二則為ErrorTwo，我們就可以定義兩個Either monad來分別作用於兩個模組：

typealias EitherOne<T> = Either<ErrorOne, T>
typealias EitherTwo<T> = Either<ErrorTwo, T>複製程式碼

從上面的程式碼我們也可以看出，Swift也能像Haskell一樣對型別構造器（泛型類）進行柯里化操作，意思是我們在實現一個泛型的時候無需把它需要的所有泛型引數都填滿，可以只填入其中的若干個。

Writer monad

為了引入Writer monad，我先丟擲一個需求:

  1. 要連續完成一系列任務
  2. 在完成每項任務後，做相關的記錄存檔（如日誌的記錄）
  3. 最終完成所有任務後，得到最終資料以及總體的記錄檔案

對於這個需求，傳統的做法可能是在全域性中儲存著檔案記錄，每當任務完成後，我們就響應地修改這個全域性檔案，直到所有任務完成。

Writer monad針對這種情況提供了更加優雅的解決方案，它的Context中儲存著檔案記錄，每次我們對資料進行運算時，我們不需要再分離一部分精力在檔案的組織和修改上，我們只需關注其中資料的運算。

Monoid

在繼續深入Writer monad前，首先提及一個概念: Monoid（單位半群），它作為數學的概念有著一些特性，但由於我們只是利用它來完成工程專案上的一些邏輯，所以不深入探討它的數學概念。這裡只是簡單提及一下它的需要滿足的特性：

對於一個集合，存在一個二元運算：

  1. 取這個集合中兩個元素進行運算，得到的結果任然是這個集合中的元素（封閉性）
  2. 這個運算子合結合律
  3. 存在一個元素（單位元），用二元運算將其與另一個元素進行運算，結果仍然是另外的那個元素。

舉個例子：
對於整數型別，它有一個加法運算，接收兩個整數，並且將兩個整數相加，得到的無疑也是一個整數，而且我們也都知道，加法是滿足結合律的。對於整數0，任何數與它相加，都是等於原來的數，所以0是這個單位半群的單位元。

我們可以在Swift中定義Monoid的協議：

// 單位半群
protocol Monoid {
    typealias T = Self
    static var mEmpty: T { get }
    func mAppend(_ next: T) -> T
}複製程式碼

其中，mEmpty表示此單位半群的單位元，mAppend表示相應的二元運算。

上面的例子就可以在Swift中這樣實現：

struct Sum {
    let num: Int
}

extension Sum: Monoid {
    static var mEmpty: Sum {
        return Sum(num: 0)
    }

    func mAppend(_ next: Sum) -> Sum {
        return Sum(num: num + next.num)
    }
}複製程式碼

我們使用Sum來表示上面例子中的單位半群。為什麼不直接使用Int來實現Monoid，非要對其再包裝多一層呢？因為Int還可以實現其他的單位半群，比如:

struct Product {
    let num: Int
}

extension Product: Monoid {
    static var mEmpty: Product {
        return Product(num: 1)
    }

    func mAppend(_ next: Product) -> Product {
        return Product(num: num * next.num)
    }
}複製程式碼

上面這個單位半群的二元運算就是乘法運算，所以單位元為1，1與任何數相乘都為原本的數。

像布林型別，可以引出兩種Monoid:

struct All {
    let bool: Bool
}

extension All: Monoid {
    static var mEmpty: All {
        return All(bool: true)
    }

    func mAppend(_ next: All) -> All {
        return All(bool: bool && next.bool)
    }
}

struct `Any` {
    let bool: Bool
}

extension `Any`: Monoid {
    static var mEmpty: `Any` {
        return `Any`(bool: true)
    }

    func mAppend(_ next: `Any`) -> `Any` {
        return `Any`(bool: bool || next.bool)
    }
}複製程式碼

當我們要判斷一組布林值是否都為真或者是否存在真時，我們就可以利用All或Any monoid的特性:

let values = [true, false, true, false]

let result1 = values.map(`Any`.init)
    .reduce(`Any`.mEmpty) { $0.mAppend($1) }.bool // true

let result2 = values.map(All.init)
    .reduce(All.mEmpty) { $0.mAppend($1) }.bool // false複製程式碼

實現Writer monad

下面繼續來深入Writer monad，首先給出它在Swift中的實現：

// Writer
struct Writer<W, T> where W: Monoid {
    let data: T
    let record: W
}

extension Writer{
    static func ret(_ data: T) -> Writer<W, T> {
        return Writer(data: data, record: W.mEmpty)
    }

    func bind<O>(_ f: (T) -> Writer<W, O>) -> Writer<W, O> {
        let newM = f(data)
        let newData = newM.data
        let newW = newM.record
        return Writer<W, O>(data: newData, record: record.mAppend(newW))
    }
}

func >>- <L, R, W>(lhs: Writer<W, L>, rhs: (L) -> Writer<W, R>) -> Writer<W, R> where W: Monoid {
    return lhs.bind(rhs)
}複製程式碼

分析下實現的原始碼：

  • 泛型引數M要求為一個Monoid，它就是表示一系列操作用所記錄的檔案的型別；泛型引數T表示被包裹在Writer monad上下文中資料的型別。
  • ret方法作用跟Haskell中的return函式一樣，將一個值包裹在某個Monad的最小上下文中。對於Writer monad，我們在ret函式中返回一個Writer，其中資料為傳入的引數，記錄檔案則為指定Monoid的單位元，這樣就能將一個資料包裹進Writer monad的最小上下文中。
  • bind的實現中，我們可以看到，裡面會自動將兩個Writer monad的記錄進行mAppend操作，返回一個包裹著新資料和新記錄的Writer monad。前面關於Monad概念中提到：Monad的bind操作是讓我們專注於資料的運算，對於上下文的處理，我們無需關心，這個是自動進行的。所以對於Writer monad，bind操作自動幫我們把記錄mAppend起來，我們也無需把其他的精力花在對記錄的操作中。
  • 為了讓程式碼更加美觀優雅，我定義了運算子>>-，它在Haskell中的樣子是>>=。

Demo

接下來我們用Writer monad做一個小Demo。
就像前面引入的需求一樣，這裡我打算做一個關於Double的一系列簡單運算，包括加、減、乘、除，每次運算後，我們需要用字串來對運算的過程進行記錄，比如x * 3會記錄成乘以3，並將之前的記錄與新運算建立的記錄進行合併，最終一系列運算完成後，我們會得到運算結果以及整個運算過程的記錄。

首先我們先讓String實現Monoid：

extension String: Monoid {
    static var mEmpty: String {
        return ""
    }

    func mAppend(_ next: String) -> String {
        return self + next
    }
}複製程式碼

這個針對String的單位半群，其二元運算為+，表示將兩個字串拼接起來，所以其單位元為一個空字串。

這裡我為Double的Writer monad型別擬一個別名，記錄型別為String，資料型別為Double：

typealias MWriter = Writer<String, Double>複製程式碼

然後定義加、減、乘、除運算：

func add(_ num: Double) -> (Double) -> MWriter {
    return { MWriter(data: $0 + num, record: "加上(num) ") }
}

func subtract(_ num: Double) -> (Double) -> MWriter {
    return { MWriter(data: $0 - num, record: "減去(num) ") }
}

func multiply(_ num: Double) -> (Double) -> MWriter {
    return { MWriter(data: $0 * num, record: "乘以(num) ") }
}

func divide(_ num: Double) -> (Double) -> MWriter {
    return { MWriter(data: $0 / num, record: "除以(num) ") }
}複製程式碼

注意，這些函式都是高階函式，若他們的形參跟返回值看成是(a) -> (b) -> c，則這些函式的作用是進行運算b X a (X為加、減、乘、除運算)，然後把結果c返回。
每次運算後都會記錄此次運算的相關資訊，比如加上X、除以X。

現在我們來測試一下：

let resultW = MWriter.ret(1) >>- add(3) >>- multiply(5) >>- subtract(6) >>- divide(7)

let resultD = resultW.data // 2.0

let resultRecord = resultW.record // "加上3.0 乘以5.0 減去6.0 除以7.0"複製程式碼

可見，我們得到了多次連續運算後的結果2.0，還有被自動拼接起來的記錄"加上3.0 乘以5.0 減去6.0 除以7.0"。

當然，Writer monad的玩法還有很多種，比如現在再出一個需求：
規定成績分數為整數，分數大於等於60分能拿到及格，現需要統計一個班同學的成績，並且判斷：整個班的同學是否都及格/是否存在至少一個同學及格。
我們可以利用上面已經介紹的All monoid以及Any monoid來建立分數的Writer monad：

typealias ScoreWriter = Writer<All, Int>

func append(_ score: Int) -> (Int) -> ScoreWriter {
    return { ScoreWriter(data: $0 + score, record: All(bool: score >= 60)) }
}

let allScores = [45, 60, 98, 77, 65, 59, 60, 86, 93]

let result = allScores.reduce(ScoreWriter.ret(0)) { $0 >>- append($1) }
let resultBool = result.record.bool // false
let resultScore = result.data // 643複製程式碼

append為一個高階函式，我們可以把它看成是一個接收兩個引數的函式的柯里化形式，我們會判斷傳入的第一個引數是否滿足合格的要求，並且將兩個引數相加，建立一個ScoreWriter。
在這個ScoreWriter monad中，我將記錄型別設為All，所以返回的結果中，布林型別表明整個班同學們的成績是否都及格了。傳入的資料中顯然有低於60的，所以最終的布林結果為false。

如果你把All改成Any，最終的布林結果就為true，表明整個班至少有一位同學是及格的：

// 這裡我用反單引號(`)將Any包裹住，因為Any為Swift中的關鍵字
typealias ScoreWriter = Writer<`Any`, Int>

func append(_ score: Int) -> (Int) -> ScoreWriter {
    return { ScoreWriter(data: $0 + score, record: `Any`(bool: score >= 60)) }
}

let allScores = [45, 60, 98, 77, 65, 59, 60, 86, 93]

let result = allScores.reduce(ScoreWriter.ret(0)) { $0 >>- append($1) }
let resultBool = result.record.bool // true複製程式碼

State Monad

對於Swift來說，由於其不是純函數語言程式設計語言，所以也不會存在資料不可變的情況，我們可以隨時用var建立變數。而Haskell由於其特性規定了所有資料都是不可變的，所以對於某些涉及狀態的運算而言，需要另闢蹊徑。State monad(狀態Monad)可以用來解決這種需求。不過在Swift中，如果你不喜歡總是定義一些變數，或者說出現變數混雜的情況，你也可以使用這種方法。

State Monad在Haskell的do語法中能發揮強勁的作用，但是在Swift中如要實現這種效果，我們需要編寫多重的lambda巢狀（閉包巢狀），這樣寫既麻煩，可觀性又不高，與函數語言程式設計簡潔的特點相違背。所以，這裡只探討用>>- (bind)鏈式呼叫State monad的相關情況。
State Monad有一定的難度，並且它可能很少會在日常的工程專案中被需要到，但是通過對它的學習把玩，可以很好地提高我們對函數語言程式設計的熟悉掌握。以下對Stata Monad的講解較為粗略，以供瞭解，若有興趣，可查閱有關State Monad的更多資訊。

首先我們來實現State Monad:

struct State<S, T> {
    let f: (S) -> (T, S)
}

extension State {
    static func ret(_ data: T) -> State<S, T> {
        return State { s in (data, s) }
    }

    func bind<O>(_ function: @escaping (T) -> State<S, O>) -> State<S, O> {
        let funct = f
        return State<S, O> { s in
            let (oldData, oldState) = funct(s)
            return function(oldData).f(oldState)
        }
    }
}

func >>- <S, T, O>(lhs: State<S, T>, f: @escaping (T) -> State<S, O>) -> State<S, O> {
    return lhs.bind(f)
}複製程式碼

如果某項操作需要狀態，我們不想在作用域中建立一個新的變數來記錄某些臨時的狀態，並隨著操作的進行而改變，可以在每次進行操作完後把新的狀態返回，這樣，我們下一次操作就可以利用新的狀態進行，以此類推。
State具有一個成員，它的型別為一個函式，這個函式可以看作是一種操作，接受某個狀態作為引數，返回操作後的結果資料以及一個新的狀態組成的元組。State Monad的ret函式接收一個任意型別的值，返回State本身。因為ret函式是將資料包裹在Monad的最小上下文中，所以此時State中的成員函式不對資料和狀態做任何的處理。
對於bind函式，它的作用就是自動幫我們將上一個操作返回的新狀態傳入到下一個操作中，所以我們呼叫bind函式進行一系列操作的時候，我們無需花精力於狀態的傳遞。

下面我舉一個使用State Monad的小例子，這個例子可能比較牽強，如果以後我想到更好的可能會重新修改下這部分。

現假設現在伺服器提供API，通過使用者的ID可以獲取到使用者的名字，我們想要獲取連續ID的n個使用者的名字，並將這些名字包裹在一個陣列中。
我們首先來模擬伺服器資料庫的資料以及API函式：

struct Person {
    let id: Int
    let name: String
}

let data = ["Hello", "My", "Name", "Is", "Tangent", "Haha"].enumerated().map(Person.init)

func fetchNameWith(id: Int) -> String? {
    return data.filter { $0.id == id }.first?.name
}複製程式碼

伺服器提供fetchNameWith方法用於通過ID獲取到指定使用者的名字，若不存在此ID的使用者，則返回nil。

我們定義用於解決此問題的State Monad型別，並建立請求函式：

typealias MState = State<Int, [String]>

func fetch(names: [String]) -> MState {
    return MState { id in
        guard let name = fetchNameWith(id: id) else { return (names, id) }
        return (names + [name], id + 1)
    }
}複製程式碼

fetch函式的型別為([String]) -> MState，引數為前面所請求到的所有使用者名稱字所組成的陣列，返回的MState中操作函式做的事情有兩件：

  1. 呼叫伺服器API，獲取到指定的使用者名稱字，並把使用者的名字新增到陣列中
  2. 將原本的使用者ID加一，以便在後面的操作中能夠獲取到下一個使用者的名字

這裡需考慮一個邊界情況，當伺服器找不到指定的使用者時，返回nil，我們的操作函式就不做任何的事情了，返回原來的資料，表明後面我們再怎麼繼續呼叫請求函式，結果都不會改變。

下面來測試一下：

let fetchFunc = MState.ret([]) >>- fetch >>- fetch >>- fetch >>- fetch
let namesAndNextID = fetchFunc.f(1)
let names = namesAndNextID.0 // ["My", "Name", "Is", "Tangent"]
let nextID = namesAndNextID.1 // 5複製程式碼

我們一開始把一個空的陣列包裹到State Monad的最小上下文中，然後進行了四次請求，bind自動完成有關狀態的操作，最後返回結果State Monad，這個結果State Monad中的操作函式已經是將前面所有的操作合併了，所以我們可以直接呼叫此操作函式，最中獲取我們想要的資料。

總結

本文概述了有關Monad(單子)的概念，探討了在Swift中實現Monad的一些缺陷點，並引入了Either Monad、Writer Monad、State Monad，嘗試在Swift中去實現它們。雖然在平時的開發中我們一般都使用物件導向的程式設計正規化，但是靈活地在你的程式碼中融入一些函數語言程式設計的概念及思想將會產生意想不到效果。
不過坑有點深?

相關文章