Swift 4.0 在类型内部实现自定义运算符作为类型方法与在全局范围内实现自定义运算符作为全局函数之间的区别

Question

给定一个解析器类型如下:

public struct Parser<Result> {
  internal let parse: (String) -> (Result, String)?

  public func run(_ string: String) -> (Result, String)? {
    guard let (result, remainder) = parse(string) else { return nil }
    return (result, remainder)
  }

  public func map<T>(_ transform: @escaping (Result) -> T )
    -> Parser<T> {
      return Parser<T> { input in
        guard let (result, remainder) = self.run(input) else { return nil }
        return (transform(result), remainder)
      }
  }

  public func followed<A>(by other: Parser<A>) -> Parser<(Result, A)> {
    return Parser<(Result, A)> {  input in
      guard let (result, remainder) = self.run(input) else { return nil }
      guard let (resultA, remainderA) = other.run(remainder) else { return nil }
      return ((result, resultA), remainderA)
    }
  }
}

第一次实现如下:

infix operator >>> : FunctionCompositionPrecedence
public func >>> <A, B> (lhs: Parser<A>, rhs: Parser<B>) 
  -> Parser<(A,B)> {
  return lhs.followed(by: rhs)
}

第二次实现如下:

infix operator >>> : FunctionCompositionPrecedence
extension Parser {
  public static func >>> <A, B> (lhs: Parser<A>, rhs: Parser<B>) 
    -> Parser<(A,B)> {
    return lhs.followed(by: rhs)
  }
}

将问题重新定义为第一个实现与第二个实现之间的区别。

另外，当我使用第一个实现，编译如下代码时，编译器报错如下“‘map’产生‘Parser’，而不是预期的上下文结果类型‘Parser’”

extension Parser {
  public static func apply <A, B> (_ lhs: Parser<(A)->B>, _ rhs: Parser<A>) -> Parser<B> {
    return (lhs >>> rhs).map{(arg) -> B in let (f, x) = arg; return f(x)}
  }
}

但是，在我使用第二个实现后，一切正常。我对它们之间的细微差别感到非常困惑。

Answer 1

与

infix operator >>> : FunctionCompositionPrecedence
extension Parser {
  public static func >>> <A, B> (lhs: Parser<A>, rhs: Parser<B>) 
    -> Parser<(A,B)> {
    return lhs.followed(by: rhs)
  }
}

您没有为编译器提供任何方法来推断通用占位符 Result在调用运算符时(我真的认为编译器应该在此处出错而不是在使用时出错)。请记住，泛型类型的静态方法是在这些类型的特化 上调用的；必须满足占位符(因为它们可以在静态范围内访问)。

直接回答

what is the difference between the first implementation and the second one.

主要区别在于，作为静态成员，您有额外的通用占位符 Result需要满足；作为顶级功能，您没有。

所以，如果你想保留 >>>作为静态方法，您需要使用 Result运算符实现签名中的占位符，以便编译器可以根据使用情况推断其类型，例如:

infix operator >>> : FunctionCompositionPrecedence
extension Parser {

  public static func >>> <B> (
    lhs: Parser, rhs: Parser<B> 
  ) -> Parser<(Result, B)> {
      return lhs.followed(by: rhs)
  }
}

现在Result可以从作为 lhs 传递的参数类型推断出来运算符的( Parser 在这种情况下是 Parser<Result> 的语法糖)。

注意你会遇到类似的问题

extension Parser {
  public static func apply <A, B> (_ lhs: Parser<(A)->B>, _ rhs: Parser<A>) -> Parser<B> {
    return (lhs >>> rhs).map{(arg) -> B in let (f, x) = arg; return f(x)}
  }
}

因为您需要明确满足 Result调用时的占位符；尽管用于满足它的类型实际上不会被该方法使用。

更好的方法是使用 Result签名中的占位符以允许编译器在调用站点推断它:

extension Parser {

  public static func apply<Arg>(
    _ lhs: Parser<(Arg) -> Result>, _ rhs: Parser<Arg>
  ) -> Parser<Result> {

    return (lhs >>> rhs).map { arg -> Result in
      let (f, x) = arg
      return f(x)
    }
  }
}

// ...

let p = Parser<(String) -> String> { input in ({ $0 + input }, "hello") }
let p1 = Parser { ($0, "") }

let p2 = Parser.apply(p, p1)
print(p2.run(" world") as Any) // Optional(("hello world", ""))

或者，更好的是，作为实例方法:

extension Parser {

  public func apply<A, B>(with rhs: Parser<A>) -> Parser<B>
    where Result == (A) -> B {

    return (self >>> rhs).map { arg -> B in
      let (f, x) = arg
      return f(x)
    }
  }
}

// ...

let p = Parser<(String) -> String> { input in ({ $0 + input }, "hello") }
let p1 = Parser { ($0, "") }

let p2 = p.apply(with: p1)
print(p2.run(" world") as Any) // Optional(("hello world", ""))