Functional Programming in Swift

此为阅读笔记,点击穿越到原地址 戳我.

一 思想转变

学习Swift时, 要转变自己考虑程式的思维.从OC的命令式,转变为Swift的函数式.

import UIKit

typealias Position = CGPoint
typealias Distance = CGFloat

// 我方战舰的在原点
func inRangel(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)
}

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

回到最原始的问题, 判断一个point是否range里,我们用了一个

func pointInRange(point: Position)->Bool{
    // Implement Method Here
    return true
}

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

typealias Region = Position -> Bool

// 我们来写几个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 fucntion. 上面的例子展示了函数式编程的一个核心: 比起创建复杂的函数如circle2, 我们更愿意写一个shift函数, 直接修改另一个函数. 我们可以这样调用
shift(Position(x: 5, y: 5), region: 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 函数, 使用两个region 作为参数, region and minusRegion, 构造一个region, 他的范围是所有在第一个 region但不在第二个region中所有点.

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

// 比起写一些很复杂的函数来解决问题, 我们可以使用一些小函数组合起来来解决多样化的问题
func inRange(ownPosition: Position, target: Position, friendly:Position, range: Distance)->Bool{
    let rangeRegion = difference(circle(range), minusRegion: circle(minimumDistance))
    let targetRegion = shift(ownPosition, region: rangeRegion)
    let friendlyRegion = shift(friendly, region: circle(minimumDistance))
    let resultRegion = difference(targetRegion, minusRegion: friendlyRegion)
    return resultRegion(target)
}

上面的code 定义了两个 regions: targetRegion and friendlyRegion, 我们根据这两个 regions来计算最终的resultRegion, 然后再判断目标是敌是友.(开火区域)

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

Type-DrivenDevelopment 驱动开发

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