函數式編程 - Swift中的Functor(函子)、Monad(單子)、Applicative

函數式編程-Swift中的Functor(函子)、Monad(單子)、Applicative

前言

初步深刻函數式編程是在寒假的時候,搞了一本Haskell的書,啃了沒多久就由於我忽然的項目任務被擱置了,不過在學習的時候也是各類看不懂,裏面的概念略微抽象,再加上當時沒有適當地實戰敲Demo,致使沒過多久腦殼就全空了。慶幸的是,Swift是一門高度兼容函數式編程範式的語言,而我又是一隻喜歡敲Swift的程序Dog,在後來我使用Swift編碼時,有意識或無心識地套用函數式編程範式的一些概念,也漸漸加深我對函數式編程的理解。這篇文章是我對本身所掌握的函數式編程的一個小總結,主要探討的是函數式編程中的幾個概念: FunctorApplicativeMonad以及它們在Swift中的表現形式。因爲本人能力有限,一些概念上的不嚴謹、編碼上的不全面但願你們多包涵,歡迎留下各位寶貴的意見或問題。html

本文爲純概念講述,後期或許會有函數式編程實戰的文章推出(我有空寫再說吧😊)git

概念

Context

在編碼時,咱們會遇到各類數據類型,基礎的數據類型咱們稱做,固然這並非指編程語言中的基本數據類型,好比說整形1它能夠稱做一個值,一個結構體struct Person { let name: String; let age: Int }的實例也能夠成爲一個值,那麼何爲Context(上下文)呢,咱們能夠將它理解爲對值的一個包裝,經過這層包裝,咱們能夠得知值此時所處在的一個狀態。在Haskell中,這個包裝就是typeclass(類型類),而在Swift中,魔性的enum(枚舉)能夠充當這個角色,一個例子,就是Swift中的Optional(可選類型),它的定義以下(相關繼承或協議關係在這裏不標出):github

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中存在。
在一些函數式響應式編程框架如ReactiveCocoaRxSwift中,Context無處不在:RACSignalObservable,甚至是Swift的基本類型Array(數組)它自己也能夠看做是一個Context。可見,只要你接觸了函數式編程,Context即會接觸。編程

這裏,我特別說下這個Context:Result,由於在後面對其餘概念以及實戰的講述中我都會以它爲基礎:json

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

Result上下文存在兩種狀態,一種是成功的狀態,當處於這個狀態,Result就會持有一個特定類型的值,另一種狀態是失敗狀態,在這個狀態中,你能夠獲取到一個錯誤的實例(這個實例能夠是你本身擬定的)。這麼這個Context有什麼用呢?想象一下,你正在進行一項網絡操做,獲取到的數據是沒法肯定的,你或許能如你所願,從服務器中獲取到你指望的值,可是也有可能此時服務器發生一些未知的錯誤,或者網絡延時,又或是一些不可抗力的影響,那麼,此時你獲得的將會是一個錯誤的表示,如HTTP Code 500...而Result能夠在這種狀況下引入來表示你在網絡操做中獲取到的最終結果,是成功仍是失敗。除了網絡請求,諸如數據庫操做、數據解析等等,Result均可以引入來進行更明確的標示。數組

何爲Functor、Applicative、Monad?

你能夠把FunctorApplicativeMonad想象成Swift中的Protocol(協議),它們能夠爲某種數據結構的抽象,而這種數據接口正是剛剛我在上面提到的Context,要將某個Context實現成FunctorApplicativeMonad,你必須實現其中特定的函數,因此,要了解什麼是FunctorApplicativeMonad,你須要知道它們定義了那些協議函數。接下來我會一一講解。服務器

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,咱們能夠調出上面Functormap僞代碼:
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
這裏咱們實現一下ResultMonad

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是一門高度適配函數式編程範式的語言,你能夠在裏面處處都能找到函數式編程思想的身影,經過上面對FunctorAppliactiveMonad相關概念的講述,在鞏固我對函數式編程的知識外,但願也能讓你對函數式編程的理解有幫助,若文章有概念不嚴謹的地方或者錯誤,望見諒,也但願可以向我提出。
謝謝閱讀。

參考連接

阮一峯的網絡日誌 - 圖解 Monad

相關文章
相關標籤/搜索