概述

我有一组不同的结构,都实现了Equatable协议,我试图将它传递给一个需要T.Iterator.Element：Equatable集合的函数.我知道如何通过使用类来解决这个问题,只需创建一个类：Vehicle：Identifiable,Equatable,然后使Car和Tractor实现Vehicle.但是,我想知道使用结构和协议是否可行？这是我正在尝试做的一个人为的例子 //: Playgr

这是我正在尝试做的一个人为的例子

//: Playground - noun: a place where people can play

protocol Identifiable {
    var ID: String { get set }
    init(ID: String)
    init()
}

extension Identifiable {
    init(ID: String) {
        self.init()
        self.ID = ID
    }
}

typealias Vehicle = Identifiable & Equatable

struct Car: Vehicle {
    var ID: String

    init() {
        ID = ""
    }

    public static func ==(lhs: Car,rhs: Car) -> Bool {
        return lhs.ID == rhs.ID
    }
}

struct Tractor: Vehicle {
    var ID: String

    init() {
        ID = ""
    }

    public static func ==(lhs: Tractor,rhs: Tractor) -> Bool {
        return lhs.ID == rhs.ID
    }
}

class Operator {
    func operationOnCollectionOfEquatables<T: Collection>(array: T) where T.Iterator.Element: Equatable {
    }
}

var array = [Vehicle]() //Protocol 'Equatable' can only be used as a generic consTraint because Self or associated type requirements

array.append(Car(ID:"VW"))
array.append(Car(ID:"Porsche"))
array.append(Tractor(ID:"John Deere"))
array.append(Tractor(ID:"Steyr"))

var op = Operator()
op.operationOnCollectionOfEquatables(array: array) //Generic parameter 'T' Could not be inferred

问题是,正如错误所述,您不能将具有Self或相关类型要求的协议用作实际类型 – 因为您丢失了这些要求的类型信息.在这种情况下,您将丢失==实现的参数的类型信息 – 正如Equatable所说,它们必须与符合类型(即Self)的类型相同.

解决方案几乎总是构建一个 type eraser.如果期望类型相等,如果它们的id属性相等,这可以像存储id属性并在==实现中进行比较一样简单.

struct AnyVehicle : Equatable {

    static func ==(lhs: AnyVehicle,rhs: AnyVehiclE) -> Bool {
        return lhs.id == rhs.id
    }

    let id : String

    init<T : Vehicle>(_ base: T) {
        id = base.id
    }
}

(注意我将您的ID属性重命名为id以符合Swift命名约定)

但是,更通用的解决方案是在类型擦除器中存储一个函数,它可以在类型转换后根据它们的==实现比较两个任意的车辆符合实例,以确保它们与类型橡皮擦的具体类型相同是用.创建的.

struct AnyVehicle : Equatable {

    static func ==(lhs: AnyVehicle,rhs: AnyVehiclE) -> Bool {

        // forWARD to both lhs's and rhs's _isEqual in order to determine equality.
        // the reason that both must be called is to preserve symmetry for when a
        // superclass is being compared with a subclass.
        // if you kNow you're always working with value types,you can omit one of them.
        return lhs._isEqual(rhs) || rhs._isEqual(lhs)
    }

    let base: Identifiable

    private let _isEqual: (_ to: AnyVehiclE) -> Bool

    init<T : Vehicle>(_ base: T) {

        self.base = base

        _isEqual = {

            // attempt to cast the passed instance to the concrete type that
            // AnyVehicle was initialised with,returning the result of that
            // type's == implementation,or false otherwise.
            if let other = $0.base as? T {
                return base == other
            } else {
                return false
            }
        }
    }
}

print(AnyVehicle(Car(id: "foo")) == AnyVehicle(Tractor(id: "foo"))) // false
print(AnyVehicle(Car(id: "foo")) == AnyVehicle(Car(id: "bar"))) // false
print(AnyVehicle(Car(id: "foo")) == AnyVehicle(Car(id: "foo"))) // true

var array = [AnyVehicle]()

array.append(AnyVehicle(Car(id: "VW")))
array.append(AnyVehicle(Car(id: "Porsche")))
array.append(AnyVehicle(Tractor(id: "John Deere")))
array.append(AnyVehicle(Tractor(id: "Steyr")))

var op = Operator()

// compiles fine as AnyVehicle conforms to Equatable.
op.operationOnCollectionOfEquatables(array: array)