Swift 泛型类型推断

Question

所以我想知道是否有人可以解释这个错误背后的原因或解释我做错了什么。

我正在尝试创建一个通用函数，该函数采用协议约束类型，该类型有一个名为solve 的静态方法。

但由于某种原因，即使它在 Xcode 中很好地解决了约束，编译器也会发出嘶嘶声。

是否有任何原因它不能推断出我已经指定的类型，或者我的代码示例中是否存在幼稚错误？

编辑：因为它不够明确

我知道如何解决它，我只是想知道为什么接口/协议中的静态成员有问题。

protocol NodeSolver {
    static func solve(_ nodes: [Node]) -> [Node]
}

func findPath<T: NodeSolver>(nodes: [Node]) -> [Node]  {        
        return T.solve(nodes)
    }

Answer 1

因为您似乎希望findPath 成为一种与符合NodeSolver 的类型 密切相关的方法，但不会在@987654324 中使用此具体NodeSolver 类型的任何实例@ 方法本身，您可能需要考虑简单地将通用 findPath 方法添加为默认实现可用于符合 NodeSolver 的所有类型的类型方法。

例如：

struct Node {}

protocol NodeSolver {
    static func solve(_ nodes: [Node]) -> [Node]
    static func findPath(nodes: [Node]) -> [Node]
}

extension NodeSolver {
    static func findPath(nodes: [Node]) -> [Node]  {
        // hopefully some more logic ...
        return Self.solve(nodes)
    }
}

struct MyNodeSolver: NodeSolver {
    // dummy solver
    static func solve(_ nodes: [Node]) -> [Node] {
        return nodes
    }
}

let myNodes = [Node(), Node()]

// make use of the default implementation of `findPath` available
// to all types conforming to 'NodeSolver': this method itself
// make use of the concrete type-specific implementation of 'solve'
// in the types conforming to 'NodeSolver'.
let dummyPath = MyNodeSolver.findPath(nodes: myNodes)

---

我在我指定的协议中处理了一个受约束的类型。和 方法调用中的实际类型。

findPath<NodeSolver1>(nodes)
findPath<NodeSolver2>(nodes)

另一个可能更接近您想要实现的解决方法是将泛型函数包装成一个泛型类型（例如，struct），它包含一个非泛型函数findPath w.r.t。泛型类型的具体版本。如果从拥有类型外部的角度查看包装的 findPath，则函数是通用的 w.r.t。所属类型的泛型类型持有者。

例如：

struct Node {}

protocol NodeSolver {
    static func solve(_ nodes: [Node]) -> [Node]
}

struct NodeSolverA: NodeSolver {
    static func solve(_ nodes: [Node]) -> [Node] {
        return nodes
    }
}

struct NodeSolverB: NodeSolver {
    static func solve(_ nodes: [Node]) -> [Node] {
        return nodes.reversed()
    }
}

// instead of a generic function, wrap a concrete function
// in a generic type
struct AnyNodeSolver<T: NodeSolver> {
    static func findPath(nodes: [Node]) -> [Node]  {
        return T.solve(nodes)
    }
}

let myNodes = [Node(), Node()]

let dummyPathA = AnyNodeSolver<NodeSolverA>.findPath(nodes: myNodes)
let dummyPathB = AnyNodeSolver<NodeSolverB>.findPath(nodes: myNodes)

Answer 2

您必须在函数签名中指定T 的类型。

func findPath<T: NodeSolver>(nodes: [Node], ofType type: T.Type) -> [Node]  {        
    return T.solve(nodes)
}

Answer 3

如果你定义了一个泛型类型，你必须让编译器以某种方式推断出实际的类型。目前没有办法实现这一目标。您将如何使用不同的NodeSolvers 对该方法进行两次调用？

Yannick 写了一个指定类型的答案 - 你问“那么泛型的意义何在？如果你必须指定它两次？” - 你不必。一般示例：

protocol P {
    static func solve(argument : String)
}

class P1 : P {
    class func solve(argument : String) {
        print("first")
    }
}

class P2 : P {
    class func solve(argument : String) {
        print("second")
    }
}


func doSome(argument : String, a : P.Type) {
    a.solve(argument: argument)
}

doSome(argument: "", a: P1.self) // prints "first"
doSome(argument: "", a: P2.self) // prints "second"

在你的情况下：

func findPath(nodes: [Node], solver: NodeSolver.Type) -> [Node]  {        
    return solver.solve(nodes)
}