原文首发于我的blog：https://chengwey.com

最近用 swift 改写之前的一个 project，发现思维方式还是过去的 OC 命令式语言的模式，而 swift 又是一门函数式语言，中间差距还蛮大的。

命令式编程：命令“机器”如何去做事情( how )，这样不管你想要的是什么( what )，它都会按照你的命令实现。

声明式编程：告诉“机器”你想要的是什么( what )，让机器想出如何去做( how )。

于是抽时间读了 Objc.io 出品的 《Functional Programming in Swift》 这本书。这本书主要介绍如何用swift写出函数式风格的代码，比起国内一些讲swift开发的书籍来说，这本才算是真正意义上的一本swift进阶的书，也符合objc一贯的气质。这里还有一些 weekly snippets，有兴趣的同学可以订阅.

Chapter 1是 Introduction，我们直接跳过来看 Chapter 2

Chapter 2 Thinking Functionally

函数在 swift 中是一等公民，意味着函数可以作为其他函数的参数、返回值就和 integers, booleans, or structs 等类型一样。

<h2 id='Battleship'>1. Example: Battleship</h2>
我们要实现一个战舰游戏，首先来判断给定一个点是否在我方战舰 range 中

typealias Position = CGPoint 
typealias Distance = CGFloat
// 我方战舰在原点
func inRange1(target: Position, range: Distance) -> Bool {
return sqrt(target.x * target.x + target.y * target.y) <= range
}
// 我方战舰不在原点
func inRange2(target: Position, ownPosition: Position, range: Distance) -> Bool {
let dx = ownPosition.x - target.x
let dy = ownPosition.y - target.y
let targetDistance = sqrt(dx * dx + dy * dy) return targetDistance <= range
}

当然，如果不想敌人靠得太近，还可以设置一个最小警戒距离，只要进入警戒距离就视为敌人

let minimumDistance: Distance = 2.0
func inRange3(target: Position, ownPosition: Position, range: Distance) -> Bool { 
    let dx = ownPosition.x - target.x
    let dy = ownPosition.y - target.y
    let targetDistance = sqrt(dx * dx + dy * dy) 
    return targetDistance <= range && targetDistance >= minimumDistance
}

根据上面所做的一些准备，我们就可以写一个判断是否友军的函数：

func inRange4(target: Position, ownPosition: Position, friendly: Position, range: Distance) -> Bool {
    let dx = ownPosition.x - target.x
    let dy = ownPosition.y - target.y
    let targetDistance = sqrt(dx * dx + dy * dy)
    let friendlyDx = friendly.x - target.x
    let friendlyDy = friendly.y - target.y
    let friendlyDistance = sqrt(friendlyDx * friendlyDx + friendlyDy * friendlyDy) 
    return targetDistance <= range && 
           targetDistance >= minimumDistance && 
           (friendlyDistance >= minimumDistance)
}

上面的函数很难掌控，我们来重构一下

<h2 id='First-ClassFunctions'>2. First-ClassFunctions</h2>
回到最原始的问题，判断一个 point 是否在 range 里我们用了一个

func pointInRange(point: Position) -> Bool { 
    // Implement method here
}

这个函数类型很重要，我们可以给他起一个别名，这样Region类型就表示一个 “Position to a Bool” 函数

typealias Region = Position -> Bool

This isn’t strictly necessary, but it can make some of the type signatures that we’ll see below a bit easier to digest

我们来写几个 functions 来 create, manipulate, combine 这些 regions。首先是我方战舰在原点的时候

func circle(radius: Distance) -> Region { 
    return { point in
        sqrt(point.x * point.x + point.y * point.y) <= radius 
    }
}

当然不可能所有的圆心都在原点位置，我们另外新加一个位置参数：

func circle2(radius: Distance, center: Position) -> Region { 
    return { point in
        let shiftedPoint = Position(x: point.x - center.x,
                                    y: point.y - center.y)
    return sqrt(shiftedPoint.x * shiftedPoint.x + 
                shiftedPoint.y * shiftedPoint.y) <= radius
    } 
}

接下来，考虑一下最原始的问题，想象一下，我们的区域不仅仅是一个 circles，可以是其他的任意形状。我们需要一个 region transformer

func shift(offset: Position, region: Region) -> Region { 
    return { point in
        let shiftedPoint = Position(x: point.x - offset.x, 
                                    y: point.y - offset.y)
        return region(shiftedPoint) 
    }
}

我们写了一个闭包来计算新的 newPoint，然后再作为参数传入 region function。上面的例子展示了函数式编程的一个核心：比起创建复杂的函数如 circle2，我们更愿意写一个 shift 函数，直接修改另一个函数。我们可以这样调用：

shift(Position(x: 5, y: 5), circle(10))

下面是一些转换 regions 的方法

// 反转region区域
func invert(region: Region) -> Region { 
    return { point in !region(point) }
}

// region1 和 region2 相交的区域
func intersection(region1: Region, region2: Region) -> Region { 
    return { point in region1(point) && region2(point) }
}

// region1 和 region2 共同的区域
func union(region1: Region, region2: Region) -> Region { 
    return { point in region1(point) || region2(point) }
}

我们可以组合使用这些函数来构造功能更强大的函数，比如创建一个 difference 函数，使用两个 regions 作为参数，region and minusRegion，构造一个region，他的范围是所有在第一个 region 但不在第二个 region 中的所有点。

func difference(region: Region, minusRegion: Region) -> Region { 
    return intersection(region, invert(minusRegion))
}

比起写一些很复杂的函数来解决问题，我们可以使用一些小函数组合起来来解决多样化的问题。

func inRange(ownPosition: Position, target: Position, 
            friendly: Position, range: Distance) -> Bool {
    let rangeRegion = difference(circle(range),
                                circle(minimumDistance))
    let targetRegion = shift(ownPosition, rangeRegion)
    let friendlyRegion = shift(friendly, circle(minimumDistance)) 
    let resultRegion = difference(targetRegion, friendlyRegion) 
    return resultRegion(target)
}

上面的 code 定义了两个 regions：targetRegion and friendlyRegion，我们根据这两个 regions 来计算出最终的 resultRegion，然后再判断目标是敌是友。（开火区域）

比起之前的 inRange4 方法，inRange 使用一种陈述式的解决方式，更加容易理解。

<h2 id='Type-DrivenDevelopment'>3. Type-DrivenDevelopment</h2>
我们定义了一系列的 functions 来描述 region，每一个 function并不十分强大，但你把他们组合起来用就会变得威力十足。决定性的设计就在于我们如何定义 regions，一旦我们确定了 Region 类型，一切就变的顺理成章。

<h2 id='Notes'>4. Notes</h2>
作者提到了本章的一些灵感来自于 Haskell 的解决方式，OC 虽然也可以通过 block 来支持 first-class functions，但总归没有 Swift 来的自然。