如何访问在协议中声明为默认值的 function 并使用来自另一个协议的关联类型？

Question

昨天我问了一个问题。 这是一个尝试将 state 的问题更清楚。

上下文：

我有一个struct家族（称为 Vector2D、Vector3D 等），它们表示各种维度的向量。 它们的实现非常相似，但由于 inheritance 不适用于struct我使用protocol （VectorProtocol），它使我能够将默认成员函数编写为protocol extensions ，而不是为每个struct重复它们。

同样，我有一系列struct （称为 Point2D、Point3D 等），它们表示各种维度的点。 它们的实现也非常相似，所以出于同样的原因我使用了另一个协议（PointProtocol）。

在每种情况下，协议都使用associatedtype来标识特定的struct实例类型。

有时 PointxDs 和 VectorxDs 交互，因此PointProtocol也有一个associatedtype类型来识别它需要处理的特定 VectorxD，而VectorProtocol有一个associatedtype类型来识别它需要处理的特定 PointxD。

到目前为止，一切正常，包括点和向量之间的交互。 例如，两个点之间的差异是一个向量，一个点和一个向量的总和是一个点，我可以定义一次运算符来处理每个维度的这些情况，如下所示：

public protocol PointProtocol {
    associatedtype VectorType: VectorProtocol
    /*    etc.  */
}

extension PointProtocol {
    public static func +(lhs: Self, rhs: VectorType) -> Self { /*…*/ }
    public static func -(lhs: Self, rhs: Self) -> VectorType { /*…*/ }
}

问题：

现在我想添加更多的struct家族（称为 Line2D、Line3D 等），它们表示各种维度的线并与点和向量交互。 我以为我在做更多相同的事情，但有细微的差别。 线由点和向量组成。

public protocol LineProtocol {
    associatedtype PointType: PointProtocol
    associatedtype VectorType: VectorProtocol
    var anchor: PointType { get set }
    var direction: VectorType { get set }
}

public struct Line2D: LineProtocol {
    public typealias PointType = Point2D
    public typealias VectorType = Vector2D
    var anchor: PointType
    var direction: VectorType
    public init(anchor: Point2D, direction:Vector2D) { … }
}

例如，在使用 Point2D 和 Vector2D 构建 Line2D 时，这不会造成任何问题。 但是，当涉及到这个默认声明时，编译器会犹豫：

extension LineProtocol {
    public func endOfLineSegment() -> PointType {
        return (anchor + direction)    // Compiler ERROR
            // Binary operator '+' cannot be applied to operands of type
            // 'Self.PointType' and 'Self.VectorType'
    }
}

看起来编译器无法找到运算符声明public static func +(lhs: PointType, rhs: VectorType) -> PointType即使anchor显然是PointProtocol类型并且方向显然是VectorProtocol类型。 所以我认为endOfLineSegment()知道 anchor 和 direction 分别是 PointType 和 VectorType ，这意味着它也应该知道它们是 PointProtocol 和 Vector Protocol ，但它不知道如何为这些协议设置两个associatedtype 。

有人知道如何解决这个问题吗？ （无需在每个有效的struct声明中单独实现 function）

下面找到足够的最小代码来在操场上生成错误

public protocol PointProtocol {
   associatedtype PointType: PointProtocol
   associatedtype VectorType: VectorProtocol
   var elements: [Float] { get set }
}

extension PointProtocol {
   public static func +(lhs: Self, rhs:VectorType) -> Self {
      var translate = lhs
      for i in 0..<2 { translate.elements[i] += rhs.elements[i] }
      return translate
   }
}

public protocol VectorProtocol {
   associatedtype VectorType: VectorProtocol
   var elements: [Float] { get set }
}

public struct Point: PointProtocol {
   public typealias PointType = Point
   public typealias VectorType = Vector
   public var elements = [Float](repeating: 0.0, count: 2)

   public init(_ x: Float,_ y: Float) {
      self.elements = [x,y]
   }
}

public struct Vector: VectorProtocol {
   public typealias VectorType = Vector
   public static let dimension: Int = 2
   public var elements = [Float](repeating:Float(0.0), count: 2)

   public init(_ x: Float,_ y: Float) {
      self.elements = [x,y]
   }
}

public protocol LineProtocol {
   associatedtype PointType: PointProtocol
   associatedtype VectorType: VectorProtocol
   var anchor: PointType { get set }
   var direction: VectorType { get set }
}

extension LineProtocol {
   public func foo() -> PointType {
      return (anchor + direction)
   }
}

public struct Line: LineProtocol {
   public typealias PointType = Point
   public typealias VectorType = Vector
   public var anchor: PointType
   public var direction: VectorType

   public init(anchor: Point, direction: Vector) {
      self.anchor = anchor
      self.direction = direction
   }

   public func bar() -> Point {
      return (anchor + direction)
   }
}

let line = Line(anchor: Point(3, 4), direction: Vector(5, 1))
print(line.bar())
//print(line.foo())

Answer 1

事实证明，这只是导致问题的 VectorType，可以通过添加此约束来解决！

extension LineProtocol where Self.VectorType == Self.PointType.VectorType {
    // Constraint passes VectorType thru to the PointProtocol
    public func endOfLineSegment() -> PointType {
        return (anchor + direction)
    }
}