Мне нужно реализовать обертку для стирания типов для моей собственной структуры, очень похожей наSequenceOf, GeneratorOfи т. д. Итак, я начал с того, что попытался просто заново внедрить стандартSequenceOf себя.

Я только что скопировал и вставил декларацию дляSequenceOfпереименовал вMySequenceOfи заполнил некоторые заглушки, чтобы получить:

/// A type-erased sequence.
///
/// Forwards operations to an arbitrary underlying sequence with the
/// same `Element` type, hiding the specifics of the underlying
/// sequence type.
///
/// See also: `GeneratorOf<T>`.
struct MySequenceOf<T> : SequenceType {

    /// Construct an instance whose `generate()` method forwards to
    /// `makeUnderlyingGenerator`
    init<G : GeneratorType where T == T>(_ makeUnderlyingGenerator: () -> G) {
        fatalError("implement me")
    }

    /// Construct an instance whose `generate()` method forwards to
    /// that of `base`.
    init<S : SequenceType where T == T>(_ base: S) {
        fatalError("implement me")
    }

    /// Return a *generator* over the elements of this *sequence*.
    ///
    /// Complexity: O(1)
    func generate() -> GeneratorOf<T> {
        fatalError("implement me")
    }
}

Я получаю ошибку компилятора: "Ни один из типов в том же типе не относится к универсальному параметру или связанному типуMsgstr "Итак, я предполагаю, что сгенерированное Xcode объявлениеSequenceOfх "where T == T«ограничение действительно означает»where G.Element == T", которая дает мне следующую компилируемую структуру:

struct MySequenceOf<T> : SequenceType {

    init<G : GeneratorType where G.Element == T>(_ makeUnderlyingGenerator: () -> G) {
        fatalError("implement me")
    }

    func generate() -> GeneratorOf<T> {
        fatalError("implement me")
    }
}

Так что теперь, достаточно просто, мне просто нужно держатьсяmakeUnderlyingGenerator из инициализатора и вызвать его изgenerate():

struct MySequenceOf<T> : SequenceType {
    let maker: ()->GeneratorOf<T>

    init<G : GeneratorType where G.Element == T>(_ makeUnderlyingGenerator: () -> G) {
        self.maker = { return makeUnderlyingGenerator() }
    }

    func generate() -> GeneratorOf<T> {
        return self.maker()
    }
}

но это дает мне ошибку: "«G» не конвертируется в «GeneratorOf»"

Этоделает компилируется, если я принудительно приведу приведение:

struct MySequenceOf<T> : SequenceType {
    let maker: ()->GeneratorOf<T>

    init<G : GeneratorType where G.Element == T>(_ makeUnderlyingGenerator: () -> G) {
        self.maker = { return makeUnderlyingGenerator() as GeneratorOf<T> }
    }

    func generate() -> GeneratorOf<T> {
        return self.maker()
    }
}

Но затем происходит сбой во время выполнения из динамического приведения.

Итак, как можно реализовать стирание типа, как это? Это должно быть возможно, потому что стандартная библиотека Swift делает это кучей (SequenceOf, GeneratorOf, SinkOf).