swift之函数式编程(二)

时间:2022-10-27 09:17:26

本文的主要内容来自《Functional Programming in Swift》这本书,有点所谓的观后总结

在本书的Introduction章中:

we will try to focus on some of the qualities that we believe well-designed functional programs in Swift should exhibit:

1. Modulatity【模块化】

2. A Careful Treatment of Mutable State 【细心对待可变的状态】: 不变性和无副作用

3.Types【类型】

其实上面的3点在我上篇文章已经详细介绍了。

Thinking Functionally  ----- 函数式编程思想,这是本书的第二章

Functions in Swift are first-class values

下面我们根据书中的例子来阐述下本章的主要内容:

1. 判断一个Point是不是在圆心为(0,0)半径为r的圆上

swift之函数式编程(二)

typealias Position = CGPoint 
typealias Distance = CGFloat
func inRange1(target: Position, range: Distance) -> Bool {
return sqrt(target.x * target.x + target.y * target.y) <= range
}

2. 判断一个点是不是在圆心不在(0,0),半径为range的圆上

swift之函数式编程(二)

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
}

3.判段一个Point是不是在一个圆环上。

swift之函数式编程(二)

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
}

4. 判断一个Point是不是在圆环的grey部分,并且与一个Frendly【有点像护航船】点的距离至少为 minimumDistance

swift之函数式编程(二)

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)
}

这个时候你会发现inRange这个方法是变得越来越难维持了。复杂而又臃肿的代码块。然后一起来重构:

First-Class Functions

这个问题的源头是归结于定义一个判断一个Point是不是在圆上的Function。

func pointInRange(point: Position)->Bool{

  // Implement method here

}

这个方法会在以后变得越来越重要,所以我们把它取过一个单独的名字

typealias Region = Position -> Bool

从现在开始,Region 将指from a Position to a Bool的一个function,虽然这不是必要的,但他可以使得默写类型的签名更容易理解。

通过一个函数来确定一个给定的点是不是在该区域内,而不是通过类或者结构体。如果你之前没有使用过函数式编程,会看起来比较陌生,但是记住:函数在swift中第一类型值(functions in Swift are first-class values! )。决定用Region来命名这个类型,而不通过像CheckIngRegion 或者RegionBlock。因为这些名字所暗示着他们是一个函数类型,但函数式编程的关键的理念是  函数就是值,无异于Structs,intergers,booleans,使用那些具有功能性质的名字违反了这一约定。

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

当然不是所有的circle的圆心都在原点,这个时候:

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)
}
}

有趣的是,有很多方法去改变现有的regions。比如,我们如果想定义一个新的region通过 翻转一个region。这个最终region是当前 region之外的所有region:

func invert(region: Region) -> Region {
return { point in !region(point) }
}

当然我们也可以组合现有的region更大更复杂的region中,比如,下面的两个方法

 func intersection(region1: Region, region2: Region) -> Region { // 圆的交
return { point in region1(point) && region2(point) }
}
func union(region1: Region, region2: Region) -> Region { // 圆的并
return { point in region1(point) || region2(point) }
}

当然,我们也可以通过上面的方法去定义更加丰富的region。下面的defference 函数中,有两个参数region 和 minusRegion,and constructs a region with all points that are in the first, but not in the second, region:   不在minuRegion且与region相交

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

 这些例子表明 用swift使用functions 计算和传参跟Intergers或者booleans没有区别

 最后我们的inRange代码是:

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)
}

当然这也有作者的一句话:

The way we’ve defined the Region type does have its disadvantages. In particular, we cannot inspect how a region was constructed: Is it com- posed of smaller regions? Or is it simply a circle around the origin? The only thing we can do is to check whether a given point is within a region or not. If we would want to visualize a region, we would have to sample enough points to generate a (black and white) bitmap.

Type-Driven Development