转载

Swift 和函数式编程的遗产

原文地址 by Rob Napier

译文地址 by Alex Tse

Rob Napier 开发过单子(Monad)，Functor of Doom。他接触过 map，flattened 和 lensed。他反复迭代尝试，提出了 Maybe 类型，今后他也将继续致力于对函数式编程的探索。

他从 Haskell 到 Church，可以确定：Swift 不是一个函数编程语言，如果硬把它们当成一回事反而会扰乱 Swift 和破坏 Cocoa。

然而，Swift 却已经从函数编程吸取了一些很不错的经验，虽然值类型可能不是当前所流行的，但它们显然是未来趋势。

Rob 研究着已经有数十年的函数语言是如何对 Swift 产生了影响，以及如何更好的使用这些特性，同时还要保持 Swift 的个性和 Cocoa 的友好，当然少不了要拥抱面向协议编程。

概述

Swift 面世一周后，我写了 “Swift并不是一种函数语言” 这篇博客。两年过去了，Swift 依旧不是函数语言。这篇文章讨论的是经历了数十载的函数编程，以更 Swifty 方式带到 Swift 里去。

什么是函数编程？

它是单子(monads)，函子(functors)，Haskell 这类优美的代码。

函数编程不是一种语言或语法，它是一种用来思考问题的方式。函数编程在 Monad 出来的前几十年就有了。我们会用函数编程来思考如何解决问题，并将它们结构化的组织起来。

用 Swift 写一段非常简单的代码看看：

var persons: [Person] = []
for name in names {
    let person = Person(name: name)
    if person.isValid {
        persons.append(person)
    }
}

这是个实现了两件事的简单循环：用 name 实例 person，然后把有效的 person 插入到数组当中。如此简单的代码，还是做了不少工作。因为要知道这其中发生了什么，必须从头看到尾过一遍。而且你还需要思考，“这个数组是做什么的？”

这段代码其实还可以更简单。我们可以关注点分离(separate the concerns)，把事情分开。

比如我们现在有两个循环，每个循环做少量的事。我们从每个简单的循环代码里面找到模式：创建一个数组，遍历一些值，在每个值上面做一些操作，最后把它们插入到另一个数组里。

当你有一些事需要重复执行多次，你可能需要类似一个 extract 函数 – Swift 就有这个函数，叫 “map”。Map 可以将一个列表的东西转换成另一个列表。要注意的是：Map 会包含所有有效或无效的 person 对象。这是个基于 names 的 persons 列表。因此我们不需要从头开始过一遍代码，我们要表达的已经在这里面。

let possiblePersons = names.map(Person.init)
let persons = possiblePersons.filter { $0.isValid }

另一个循环模式也很常见：叫“filter”。Filter 接受一个返回 bool 的闭包函数。Filter 适用这个例子，可以得到有效的 person。我们可以将 map 和 filter 放在一起，把 map 得到的 Person 列表放到 filter 函数当中。

我们从上面的7行代码减少到2行。此外，我们可以重组它们：把这些所有函数通过链式(chaining)放在一起处理。

它十分易读，我们一次就可以读完。

let persons = names
    .map(Person.init)
    .filter { $0.isValid }

这种方式值得好好学习，我们应该适应这种写法（ 在我看来这很Swift ）。在这个例子里无需再写 for 循环。

函数式工具

在1977年，约翰·巴科斯(John Backus)(帮助发明了 FORTRAN 和 ALGOL)赢得了图灵奖，并发表了一场名叫 “编程能否从 Von Neumann 风格中解放出来” 的演讲，我喜欢这个标题。“Von Neumann 风格”指的就是 FORTRAN 和 ALGOL。

这次演讲是一场道歉，原因是他发明了 FORTRAN 和 ALGOL。他解释说，指令式编程是一步一步的改变一些状态，直到进入你想得到的最终状态。他说“函数”这并不代表今天所说的功能，他鼓励许多函数研究者去学习研究。

我对该演讲很感兴趣，因为有一些东西可以带给 Swift：我们如何将复杂的东西分解成简单的东西。使这些简单的东西变得通用，然后再使用一些规则（如代数）将它们粘合起来。

代数的规则是把东西堆放在一起，然后按条件分离，最后一起转换它们。我们可以想一个用来控制程序的规则，事实上我们已经做到了：将一个循环分解成两个更简单的循环，找到它们惯用的形式，然后用链式(chaining)链在一起。当 Haskell 开发者第一次接触 Swift 的时候，往往会觉得不爽，因为他们一直实践的是 Haskell 的理论。

就如所有函数式语言一样，Haskell 的基础构成单位就是函数。它们都有非常好的方法来组织函数。下面我创建了一个新函数，叫 sum ，把 foldr 函数和 + 函数合在一起，并赋予其初始值为 0 。你阅读时可能觉得不顺畅，但是一旦运用起来，它的魅力会把你折服。

let sum = foldr (+) 0
  sum [1..10]

你可以用在 Swift 上，但你会发现代码变得丑陋，又不能很好的运行，别用错了单位组合，Swift 可不是函数式。

Swift 的构成单位是类型。你可以用 Classes，structs，enums 和 protocols 来构建(compose)。我们通常会通过一个函数将两种类型结合在一起，使用更简单的方式构建它们。

Swift 另一种常见的构成是将类型添加上下文(context)。最常见的是可选(optionals)类型。可选(optional)是添加上下文的类型，这个上下文可能有值，可能没有。那么这个类型就包含了一个小小的信息：它是否存在？这就是上下文的意思。添加上下文比其他跟踪信息的方式更强大。

extension MyStruct<T>:Sequence {
    func makeIterator() -> AnyIterator<T> {
return ... }
}

我们可以跟踪查看一个值，判断它是不是整数，是否有值，是否为 -1 ，如果是 -1 那这意味着是无效值。那么如果每个地方都写上这样的判断，你会发现代码开始变得丑陋起来，而且容易出错，甚至编译器也帮不到你。

如果我们把 int 加上可选类型，那么编译器就可以帮助你，这个 int 就有了这样的上下文：“有值，没值，我可以确保你不会忘记它”。如果你曾经使用过 -1 ，而这又很容易忘记检查，那么你的程序就会走到你意想不到的地方。

// No value: magic value
let noValue = -1
let n = 0
if n != noValue { ... }
 
// No value: context
let n: Int? = 0
if let n = n { ... }

例子

让我们来看一个更复杂的例子。

func login(username: String, password: String,
          completion: (String?, Error?) -> Void)
login(username: "rob", password: "s3cret") {
    (token, error) in
    if let token = token {
        // success
    } else if let error = error {
// failure }
}

这是很常见的 API。我们有一个 登录 函数，需要 用户名 和 密码 ，同时还会回传一个 token 和一个可能会出现错误的信息。我认为我们可以把上下文(content)处理的更好。

第一个问题是 completion 回调。这里说的是一个 String，但这个字符串是什么？是一个 token。我可以加上一个 label，但这并没有用。在 Swift 中，label 不是类型。即时这样做了，它依旧是字符串，字符串可以表示很多东西。

Token 有一些规则：它可能是固定长度，或者不能为空。这些都可以用字符串表示，但都不能表示 token。我们想要 token 带有更多的上下文。它是有规则的，所以我们要使用这些规则。既然如此，我们可以给它更多的结构。这就是为什么称它为 struct 。

struct Token {
    let string: String
}

我把字符串加入到结构当中。这不会产生其他开销，也不会有任何额外内存的使用，但现在我可以把一些规则运用在这里。

在这就只能构建一些指定的字符串，使用扩展还可以创建一些其他字符串。更棒的是这可以添加所有类型，string，dictionary，array，int 等，统统没问题。

当有了这些类型，你就可以把它们添加到一个上下文当中，并在使用它们的地方控制它们。意味着你可以控制它们是什么意思。我不再需要 label 或添加标注(comment)，因为这第一眼可以看出是 Token 类型，第一个参数就是 令牌(token) 。

第二个问题是我们传入了一个 用户名 和 密码 。在大部分的程序中，你总会把它们一起传入进去；但密码本身就很少被使用到。我想要创建一个规则，允许我用“and”把用户名和密码组合起来，所以我需要一个“and”类型。事实上我们已经有一个，那就是刚才用到的 struct。

“AND”类型(积)

struct Credential {
  var username: String
  var password: String
}

Struct 是“and”类型。 Credential 是一个 用户名 和 密码 。“and”类型常用的名字叫“积类型”(product type)。

我鼓励你大声的把看法说出来。例如：“credential 结构是一个用户名和密码。”是否有意义？如果没有意义，这或许是一个错误的类型，又或许是你构建错了。

func login(credential: Credential,
          completion: (Token?, Error?) -> Void)
 
 
let credential = Credential(username: "rob",
                            password: "s3cret")
login(credential: credential) { (token, error) in
    if let token = token {
        // success
    } else if let error = error {
        // failure
    }
}

现在我们可以把 用户名 和 密码 换成 Credential ：这也使得我们的验证函数变得更短，更清晰，还开辟了更多不错的可能：对 Credential 进行扩展，或者用其他类型来代替它们。或许我们想要一个 one0time 密码，一个访问令牌(access tokens)，或者 Facebook、Google 等第三方登录。现在我不需要修改其他地方的代码，因为这里只需传一个凭证即可。

但这依旧有问题。我们已经传递了这个 (Token?, Error?) 元组(tuple) – 元组是“and”类型。它们都是匿名构造体。我们的意思是“这可能是一个 token？可能是一个 error”吗？所以有四种可能：都是，都不是，要么是 token，要么是 error。但任何场景下，只有其中两种可能性。如果我同时得到一个 token 和 error，怎么办？这是错误的情况吗？需要一个致命的错误码？需要忽略它吗？此时你需要思考一下才能针对性的测试。

“OR”类型(和)

问题是你不需要把所有情况都表示出来 – 你只需表达清楚这是 token 或是 error。那么是否有一个“or”类型提供我们使用吗？

enum Result<Value> {
    case success(Value)
    case failure(Error)
}

这是一个枚举(enum) – 枚举是“or”类型，而结构(struct)是“and”类型。“and”类型是“积类型”(product type)，而“or”是“和类型”(sum type)。

func login(credential: Credential,
          completion: (Result<Token>) -> Void)
login(credential: credential) { result in
    switch result {
    case .success(let token): // success
    case .failure(let error): // failure
    }
}

我构建一个 result 类型。 result 类型不是内建在 Swift 里 ，这真的让我很恼火。幸好它很容易构建。我们将赋予 value 更多上下文，从一个普通 value 变成有“登录成功”含义的 value。

我们这里的 error 也有了更多上下文，它更像处理失败情况的 error。如果返回像之前的结果，最终 token 会包含在里面，所有不可能发生的情况都需要编写一次测试。现在我们并不需要担心，因为已经不会发生这种情况了。我可不想为不存在的 bug 编写一个个测试。

我喜欢这个API。我通用一个 credential，它就会返回一个最终的 token。