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

以下解决方案有些通用,符合协议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

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