Generics 比较泛型结构类型

如何确定泛型结构的两个实例是否属于同一类型

例如，给定以下结构：

struct FooBar<T> {
    let variable: T
    init(arg: T) {
        variable = arg
    }
}

如何确定

foo

、

bar

或

baz

是否属于相同或不同的类型

---

这给

类型“Foo”不符合协议“AnyObject”

---

这给

无法使用类型为“（Foo.type，Foo.type）”的参数列表调用“==”

---

这会产生三个错误：

一行中的连续语句必须用“；”分隔

（这需要在句点和“dynamicType”之间加一个分号）

虚线类型中应为标识符

及

期望表达式

编辑： 对于过早的回答，很抱歉，它实际上不起作用，因为当从另一个函数中调用时，编译器将为不同类型选择函数：

func foobar<T,U> (lhs: Foo<T>, rhs: Foo<U>) -> Bool {
    return lhs.sameType(rhs)
}

并使用两个不同的

Foo

s重载函数：

func sameType<T,U> (a: Foo<T>, b: Foo<U>) -> Bool {
    return false;
}

这与结构上的实例方法的工作方式相同：

    func sameType (other: Foo) -> Bool {
        return true
    }

    func sameType<U> (other: Foo<U>) -> Bool {
        return false
    }

---

结果是正确的，因为

因为Foo（v:x[0]）

具有类型

Foo

我从中获得了一些灵感，提出了以下解决方案：

func sameType<L,R>(left: L, right: R) -> Bool {
    if let cast = left as? R {
        return true
    } else {
        return false
    }
}

此处的

sameType

函数将始终返回

true

。就

sameType

而言，

foo

和

bar

的类型是

Any

，而不是我可能将其降级为的任何最具体的类型

---

可能还值得注意的是，如果我尝试将其嵌套为实例方法，Xcode会崩溃。再读一遍，Xcode崩溃。不是“产生不想要的结果”。应用程序崩溃

例如：

func sameType<L,R>(left: L, right: R) -> Bool {
    if let cast = left as? R {
        return true
    } else {
        return false
    }
}

struct Foo<T> {
    func sameType<U>(bar: U) -> Bool {
        return sameType(self, bar)
    }
}

let x = Foo<Int>()
let y = Foo<Float>()

if x.sameType(y) {
    println("x is a y")
}

---

Xcode编译和运行得很好。

如果我没有误解，您不想知道

FooBar

类型的变量是否属于同一类型（因为它们是），您需要检查它们是否使用相同的泛型类型

由于结构已包含泛型类型的属性，因此可以将其用于类型比较，而不是使用结构本身：

func areExactType<U>(x: FooBar<U>) -> Bool {
    return x.variable is T
}

func-areExactType（x:FooBar）->Bool{
返回x。变量为T
}

我在操场上进行了测试，它可以处理基本数据类型、数组、字典等。

---

缺点是，为了使其工作，结构必须具有泛型类型的属性。

它在非常有限的情况下工作，否则将毫无用处。我可以投票否决我自己的答案吗？在某些特定情况下仍然有用situations@Sebastian我发现你的答案有一点改进。在Swift 3.0中似乎不起作用：“参数标签与可用的重载不匹配。”对我来说，你的答案有点混乱。我不明白哪一部分是正确的，哪一部分是错误的。你知道哪一部分是故意写错的，哪一部分是故意写错以指出缺陷的。可以进行编辑吗？使用结构本身可以适当区分Foo和Foo是的，我同意这一点，但最终您要查找的是

T==U

。这只是解决问题的另一种方式。我看到您没有将任何答案标记为解决方案，所以我认为您正在寻找替代方案。但是如果您的结构是多个泛型类型，那么您的方法很快就会变得复杂。此外，如果类型不是一个可公开访问的变量呢？答案基于您提供的示例代码-它不是通用的，我同意当泛型不止一个时，它会变得复杂。至于可访问性，私有变量是可访问的，只要

x

参数的类型相同（在我们的例子中总是这样），我在谷歌搜索后才发现这个问题。未来的我感谢过去的我。

func sameType<T> (a: Foo<T>, b: Foo<T>) -> Bool {
    return true
}

func sameType<T,U> (a: Foo<T>, b: Foo<U>) -> Bool {
    return false;
}

let a = Foo(v: 1.0)
let b = Foo(v: "asdf")
sameType(a, b) // false
sameType(a, a) // true

    func sameType (other: Foo) -> Bool {
        return true
    }

    func sameType<U> (other: Foo<U>) -> Bool {
        return false
    }

import Foundation
let x = NSArray(object: 1)
let y = NSArray(object: "string")
sameType(Foo(v: x[0]), Foo(v: y[0])) // true

func sameType<L,R>(left: L, right: R) -> Bool {
    if let cast = left as? R {
        return true
    } else {
        return false
    }
}

func compare<T,U>(foo: T, bar: U) -> Bool {
    return sameType(foo, bar)
}

func compare(foo: Any, bar: Any) -> Bool {
    return sameType(foo, bar)
}

func sameType<L,R>(left: L, right: R) -> Bool {
    if let cast = left as? R {
        return true
    } else {
        return false
    }
}

struct Foo<T> {
    func sameType<U>(bar: U) -> Bool {
        return sameType(self, bar)
    }
}

let x = Foo<Int>()
let y = Foo<Float>()

if x.sameType(y) {
    println("x is a y")
}

if sameType(x,y) {
    println("x is a y")
}

func areExactType<U>(x: FooBar<U>) -> Bool {
    return x.variable is T
}