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($0.0.doubleValue - $0.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’
以下解决方案有些通用,符合协议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的类型约束.
/* 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
}
请注意,我已将Double返回距离更改为可选;您可以按照自己的意愿处理,但如果自身和其他数组的长度不同,或Self和[T]类型不同,则需要显示不符合 – 我将在此处使用nil.
我们现在可以通过EuclidianPoint协议实现我们对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)
}
}
请注意,在距离函数的内部if子句中,我们使用显式向下转换为T,但由于我们断言Self的元素是T类型,所以这没关系.
无论如何,有了这个,我们就完成了,我们可以测试我们的“通用”数组扩展,我们现在注意到它也符合你的协议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,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
好！
我的第一个答案仍然留有一条说明：
通用类型数组扩展到协议实际上最近才在这里被问到：
> Extending typed array by conforming to a protocol in Swift 2
一致意见是你不能以一种你可能期望的“整洁的”方式对数组进行通用的扩展.然而,有一些模拟这种行为的解决方法,一种是我上面使用的那种行为.如果您对其他方法感兴趣,我建议您查看此主题.
