具有泛型类型的协议函数

Question

我想创建如下协议：

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

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

我想让解析器返回特定类型的结果或另一个解析器。

如果我在Parser 上使用关联类型，那么我不能在enum 中使用Parser。如果我在parse() 函数上指定了泛型类型，那么我无法在没有泛型类型的实现中定义它。

我怎样才能做到这一点？

---

使用泛型，我可以这样写：

class Parser<Result> {
    func parse() -> ParserOutcome<Result> { ... }
}

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

这样，Parser 将由结果类型参数化。 parse() 可以返回 Result 类型的结果，或任何类型的解析器，该解析器将输出 Result 类型的结果，或由相同 Result 类型参数化的另一个解析器。

然而，据我所知，对于关联类型，我将始终有一个 Self 约束：

protocol Parser {
    associatedtype Result

    func parse() -> ParserOutcome<Result, Self>
}

enum ParserOutcome<Result, P: Parser where P.Result == Result> {
    case result(Result)
    case parser(P)
}

在这种情况下，我不能再使用任何类型的解析器来返回相同的 Result 类型，它必须是相同类型的解析器。

我希望使用Parser 协议获得与使用泛型定义相同的行为，并且我希望能够在类型系统的范围内做到这一点，而无需引入新的盒装类型，只需就像我可以使用正常的通用定义一样。

在我看来，在 Parser 协议中定义 associatedtype OutcomeParser: Parser，然后返回由该类型参数化的 enum 可以解决问题，但如果我尝试以这种方式定义 OutcomeParser，我会收到错误：

类型不能将自身作为要求引用

Answer 1

完成这项工作所需的功能状态：

• 递归协议约束 (SE-0157) 已实现 (Swift 4.1)
• 协议中的任意要求 (SE-0142) 已实现 (Swift 4)
• 通用类型别名 (SE-0048) 已实现 (Swift 3)

---

目前看来，如果不引入盒装类型（“类型擦除”技术），这是不可能实现的，并且正如 @ 的 Recursive protocol constraints 和 Arbitrary requirements in protocols 部分所述，这是 Swift 的未来版本所考虑的东西987654326@（因为不支持generic protocols）。

当 Swift 支持这两个特性时，以下内容应该生效：

protocol Parser {
    associatedtype Result
    associatedtype SubParser: Parser where SubParser.Result == Result

    func parse() -> ParserOutcome<Result, SubParser>
}

enum ParserOutcome<Result, SubParser: Parser where SubParser.Result == Result> {
    case result(Result)
    case parser(P)
}

使用generic typealiases，子解析器类型也可以提取为：

typealias SubParser<Result> = Parser where SubParser.Result == Result

Answer 2

我不会这么快就将类型擦除视为“hacky”或“绕过 [...] 类型系统”——事实上，我认为它们与 类型系统，以便在使用协议时提供有用的抽象层（如前所述，用于标准库本身，例如 AnySequence、AnyIndex 和 AnyCollection）。

正如您自己所说，您在这里要做的就是有可能从解析器返回给定的结果，或者返回另一个处理相同结果类型的解析器。我们不关心该解析器的具体实现，我们只想知道它有一个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 中，您可以简单地指定parser 案例具有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 仍在强制执行类型安全。我们正在尝试将BarParser 实例（与Strings 一起使用）包装在需要Int 泛型参数的AnyParser 类型已擦除包装器中，从而导致编译器错误。一旦将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()
}

Answer 3

我认为您想对 ParserOutcome 枚举使用通用约束。

enum ParserOutcome<Result, P: Parser where P.Result == Result> {
    case result(Result)
    case parser(P)
}

这样，您将无法将ParserOutcome 与不符合Parser 协议的任何内容一起使用。您实际上可以再添加一个约束以使其更好。添加Parser 结果的结果将与Parser 的关联类型相同的约束。