为什么编译器看不到协议中的默认代码？

Question

编辑：我已经重申并希望通过here 澄清这个问题。现在我已经添加了解决方案。

我已经定义了一个函数（参见附件示例中的foo()）作为structs 采用我的protocol 的默认函数。它应用了针对其他两个变量定义的 + 运算符，这些变量本身采用其他 protocols 和 + 在其中一个协议中定义。变量使用associatedtypes 输入。 我收到消息：

二元运算符“+”不能应用于“Self.PointType”和“Self.VectorType”类型的操作数

如果我在 struct 中实现该函数（参见附件中的 bar()），它可以工作，所以我确信我的 + 运算符可以工作。 我的例子被缩减到在操场上工作所需的最低限度。只需删除 LineProtocol extension 中的 cmets 即可获得错误。在我看来，Self.PointType 是 Point 而Self.VectorType 是 Vector。

明确一点：我使用associatedtypes 的原因是因为许多不同的structs 采用了示例中的三个协议中的每一个，所以我无法直接命名它们

public protocol 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())

根据@Honey 的建议改编的解决方案： 将扩展替换为：

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

Answer 1

我知道问题出在哪里。不确定我的解决方案是否是最佳答案。

问题在于您的两个关联类型本身都有关联类型。

所以在扩展中，Swift 编译器无法确定关联类型的类型——除非你对其进行约束。

喜欢做：

extension LineProtocol where Self.VectorType == Vector, Self.PointType == Point {
    public func foo() -> Self.PointType {
      return (anchor + direction)
   }
}

您的代码适用于您的具体类型Line，因为您的两个关联类型都满足了它们的要求，即：

public typealias PointType = Point // makes compiler happy!
public typealias VectorType = Vector  // makes compiler happy!

FWIW，您本可以摆脱与您的 associatedtype 要求的显式一致性，让编译器推断¹ 符合您的 associatedtypes 要求，并这样编写您的 Line 类型：

public struct Line: LineProtocol {

   public var anchor: Point
   public var direction: Vector

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

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

---

1：Generics - Associated Types

感谢 Swift 的类型推断，您实际上不需要声明 Int 的具体项目作为 IntStack 定义的一部分。因为 IntStack 符合 Container 的所有要求 协议，Swift 可以推断出要使用的适当项目，只需通过 查看 append(_:) 方法的 item 参数的类型和 返回下标的类型。事实上，如果你删除 typealias Item = 上面代码中的 int 行，一切仍然有效，因为很清楚应该为 Item 使用什么类型。