Limitation des classes dérivées de classes génériques en swift

Je suis en train de dériver ma classe de la classe générique:

class foo<T> {}
class bar : foo<Int> {}

Mais ce code ne peut pas compiler avec salle d'erreur:

Classes dérivées de classes génériques doivent également être générique

Comment faire pour éviter cette limitation? Est-il possible?

Non, il n'est pas possible.
Afin générique en swift est presque inutilisable
Pas vrai, il n'a tout simplement pas la même conception de génériques dans d'autres langues.
veuillez voir mon "pauvre homme solution à votre problème.
Je suis d'accord c'est très invalidante.

InformationsquelleAutor ssgreg | 2014-06-10

23

Ssreg,

Malheureusement, ce n'est officiel:

Vous pouvez sous-classe d'une classe générique, mais la sous-classe doit aussi être un
classe générique.

Laissez-nous espérer qu'Apple corrige cela dans une future version.

Attendant, laissez-nous voir cela comme une opportunité à exploiter l'agrégation au lieu de sous-classement.

REMARQUE:

Comme un homme pauvre version de la solution, on peut utiliser typealias:
```
class foo<T> {}
class bar<Int> : foo<Int> {}
typealias Bar = bar<Int>
```
De cette façon, le reste du code peut être écrit comme si Apple a déjà fixé la question.
- Vous semblez être en citant la documentation, pouvez-vous confirmer cela? Je ne trouve pas ce passage dans votre lien (ou en vertu de la section Types). Je me demande si ils ont changé les docs et éventuellement l'intention.
- Hey @chrisco, je l'ai juste essayé en b6: pas de cigare, le compilateur se plaint.
- À droite, j'ai remarqué la même chose en B6. Mais la documentation de si - c'était qu'une citation directe, parce que je ne vois pas ce passage maintenant?
- Oui, j'étais une citation directe. Et vous avez raison, ne peut pas trouver de la doc... C'est étrange.
- notons que lorsque vous écrivez class bar<Int> : foo<Int> {} l'Int devenir un espace réservé pour le type générique, en remplaçant le réel swift type Int. Cela permet de générer très drôle messages d'erreur lorsque vous essayez d'utiliser l'Int des propriétés à l'intérieur de la classe.. C'est mieux d'utiliser la hpique solution inutilisée de type générique dans la classe enfant, et de lier la classe de base pour le vrai type Int (ou celui de votre choix)
- Tour de Nice avec la typealiasing.
- Je ne crois pas que cela va fonctionner. Comme @hariseldon78 dit, Int est maintenant un type générique. Lorsque j'essaie Bar<[MyClass]> : Foo<[MyClass]> il se plaint d'un manque de "identificateur de nom de paramètre générique"
- Au lieu de cela, je suis en train de faire: class bar<T:Int> : foo<Int> {}
InformationsquelleAutor Jean Le Moignan
16

Dans Swift 2 il est possible de sous-classe d'une classe générique:
```
class Something {}

class Base<T> {}

class Fancy : Base<Something> {}
```
- Enfin!!! Et maintenant, on joue le jeu de l'attente...
- Est-il préliminaire de la documentation/blog devis sur cette référence?
- Je n'ai pas à le trouver. Je l'ai essayer sur l'aire de jeu.
- Vous n'avez pas sous-classé le générique, vous avez sous-classé le réifiée générique comme un type de béton. L'objet est ici serait class Fancy : Base<T>. C'est pourquoi @Tom van Zummeren la réponse semble correct
InformationsquelleAutor ricardopereira
15

Une alternative à la typealias solution est de prendre de la documentation littéralement:

Vous pouvez sous-classe d'une classe générique, mais la sous-classe doit aussi être un
classe générique.

Nous faire sous-classe d'une classe générique, mais d'un autre type que nous n'utilisons pas pour rien.
```
class foo<T> {

    func doSomething(t:T) -> T {
        return t;
    }
}

class bar<S> : foo<Int> {

    override func doSomething(t:Int) -> Int {
        return t * t;
    }
}

let b : bar = bar<AnyObject>()
b.doSomething(5) // 25 instead of 5
```
Je préfère cette approche à l'aide de typealias parce que de ne pas polluer l'espace de noms avec un type supplémentaire. Ceci est particulièrement important si le sous-classe (bar) est destiné à être public ou internal.

Modifier

La documentation ne comprend plus la phrase sur la prescription de génériques sous-classes. J'espère que cela signifie que Apple prévoit de modifier ce, plus tôt que tard.
- Testé superficiellement Beta 6.
- c'est drôle de voir comment ils conçoivent la langue autour du compilateur limites, au lieu de vice versa..
- Cela semble fonctionner, mais de rangement avec typealias bar = bar<AnyObject> ne
- Je suggère la création d'intermédiaires avec un autre nom, afin que vous pouvez utiliser le typealias avec la technique ci-dessus.\n par exemple: classe GenericBase<T> {}\n classe _ExtendBase<T> : GenericBase<String> { }\n typealias ExtendBase = _ExtendBase<AnyObject>
InformationsquelleAutor hpique
15

J'ai eu le même problème et j'ai trouvé une solution!
```
class SomeType {
}
class Foo<T> {
}
class Bar<T: SomeType>: Foo<T> {
}
```
Maintenant vous pouvez le faire:
```
let bar = Bar()
```
Par défaut, ce sera de la Barre type de SomeType. Le seul inconvénient est que vous ne pouvez le faire pour "subclassable' types. Donc, pour Int cela ne fonctionnera pas.
- Cela fonctionne, mais a une légère odeur de code à elle. Jolie trouvaille.
- Voulais juste appuyer sur ses conclusions et de proposer une modification possible. J'ai eu du succès en misant sur votre réponse à déclarer une classe public final class NonGenericSubclass {}, puis en appuyant sur l'exemple ci-dessus, je voudrais déclarer Bar comme suit: class Bar<T : NonGenericSubclass> : Foo<Int> { ... }. De cette façon, je bénéficie de tous les avantages de la Foo type int, mais je peux toujours initialiser comme si Bar n'étaient pas générique. Aussi, parce que NonGenericSubclass est déclaré final, il ne peut pas être sous-classé, de sorte que toute la classe de déclaration d'un type générique peut la considérer comme non générique pour toutes fins utiles. Bonne trouvaille!
- Grande trouver...
InformationsquelleAutor Tom van Zummeren

Vous devez vous connecter pour publier un commentaire.