过滤没有反射或强制转换的泛型类型

Question

在 Kotlin 中，reified generics 的形式有限。有没有办法使用具体化来过滤泛型类型而不使用getClass() 或as 或任何类型的奇怪注释，即。只需使用is 关键字？例如，我有以下结构：

import java.util.*

internal class Layout<out T : LayoutProtocol>(val t: T) {
    fun getName(): String {
        return t.getName()
    }
}

interface LayoutProtocol {
    fun getName(): String
}

internal class Vertical : LayoutProtocol {
    override fun getName(): String {
        return "Vertical"
    }
}

internal class Horizontal : LayoutProtocol {
    override fun getName(): String {
        return "Horizontal"
    }
}

fun main(args: Array<String>) {
    val layouts = LinkedList<Layout<*>>()
    layouts.add(Layout<Horizontal>(Horizontal()))
    layouts.add(Layout<Vertical>(Vertical()))
    println("Horizontal layouts:")
    layouts.filterIsInstance<Layout<Horizontal>>().forEach { println(it.getName()) }
}

这个输出：

Horizontal layouts:
Horizontal
Vertical

我希望它输出以下内容。有什么办法得到：

Horizontal layouts:
Horizontal

如果我们查看filterIsInstance(...) 的源代码，Kotlin 做了一些棘手的事情来规避类型擦除，但仍然不起作用：

/**
 * Returns a list containing all elements that are instances of specified type parameter R.
 */
public inline fun <reified R> Iterable<*>.filterIsInstance(): List<@kotlin.internal.NoInfer R> {
    return filterIsInstanceTo(ArrayList<R>())
}

/**
 * Appends all elements that are instances of specified type parameter R to the given [destination].
 */
public inline fun <reified R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C {
    for (element in this) if (element is R) destination.add(element)
    return destination
}

如果这在 Kotlin 中是不可能的，是否有任何语言（JVM 或非 JVM）可以让我执行以下操作：

inline fun <reified R: LayoutProtocol> filterVerticals(from: Iterable<Layout<R>>): Iterable<Layout<Vertical>> {
    val dest = ArrayList<Layout<Vertical>>()

    for (element in from)
        if (element is Layout<Vertical>)
            dest.add(element)

    return dest
}

Answer 1

由于类型擦除，没有简单的方法可以做到这一点，但如果你真的想要并且性能/可读性/易错性不是你担心的事情，你可以做一些技巧：

首先，让我们在Layout 中添加一个工厂方法来保留擦除的类型

open internal class Layout<T : LayoutProtocol>(val t: T) {
  ...
  companion object {
    inline fun <reified T: LayoutProtocol> create(instance: T): Layout<T> {
      return object: Layout<T>(instance) {}
    }
  }
}

（注意：为了简单起见，我在这里删除了方差）

其次，你需要一个辅助类

open class TypeLiteral<T> {
  val type: Type = getSuperclassTypeParameter(javaClass)

  companion object {
    fun getSuperclassTypeParameter(subclass: Class<*>) =
      (subclass.genericSuperclass as ParameterizedType).actualTypeArguments[0]
  }
}

（注意：Guice DI 使用相同的方法，它包含生产就绪的TypeLiteral 实现）

最后是我们自己的过滤方法

inline fun <reified R> Iterable<*>.genericFilterIsInstance() where R : Any =
  filterIsInstance<R>()
  .filter { object : TypeLiteral<R>() {}.type == it.javaClass.genericSuperclass }

现在它会打印出你想要的东西

fun main(args: Array<String>) {
  val layouts = LinkedList<Layout<*>>()
  layouts.add(Layout.create(Horizontal()))
  layouts.add(Layout.create(Vertical()))
  println("Horizontal layouts:")
  layouts.genericFilterIsInstance<Layout<Horizontal>>().forEach { println(it.getName()) }
  /* prints:
  Horizontal layouts:
  Horizontal
   */
}

但是，请不要在生产代码中使用此答案。在现实生活中，传递一个类实例进行过滤总是更好的选择。

Answer 2

只需通过 Layout 类的 t: T 属性过滤 layouts LinkedList。

layouts.filter { it.t is Horizontal }.forEach { println(it.getName()) }

它将准确打印您想要的内容。即。

Horizontal layouts:
Horizontal