swift - Swift 中采用类型名称的通用函数

Question

在 C# 中，可以通过指定类型来调用泛型方法:

public T f<T>()
{
   return something as T
}

var x = f<string>()

Swift 不允许您在调用泛型方法时对其进行专门化。编译器想要依赖类型推断，所以这是不可能的:

func f<T>() -> T? {
    return something as T?
}

let x = f<String>() // not allowed in Swift

我需要的是一种使用泛型将类型传递给函数并且该函数返回该类型的对象的方法

这可行，但不太适合我想做的事情:

let x = f() as String?

编辑(澄清)

我可能不太清楚问题实际上是什么，这都是关于调用返回给定类型(任何类型)的函数的更简单的语法。

作为一个简单的示例，假设您有一个 Any 数组，并且创建了一个返回给定类型的第一个元素的函数:

// returns the first element in the array of that type
func findFirst<T>(array: [Any]) -> T? {
    return array.filter() { $0 is T }.first as? T
}

你可以像这样调用这个函数:

let array = [something,something,something,...]

let x = findFirst(array) as String?

这非常简单，但是如果返回的类型是带有方法的某种协议(protocol)并且您想在返回的对象上调用该方法怎么办:

(findFirst(array) as MyProtocol?)?.SomeMethodInMyProtocol()
(findFirst(array) as OtherProtocol?)?.SomeMethodInOtherProtocol()

这种语法很尴尬。在 C#(与 Swift 一样强类型)中，您可以执行以下操作:

findFirst<MyProtocol>(array).SomeMethodInMyProtocol();

遗憾的是，这在 Swift 中是不可能的。

所以问题是:有没有办法用更干净(不那么尴尬)的语法来完成这个任务。

Answer 1

不幸的是，您无法显式定义泛型函数的类型(通过使用 <...> 语法)。但是，您可以提供一个泛型元类型 ( T.Type ) 作为函数的参数，以便允许 Swift 推断函数的泛型类型，如 Roman has said 。 p>

对于您的具体示例，您希望您的函数如下所示:

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

这里我们使用 compactMap(_:) 来获取成功转换为 T 的元素序列，然后使用 first 来获取该序列的第一个元素。我们还使用 lazy，以便我们可以在找到第一个元素后停止评估元素。

使用示例:

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()

请注意，您必须使用 .self 才能引用特定类型的元类型(在本例中为 SomeProtocol )。也许不像您想要的语法那样光滑，但我认为它与您将获得的一样好。

尽管值得注意的是，在这种情况下，该函数最好放置在 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")