Swift 标准库的 `AdditiveArithmetic` 协议:SE-0233 设计解析与泛型数值编程实践

原创2026-09-21 16:45:572,296 阅读
文章标签:文档编程语言

Swift 标准库的 AdditiveArithmetic 协议:SE-0233 设计解析与泛型数值编程实践

本篇指南以 SE-0233 提案(Make Numeric Refine a new AdditiveArithmetic Protocol)为骨架展开。该提案由 Richard Wei 撰写、Chris Lattner 担任审核经理,最终随 Swift 5.0 落地为标准库实现,是理解 Swift 数值协议层级、为向量/矩阵等自定义类型设计算术 API 的关键起点。读完本文,你将掌握 AdditiveArithmetic 的设计动机、协议完整定义、Numeric 协议族的演变方式,以及它在后续提案(如 DurationProtocol、Int128)中的真实应用。

一、为什么要拆分 Numeric:三个核心痛点

在 SE-0233 之前,Swift 标准库中的 Numeric 协议同时细化了 ExpressibleByIntegerLiteral(整数字面量可表达)并定义了全部算术运算符。对标量类型(Int、Double 等)来说这非常方便;但对向量(vector)类型来说,直接遵守 Numeric 会在数学语义、字面量转换和类型推断三个层面出现问题。

1. 向量遵守 Numeric 在数学上不正确

Numeric 大致对应数学中的**环(ring)**概念——环要求元素之间存在乘法。但向量空间(vector space)不是环:向量与向量之间的乘法并未定义。提案明确指出,Numeric 中的乘法要求会让向量类型与数学定义相矛盾:

static func * (lhs: Self, rhs: Self) -> Self
static func *= (lhs: inout Self, rhs: Self)

让一个向量类型声明"自己可以乘自己",既不符合向量空间的数学结构,也会诱导用户写出语义错误的代码。

2. 动态形状向量的字面量转换未定义

向量可以是动态形状的(dynamically shaped),即形状(shape)需要在从标量初始化向量时提供。动态形状向量类型通常有 init(repeating:shape:) 这样的初始化器。

但遵守 Numeric 就必须遵守 ExpressibleByIntegerLiteral,进而必须实现 init(integerLiteral:)。问题在于:在没有给定形状的情况下,从标量到动态形状向量的转换本身是不明确的。

struct Vector<Scalar: Numeric>: Numeric {
  // 没问题!
  init(repeating: Scalar, shape: [Int]) { ... }

  // 形状是什么?
  init(integerLiteral: Int)
}

3. 运算符重载引发类型检查歧义

向量在数学上属于向量空间。向量之间没有乘法定义,但**标量乘法(scalar multiplication)**必须存在:

static func * (lhs: Vector, rhs: Scalar) -> Vector { ... }

而在机器学习等数值计算社区中,大量库又习惯把向量之间的 * 定义为逐元素乘法(element-wise multiplication)。于是 * 被同时重载为:

static func * (lhs: Vector, rhs: Vector) -> Vector { ... }
static func * (lhs: Vector, rhs: Scalar) -> Vector { ... }

这段代码能编译,但实际无法使用。看下面这个最普通的用例:

let x = Vector<Int>(...)
x * 1 // 歧义!既可以是 x * Vector(integerLiteral: 1),也可以是 x * (1 as Int)

字面量 1 既能被隐式转换为 Scalar,也能被转换为 Vector(因为 Vector 遵守 Numeric 就默认可以表达整数字面量),而 * 对两者都有重载,于是类型检查器无法抉择。这正是 Numeric 细化 ExpressibleByIntegerLiteral 带来的连锁后果。

二、解决方案:引入 AdditiveArithmetic

提案的核心思路是:保持 Numeric 的行为与要求不变,同时引入一个新协议,它——

  • 不要求遵守 ExpressibleByIntegerLiteral;
  • 在向量与标量之间共享公共属性和运算符。

要找到这样一个数学概念,既贴近实际、又不必引入不必要的抽象代数体系,最合适的就是加法群(additive group):包含一个零元素(zero)以及 Numeric 上已有的全部加法运算符。Numeric 将细化这个新协议;向量类型/协议也会遵守/细化它。

三、详细设计:协议定义与标准库改造

1. AdditiveArithmetic 的完整定义

新协议要求所有加法算术运算符(即当时 Numeric 已要求的那些)以及一个零值。零是加法群的基本属性:

public protocol AdditiveArithmetic: Equatable {
  /// 零值。
  static var zero: Self { get }

  /// 将两个值相加并产生它们的和。
  ///
  /// 加法运算符(`+`)计算其两个参数的和。例如:
  ///
  ///     1 + 2                   // 3
  ///     -10 + 15                // 5
  ///     -15 + -5                // -20
  ///     21.5 + 3.25             // 24.75
  ///
  /// 不能用 `+` 对不同类型的参数进行运算。要对不同类型求值,
  /// 请先将其中一个值转换为另一个值的类型。
  ///
  ///     let x: Int8 = 21
  ///     let y: Int = 1000000
  ///     Int(x) + y              // 1000021
  ///
  /// - Parameters:
  ///   - lhs: 第一个要相加的值。
  ///   - rhs: 第二个要相加的值。
  static func + (lhs: Self, rhs: Self) -> Self

  /// 将两个值相加并把结果存回左侧变量。
  ///
  /// - Parameters:
  ///   - lhs: 第一个要相加的值。
  ///   - rhs: 第二个要相加的值。
  static func += (lhs: inout Self, rhs: Self) -> Self

  /// 从一个值中减去另一个值并产生它们的差。
  ///
  /// 减法运算符(`-`)计算其两个参数的差。例如:
  ///
  ///     8 - 3                   // 5
  ///     -10 - 5                 // -15
  ///     100 - -5                // 105
  ///     10.5 - 100.0            // -89.5
  ///
  /// 不能用 `-` 对不同类型的参数进行运算。要对不同类型求值,
  /// 请先将其中一个值转换为另一个值的类型。
  ///
  ///     let x: UInt8 = 21
  ///     let y: UInt = 1000000
  ///     y - UInt(x)             // 999979
  ///
  /// - Parameters:
  ///   - lhs: 一个数值。
  ///   - rhs: 要从 `lhs` 中减去的值。
  static func - (lhs: Self, rhs: Self) -> Self

  /// 从第一个值中减去第二个值并把结果存回左侧变量。
  ///
  /// - Parameters:
  ///   - lhs: 一个数值。
  ///   - rhs: 要从 `lhs` 中减去的值。
  static func -= (lhs: inout Self, rhs: Self) -> Self
}

注意 += 和 -= 的签名:它们以 inout Self 修改左侧操作数并返回 Self(这是 Swift 运算符协议的标准写法,便于链式/表达式组合)。协议还细化了 Equatable,因为加法群的元素必须可判定相等。

2. Numeric 协议的改造

从 Numeric 中移除算术运算符要求,并让它细化 AdditiveArithmetic。改造后的 Numeric 只保留乘法、幅值(magnitude)与整数转换相关要求:

public protocol Numeric: AdditiveArithmetic, ExpressibleByIntegerLiteral {
  associatedtype Magnitude: Comparable, Numeric
  init?<T>(exactly source: T) where T : BinaryInteger
  var magnitude: Self.Magnitude { get }
  static func * (lhs: Self, rhs: Self) -> Self
  static func *= (lhs: inout Self, rhs: Self) -> Self
}

这样一来,Numeric 不再要求所有数值类型都具备乘法(环结构),加法部分下沉到了更基础的协议层。

3. 为现有数值类型自动提供 zero

为了让当时已遵守 Numeric 的类型不必重新实现 zero,提案为 AdditiveArithmetic 提供了一个约束在 Self: ExpressibleByIntegerLiteral 上的扩展:

extension AdditiveArithmetic where Self: ExpressibleByIntegerLiteral {
  public static var zero: Self {
    return 0
  }
}

即:只要一个类型能用整数字面量表达,它的 zero 就直接取字面量 0。Int、Double、Float 等现有类型因此零成本获得 zero 实现,保持了源码兼容。

4. 一元正号 + 下沉到 AdditiveArithmetic

标准库中原本由 Numeric 的扩展提供前缀 +(一元正号)。由于加法运算现在定义在 AdditiveArithmetic 上,该扩展也随之迁移:

extension AdditiveArithmetic {
  /// 原样返回给定数值。
  ///
  /// 一元加号运算符(`+`)可以在正数代码中使用,
  /// 与一元减号运算符保持对称。
  ///
  ///     let x = -21
  ///     let y = +21
  ///     // x == -21
  ///     // y == 21
  ///
  /// - Returns: 原样返回给定参数。
  public static prefix func + (x: Self) -> Self {
    return x
  }
}

这意味着任何只支持加法运算的向量类型,也能免费获得一元 +,而无需特意实现。

四、仓库中的后续应用:从提案到标准库实践

SE-0233 落地后,AdditiveArithmetic 成为 Swift 标准库数值协议栈的基石,本仓库中多个后续提案都在真实地复用这一协议。

1. SE-0329:DurationProtocol 直接细化 AdditiveArithmetic

在 时钟与持续时间提案(SE-0329)中,DurationProtocol 被定义为:

public protocol DurationProtocol: Comparable, AdditiveArithmetic, Sendable {
  // ... 此外还要求与二进制整数做除法、乘法等
}

提案专门解释了为什么 InstantProtocol 不遵守 AdditiveArithmetic:该协议要求把两个瞬时值相加并定义零值,而零值来自时钟、无法对所有 InstantProtocol 类型静态获知。反过来,Duration 的加法语义天然符合加法群,所以 extension Duration: AdditiveArithmetic { } 直接采用。这正好印证了 SE-0233 的设计初衷——用 AdditiveArithmetic 表达"支持加法运算"这一最小公共能力。

2. SE-0425:Int128 的数值协议栈

在 Int128 提案(SE-0425)中,新整数类型按标准库惯例依次遵守 AdditiveArithmetic 与 [Signed]Numeric,说明 AdditiveArithmetic 已成为所有标准数值类型必须经过的第一层协议。

3. SE-0358:AdditiveArithmetic 位列主关联类型名单

在 标准库主关联类型提案(SE-0358)中,AdditiveArithmetic 与 Equatable、Hashable、Comparable、Error 等一同被列为主关联类型(primary associated types)场景中的核心协议——这些协议是泛型编程中最常被用作约束的抽象。

4. SE-0368:一元 + 与 StaticBigInt 的关系

在 StaticBigInt 提案(SE-0368)中,作者特别说明:为 StaticBigInt 定义前缀 + 时不再选择 AdditiveArithmetic 上的一元 + 泛型实现,因为具体重载优先于泛型重载。这从侧面说明 SE-0233 将一元 + 放入 AdditiveArithmetic 扩展后,确实被标准库内部广泛继承使用。

五、兼容性与 ABI 影响

源码兼容性(Source compatibility)

提案声称改动完全源码兼容。核心原因在于:所有要求都是新增(zero 的默认实现由扩展兜底),原有 Numeric 的算术运算符要求被保留在 AdditiveArithmetic 中,只是协议层级发生了重组;既有遵守 Numeric 的代码无需任何修改。

ABI 稳定性(ABI stability)

提案明确承认该改动会影响标准库现有 ABI——因为它改变了协议层级(protocol hierarchy)与协议要求(protocol requirements)。因此该协议必须在 Swift 5 分支(branching date)之前敲定。这与 Swift 5.0 发布说明 的主题完全吻合:Swift 5 的首要目标是 ABI 稳定性,所有涉及标准库协议层级的改动都需要在冻结 ABI 前完成。事实上,SE-0233 正是 Swift 5 之前最终敲定的标准库协议设计之一。

API 韧性(API resilience)

同理,该改动会影响现有 ABI,且无法避免——因为它改变了协议层级和协议要求,属于不可逆的结构性变化,这也是它必须赶在 Swift 5 ABI 冻结前落地的根本原因。

六、备选方案:为什么最终选择了 AdditiveArithmetic

提案讨论并否决了三个备选设计,理解这些权衡有助于把握协议设计的边界:

  1. 让 Numeric 不再细化 ExpressibleByIntegerLiteral,但不引入新协议。 这确实能解决向量协议的类型检查歧义,但会破坏现有代码——泛型于 Numeric 的函数可能依赖整数字面量初始化。Steve Canon 还指出这在数学上也不准确:从整数到每个带单位环(ring with unity)都存在一个典范同态(canonical homomorphism)。此外,让向量类型遵守 Numeric 以获得算术运算符是合理的,但让向量(尤其是固定秩向量)可被整数字面量表达则并不常见。

  2. 在 AdditiveArithmetic 之上再增加一个细化它的 MultiplicativeArithmetic,让 Numeric 细化它。 这是 AdditiveArithmetic 的自然延伸,但其实际收益在当时并不明确,故被搁置(后续 Swift 社区确实演进出了 swift-numerics 包中的 AdditiveArithmetic 等扩展,但那是另一个仓库的实践)。

  3. 用 init() 取代 zero 静态计算属性。 这更贴合 Swift 偏爱初始化器的风格,但会强制所有遵守类型提供 init(),在某些场景下会产生误导。例如 Matrix() 到底创建的是零矩阵还是单位矩阵?写成 zero 则彻底消除了这种歧义——Matrix.zero 的语义一目了然。

七、实践要点总结

对今天编写 Swift 代码的你,SE-0233 留下的关键经验可以浓缩为四点:

  1. 区分"数"与"加法空间":只要类型支持加法、减法并存在零元素,就遵守 AdditiveArithmetic,而不是贸然遵守 Numeric。向量、矩阵、Duration 这类"能加但不能乘"的类型,都该落在 AdditiveArithmetic 这一层。
  2. 不要因 Numeric 被迫实现字面量初始化:动态形状类型(如 Vector<Scalar>)遵守 Numeric 会带来 init(integerLiteral:) 的形状歧义;改为遵守 AdditiveArithmetic 即可避免,同时仍能参与泛型算法。
  3. 泛型约束用最弱抽象:编写求和、均值、差等泛型算法时,用 T: AdditiveArithmetic 做约束,可以让标量(Int、Double)与向量类型共用同一套代码,这正是提案最初"让泛型算法同时适用于标量与向量"的目标。
  4. zero 的默认行为:任何遵守 ExpressibleByIntegerLiteral 的类型会自动获得 zero == 0 的实现;对于无法用整数字面量表达的加法空间类型,则需自行提供有明确语义的 zero(例如零矩阵),避免使用含义模糊的 init()。

SE-0233 是 Swift 标准库数值抽象走向成熟的重要一步:它把"环"与"加法群"清晰地分层,既解决了向量类型无法干净遵守 Numeric 的工程痛点,也为后续 Duration、Int128 等类型的协议设计提供了可复用的基础架构。

登录后查看全文
swift-evolution