Swift Equatable sur un protocole

Si vous mettre directement en œuvre Equatable sur un protocole, il ne sera pas plus être utilisable comme un type, qui va à l'encontre de l'objectif de l'utilisation d'un protocole. Même si vous venez de mettre en œuvre == fonctions sur les protocoles sans Equatable de la conformité, les résultats peuvent être erronés. Voir ce post sur mon blog pour une démonstration de ces questions:

https://khawerkhaliq.com/blog/swift-protocols-equatable-part-one/

L'approche que j'ai trouvé le mieux est d'utiliser le type de l'effacement. Cela permet de faire == comparaisons pour les types de protocole (enveloppé dans le type de gommes à effacer). Il est important de noter que, tandis que nous continuons à travailler au niveau du protocole, le == comparaisons sont délégués de la sous-types de béton pour garantir des résultats corrects.

J'ai construit un type de gomme à l'aide de votre exemple et ajouté un peu de code de test à la fin. J'ai ajouté une constante de type String au protocole et a créé deux conformes types (les structures sont les plus faciles pour fins de démonstration) pour être en mesure de tester les différents scénarios.

Pour une explication détaillée du type d'effacement de la méthodologie utilisée, vérifiez la partie deux de la au-dessus de blog:

https://khawerkhaliq.com/blog/swift-protocols-equatable-part-two/

Le code ci-dessous devrait soutenir la comparaison d'égalité que vous avez voulu mettre en œuvre. Vous avez juste à envelopper le type de protocole dans un type de gomme à l'instance.

protocol X {
var name: String { get }
func isEqualTo(_ other: X) -> Bool
func asEquatable() -> AnyEquatableX
}
extension X where Self: Equatable {
func isEqualTo(_ other: X) -> Bool {
guard let otherX = other as? Self else { return false }
return self == otherX
}
func asEquatable() -> AnyEquatableX {
return AnyEquatableX(self)
}
}
struct Y: X, Equatable {
let name: String
static func ==(lhs: Y, rhs: Y) -> Bool {
return lhs.name == rhs.name
}
}
struct Z: X, Equatable {
let name: String
static func ==(lhs: Z, rhs: Z) -> Bool {
return lhs.name == rhs.name
}
}
struct AnyEquatableX: X, Equatable {
var name: String { return value.name }
init(_ value: X) { self.value = value }
private let value: X
static func ==(lhs: AnyEquatableX, rhs: AnyEquatableX) -> Bool {
return lhs.value.isEqualTo(rhs.value)
}
}
//instances typed as the protocol
let y: X = Y(name: "My name")
let z: X = Z(name: "My name")
let equalY: X = Y(name: "My name")
let unequalY: X = Y(name: "Your name")
//equality tests
print(y.asEquatable() == z.asEquatable())           //prints false
print(y.asEquatable() == equalY.asEquatable())      //prints true
print(y.asEquatable() == unequalY.asEquatable())    // prints false

Noter que, depuis le type de gomme est conforme au protocole, vous pouvez utiliser des instances du type gomme n'importe où une instance du type de protocole est prévu.

Espère que cette aide.

Ne savez pas pourquoi vous avez besoin de toutes les instances de votre protocole pour se conformer à Equatable, mais je préfère laisser les classes de mettre en œuvre l'égalité des méthodes.

Dans ce cas, je vous laisse le protocole simple:

protocol MyProtocol {
func doSomething()
}

Si vous avez besoin qu'un objet qui est conforme à MyProtocol est également Equatable vous pouvez utiliser MyProtocol & Equatable comme une contrainte de type:

//Equivalent: func doSomething<T>(element1: T, element2: T) where T: MyProtocol & Equatable {
func doSomething<T: MyProtocol & Equatable>(element1: T, element2: T) {
if element1 == element2 {
element1.doSomething()
}
}

De cette façon, vous pouvez garder votre cahier des charges clair et de laisser les sous-classes de mettre en œuvre leur égalité méthode uniquement si nécessaire.

J'ai toujours le conseiller à l'encontre de la mise en œuvre de == l'utilisation du polymorphisme. C'est un peu une odeur de code. Si vous voulez donner le cadre de l'utilisateur de quelque chose, il peut tester l'égalité avec alors vous devriez vraiment être un distributeur de struct, pas un protocol. Cela ne veut pas dire qu'il ne peut pas être le protocols qui sont des distributeurs de la structs si:

struct Info: Equatable {
let a: Int
let b: String
static func == (lhs: Info, rhs: Info) -> Bool {
return lhs.a == rhs.a && lhs.b == rhs.b
}
}
protocol HasInfo {
var info: Info { get }
}
class FirstClass: HasInfo {
/* ... */
}
class SecondClass: HasInfo {
/* ... */
}
let x: HasInfo = FirstClass( /* ... */ )
let y: HasInfo = SecondClass( /* ... */ )
print(x == y) //nope
print(x.info == y.info) // yep

Je pense que ce plus efficacement communique votre intention, qui est en gros "vous avez ces choses et vous ne savez pas si ce sont les mêmes choses, mais vous ne savez qu'ils ont le même ensemble de propriétés et vous pouvez tester si ces propriétés sont les mêmes." C'est assez proche de la façon dont je voudrais mettre en œuvre que Money exemple.

Tous les gens qui disent que vous ne pouvez pas mettre en œuvre Equatable pour un protocole, il suffit de ne pas essayez assez dur. Voici la solution (Swift 4.1) pour votre protocole X exemple:

protocol X: Equatable {
var something: Int { get }
}
//Define this operator in the global scope!
func ==<L: X, R: X>(l: L, r: R) -> Bool {
return l.something == r.something
}

Et ça marche!!!

class Y: X {
var something: Int = 14
}
struct Z: X {
let something: Int = 9
}
let y = Y()
let z = Z()
print(y == z) //false

y.something = z.something
pirnt(y == z) // true

Le seul problème est que vous ne pouvez pas écrire let a: X = Y() en raison de "Protocole ne peut être utilisé comme une contrainte générique" erreur.