Les tableaux de Génériques Swift

Il y a un moyen de tri de faire ce que vous voulez - sorte de. Il y a un moyen, avec des protocoles, afin d'éliminer le type de restriction et de toujours obtenir le résultat que vous souhaitez, en quelque sorte, mais il n'est pas toujours joli. Voici ce que j'ai trouvé comme protocole dans votre situation:

protocol MyProtocol {
    func getValue() -> Self 
}

extension Int: MyProtocol {
    func getValue() -> Int {
        return self
    }
}

extension Double: MyProtocol {
    func getValue() -> Double {
        return self
    }
}

Noter que le value de la propriété que vous avez mis dans votre protocole de déclaration a été changé à une méthode qui retourne l'objet.

Ce n'est pas très intéressant.

Mais maintenant, parce que vous avez réussi à se débarrasser de la value propriété dans le protocole, MyProtocol peut être utilisé comme un type, pas seulement comme une contrainte de type. Votre Container classe n'a même pas besoin d'être plus générique. Vous pouvez la déclarer comme ceci:

class Container {
    var values: [MyProtocol]

    init(_ values: MyProtocol...) {
        self.values = values
    }

    func myMethod() -> [MyProtocol] {
        return values
    }
}

Et parce que Container est plus générique, vous pouvez créer un Array de Containers et itérer à travers eux, imprimer les résultats de la myMethod() méthode:

var containers = [Container]()

containers.append(Container(1, 4, 6, 2, 6))
containers.append(Container(1.2, 3.5))

for container in containers {
    println(container.myMethod())
}

// Output: [1, 4, 6, 2, 6]
//          [1.2, 3.5]

L'astuce est de construire un protocole qui comprend seulement les fonctions génériques et n'attache pas d'autres exigences de conformité de type. Si vous pouvez vous en sortir avec le faire, vous pouvez utiliser le protocole comme un type, et pas seulement comme une contrainte de type.

Et comme un bonus (si vous voulez appeler ça comme ça), votre gamme de MyProtocol valeurs peut même mélanger les différents types conformes à MyProtocol. Donc si vous donnez String un MyProtocol extension comme ceci:

extension String: MyProtocol {
    func getValue() -> String {
        return self
    }
}

Vous pouvez initialiser réellement un Container avec un mélange de types:

let container = Container(1, 4.2, "no kidding, this works")

[Avertissement - je suis en train de tester cela dans l'un des terrains de jeux en ligne. Je n'ai pas pu le tester dans Xcode pourtant...]

Edit:

Si vous voulez toujours Container être générique et ne détiennent un type d'objet, vous pouvez l'obtenir en faisant il se conformer à son propre protocole:

protocol ContainerProtocol {
    func myMethod() -> [MyProtocol]
}

class Container<T: MyProtocol>: ContainerProtocol {
    var values: [T] = []

    init(_ values: T...) {
        self.values = values
    } 

    func myMethod() -> [MyProtocol] {
        return values.map { $0 as MyProtocol }
    }
}

Maintenant, vous pouvez encore disposez d'un tableau de [ContainerProtocol] d'objets et d'itérer à travers eux en invoquant myMethod():

let containers: [ContainerProtocol] = [Container(5, 3, 7), Container(1.2, 4,5)]

for container in containers {
    println(container.myMethod())
}

Peut-être que cela ne fonctionne pas pour vous, mais maintenant Container est limité à un seul type, et pourtant, vous pouvez toujours parcourir un tableau de ContainterProtocol objets.

Cela peut être mieux expliqué avec des protocoles comme Equatable. Vous ne pouvez pas déclarer un tableau [Equatable] parce que pendant que les deux Int instances peuvent être comparés les uns aux autres et de deux instances de Double peuvent être comparés les uns aux autres, vous ne pouvez pas comparer un Int à un Double bien qu'ils mettent en œuvre Equatable.

MyProtocol est un protocole, ce qui signifie qu'il fournit une interface générique. Malheureusement, vous avez également utilisé Self dans la définition. Cela signifie que chaque type qui est conforme à MyProtocol mettra en œuvre différemment.

Que vous avez écrit vous-même - Int aura value comme var value: Int tout un MyObject aura value comme var value: MyObject.

Qui signifie qu'une struct/classe qui est conforme à MyProtocol ne peut pas être utilisé à la place d'un autre struct/classe qui est conforme à MyProtocol. Cela signifie également que vous ne pouvez pas utiliser MyProtocol de cette façon, sans spécification d'un type de béton.

Si vous remplacez que Self avec un type de béton, par exemple AnyObject, il va fonctionner. Cependant, actuellement (Xcode 6.3.1), il déclenche une erreur de segmentation lors de la compilation).

J'ai changé le tableau de déclaration d'un tableau de AnyObject de sorte que le filtre, d'une carte et de réduire pourraient être utilisés (et a également ajouté dans quelques objets à vérifier).

let containers: [AnyObject] = [Container<Int>(1, 2, 3), Container<Double>(1.0, 2.0, 3.0), "Hello", "World", 42]

Cela vous permettra de vérifier le type de la matrice et le filtre avant de parcourir le tableau

let strings = containers.filter({ return ($0 is String) })

println(strings) //[Hello, World]

for ints in containers.filter({ return ($0 is Int) }) {
    println("Int is \(foo)") //Int is 42
}

let ints = containers.filter({ return ($0 is Container<Int>) })
//as this array is known to only contain Container<Int> instances, downcast and unwrap directly
for i in ints as [Container<Int>] {
    //do stuff
    println(i.values) //[1, 2, 3]
}