过滤通用类型，无需反射或转换

Question

在 Kotlin 中，有一种有限形式的具体化泛型。有没有什么方法可以使用具体化来过滤通用类型，而不使用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
   */
}

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