Swift 消除协议组合歧义

是否可以确定合成的

Any.Type

是否包含特定的

Any.Type

（A&B）.self

包含

A.self

=>true

（B&C）.self

包含

A.self

=>错误

代码示例

protocol A {}
protocol B {}
typealias AB = A & B

func conformsToA(_ type: Any.Type) -> Bool {
    return type == A.self
}

print(conformsToA(A.self))       // true
print(conformsToA(AB.self))      // false (but should be true)

我可以为

type==（a&B）.self在
conformsToA（:）
中添加一个特定的子句，但这很快就会变得难以管理。想象一下，如果引入了C-Z协议，我尝试检查如下内容：

conformsToA((A & C & E & Z).self)

另一次尝试使用Alistra的第二种方法

protocol A {}
protocol B {}
typealias AB = A & B
func conformsToA<T>(_ t1: T.Type) -> Bool {
    return T.self is A
}

print(conformsToA(A.self))       // false (but should be true)
print(conformsToA(AB.self))      // false (but should be true)

协议A{}
B议定书{}
类型别名AB=A&B
func conformsToA（t1:T.Type）->Bool{
返回T.self是一个
}
print（conformsToA（A.self））//false（但应为true）
print（conformsToA（AB.self））//false（但应为true）
编辑：正如@Hamish在评论中所说，这是不可能的

这里有一个快速进化的建议可以解决这个问题

它没有进入Swift 4第2阶段

您可以使用泛型和
is

protocol A {}
protocol B {}
protocol C {}
typealias AB = A & B
typealias ABC = A & B & C

func conformsTo<T>(_ object: Any, t: T.Type) -> Bool {
    return object.self is T
}

class CL : AB {}

print(conformsTo(CL(), t: A.self)) // true
print(conformsTo(CL(), t: AB.self)) // true
print(conformsTo(CL(), t: ABC.self)) // false

协议A{}
B议定书{}
协议C{}
类型别名AB=A&B
类型别名ABC=A&B&C
func conformsTo（uObject:Any，t:t.Type）->Bool{
返回object.self为T
}
类别CL:AB{}
print（conformsTo（CL（），t:A.self））//true
打印（符合（CL（），t:AB.self））//true
打印（conformsTo（CL（），t:ABC.self））//false

或者没有类的实例

protocol A {}
protocol B {}
protocol C {}
typealias AB = A & B
typealias ABC = A & B & C

func conformsTo<T, U>(_ t1: T.Type, t2: U.Type) -> Bool {
    return T.self is U.Type
}


print(conformsTo(ABC.self, t2: A.self)) // false
print(conformsTo(ABC.self, t2: AB.self)) // false
print(conformsTo(ABC.self, t2: ABC.self)) // true
print(conformsTo(AB.self, t2: A.self)) // false
print(conformsTo(AB.self, t2: AB.self)) // true
print(conformsTo(AB.self, t2: ABC.self)) // false
print(conformsTo(A.self, t2: A.self)) // true
print(conformsTo(A.self, t2: AB.self)) // false
print(conformsTo(A.self, t2: ABC.self)) // false

协议A{}
B议定书{}
协议C{}
类型别名AB=A&B
类型别名ABC=A&B&C
函数符合（uT1:T.型，t2:U.型）->Bool{
返回T.self为U型
}
打印（符合（ABC.self，t2:A.self））//false
打印（符合（ABC.self，t2:AB.self））//false
打印（符合（ABC.self，t2:ABC.self））//true
打印（符合（AB.self，t2:A.self））//false
打印（符合（AB.self，t2:AB.self））//true
打印（符合（AB.self，t2:ABC.self））//false
打印（符合（A.self，t2:A.self））//true
打印（符合（A.self，t2:AB.self））//false
打印（符合（A.self，t2:ABC.self））//false
您的第二个示例只匹配相同的情况，即
ABC.self
和
ABC.self
——但不是像
ABC.self
和
A.self
这样的情况。不幸的是，我需要一个没有具体对象的解决方案，因此第一个选项不能完全解决它。Hamish指出的第二个解决方案也不是我想要的。我已经更新了我的代码，并使用了第二个解决方案的修改版本，但结果仍然不太正确。如果不创建符合给定协议的具体类型的实例，我认为这是不可能的，因为，因此
AB.self
不是
a.Protocol
。虽然我很好奇你的用例是什么？有趣的是，在玩这个的时候发现了一个奇怪的bug–
a.self是a.Type
的计算结果是
true
（它真的不应该）。演员
A.self-as！A.Type
失败。