作者:Ole Begemann,原文链接,原文日期:2016/07/29
译者:钟颖;校对:小铁匠Linus;定稿:CMB

更新:
2016-08-02 已将代码更新至 Xcode 8 Beta 4

本系列其他文章:

(1) Measurements 和 Units 概览

(2) 乘法和除法

(3) 内容提炼(本文)

(4) 幽灵类型

Swift 中 Measurements 和 Units 的系列文章中,仍然有一些收尾工作要做。如果你还没有看过之前的文章的话,可以在第一部分中找到 Foundation 框架中 Measurements 和 Units 接口的大致介绍,并在第二部分中看到我如何扩展该系统用于类型安全的乘法和除法。

在计算过程中保持单位

在我们之前的文章里面,乘法和除法在计算之前总是会将单位转换到各自的默认单位,正如我们在 UnitProduct 协议的 defaultUnitMapping() 方法定义的那样。为了让结果在各种计算场景下都正确,无论传入参数的单位是什么。

到目前为止,我们仍然使用一个默认的单位映射作为计算结果的单位。比如说,UnitSpeedUnitDurationUnitLength 的映射是 (.metersPerSecond, .seconds, .meters)。这意味着 72 千米每 2 小时 将会在计算前被转换成 72000 米每 7200 秒。然后我们会将计算结果封装成 Measurement<UnitVelocity> 并且返回,它的单位将会是米每秒。

从实现的角度来说这是一个最简单的方案,但是可以想象的是,方法的调用者会更希望在计算中尽可能保持单位一致。如果我输入米和秒,则尽可能的返回米每秒,但是如果我输入千米和小时,则希望返回千米每小时。

首选单位映射

我们可以在协议里面添加一个新的方法来实现这个目标,这个方法会通过优先级排序返回一个单位映射的集合。在计算的时候我们通过遍历这个集合,为当前的计算找出最合适的单位映射。如果没有匹配到,则回退到默认的单位映射。我把这个方法叫做 preferredUnitMappings()。完整的协议看起来像是这样:

protocol UnitProduct {
associatedtype Factor1: Dimension
associatedtype Factor2: Dimension
associatedtype Product: Dimension

static func defaultUnitMapping() -> (Factor1, Factor2, Product)
static func preferredUnitMappings() -> [(Factor1, Factor2, Product)]
}

我们需要提供一个返回空数组的默认实现,这样的话如果协议的实现者不需要这个功能,他也可以选择忽略这个方法。

extension UnitProduct {
// 默认实现
static func preferredUnitMappings() -> [(Factor1, Factor2, Product)] {
return []
}
}

接下来,我们需要提供一系列的便捷方法,他们的功能是为乘法或者除法的参数匹配出合适的单位映射。这个方法需要三个重载的形式,取决于 Factor1Factor2Product 三个参数是哪两个组成一对。他们的工作原理是相同的:返回在 preferredUnitMappings 列表里面同时匹配两个参数的第一个结果。如果没有匹配的话,返回默认的单位映射。我们使用 Swift 3 里面 Sequence 的新方法 first(where:) 来实现这个功能:

extension UnitProduct {
static func unitMapping(factor1: Factor1, factor2: Factor2) -> (Factor1, Factor2, Product) {
let match = preferredUnitMappings().first { (f1, f2, _) in
f1 == factor1 && f2 == factor2
}
return match ?? defaultUnitMapping()
}

static func unitMapping(product: Product, factor2: Factor2) -> (Factor1, Factor2, Product) {
let match = preferredUnitMappings().first { (_, f2, p) in
p == product && f2 == factor2
}
return match ?? defaultUnitMapping()
}

static func unitMapping(product: Product, factor1: Factor1) -> (Factor1, Factor2, Product) {
let match = preferredUnitMappings().first { (f1, _, p) in
p == product && f1 == factor1
}
return match ?? defaultUnitMapping()
}
}

在计算中使用首选单位映射

最后,我们可以修改乘法和除法来使用这个新功能。计算过程本身没有任何变化,我们还是通过默认的单位进行计算。但是在返回结果之前,我们将其转换到我们首选的单位映射。如下是除法的代码(实现另一个重载方法的实现是类似的):

/// UnitProduct / Factor2 = Factor1
public func / <UnitType: Dimension> (lhs: Measurement<UnitType>, rhs: Measurement<UnitType.Factor2>)
-> Measurement<UnitType.Factor1> where UnitType: UnitProduct, UnitType == UnitType.Product {

// 使用默认单位进行计算
let (resultUnit, rightUnit, leftUnit) = UnitType.defaultUnitMapping()
let value = lhs.converted(to: leftUnit).value / rhs.converted(to: rightUnit).value
let result = Measurement(value: value, unit: resultUnit)

// 转换到首选的单位
let (desiredUnit, _, _) = UnitType.unitMapping(product: lhs.unit, factor2: rhs.unit)
return result.converted(to: desiredUnit)
}

一切准备就绪,我们可以为 UnitLength 实现 preferredUnitMappings() 这个方法,他实现了 UnitProduct 这个协议:

extension UnitLength {
static func preferredUnitMappings() -> [(UnitSpeed, UnitDuration, UnitLength)] {
return [
(.kilometersPerHour, .hours, .kilometers),
(.milesPerHour, .hours, .miles),
(.knots, .hours, .nauticalMiles)
]
}
}

现在,计算过程中匹配到合适单位的将会得到保留(会带有一点舍入误差):

Measurement(value: 72, unit: UnitLength.kilometers) / Measurement(value: 2, unit: UnitDuration.hours)
// → 35.999971200023 km/h
Measurement(value: 10, unit: UnitLength.miles) / Measurement(value: 1, unit: UnitDuration.hours)
// → 9.99997514515231 mph
Measurement(value: 25, unit: UnitLength.nauticalMiles) / Measurement(value: 2, unit: UnitDuration.hours)
// → 12.5000107991454 kn

这是一个好主意吗?

我不太确定这个方案是不是真的是一个好想法。他使代码变得相当的复杂,但是收益可以说是很小的。而且在每一次计算时,枚举首选单位列表会使代码变得慢一点点^1,这可能在循环中会是个问题。但像我们在这里做的这种简单的计算应该尽可能的快。

乘方的问题

如果你使用过 UnitProduct 这个协议的话,可能发现它并不能应用于物理量的乘方,也就是说,Factor1Factor2 类型相同的情况。面积 = 长度 × 长度 是一个很好的例子:

extension UnitArea: UnitProduct {
typealias Factor1 = UnitLength
typealias Factor2 = UnitLength
typealias Product = UnitArea

static func defaultUnitMapping() -> (UnitLength, UnitLength, UnitArea) {
return (.meters, .meters, .squareMeters)
}
}

如果我们尝试执行两个长度的乘法时,编译器会因为 * 运算符的歧义而报错。

let width = Measurement(value: 4, unit: UnitLength.meters)
let height = Measurement(value: 6, unit: UnitLength.meters)
let area: Measurement<UnitArea> = width * height
// error: Ambiguous use of operator '*'

原因是我们有两个乘法重载运算符,一个是 (Factor1, Factor2) -> Product 另一个是 (Factor2, Factor1) -> Product。当 Factor1Factor2 类型相同的时候,这两个重载方法的类型是一模一样的,编译器不知道应该调用哪个,所以就会报错。(在我们的场景中,两个方法都是对的,他们能算出同一个结果,但是编译器并不知道这一点)

最好的解决方案是,我们能够给其中一个方法添加一个通用的约束,类似于 Factor1 != Factor2,可以让类型检查在参数类型相同的时候将其区分开来。像这样:

func * <UnitType: Dimension> (...) -> ...
where UnitType: UnitProduct, UnitType == UnitType.Product, UnitType.Factor1 != UnitType.Factor2
// error: Expected ':' or '==' to indicate a conformance or same-type requirement

遗憾的是,Swift 并不支持这样的语法,Swift 的 where 语句只能包含 :==

单独给乘方的协议

我们通过引入一个单独的协议,UnitSquare 协议,来解决这个问题,用于定义乘方关系。这个协议只需要两个 associated 类型,FactorProduct

protocol UnitSquare {
associatedtype Factor: Dimension
associatedtype Product: Dimension

static func defaultUnitMapping() -> (Factor, Factor, Product)
static func preferredUnitMappings() -> [(Factor, Factor, Product)]
}

我们在这里就不展开其具体实现了,因为这个协议和 UnitProduct 很大程度上是相同的。(他的乘法和除法重载都只需要一个,相反的是 UnitProduct 需要两个。)

如果我们将 UnitArea 遵循 UnitSquare,那么这些计算就能符合我们的预期:

extension UnitArea: UnitSquare {
typealias Factor = UnitLength
typealias Product = UnitArea

static func defaultUnitMapping() -> (UnitLength, UnitLength, UnitArea) {
return (.meters, .meters, .squareMeters)
}
}

let width = Measurement(value: 4, unit: UnitLength.meters)
let height = Measurement(value: 6, unit: UnitLength.meters)
let area: Measurement<UnitArea> = width * height
// → 24.0 m²
area / width
// → 6.0 m
area / height
// → 4.0 m

自身相除

谜题的最后一部分,我想应该是实现两个相同类型的除法,比如说 6 米 / 4 米 = 1.5。计算结果应该是一个没有单位的量(换句话说是一个 Double 类型),并且对所有的 Dimension 类型都是可以有效的。

支持这一特性十分简单,我们只需要再增加一个重载的除法。可以描述为:输入两个相同 Dimension 的量,返回一个 Double 值。我们通过将两个量都转换成基本类型来实现这个除法:

func / <UnitType: Dimension> (lhs: Measurement<UnitType>, rhs: Measurement<UnitType>) -> Double {
return lhs.converted(to: UnitType.baseUnit()).value / rhs.converted(to: UnitType.baseUnit()).value
}

let ratio = height / width
// → 1.5

代码

我将在本系列文章中讨论到的所有代码放到了一个叫 Ampere 的库里面,你可以在 GitHub 上面找到。这个工作正在进展中,我还没有将其变成一个“真正的”库,类似于加入版本控制以及支持 CocoaPods,因为我不知道社区会不会对这些内容感兴趣。所以,让我知道你的想法吧!

本文由 SwiftGG 翻译组翻译,已经获得作者翻译授权,最新文章请访问 http://swift.gg

文章目录
  1. 1. 在计算过程中保持单位
  2. 2. 首选单位映射
  3. 3. 在计算中使用首选单位映射
  4. 4. 这是一个好主意吗?
  5. 5. 乘方的问题
  6. 6. 单独给乘方的协议
  7. 7. 自身相除
  8. 8. 代码