Swift: Convert Foo<String> to Foo<Any> - ios

Question

here is my code
class Foo<T> {
}
class Main {
static func test() {
var foo: Foo<Any>
var bar = Foo<String>()
//Do all my stuff with foo necessitating String
foo = bar
}
}
When I try to assign foo = bar I get an error Cannot assign a value of type Foo<String> to a value of type Foo<Any>.
I don't understand why I got this error, since String conforms to Any.
If I do exactly the same thing but using Array, I don't have any error
static func test() {
var foo: Array<Any>
var bar = Array<String>()
//Do all my stuff with foo necessitating String
foo = bar
}
Does anyone know what's wrong with my code?
Thanks

Answer 1

Arrays and dictionaries are special types that have this kind of behavior built in. This does, however, not apply to custom generic types. The type Foo<Any> is not a supertype (or in this case superclass) of Foo<String> even though Any is a supertype of String. Therefore, you cannot assign variables of these types to each other.
Depending on your particular case the solution outlined in Swift Cast Generics Type might work for you. When Foo wraps a value of type T you can add a generic constructor that converts the value from a differently typed instance of Foo.
class Foo<T> {
var val: T
init(val: T) {
self.val = val
}
init<O>(other: Foo<O>) {
self.val = other.val as! T
}
}
class Main {
static func test() {
var foo: Foo<Any>
var bar = Foo<String>(val: "abc")
//Do all my stuff with foo necessitating String
foo = Foo<Any>(other: bar)
}
}

Answer 2

I have improved on #hennes answer by adding the ability to define how you want to convert from type O to type T
class Foo<T> {
var val: T
init(val: T) {
self.val = val
}
init<O>(other:Foo<O>, conversion:(O) -> T) {
self.val = conversion(other.val)
}
}
class Main {
static func test() {
var foo: Foo<Int>
var bar = Foo<String>(val: "10")
//Do all my stuff with foo necessitating String
foo = Foo<Int>(other: bar, conversion: {(val) in
return Int(val.toInt()!)
})
print(foo.val) //prints 10
print(foo.val.dynamicType) //prints Swift.Int
}
}
This gives you the ability to convert between two types that don't support casting to each other. Additionally, it gives a compiler warning when the conversion is illegal, as opposed to crashing due to the forced cast.
No idea why there is a difference in compiler warnings for 1 or >1 line closures but there are.
Bad compiler warning for 1-line closure
Good compiler warning for 2-line closure