Swift Cast as Generic crashing with UInt

Question

Why does the following Array extension crash if the array used with it is of type UInt, but works if the array is of type Int or String?

extension Array
{
func indexOf<T:Equatable>(value:T) -> Int?
{
    for (i, val) in enumerate(self)
    {
        if (val as T == value)
        {
            return i;
        }
    }
    return nil;
}
}

var a:[UInt] = [243, 234, 1, 212, 3, 56, 88, 11, 77];
var i = a.indexOf(234);

Error produced:

Playground execution failed: error: Execution was interrupted, reason: EXC_BREAKPOINT (code=EXC_I386_BPT, subcode=0x0). The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation. * thread #1: tid = 0x27a3c, 0x00000001079d3f27 libswift_stdlib_core.dylibswift_dynamicCast + 1063, queue = 'com.apple.main-thread', stop reason = EXC_BREAKPOINT (code=EXC_I386_BPT, subcode=0x0) * frame #0: 0x00000001079d3f27 libswift_stdlib_core.dylibswift_dynamicCast + 1063 frame #1: 0x00000001137bbbc8

Where is the difference to your previous (now deleted) question http://stackoverflow.com/questions/24971573/extending-swift-array-with-indexof-crashes-with-uint-typed-array ? — Martin R, Jul 26 '14 at 15:04
Where is the relevance of your comment compared to your comment in my previous question?! — BadmintonCat, Jul 26 '14 at 15:11
possible duplicate of [Array extension to remove object by value](http://stackoverflow.com/questions/24938948/array-extension-to-remove-object-by-value) — Martin R, Jul 26 '14 at 15:19

drewag · Accepted Answer · 2014-07-26T15:20:48.220

The problem is that the T: Equatable that you define is unrelated to the T that is stored in the array. When you do val as T, you are converting from the array value type to your new local T that is required to be equatable.

When you call indexOf with a literal, it is not being forced into the same type as is stored in a because the type is not enforced to match by your extension.

You are better off with a function to get the index of an object in an array:

func indexOfObject<T : Equatable>(object: T, inArray collection: [T]) -> Int? {
    var index : Int = 0
    for testObject in collection {
        if testObject == object {
            return index
        }
        index++
    }
    return nil
}

That strictly enforces that the T type is equatable and matches the type of the object passed in.

Better yet, you might want to use an extension like this:

extension Array {
    func indexOfObjectPassingTest(test: (object: T) -> Bool) -> Int? {
        var index : Int = 0
        for object in self {
            if test(object: object) {
                return index
            }
            index++
        }
        return nil
    }
}

That is more flexible and allows you to do:

var i = a.indexOfObjectPassingTest({$0 == 234})

Notice also that I do not define T for my method because it is already defined in the Array itself.

Thanks for the quick explanation and example! Seems an extension will not be suitable for this. — BadmintonCat, Jul 26 '14 at 15:22
Maybe I'm not seeing the flexibility yet but I believe closures should not be necessary for a simple indexOf call. — BadmintonCat, Jul 26 '14 at 15:28
@Avalon, a closure is only "necessary" in this case because you cannot guarantee that all types stored in an array are equatable. It gives you the extra flexibility to do infinite types of tests to find an object, all with one method. For example, you could use `{$0 > 234}` to find the first index that is greater than 234. You could also use `{$0 === someObj}` for an array that stores a reference type (a Class type) — drewag, Jul 26 '14 at 15:31
I see! Yes, that's quite flexible. Thanks for the info. I will regard both methods. — BadmintonCat, Jul 26 '14 at 15:35

Swift Cast as Generic crashing with UInt

1 Answers1