swift – 具有通用类型的协议功能

正如你所说,你在这里所做的一切都有可能从一个解析器返回一个给定的结果,或是使用相同结果类型的另一个解析器.我们不关心该解析器的具体实现,我们只想知道它有一个返回相同类型的结果的parse()方法,或者具有相同要求的另一个解析器.

类型擦除对于这种情况是完美的,因为所有您需要做的是引用给定的解析器的parse()方法,允许您抽取掉该解析器的其余实现细节.重要的是要注意,您不会在此丢失任何类型的安全性,因此您根据需要指定的方式与解析器的类型完全相同.

如果我们看一个类型删除的解析器AnyParser的潜在实现,希望你会看到我的意思：

struct AnyParser<Result> : Parser {

    // A reference to the underlying parser's parse() method
    private let _parse : () -> ParserOutcome<Result>

    // Accept any base that conforms to Parser,and has the same Result type
    // as the type erasure's generic parameter
    init<T:Parser where T.Result == Result>(_ base:T) {
        _parse = base.parse
    }

    // ForWARD calls to parse() to the underlying parser's method
    func parse() -> ParserOutcome<Result> {
        return _parse()
    }
}

现在在ParserOutcome中,您可以简单地指定解析器大小写具有关联值AnyParser< Result>即可以使用给定的Result通用参数的任何类型的解析实现.

protocol Parser {
    associatedtype Result
    func parse() -> ParserOutcome<Result>
}

enum ParserOutcome<Result> {
    case result(Result)
    case parser(AnyParser<Result>)
}

...

struct BarParser : Parser {
    func parse() -> ParserOutcome<String> {
        return .result("bar")
    }
}

struct FooParser : Parser {
    func parse() -> ParserOutcome<Int> {
        let nextParser = BarParser()

        // error: CAnnot convert value of type 'AnyParser<Result>'
        // (aka 'AnyParser<String>') to expected argument type 'AnyParser<_>'
        return .parser(AnyParser(nextParser))
    }
}

let f = FooParser()
let outcome = f.parse()

switch outcome {
case .result(let result):
    print(result)
case .parser(let parser):
    let nextOutcome = parser.parse()
}

从这个例子可以看出,Swift仍然执行类型安全.我们试图在一个AnyParser类型的擦除包装器中包装一个BarParser实例(与Strings一起使用),该包装器需要一个Int泛型参数,导致编译器错误.一旦FooParser被参数化以使用Strings而不是Int,则编译器错误将被解析.

事实上,由于AnyParser在这种情况下只能作为单一方法的包装器,另一个潜在的解决方案(如果真的憎恶类型的擦除)就是直接使用它作为ParserOutcome的关联值.

protocol Parser {
    associatedtype Result
    func parse() -> ParserOutcome<Result>
}

enum ParserOutcome<Result> {
    case result(Result)
    case anotherParse(() -> ParserOutcome<Result>)
}


struct BarParser : Parser {
    func parse() -> ParserOutcome<String> {
        return .result("bar")
    }
}

struct FooParser : Parser {
    func parse() -> ParserOutcome<String> {
        let nextParser = BarParser()
        return .anotherParse(nextParser.parsE)
    }
}

...

let f = FooParser()
let outcome = f.parse()

switch outcome {
case .result(let result):
    print(result)
case .anotherParse(let nextParsE):
    let nextOutcome = nextParse()
}