Functional Programming in Swift(

作者: walkingway | 来源:发表于2015-03-15 21:56 被阅读1401次

    原文首发于我的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 来的自然。

    相关文章

      网友评论

        本文标题:Functional Programming in Swift(

        本文链接:https://www.haomeiwen.com/subject/whkixttx.html