Swift generics and subclasses

Question

my question might be simple, but it got me puzzled a bit: Imagine I have an array of different objects which all have a common parent class "MyClass".

var values = [MyClass]()

However they all have their specific subclass like for example "MyClassSubclass".

values.append(MyClassSubclass())

I now want to create a generic method returning me the first object inside this array which is of type MyClassSubclass. I would like to prevent casting the object, but instead have a generic method which takes the subclass object as T parameter and returns me the first occurrence of subclass T inside this array.

I thought of something like this (but surely that does not work):

func getFirst<T: MyClass>(_ ofType : T.Type) -> T?

I guess I'm just stuck and I don't know what to search for, so if someone could help me I would greatly appreciate it.

Edit Example based on the above values:

class MyClass {}
class MyClassSubclass : MyClass {}
class MyClassSubclass2 : MyClass{}

var values = [MyClass]()
values.append(MyClassSubclass())
values.append(MyClassSubclass2())

//Return the first class element appearing here as a subclass type
func getFirst<T>(_ ofType : T.Type) -> T?{}

Thanks

Martin R · Accepted Answer · 2017-08-11 08:48:32Z

7

One approach is to iterate over the array and use optional binding to check if an element is of the given type:

func getFirst<T: MyClass>(ofType: T.Type) -> T? {
    for elem in values {
        if let item = elem as? T {
            return item
        }
    }
    return nil
}

This can be simplified using for case with the as pattern:

func getFirst<T: MyClass>(ofType: T.Type) -> T? {
    for case let item as T in values {
        return item
    }
    return nil
}

Another approach is to use flatMap to find all items of the given type and return the first one:

func getFirst<T: MyClass>(ofType: T.Type) -> T? {
    return values.flatMap { $0 as? T }.first
}

If the array can be large and you want to avoid the creation of an intermediate array then you can use lazy:

func getFirst<T: MyClass>(ofType: T.Type) -> T? {
    return values.lazy.flatMap { $0 as? T }.first
}

As an array extension method this would be

extension Array {
    func getFirst<T>(ofType: T.Type) -> T? {
        return flatMap { $0 as? T }.first
    }
}

edited Aug 11, 2017 at 8:48

answered Aug 11, 2017 at 8:40

Martin R

541k98 gold badges1.3k silver badges1.4k bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

binloan Over a year ago

I like your approach. Which one you think would be the fastest to return the first occurrence?

Martin R Over a year ago

@binloan: My guess would be that the for-loops are the fastest, one would have to to measure and compare. But I would recommend to check first if the performance of this part is crucial to your app. If the arrays are not large then I doubt that there will be much difference.

binloan Over a year ago

Okay I will test that. My arrays currently are not large, but this might happen in the future and I would like to have a proper implementation.

xoudini Over a year ago

+1 for the comprehensive answer. And @binloan, the for loops would probably be the faster (on average), since the flatMaps don't short circuit the operation.

Martin R Over a year ago

@xoudini: lazy.flatMap returns a "lazy collection", so that would short-circuit, but it has more overhead. So it depends on the array size.

思齐省身躬行 · Accepted Answer · 2017-08-11 08:31:29Z

2

If you'd like to use global function, which is not recommended, try this

func getFirst<T>(ofType: T.Type) -> T? where T: MyClass {
  for value in values where value is T {
    return value as? T
  }
  return nil
}

let first = getFirst(ofType: MyClassSubclass2.self)

The first answer should be better for Swift.

answered Aug 11, 2017 at 8:31

思齐省身躬行

1816 bronze badges

2 Comments

binloan Over a year ago

This looks rather smooth even though the "?" cast will be slower than if you used the "if let " structure. But why in your opinion this function is not recommended?

思齐省身躬行 Over a year ago

mainly because it's not elegant for reusing , the "extension array" is better

xoudini · Accepted Answer · 2017-08-11 08:25:29Z

1

This feels a bit like abuse of generics, but here's an extension:

extension Array where Element == MyClass {
    func getFirst<T>(_ ofType: T.Type) -> T? {
        return self.first(where: { ofType == type(of: $0) }) as? T
    }
}

The method can then be called as let first = values.getFirst(MyClassSubclass.self).

I'd personally prefer simply casting inline for clarity:

let first = values.first(where: { type(of: $0) == MyClassSubclass.self }) as? MyClassSubclass

answered Aug 11, 2017 at 8:25

xoudini

7,0215 gold badges26 silver badges37 bronze badges

2 Comments

binloan Over a year ago

I like the extension way however to clarify this. It will be part of a touch framework where a framework user shall be able to easily retrieve the first instance of an object type. That's why I want this. So extensions would be bad because of the needed public scope. Also your second approach would not work because it moves the load to the framework user (am I right?) -

xoudini Over a year ago

Why would extensions be bad in a framework? A lot of frameworks use extensions of built-in Swift and UIKit types.

Collectives™ on Stack Overflow

Swift generics and subclasses

3 Answers 3

5 Comments

2 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

5 Comments

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related