swift – 扩展通用数组以采用协议

概述假设我已经定义了这样一个协议： protocol EuclideanPoint { func distance(other: Self) -> Double func dimension() -> UInt} 现在我想扩展[Float]和[Double]来采用该协议. 但是以下代码： extension [Float]: EuclideanPoint { func dis 假设我已经定义了这样一个协议：

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

现在我想扩展[float]和[Double]来采用该协议.

但是以下代码：

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),但建议的解决方案是使用扩展CollectionType,其中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(
/* 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 methodto Array where Generator.Element are constrainted to MyTypes */protocol EuclIDeanPoint {    func distance<T: MyTypes> (other: [T]) -> Double?    func dimension() -> UInt}
.0.doubleValue - 
/* 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)    }}
.1.doubleValue,2) }.reduce(0,combine: +))    }    func dimension() -> UInt {        return UInt(self.count)    }}

给[Double]和[float] .distance()和.dimension()方法.然而,[Double]或[float]不能用来代替符合EuclIDeanPoint协议所需的东西,产生错误：

error: type ‘[Double]’ does not conform to protocol ‘EuclIDeanPoint’

EDITED

以下解决方案有些通用,符合协议EuclIDianPoint,并基于两个假设：

>我们允许在EuclIDeanPoint协议中为方法距离的蓝图包含泛型类型约束,并且我们将使用泛型([T])而不是参数类型为Self.但是,我们将确定(在编译时)[T]与Self的相同类型(此处为[Double],[float]或[Int]类型的Self),并确定[T]符合议程EuclIDianPoint.
>您可以将我们的函数编程技术(例如.map和.reduce)保留在此特定应用程序之外,并且只关注实现“欧几里德协议采用的通用数组”. Swift中的这些.map,.reduce等功能确实很简洁实用,但在许多应用程序中只是for-hood-for循环的包装器,所以你不会因为手动命令式的风格而失去任何性能.事实上,已知.reduce由于重复的数组复制分配而执行非常不可选的,同时减少了数组(我不会在这里更多地介绍……).无论如何,也许你可以利用我的例子并将其调整回更具功能性的范例.

我们从一个自定义类型协议MyTypes开始,它将作为我们想要包含在我们的泛型中的类型的接口.我们还添加了略微更新的EuiclIDianPoint协议,其中我们使用协议MyTypes作为距离(…)函数blue-print中使用的泛型T的类型约束.

/* 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,0.0]let arr1i = [1,2,3]let _a = arr1d.dimension() // 3,OKlet _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

请注意,我已将Double返回距离更改为可选;您可以按照自己的意愿处理,但如果自身和其他数组的长度不同,或Self和[T]类型不同,则需要显示不符合 – 我将在此处使用nil.

我们现在可以通过EuclIDianPoint协议实现我们对Array的扩展：

请注意,在距离函数的内部if子句中,我们使用显式向下转换为T,但由于我们断言Self的元素是T类型,所以这没关系.

无论如何,有了这个,我们就完成了,我们可以测试我们的“通用”数组扩展,我们现在注意到它也符合你的协议EuclIDianPoint.

好！

我的第一个答案仍然留有一条说明：

通用类型数组扩展到协议实际上最近才在这里被问到：

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

一致意见是你不能以一种你可能期望的“整洁的”方式对数组进行通用的扩展.然而,有一些模拟这种行为的解决方法,一种是我上面使用的那种行为.如果您对其他方法感兴趣,我建议您查看此主题.

总结

以上是内存溢出为你收集整理的swift – 扩展通用数组以采用协议全部内容，希望文章能够帮你解决swift – 扩展通用数组以采用协议所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。