Swift通用类型推理

Question

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

我想创建一个通用函数，它需要一个协议约束类型，它有一个静态方法称为求解。

但由于某些原因，即使它解决了Xcode中的约束问题，编译器仍然会引发一些棘手的问题。

是否有任何理由不应该能够推断出我已经指定的类型，或者在我的代码示例中是否存在天真的错误？

编辑：由于它不是足够

我知道如何解决它明确的，我只是好奇，对于为什么在接口的静态成员/协议是有问题的解释。

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

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

Answer 1

因为它似乎想要findPath是强连接到的类型符合NodeSolver的方法，但在findPath方法本身不会使用这种混凝土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

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

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) 
} 

Answer 4

谈过谁与这个回答一个同事（这是在C＃中，但相关的）

，并解释来讲这个问题的问题语言实现。

感谢您的答案和时间。

https://blogs.msdn.microsoft.com/ericlippert/2007/06/14/calling-static-methods-on-type-parameters-is-illegal-part-one/