Массивы дженериков в Swift

это хороший пример "что ты хочу произойдет?"И фактически демонстрирует сложность, которая взрывается, если у Swift действительно первоклассные типы.

protocol MyProtocol {
    var value: Self { get }
}

большой. MyProtocol.value возвращает любой тип реализует его, помня, что это должно быть определено во время компиляции, а не во время выполнения.

var containers: [Container<MyProtocol>] = []

Итак, определено во время компиляции, какой это тип? Забудьте о компиляторе, просто сделайте это на бумаге. Да, не уверен, что это будет за тип. Я имею в виду б тип. Нет metatypes.

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

вы знаете, что идете по неправильному пути, когда AnyObject пробрался в ваши подписи. Ничего из этого никогда не сработает. После AnyObject только рубище.

или есть что-то еще, что я пропустил?

да. Вам нужен тип, А вы его не предоставили. Вы предоставили правило для ограничения типа, но не фактического типа. Вернитесь к своей настоящей проблеме и подумайте об этом более глубоко. (Анализ метатипов почти никогда не является вашей" реальной " проблемой, если вы не работаете над докторской диссертацией CS, и в этом случае вы будете делать это в Идрисе, а не Swift. Какую реальную проблему вы решаете?

это можно лучше объяснить с помощью таких протоколов, как Equatable. Вы не можете объявить массив [Equatable] потому что пока два Int экземпляры можно сравнить друг с другом и два экземпляра Double можно сравнить друг с другом, вы не можете сравнить Int до Double хотя они оба реализуют Equatable.

MyProtocol является протоколом, что означает, что он предоставляет общий интерфейс. К сожалению, вы также использовали Self в определении. Это означает, что каждый тип что соответствует MyProtocol будет реализовывать его по-другому.

вы сами это писали - Int будет value as var value: Int а MyObject будет value as var value: MyObject.

это означает, что структура / класс, который соответствует MyProtocol не может использоваться вместо другой структуры / класса, который соответствует MyProtocol. Это также означает, что вы не можете использовать MyProtocol таким образом, без указания конкретного типа.

если вы замените, что Self С конкретный тип, например,AnyObject, он будет работать. Однако в настоящее время (Xcode 6.3.1) он вызывает ошибку сегментации при компиляции).

если вы попробуете этот измененный пример на игровой площадке, он будет систематически сбой:

// Obviously a very pointless protocol...
protocol MyProtocol {
    var value: Int { get }
}

extension Int   : MyProtocol {  var value: Int    { return self } }
//extension Double: MyProtocol {  var value: Double { return self } }

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

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


var containers: [Container<MyProtocol>] = []

вероятно, они все еще работают над этим, и все может измениться в будущем. Во всяком случае, на данный момент мое объяснение заключается в том, что протокол не является конкретного типа. Таким образом, теперь вы не знаете, сколько места в ОЗУ займет что-то, соответствующее протоколу (например,Int может не занимать столько же ОЗУ, сколько Double). Таким образом, это может быть довольно проблема выделения массива в памяти. С помощью NSArray вы выделяете массив указателей (указателей на NSObjects) и все они занимают одинаковое количество ОЗУ. Вы можете думать о NSArray как массив конкретного типа "указатель на NSObject". Таким образом, нет проблем с вычислением распределения ОЗУ.

считают, что Array а также Dictionary в Swift составляют Общая Структура, а не объекты, содержащие указатели на объекты как в В Obj-С.

надеюсь, что это помогает.

Я изменил объявление массива на массив AnyObject, чтобы можно было использовать фильтр, карту и уменьшить (а также добавить еще несколько объектов для проверки).

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

Это позволит вам проверить тип в массив и фильтровать, прежде чем цикл через массив

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

println(strings) // [Hello, World]

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

let ints = containers.filter({ return ( 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]
}