Limitation du protocole Swift avec avancé

Question

J'ai rencontré un problème conceptuel et je recherche des conseils. J'ai une classe de base qui définit toutes les propriétés communes un type d'objet donné:

class Widget { 
    var id: Int 
    var type: String 
} 

Beaucoup de ces widgets partagent d'autres propriétés et capacités qui sont facilement regroupées. Les propriétés/fonctionnalités intègrent parfaitement dans les protocoles:

protocol WidgetryA { 
    func widgetAFunc() 
} 

protocol WidgetryB { 
    func widgetBFunc() 
} 

Il est facile d'étendre la classe Widget pour se conformer à ces différents protocoles:

extension Widget: WidgetryA { 
    func widgetAFunc() { } 
} 

Notez que les widgets peuvent se conformer à de multiples protocoles. Pas de problème jusqu'à présent! Ce que je voudrais faire, et ce que je lutte avec, est la suivante ... Widgets qui ont une certaine valeur Widget.type devrait essentiellement être interdit de se conformer à un protocole Widgetry donné. Ainsi, par exemple:

// this obviously doesn't work with where -- is there an alternative? 
extension Widget: WidgetryA where Self.type == "foo" { 
    func widgetAFunc() { } 
} 

Maintenant, je pouvais faire quelque chose comme grossier et inélégant garde() uant dans les fonctions de protocole pour éviter Widgets du mal Widget.type de faire des appels qu'ils ne devraient pas. Je pense que les types associés pourraient fournir un chemin praticable pour atteindre ce que je veux, mais je me bats avec une construction qui fonctionne. Toute pensée ou conseil serait apprécié!

Answer 1

Ce n'est pas possible comme décrit dans Swift pour plusieurs raisons:

1. Le compilateur Swift ne sait pas ce que les valeurs d'exécution pour la propriété « type » seront

2. Swift les génériques et les extensions de protocole ne prennent pas en charge l'exclusion/la désactivation/la suppression des méthodes et des implémentations basées sur des contraintes, et les contraintes génériques ne prennent pas en charge les types correspondants qui ne sont PAS quelque chose.

Cependant, plutôt que d'utiliser la chaîne de type, je suggère faire le Widget « type » un protocole lui-même, puis ajoutez les mises en œuvre par extension du protocole aux instances seulement qui sont Widgets qui sont conformes au protocole de type correct (s)

Answer 2

Vous pouvez faire une extension du protocole:

extension WidgetryA where Self: Foo { 
    func widgetAFunc() { } 
} 

donc ce widgetAFunc sera mis en œuvre que pour les classes qui sont de Foo type et conformes à WidgetryA protocole. Et bien sûr, vous devez créer des sous-classes de Widget.