前言
\u0026#xD;\n\u0026#xD;\nSwift 其实比 Objective-C 复杂很多,相对于出生于上世纪 80 年代的 Objective-C 来说,Swift 融入了大量新特性。这也使得我们学习掌握这门语言变得相对来说更加困难。不过一切都是值得的,Swift 相比 Objective-C,写出来的程序更安全、更简洁,最终能够提高我们的工作效率和质量。
\u0026#xD;\n\u0026#xD;\nSwift 相关的学习资料已经很多,我想从另外一个角度来介绍它的一些特性,我把这个角度叫做「烧脑体操」。什么意思呢?就是我们专门挑一些比较费脑子的语言细节来学习。通过「烧脑」地思考,来达到对 Swift 语言的更加深入的理解。
\u0026#xD;\n\u0026#xD;\n这是本体操的第五节,练习前请做好准备运动,保持头脑清醒。
\u0026#xD;\n\u0026#xD;\nWhy Monad?
\u0026#xD;\n\u0026#xD;\n因为 Monad 的定义有点复杂,我们先说为什么要理解和学习它。业界对于 Monad 的用处有着各种争论,特别是学术派喜欢用 Haskell 来解释它,因为「Haskell 是纯函数式编程语言」。但这往往让问题更加复杂了----我为了理解一个概念,还需要先学习一门新语言。
\u0026#xD;\n\u0026#xD;\n所以我希望就 Swift 这门语言,分享一下理解 Monad 有什么用。实际上,即使在 Wikipedia 上,Monad 也没有被强行用 Haskell 来解释。所以我相信基于 Swift 语言,还是可以把 Monad 的概念讲清楚。
\u0026#xD;\n\u0026#xD;\n在我看来,之所以有 Monad 这种结构,实际上是为了链式调用服务的。什么是链式调用呢?我们来看看下面一段代码:
\u0026#xD;\n\u0026#xD;\n\u0026#xD;\nlet tq: Int? = 1\u0026#xD;\ntq.flatMap {\u0026#xD;\n $0 * 100\u0026#xD;\n}.flatMap {\u0026#xD;\n \"image\" + String($0)\u0026#xD;\n}.flatMap {\u0026#xD;\n UIImage(named: $0)\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
所以,如果一句话解释 Monad,那就是:Monad 是一种设计模式,使得业务逻辑可以用链式调用的方式来书写。
\u0026#xD;\n\u0026#xD;\n在某些情况下,链式调用的方式组织代码会特别有效,比如当你的调用步骤是异步的时候,很容易写成多层嵌套的dispatch_async
,使用 Monad 可以使得多层嵌套被展开成链式调用,逻辑更加清楚。除了异步调用之外,编程中涉及输入输出、异常处理、并发处理等情况,使用 Monad 也可以使得代码逻辑更清晰。
基础知识
\u0026#xD;\n\u0026#xD;\n封装过的值(wrapped value)
\u0026#xD;\n\u0026#xD;\n这个中文词是我自己想出来的,有一些人把它叫做「上下文中的值」(value with a context),有一些人把它叫做「容器中的值」(value in a container),意思是一样的。
\u0026#xD;\n\u0026#xD;\n什么叫做「封装过的值」呢?即把裸露的数据放到另一个结构中。例如:
\u0026#xD;\n\u0026#xD;\n- 数组就是对值的一种封装,因为数组把裸露的元素放到了一个线性表结构中。\u0026#xD;\n\t
- Optional 也是对值的一种封装,因为 Optional 把值和空放到了一个枚举(enum)类型中。\u0026#xD;\n
如果你愿意,你也可以自己封装一些值,比如把网络请求的结果和网络异常封装在一起,做成一个 enum (如下所示)。
\u0026#xD;\n\u0026#xD;\n\u0026#xD;\nenum Result\u0026lt;T\u0026gt; {\u0026#xD;\n case Success(T)\u0026#xD;\n case Failure(ErrorType)\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
判断一个数据类型是不是「封装过的值」,有一个简单的办法:就是看这个数据类型能不能「被打开」,拿出里面的裸露的元素。
\u0026#xD;\n\u0026#xD;\n- 数组可以被打开,拿出里面的数组元素。\u0026#xD;\n\t
- Optional 可以被打开,拿出里面的值或者 .None。\u0026#xD;\n\t
- 一个 Int 类型的值,无法「被打开」,所以它不是「封装过的值」。\u0026#xD;\n
一个字符串是不是「封装过的值」呢?前提是你如何定义它「被打开」,如果你把它的打开定义成获得字符串里面的每个字符,那么字符串也可以是一个「封装过的值」。
\u0026#xD;\n\u0026#xD;\nflatMap
\u0026#xD;\n\u0026#xD;\n在上一篇烧脑文章中我们也提到过,要识别一个类型是不是 Monad,主要就是看它是否实现了 flatMap
方法。但是,如果你像下面这么实现 flatMap
,那也不能叫 Monad:
\u0026#xD;\nclass TangQiao {\u0026#xD;\n func flatMap() {\u0026#xD;\n print(\"Hello world\")\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
Monad 对于 flatMap
函数有着严格的定义,在 Haskell 语言中,这个函数名叫 bind,但是定义是一样的,这个函数应该:
- 作用在一个「封装过的值」M 上。\u0026#xD;\n\t
- 它的参数应该是另一个闭包 F,这个闭包 F:接受一个解包后的值,返回一个「封装过的值」。\u0026#xD;\n
具体在执行的时候,flatMap
会对 M 进行解包得到 C,然后调用闭包 F,传入解包后的 C,获得新的「封装过的值」。
我们来看看 Optional 的 flatMap
实现,验证一下刚刚说的逻辑。源码地址是:https://github.com/apple/swift/blob/master/stdlib/public/core/Optional.swift。
\u0026#xD;\npublic func flatMap\u0026lt;U\u0026gt;(@noescape f: (Wrapped) throws -\u0026gt; U?) \u0026#xD;\n rethrows -\u0026gt; U? {\u0026#xD;\n switch self {\u0026#xD;\n case .Some(let y):\u0026#xD;\n return try f(y)\u0026#xD;\n case .None:\u0026#xD;\n return .None\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
Optional 的 flatMap
:
- 作用在一个「封装过的值」:
self
身上。\u0026#xD;\n\t - 接受一个闭包参数
f
,这个f
的定义是:接受解包后的值,返回一个「封装过的值」:U?
。\u0026#xD;\n\t - 在执行时,
flatMap
先对self
进行解包,代码是case .Some(let y)
。\u0026#xD;\n\t - 如果解包成功,则调用函数 f,得到一个新的「封装过的值」,代码是
try f(y)
。\u0026#xD;\n\t - 如果解包出来是 .None,则返回 .None。\u0026#xD;\n
设计背后的追问
\u0026#xD;\n\u0026#xD;\nflatMap
接受的这个闭包参数,直观看起来很奇怪。接受的是解包的值,返回的又是封装过的值,一点都没有对称的美!
为什么要这么设计?不这么设计就不能完成链式调用吗?我想了半天,答案就是一个字:懒!
\u0026#xD;\n\u0026#xD;\n为什么这么说呢?因为「封装过的值」大多数时候不能直接计算,所以要计算的时候都要先解包,如果我们为了追求「对称的美」,使得函数接受的参数和返回的值都是「封装过的值」,当然是可以的。不过如果这么设计的话,你就会写大量雷同的解包代码。程序设计的时候追求「Don't Repeat Yourself」原则,这么做当然是不被接受的。
\u0026#xD;\n\u0026#xD;\nFunctor
\u0026#xD;\n\u0026#xD;\n刚刚我们说,在设计上为了复用代码,我们必须保证闭包的参数是解包后的值。
\u0026#xD;\n\u0026#xD;\n那么,同样的道理,每次返回之前都封包一下,不一样很重复么?我们返回的值能不能是解包后的原始值,然后自动封装它?
\u0026#xD;\n\u0026#xD;\n答案是可以的,但是这就不是 Monad 了,这成了 Functor 了。我们上一讲提到过,Functor 中实现的 map
方法,就是一个接受解包后的值,返回结果仍然是解包后的值。为了保证链式调用,map 会自动把结果再封包一次。
我们再来回顾一下 map
的源码吧:
\u0026#xD;\npublic func map\u0026lt;U\u0026gt;(@noescape f: (Wrapped) throws -\u0026gt; U) \u0026#xD;\n rethrows -\u0026gt; U? {\u0026#xD;\n switch self {\u0026#xD;\n case .Some(let y):\u0026#xD;\n return .Some(try f(y))\u0026#xD;\n case .None:\u0026#xD;\n return .None\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
在该源码中,函数 f
在被执行完后,结果会被封包成 Optional 类型,相关代码是:.Some(try f(y))
。
所以,Optional 的 map
和 flatMap
差别真的非常非常小,就看你的闭包想不想自己返回封装后的值了。
在具体业务中,我们也有一些实际的需求,需要我们自己控制返回封装后的值。比如 Optional 在操作的时候,如果要返回 .None,则需要使用 flatMap
,错误的使用了 map
函数的话,就会带来多重嵌套 nil 的问题。比如下面这个代码,变量 b
因为是一个两层嵌套的 nil,所以 if let
失效了。
\u0026#xD;\nlet tq: Int? = 1\u0026#xD;\nlet b = tq.map { (a: Int) -\u0026gt; Int? in\u0026#xD;\n if a % 2 == 0 {\u0026#xD;\n return a\u0026#xD;\n } else {\u0026#xD;\n return nil\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\nif let _ = b {\u0026#xD;\n print(\"not nil\")\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
归根结底,你在编程时使用 Monad 还是 Functor,取决于你的具体业务需求:
\u0026#xD;\n\u0026#xD;\n- 如果你在处理「封装过的值」时,不会(或不需要)返回异常数据,则可以使用 Functor,让数据的封装过程交给
map
函数来处理。\u0026#xD;\n\t - 如果你在处理「封装过的值」时,需要在闭包函数里返回类似 nil(或 ErrorType)一类的数据,则可以使用 Monad,自己返回新的「封装过的值」。\u0026#xD;\n
Applicative
\u0026#xD;\n\u0026#xD;\nSwift 语言中并没有原生的 Applicative,但是 Applicative 和 Functor、Monad 算是三个形影不离的三兄弟,另外它们三者的差异都很小,所以干脆一并介绍了。
\u0026#xD;\n\u0026#xD;\n刚刚我们讨论 Functor 与 Monad 时,都是说把值放在一个容器里面。但是我们别忘了,Swift 是函数式语言,函数是一等公民,所以,函数本身也是一种值,它也可以放到一个容器里面,而我们要讨论的 Applicative,就是一种关于「封装过的函数」的规则。
\u0026#xD;\n\u0026#xD;\nApplicative 的定义是:使用「封装过的函数」处理「封装过的值」。这个「封装过的函数」解包之后的参数类型和 Functor 的要求是一样的。
\u0026#xD;\n\u0026#xD;\n按照这个定义,我们可以自己改造数组和 Optional,使它们成为 Applicative,以下代码就是一个示例,来自 这里。
\u0026#xD;\n\u0026#xD;\n\u0026#xD;\nextension Optional {\u0026#xD;\n func apply\u0026lt;U\u0026gt;(f: (T -\u0026gt; U)?) -\u0026gt; U? {\u0026#xD;\n switch f {\u0026#xD;\n case .Some(let someF): return self.map(someF)\u0026#xD;\n case .None: return .None\u0026#xD;\n }\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\n\u0026#xD;\nextension Array {\u0026#xD;\n func apply\u0026lt;U\u0026gt;(fs: [Element -\u0026gt; U]) -\u0026gt; [U] {\u0026#xD;\n var result = [U]()\u0026#xD;\n for f in fs {\u0026#xD;\n for element in self.map(f) {\u0026#xD;\n result.append(element)\u0026#xD;\n }\u0026#xD;\n }\u0026#xD;\n return result\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
我们为数组和 Optional 增加了一个 apply
方法,而这个方法符合 Applicative 的定义。如果和 map
方法对比,它们的唯一差别就是闭包函数是封装过后的了:
- 对于 Optional 来说,
apply
的闭包函数也变成 Optinoal 的了。\u0026#xD;\n\t - 对于数组来说,
apply
的闭包函数也是一个数组(我们之前介绍过,数组也是对数据的一种封装)。\u0026#xD;\n
Monad 的应用
\u0026#xD;\n\u0026#xD;\n理论都离不开应用,否则就是「然并卵」了,讲完了概念,我们来看看除了 Swift 语言中的数组和 Optional,业界还有哪些对于 Monad 的应用。
\u0026#xD;\n\u0026#xD;\nPromise
\u0026#xD;\n\u0026#xD;\nPromiseKit 是一个同时支持 Objective-C 和 Swift 的异步库。它用 Promise 来表示一个未来将要执行的操作,使用它可以简化我们的异步操作。因为篇幅有限,本文并不打算展开详细介绍 Promise,我们就看一个实际的使用示例吧。
\u0026#xD;\n\u0026#xD;\n假设我们有一个业务场景,需要用户先登录,然后登录成功后发API获取数据,获取数据后更新 UITableView 的内容,整个过程如果有错误,显示相应的错误信息。
\u0026#xD;\n\u0026#xD;\n传统情况下,我们需要把每个操作都封装起来,然后我们可以选择:
\u0026#xD;\n\u0026#xD;\n- 方法一:用多层嵌套的
dispatch_async
把逻辑写到一起,但是这样嵌套代码,可读性和可维护性很差。\u0026#xD;\n\t - 方法二:每一步有一个 delegate 回调函数,把业务逻辑分散到各个回调函数中。但是这样不但逻辑分散了,而且关键的函数调用的依赖关系被我们隐藏起来了。\u0026#xD;\n
另外,以上两种方法处理错误逻辑都可能会有多处,虽然我们可以把报错也封装成一个函数,但是在多个地方调用也不太舒服。使用 PromiseKit 之后,刚刚提到的业务场景可以用如下的示意代码来完成:
\u0026#xD;\n\u0026#xD;\n\u0026#xD;\nlogin().then {\u0026#xD;\n return API.fetchKittens()\u0026#xD;\n}.then { fetchedKittens in\u0026#xD;\n self.kittens = fetchedKittens\u0026#xD;\n self.tableView.reloadData()\u0026#xD;\n}.catch { error in\u0026#xD;\n UIAlertView(…).show()\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
另外,如果你的逻辑涉及并发,PromiseKit 也可以很好地处理,例如,你希望发两个网络请求,当两个网络请求都结束时,做相应的处理。那就可以让 PromiseKit 的 when
方法与 then
结合工作:
\u0026#xD;\nlet search1 = MKLocalSearch(request: rq1).promise()\u0026#xD;\nlet search2 = MKLocalSearch(request: rq2).promise()\u0026#xD;\n\u0026#xD;\nwhen(search1, search2).then { response1, response2 in\u0026#xD;\n //…\u0026#xD;\n}.catch { error in\u0026#xD;\n // called if either search fails\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
在 PromiseKit 的设计中,then
方法接受的闭包的类型和 flatMap
是一样的,所以它本质上就是 flatMap
。Promise 其实就是一种 Monad。
ReactiveCocoa
\u0026#xD;\n\u0026#xD;\n比起 PromiseKit,ReactiveCocoa 的名气要大得多。最新的 ReactiveCocoa 4.0 同时支持 Objective-C 和 Swift,我们在源码中发现了 RAC 的 SignalType
就是一个 Monad:
\u0026#xD;\nextension SignalType {\u0026#xD;\n\u0026#xD;\n public func flatMap\u0026lt;U\u0026gt;(strategy: FlattenStrategy, transform: Value -\u0026gt; SignalProducer\u0026lt;U, Error\u0026gt;)\u0026#xD;\n -\u0026gt; Signal\u0026lt;U, Error\u0026gt; {\u0026#xD;\n return map(transform).flatten(strategy)\u0026#xD;\n }\u0026#xD;\n\u0026#xD;\n public func flatMap\u0026lt;U\u0026gt;(strategy: FlattenStrategy, transform: Value -\u0026gt; Signal\u0026lt;U, Error\u0026gt;) \u0026#xD;\n -\u0026gt; Signal\u0026lt;U, Error\u0026gt; {\u0026#xD;\n return map(transform).flatten(strategy)\u0026#xD;\n }\u0026#xD;\n}\u0026#xD;\n
\u0026#xD;\n\u0026#xD;\n
总结
\u0026#xD;\n\u0026#xD;\n我们再次总结一下 Monad、Functor、Applicative:
\u0026#xD;\n\u0026#xD;\n- Monad:对一种封装过的值,使用
flatMap
函数。\u0026#xD;\n\t - Functor:对一种封装过的值,使用
map
函数。\u0026#xD;\n\t - Applicative:对一种封装过的值,使用
apply
函数。\u0026#xD;\n
我们再对比一下flatMap
、map
和 apply
:
flatMap
:对自己解包,然后应用到一个闭包上,这个闭包:接受一个「未封装的值」,返回一个「封装后的值」。\u0026#xD;\n\tmap
:对自己解包,然后应用到一个闭包上,这个闭包:接受一个「未封装的值」,返回一个「未封装的值」。\u0026#xD;\n\tapply
:对自己解包,然后对闭包解包,解包后的闭包:接受一个「未封装的值」,返回一个「未封装的值」。\u0026#xD;\n
参考链接
\u0026#xD;\n\u0026#xD;\n- Swift Functors, Applicatives, and Monads in Pictures\u0026#xD;\n\t
- Functor、Applicative 和 Monad\u0026#xD;\n\t
- Promises are the monad of asynchronous programming\u0026#xD;\n