java - Kotlin 的类型具体化使哪些在 Java 或 Scala 中无法实现的成为可能？

Question

我最熟悉 Java 类型删除(及其所有问题和好处)。我对 Kotlin 类型系统的扩展可能性有一些有限的了解，但我对类型具体化如何在面向删除的 JVM 上工作没有清楚的了解。什么是类型具体化，Kotlin 如何在 JVM 上实现它，这与 Java 的类型删除和 Scala 复杂的类型系统有何不同？

Answer 1

什么是物化？

类型具体化是 Kotlin 的技巧之一。如果将泛型参数声明为 reified，它只会发生在内联泛型函数中。 .

由于是内联的，通用参数可以是具体的class , 而不仅仅是编译时的类型信息。
你可以在 Java 中做一些不可能的事情，比如:

实例

您现在可以使用 instanceof s(在 Kotlin 中，is s):

inline fun <reified T> f(a: Any) {
    if (a is T) println("Hi!")
}

这在 Java 中显然是不可能的。

反射(reflection)

您可以获得 java java.lang.Class<T>现在来自泛型参数的实例。

inline fun <reified T> f(a: Any) {
    println("Hey! my class is ${T::class.java}!")
    if (a.javaClass == T::class.java) println("Hi!")
}

另外，KClass还有:

inline fun <reified T> f(a: Any) {
    println("KClass: ${T::class}")
}

您可以使用空构造函数创建实例:

inline fun <reified T> f(a: Any) {
    val o: T = T::class.java.newInstance()
}

调用其他具体化

仅限 reified通用参数可以传递给其他 reified功能。

inline fun <reified T> f(a: Any) {
    g<T>(a)
}

inline fun <reified T> g(a: Any) {
    if (a is T) println("Bingo!")
}

这在 Kotlin 中是不可能的:

inline fun <reified T> f(a: Any) {
}

fun <T> g(a: Any) {
    f<T>(a) // error
}

缺点(已编辑)

如果您使用其他语言调用 reified Kotlin 中的内联函数，函数参数为 java.lang.Object .

您不能使用其他语言来调用 reified功能。

比如，如果我们在 A.kt 中有一个具体化的函数:

inline fun <reified T> f(a: T) = println(T::class.java)

并使用反射获取它(它将被编译为私有(private)):

Method method = AKt.class.getDeclaredMethod("f", Object.class);

此代码将成功运行，无异常。
但是由于它的实现，你不能调用它(我没有仔细阅读生成的字节码，抱歉):

private static final void f(Object a) {
  Intrinsics.reifiedOperationMarker(4, "T"); // I didn't see
  // the implementation of this line, so I thought it's
  // possible to call it in other languages
  Class var2 = Object.class;
  System.out.println(var2);
}

看评论。并查看reifiedOperationMarker的定义:

public static void reifiedOperationMarker(int id, String typeParameterIdentifier) {
    throwUndefinedForReified();
}

它会抛出 UnsupportedOperationException .

结论:reified只能在 Kotlin 中使用。

关于斯卡拉

真的很难说 Kotlin 还是 Scala 哪个更好，因为 Scala 有更多方法可以在运行时获取类型信息。

Alexey Romanov 说 Scala 可以，但 Kotlin 不能:

using ClassTags in a recursive function

我认为这可以通过在函数中使用函数来解决:

inline fun <reified T> g(a: Any): Int {
  var recur: ((Any) -> T)? = null
  recur = { recur!!.invoke(it) as T } // use T is possible here
  return recur(a)
}

请注意，这只是一个语法正确的示例。
当然，这是无限循环和不必要的强制转换。

他还说:

storing them in collections and using them to call ClassTag-using functions later.

这是一个真正的问题，因为这需要noinline lambdas，而 Kotlin 的 reified是基于内联的。