programacion - protocolos swift

Swift 2 añade la conformidad del protocolo a los protocolos.

Question

¿Puedo agregar la conformidad del protocolo a un protocolo a través de una extensión rápida?

//Plain old protocol here
protocol MyData {
var myDataID: Int { get }
}

Quiero hacer que el protocolo MyData sea equiparable de forma predeterminada (solo compare el ID)

extension MyData : Equatable { }

Pero me sale este error encantador:

"La extensión del protocolo ''MyData'' no puede tener una cláusula de herencia"

El comportamiento que busco es BananaData conforme a Equatable (un protocolo) porque implementa el protocolo MyData que puede proporcionar una implementación predeterminada de Equatable

//This is the method to implement Equatable
func ==(lhs: MyData, rhs: MyData) -> Bool {
return lhs.myDataID == rhs.myDataID
}
struct BananaData: MyData {
var myDataID: Int = 1
}
func checkEquatable(bananaOne: BananaData, bananaTwo: BananaData) {
//This compiles, verifying that BananaData can be compared
if bananaOne == bananaTwo { }
//But BananaData is not convertible to Equatable, which is what I want
let equatableBanana = bananaOne as Equatable
//I don''t get the additional operations added to Equatable (!=)
if bananaOne != bananaTwo { } //Error
}

Answer 1

¿Este patio hace lo que quieres? Lo hice en base a lo que entiendo de la Programación Orientada a Protocolo en Swift de WWDC 2015.

import Foundation
//Plain old protocol here
func == (lhs: MyData, rhs: MyData) -> Bool {
return lhs.myDataID == rhs.myDataID
}
func != (lhs: MyData, rhs: MyData) -> Bool {
return lhs.myDataID != rhs.myDataID
}
protocol MyData {
var myDataID: Int { get }
}
extension MyData where Self: Equatable {
}
struct BananaData: MyData {
var myDataID: Int = 1
}
func checkEquatable(bananaOne: BananaData, bananaTwo: BananaData) {
//This compiles, verifying that BananaData can be compared
if bananaOne == bananaTwo {
print("Same")
}
//But BananaData is not convertible to Equatable, which is what I want
//I don''t get the additional operations added to Equatable (!=)
print(bananaOne.myDataID)
print(bananaTwo.myDataID)
if bananaOne != bananaTwo {
}
//Error
}
let b1 = BananaData(myDataID: 2)
let b2 = BananaData(myDataID: 2)
checkEquatable(b1, bananaTwo: b2)
let c = b1 == b2 // Evaluates as true

Answer 2

Como dice el mensaje de error: una extensión de un protocolo no puede tener una cláusula de herencia. En su lugar, puede hacer que el protocolo MyData herede de Equatable en la declaración original.

protocol MyData: Equatable {
var myDataID: Int { get }
}

A continuación, puede extender y agregar una implementación de == para los tipos que se ajustan a MyData :

func == <T: MyData>(lhs: T, rhs: T) -> Bool {
return lhs.myDataID == rhs.myDataID
}

Sin embargo, yo no recomendaría esto! Si agrega más propiedades a los tipos conformes, no se verificará la igualdad de sus propiedades. Tomemos el siguiente ejemplo:

struct SomeData: MyData {
var myDataID: Int
var myOtherData: String
}
let b1 = SomeData(myDataID: 1, myOtherData: "String1")
let b2 = SomeData(myDataID: 1, myOtherData: "String2")
b1 == b2 // true, although `myOtherData` properties aren''t equal.

En el caso anterior, tendría que anular == para SomeData para obtener el resultado correcto, por lo que el == que acepta MyData redundante.