如何实现类型擦除的通用包装器？

Question

我需要实现我自己的结构类型擦除包装,非常相似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")
    }
}

我得到编译器错误:" 同类型中的任何一种类型都不是指泛型参数或关联类型 ".所以我假设Xcode生成的SequenceOf's" 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).

Answer 1

尝试:

struct MySequenceOf<T> : SequenceType {
    private let _generate:() -> MyGeneratorOf<T>

    init<G : GeneratorType where G.Element == T>(_ makeUnderlyingGenerator: () -> G) {
        _generate = { MyGeneratorOf(makeUnderlyingGenerator()) }
    }

    init<S : SequenceType where S.Generator.Element == T>(_ base: S) {
        _generate = { MyGeneratorOf(base.generate()) }
    }

    func generate() -> MyGeneratorOf<T> {
        return _generate()
    }
}

struct MyGeneratorOf<T> : GeneratorType, SequenceType {

    private let _next:() -> T?

    init(_ nextElement: () -> T?) {
        _next = nextElement
    }

    init<G : GeneratorType where G.Element == T>(var _ base: G) {
        _next = { base.next() }
    }

    mutating func next() -> T? {
        return _next()
    }

    func generate() -> MyGeneratorOf<T> {
        return self
    }
}

实施的基本策略ProtocolOf<T>是这样的:

protocol ProtocolType {
    typealias Value
    func methodA() -> Value
    func methodB(arg:Value) -> Bool
}

struct ProtocolOf<T>:ProtocolType {
    private let _methodA: () -> T
    private let _methodB: (T) -> Bool

    init<B:ProtocolType where B.Value == T>(_ base:B) {
        _methodA = { base.methodA() }
        _methodB = { base.methodB($0) }
    }

    func methodA() -> T { return _methodA() }
    func methodB(arg:T) -> Bool { return _methodB(arg) }
}

添加到评论中回答@MartinR.

是否有一个特殊的原因,即_generate是一个闭包而不是发电机本身？

首先,我认为,这是规范或语义的问题.

不用说,不同之处在于"何时创建发电机".

考虑以下代码:

class Foo:SequenceType {
    var vals:[Int] = [1,2,3]
    func generate() -> Array<Int>.Generator {
        return vals.generate()
    }
}

let foo = Foo()
let seq = MySequenceOf(foo)
foo.vals = [4,5,6]
let result = Array(seq)

问题是:result应该[1,2,3]还是[4,5,6]？我MySequenceOf和内置的SequenceOf结果是后者.我只是将行为与内置行为相匹配.