是否有任何方法可以确定子协议的一致性，例如是否符合Swift 2中的通用协议(在运行时或编译期间)

我正在将Java库移植到Swift 2.0，并且在泛型方面遇到了一些问题。

我有以下协议层次结构：

public protocol Graph {
    typealias V: Hashable
    typealias E: Hashable
    func getAllEdges(sourceVertex: V, targetVertex: V) -> Set<E>?
    func getEdge(sourceVertex: V, targetVertex: V) -> E?
    func getEdgeFactory() -> EdgeFactory<V, E>?
    func addEdge(sourceVertex: V, targetVertex: V) -> E?
    func addEdge(sourceVertex: V, targetVertex: V, e: E) -> Bool
    func addVertex(v: V) -> Bool
    func containsEdge(sourceVertex: V, targetVertex: V) -> Bool
    func containsEdge(e: E) -> Bool
    func containsVertex(v: V) -> Bool
    func edgeSet() -> Set<E>
    func edgesOf(v: V) -> Set<E>
    func removeAllEdges<T: CollectionType where T.Generator.Element == E>(edges: T) -> Bool
    func removeAllEdges(sourceVertex: V, targetVertex: V) -> Set<E>?
    func removeAllVertices<T: CollectionType where T.Generator.Element == V>(vertices: T) -> Bool
    func removeEdge(sourceVertex: V, targetVertex: V)
    func removeEdge(e: E) -> Bool
    func removeVertex(v: V) -> Bool
    func vertexSet() -> Set<V>
    func getEdgeSource(e: E) -> V
    func getEdgeTarget(e: E) -> V
    func getEdgeWeight(e: E) -> Double
}
public protocol DirectedGraph: Graph {
    func inDegreeOf(vertex: V) -> Int
    func incomingEdgesOf(vertex: V) -> Set<E>
    func outDegreeOf(vertex: V) -> Int
    func outgoingEdgesOf(vertex: V) -> Set<E>
}
public protocol UndirectedGraph: Graph {    
    func degreeOf(vertex: V) -> Int
}

下面是引起麻烦的类的定义：

public class CrossComponentIterator
    <V: Hashable, E: Hashable, D, G: Graph
        where G.V == V, G.E == E>
    : AbstractGraphIterator<V, E>

也就是说，它有一个方法，应该根据传递的图的实际类型初始化它的一个变量——DirectedGraph或UndirectedGraph。

我试图通过声明多个版本的函数来解决这个问题：

func createGraphSpecifics<DG: Graph where DG: DirectedGraph, DG.V == V, DG.E == E>(graph: DG)
    -> CrossComponentIteratorSpecifics<V, E>
{
    return DirectedSpecifics<V, E, DG>(graph: graph)
}
func createGraphSpecifics<UG: Graph where UG: UndirectedGraph, UG.V == V, UG.E == E>(graph: UG)
    -> CrossComponentIteratorSpecifics<V, E>
{
    return UndirectedSpecifics<V, E, UG>(graph: graph)
}
func createGraphSpecifics<GG: Graph where GG.V == V, GG.E == E>(graph: GG)
    -> CrossComponentIteratorSpecifics<V, E>
{
    fatalError("Unknown graph type instance")
}

但不幸的是，对于图的任何实例（即使它符合"DirectedGraph"或"UndirectedGraph"），都只调用函数的最后一个版本

我知道，我可能可以通过将协议DirectedGraph和UndirectedGraph转换为抽象类来解决这个问题（我指的是在每个声明的函数中都有致命错误（）的类，因为Swift在法律上不支持抽象类）。

但也许还有另一种更优雅、更快捷的解决方案？

在Java中，这是微不足道的——在运行时检查与接口的一致性：

if (g instanceof DirectedGraph<?, ?>) {
    return new DirectedSpecifics<V, E>((DirectedGraph<V, E>) g);
} else {
    return new UndirectedSpecifics<V, E>(g);
}

编辑以下是我试图实现的最低代码：

protocol P {
    // This typealias makes impossible to use 'P'
    // (or its descendants) as a type.
    // It can be used only as generic constraint.
    typealias A
    // myfunc is needed for compiler to infer 'A'
    func myfunc(a: A)
}
protocol P1:P {
    func p1specific(a: A)
}
protocol P2:P {
    func p2specific(a: A)
}
struct S<T:P> {
    init(t: T) {
        // TODO: check if 't' conforms to 'P1', 'P2', both or neither
    }
}
// Examples of concrete implementations of 'P1' and 'P2'
struct S1<X>:P1{
    func myfunc(a: X) {}
    func p1specific(a: X) {}
}
struct S2<X>:P2{
    func myfunc(a: X) {}
    func p2specific(a: X) {}
}