假设我定义了这样一个协议(protocol):

protocol EuclideanPoint {
    func distance(other: Self) -> Double
    func dimension() -> UInt
}

现在我想扩展 [Float] 和 [Double] 以采用该协议(protocol)。

但是下面的代码:

extension [Float]: EuclideanPoint {
    func distance(other: [Float]) {
        return Double(zip(self, other).map{a, b in pow(a-b,2)}.reduce(0, combine: +))
    }
    func dimension() {
        return UInt(self.count)
    }
}

因错误而无效

error: constrained extension must be declared on the unspecialized generic type 'Array' with constraints specified by a 'where' clause

我发现了类似的问题(如 this )，但建议的解决方案是使用 extension CollectionType where Generator.Element == S { ... }，但在这种情况下它会导致错误:

error: protocol 'CollectionType' can only be used as a generic constraint because it has Self or associated type requirements

有什么解决办法吗？

编辑:

使用建议的解决方案:

protocol DoubleConvertibleType {
    var doubleValue: Double { get }
}

extension Double : DoubleConvertibleType { var doubleValue: Double { return self         } }
extension Float  : DoubleConvertibleType { var doubleValue: Double { return Double(self) } }
extension CGFloat: DoubleConvertibleType { var doubleValue: Double { return Double(self) } }

extension Array where Element : DoubleConvertibleType {
    func distance(other: Array) -> Double {
        return Double(zip(self, other).map{ pow($0.0.doubleValue - $0.1.doubleValue, 2) }.reduce(0, combine: +))
    }

    func dimension() -> UInt {
        return UInt(self.count)
    }
}

给 [Double] 和 [Float] .distance() 和 .dimension() 方法.然而 [Double] 或 [Float] 不能用于代替符合 EuclideanPoint 协议(protocol)所需的内容，从而产生错误:

error: type '[Double]' does not conform to protocol 'EuclideanPoint'

最佳答案

已编辑

以下解决方案有些通用，符合协议(protocol) EuclidianPoint，并且基于两个假设:

• 我们被允许在您的 EuclideanPoint 协议(protocol)中为方法 distance 的蓝图包含一个通用类型约束，并且，而不是参数类型Self，我们将使用泛型 ([T])。然而，我们将(在编译时)确定 [T] 与 Self 属于同一类型(此处，Self 属于 [Double]、[Float] 或 [Int] 类型)，确定 [T] 符合协议(protocol) 欧几里得点。

• 您认为我们将 .map 和 .reduce 等函数式编程技术留在这个特定应用程序之外，您可以接受，而只专注于实现“采用欧几里得协议(protocol)的通用数组”。 Swift 中的这些 .map、.reduce 等功能确实简洁实用，但在许多应用程序中只是 for 循环背后的包装器，所以你赢了以手动命令式方式做事会失去任何性能。事实上，众所周知，.reduce 在减少数组时由于重复的数组复制赋值而执行完全非可选的操作(我不会在这里详细介绍......)。无论如何，也许您可​​以利用我的示例并将其调整回更实用的范例。

我们从一个自定义类型协议(protocol)开始，MyTypes，它将作为我们想要包含在我们的泛型中的类型的接口(interface)。我们还添加了稍微更新的 EuiclidianPoint 协议(protocol)，其中我们使用协议(protocol) MyTypes 作为对 distance 中使用的通用 T 的类型限制(...) 函数蓝图。

/* Used as type constraint for Generator.Element */
protocol MyTypes {
    func -(lhs: Self, rhs: Self) -> Self
    func +=(inout lhs: Self, rhs: Self)
}

extension Int : MyTypes { }
extension Double : MyTypes { }
extension Float : MyTypes { }
    /* Extend with the types you wish to be covered by the generic ... */

/* Used as extension to Array : blueprints for extension method
to Array where Generator.Element are constrainted to MyTypes */
protocol EuclideanPoint {
    func distance<T: MyTypes> (other: [T]) -> Double?
    func dimension() -> UInt
}

请注意，我已将 distance 的 Double 返回更改为可选；你可以按照你的意愿处理这个，但是如果 self 和 other 数组的长度不同，或者类型 Self 和 [T ] 不同，将需要显示不符合项——我将在此处使用 nil。

我们现在可以通过 EuclidianPoint 协议(protocol)实现我们对 Array 的扩展:

/* Array extension by EuclideanPoint protocol */
extension Array : EuclideanPoint {

    func distance<T: MyTypes> (other: [T]) -> Double? {
        /* [T] is Self? proceed, otherwise return nil */
        if let a = self.first {
            if a is T && self.count == other.count {
                var mySum: Double = 0.0
                for (i, sElement) in self.enumerate() {
                    mySum += pow(((sElement as! T) - other[i]) as! Double, 2)
                }
                return sqrt(mySum)
            }
        }
        return nil
    }

    func dimension() -> UInt {
        return UInt(self.count)
    }
}

请注意，在 distance 函数的内部 if 子句中，我们使用了到 T 的显式向下转换，但是由于我们已经断言 Self 的元素 是 T 类型，这没问题。

无论如何，我们已经完成了，我们可以测试我们的“通用”数组扩展，我们注意到它现在也符合您的协议(protocol) EuclidianPoint。

/* Tests and Examples */
let arr1d : [Double] = [3.0, 4.0, 0.0]
let arr2d : [Double] = [-3.0, -4.0, 0.0]
let arr3d : [Double] = [-3.0, -4.0]

let arr1f : [Float] = [-3.0, -4.0, 0.0]

let arr1i = [1, 2, 3]

let _a = arr1d.dimension() // 3, OK
let _b = arr1d.distance(arr2d) // 10, OK (A->B dist)
let _c = arr1d.distance(arr1f) // nil (Incomp. types)
let _d = arr1d.distance(arr3d) // nil (Incomp. sizes)
let _e = arr1i.distance(arr1d) // nil (Incomp. types)

    /* for use in function calls: generic array parameters constrained to
       those that conform to protocol 'EuclidianPoint', as requested     */
func bar<T: MyTypes, U: protocol<EuclideanPoint, _ArrayType> where U.Generator.Element == T> (arr1: U, _ arr2: U) -> Double? {

    // ...

    return arr1.distance(Array(arr2))
        /* We'll need to explicitly tell the distance function
           here that we're sending an array, by initializing an 
           array using the Array(..) initializer                */
}
let myDist = bar(arr1d, arr2d) // 10, OK

好的!

我的第一个答案还剩下一个注释:

将通用类型数组扩展到协议(protocol)实际上最近才在这里被问到:

• Extending typed array by conforming to a protocol in Swift 2

共识是您不能以您可能期望的“简洁快捷”的方式对协议(protocol)进行数组的通用扩展。然而，有一些变通方法可以模仿这种行为，其中之一就是我在上面使用的方法。如果您对另一种方法感兴趣，我建议您查看此线程。

关于swift - 扩展泛型 Array<T> 以采用协议(protocol)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34475597/