Generic function taking a type name in Swift

by

Unfortunately, you cannot explicitly define the type of a generic function (by using the <...> syntax on it). However, you can provide a generic metatype (T.Type) as an argument to the function in order to allow Swift to infer the generic type of the function, as Roman has said.

For your specific example, you’ll want your function to look something like this:

func findFirst<T>(in array: [Any], ofType _: T.Type) -> T? {
  return array.lazy.compactMap { $0 as? T }.first
}

Here we’re using compactMap(_:) in order to get a sequence of elements that were successfully cast to T, and then first to get the first element of that sequence. We’re also using lazy so that we can stop evaluating elements after finding the first.

Example usage:

protocol SomeProtocol {
  func doSomething()
}

protocol AnotherProtocol {
  func somethingElse()
}

extension String : SomeProtocol {
  func doSomething() {
    print("success:", self)
  }
}

let a: [Any] = [5, "str", 6.7]

// Outputs "success: str", as the second element is castable to SomeProtocol.
findFirst(in: a, ofType: SomeProtocol.self)?.doSomething()

// Doesn't output anything, as none of the elements conform to AnotherProtocol.
findFirst(in: a, ofType: AnotherProtocol.self)?.somethingElse()

Note that you have to use .self in order to refer to the metatype of a specific type (in this case, SomeProtocol). Perhaps not a slick as the syntax you were aiming for, but I think it’s about as good as you’re going to get.

Although it’s worth noting in this case that the function would be better placed in an extension of Sequence:

extension Sequence {
  func first<T>(ofType _: T.Type) -> T? {
    // Unfortunately we can't easily use lazy.compactMap { $0 as? T }.first
    // here, as LazyMapSequence doesn't have a 'first' property (we'd have to
    // get the iterator and call next(), but at that point we might as well
    // do a for loop)
    for element in self {
      if let element = element as? T {
        return element
      }
    }
    return nil
  }
}

let a: [Any] = [5, "str", 6.7]
print(a.first(ofType: String.self) as Any) // Optional("str")

More Related Contents:

  1. Extend array types using where clause in Swift
  2. Protocol doesn’t conform to itself?
  3. Overriding methods in Swift extensions
  4. Swift generic coercion misunderstanding
  5. Protocol can only be used as a generic constraint because it has Self or associatedType requirements
  6. Return instancetype in Swift
  7. Swift 2 – UnsafeMutablePointer to object
  8. Swift do-try-catch syntax
  9. Is it possible to add type constraints to a Swift protocol conformance extension?
  10. What does “Protocol … can only be used as a generic constraint because it has Self or associated type requirements” mean?
  11. The “++” and “–” operators have been deprecated Xcode 7.3
  12. Using a Type Variable in a Generic
  13. Get integer value from string in swift
  14. Is it possible to replicate Swifts automatic numeric value bridging to Foundation (NSNumber) for (U)Int8/16/32/64 types?
  15. Swift generics not preserving type
  16. Fix warning “C-style for Statement is deprecated” in Swift 3
  17. fatal error: swapping a location with itself is not supported with Swift 2.0
  18. Why is Equatable not defined for optional arrays
  19. Selecting global or object print function
  20. How to pass one SwiftUI View as a variable to another View struct
  21. Swift 2.0 : ‘enumerate’ is unavailable: call the ‘enumerate()’ method on the sequence
  22. Any reason not use use a singleton “variable” in Swift?
  23. Default value for optional generic parameter in Swift function
  24. Convert Swift Array to Dictionary with indexes [duplicate]
  25. Iterate through a String Swift 2.0
  26. How do you enumerate OptionSetType in Swift?
  27. Convert Character to Int in Swift 2.0
  28. Xcode 7 Swift 2 impossible to instantiate UIViewController subclass of generic UITableViewController
  29. Whats the Swift animate WithDuration syntax?
  30. How to convert a binary to decimal in Swift?

Leave a Comment