Strange generics behavior in swift - ios

Question

Good day!
I am currently trying to learn programming swift and trying some examples of generics. Here is my example code
func findAll<T: Equatable>(arr: [T], _ elem: T) -> [Int] {
var indexesArr = [Int]()
var counter = 0
for i in arr {
if i == elem {
indexesArr.append(counter)
}
counter++
}
return indexesArr
}
findAll([5, 3, 7, 3, 9], 3)
findAll(["a", "b", "c", "b", "d"], 2.0)
It was supposed, that both arguments will be of the same type. But, unfortunately, as you can see I pass an array of string characters and a Double in my second function invocation and it still works! It returns an empty array []. No runtime or compile errors.
Please, explain me why it works and some workarounds maybe. Thank you!

Answer 1

Presumably you have import Cocoa or import Foundation in your code somewhere. If you remove that, you'll find that your code behaves as you're expecting.
The reason this happens is that importing Foundation causes Swift.Array to magically bridge to NSArray (aka [AnyObject]), and certain primitive value types to magically bridge to Foundation object types (like NSString and NSNumber). Once that happens, it's perfectly legal to call your function with parameters of types [AnyObject] and AnyObject.
I'm not aware of a good way around the magic conversion, but one way that works is to force your generic parameter to have a protocol that primitive value types conform to, but primitive values magically wrapped in Cocoa objects don't. One way to assure such is to create your own protocol:
public protocol NotAnyObject {}
extension Int: NotAnyObject {}
extension String: NotAnyObject {}
extension Double: NotAnyObject {}
func findAll<T: Equatable where T: NotAnyObject>(arr: [T], _ elem: T) -> [Int] { /*...*/ }
I'm not sure this is the best way, though... alternative proposals are welcome.
By the way, a more idiomatic/Swifty way to do something like this would be as a type extension (either a protocol extension, as below, or an extension on Array where Element: Equatable). You can even go functional-programming-style just for fun:
extension CollectionType where Generator.Element : Equatable {
public func allIndexesOf(element: Self.Generator.Element) -> [Self.Index] {
return zip(self.indices, self) // makes sequence of (index, element)
.filter { $0.1 == element }
.map { $0.0 }
}
}
Call it like this:
let threes = [5, 3, 7, 3, 9].allIndexesOf(3)
// returns [1, 3]
This is still subject to the same magic conversions issue, though:
let notThrees = ["twenty", "forty", "eight"].allIndexesOf[2.0]
// still compiles, returns []
So you'd still need to either use this extension only from Swift files that don't import Foundation, or apply a variant of the same hack as above, e.g.:
extension CollectionType where Generator.Element: Equatable,
Generator.Element: NotAnyObject { /*...*/ }

Answer 2

For the problem explanation see rickster's answer
Note that to solve problems like this, you can always just check how Swift libraries do it. The solution is to have both arguments as generics and using protocol constraints.
E.g. using SequenceType protocol instead of an Array.
func findAll<S: SequenceType, T: Equatable where S.Generator.Element == T>(arr: S, _ elem: T) -> [Int] {
var indexesArr = [Int]()
var counter = 0
for i in arr {
if i == elem {
indexesArr.append(counter)
}
counter++
}
return indexesArr
}