我希望编写的代码允许我像这样在不同类型之间建立绑定(bind):

Map.add(1.0).to(CGPointZero) // (x:1.0, y:1.0)

这是一个人为的例子，但如果它可以工作，可能是一种捕捉关系的好方法。在 C++ 中，这将是直截了当的，您将创建如下内容:

class Binding<typename FromType> {

    FromType from;

    to<typename ToType>(ToType toType) {
        return from + toType
    }
}

class Map {

     Binding<T> add<T>(t:T) {
        return Binding<T>(t:t)
    }
}

编译器会判断是否可以添加这些类型。

不过，Swift 是另一种动物，您需要在使用协议(protocol)类型之前捕获这种关系。它可能看起来像这样:

public protocol ScalarArithmetic {
    typealias SomeScalarType

     func +(lhs: SomeScalarType, rhs: Self) -> Self
}

//  Double + CGPoint
public func + (lhs:Double, rhs:CGPoint) -> CGPoint {
    return CGPoint(x: rhs.x + CGFloat(lhs), y:rhs.y + CGFloat(lhs))
}

//  Float + CGPoint
public func + (lhs:Float, rhs:CGPoint) -> CGPoint {
    return CGPoint(x: rhs.x + CGFloat(lhs), y:rhs.y + CGFloat(lhs))
}


class Binding<T> {
    var from: T

    init(t:T) { self.from = t }

    func to<S:ScalarArithmetic where S.SomeScalarType == T>(s:S) -> S {
        return self.from + s
    }
}

class Map {

    class func add<T>(t:T) -> Binding<T> {
        return Binding<T>(t:t)
    }
}

但问题是如何绑定(bind)类型 - 让我们以 CGPoint 为例，使用多个标量类型，因此上述机制可用于一系列绑定(bind)(如上面的 C++ 示例)。

这行不通，因为编译器不喜欢重复的语句:

extension CGPoint : ScalarArithmetic {
    typealias SomeScalarType = Double

}

extension CGPoint : ScalarArithmetic {
    typealias SomeScalarType = Float
}

我尝试在它自己的协议(protocol)中捕获标量类型——也许这就是实现它的方式，但它把问题推向了道路:

public protocol SomeScalarType {}
extension Double: SomeScalarType {}
extension Float: SomeScalarType {}

public protocol ScalarArithmetic {
    func +(lhs: SomeScalarType, rhs: Self) -> Self
}

//  Double + CGPoint
public func + (lhs:Double, rhs:CGPoint) -> CGPoint {
    return CGPoint(x: rhs.x + CGFloat(lhs), y:rhs.y + CGFloat(lhs))
}

//  Float + CGPoint
public func + (lhs:Float, rhs:CGPoint) -> CGPoint {
    return CGPoint(x: rhs.x + CGFloat(lhs), y:rhs.y + CGFloat(lhs))
}

extension CGPoint: ScalarArithmetic {} // does not conform to ScalarArithmetic
// since it is not implemented in terms of the ScalarArithmetic protocol,
// despite having the necessary operators.

所以为了让自己接受我自己的答案，是否留下唯一的选择，使 ScalarType “足够可转换”，它可以转换为所需的原始类型:

public func + (lhs:SomeScalarType, rhs:SomeScalarType) -> CGPoint {
    return CGPoint(x: rhs.x + CGFloat(lhs), y:rhs.y + CGFloat(lhs))
}

我该怎么做，和/或有更好的解决方案吗？

提前致谢。

最佳答案

Swift 有意不为你强制转换类型。这是一种语言选择，绕过它会很困难。您不能 + 任意数字类型。您的 C++ 示例之所以有效，是因为可以添加任意数量的东西，而在 Swift 中则不能。

IMO，对于您要执行的操作，正确答案是:

public func + (lhs:Double, rhs:CGPoint) -> CGPoint {
    return CGPoint(x: rhs.x + CGFloat(lhs), y:rhs.y + CGFloat(lhs))
}

句号。但是附加到 + 是一件很糟糕的事情。您不能有意义地 + 标量和矢量。这种事情最好定义为:

public func + (lhs:CGPoint, rhs:CGPoint) -> CGPoint {
    return CGPoint(x: rhs.x + lhs.x, y:rhs.y + lhs.y)
}

然后制作你想要添加的 CGPoint(即使你必须创建一个 Diagonal(1) 函数来提供帮助。我知道这是一个人为的例子，但我希望对于整个问题也是如此。使类型自动强制转换应该非常小心。创建一个 init 几乎总是更好，它可以让你明确地将一个转换为另一个。然后运营商是有道理的。

这就是 Swift 允许更强大的类型安全性的全部优势。例如，我有一些这样的代码:

// Frequency and Time are reciprocols
public func *(lhs: SignalTime,      rhs: SignalFrequency) -> Double { return lhs.seconds * rhs.hertz }
public func *(lhs: SignalFrequency, rhs: SignalTime)      -> Double { return rhs * lhs }

public func /(lhs: Double, rhs: SignalFrequency) -> SignalTime { return SignalTime(seconds: lhs / rhs.hertz) }
public func /(lhs: Double, rhs: SignalTime)      -> SignalFrequency { return SignalFrequency(hertz: lhs / rhs.seconds) }

// Frequency can be scaled by a constant
public func *(lhs: SignalFrequency, rhs: Double)          -> SignalFrequency { return SignalFrequency(hertz: lhs.hertz * rhs) }
public func *(lhs: Double,          rhs: SignalFrequency) -> SignalFrequency { return rhs * lhs }

这一切都非常明确甚至乏味，但它应该如此。有组合这些类型的有用方法，也有组合这些类型的非法方法。 x/y 返回与 y/x 完全不同的类型。这样做在编译阶段发现了几个“哦，我不小心将频率乘以频率”的错误。试图用最少的代码使所有这些“神奇地工作”往往会以允许非法操作的方式过度扩展类型。

我会避免使用 ScalarArithmetic，直到您有一个非常好的且明确的用例。如果你有一个不同的例子，看看会很有趣，但我希望答案是相似的。小心过度强制。

关于ios - Swift:协议(protocol):捕获类型之间的兼容性，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25874300/