Functional Programming in Swift(一)

最近用 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 等类型一样。

1. Example: Battleship

我们要实现一个战舰游戏,首先来判断给定一个点是否在我方战舰 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)
}

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

2. First-ClassFunctions

回到最原始的问题,判断一个 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 使用一种陈述式的解决方式,更加容易理解。

3. Type-DrivenDevelopment

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

4. Notes

作者提到了本章的一些灵感来自于 Haskell 的解决方式,OC 虽然也可以通过 block 来支持 first-class functions,但总归没有 Swift 来的自然。


-EOF-

如果感觉此文对你有帮助,请随意打赏支持作者 😘

chengway

认清生活真相之后依然热爱它!

Subscribe to Talk is cheap, Show me the world!

Get the latest posts delivered right to your inbox.

or subscribe via RSS with Feedly!