scala - 复合类型元素数组

Question

我最近一直在玩复合类型，最近我正在尝试以下代码:

import scala.reflect._

object Main {

  def main(args: Array[String]) {
    val a1 = classTag[Int with String with Double].newArray(3)
    println(a1.mkString(" "))

    val a2 = classTag[String with Int with Double].newArray(3)
    println(a2.mkString(" "))

    val a3 = classTag[Double with Int with String].newArray(3)
    println(a3.mkString(" "))
  }

}

输出如下:

0 0 0
null null null
0.0 0.0 0.0

结果对我来说有点奇怪。每个数组元素都可以访问三种类型的方法:Int、String 和 Double。幕后到底发生了什么？复合类型实际上是第一种类型的实例？可以显式实例化复合类型吗？他们的用例仅适用于当组成复合的类型通过继承等相关时？谢谢。

附言:我使用的是 Scala 2.11.4

Answer 1

What is happening exactly behind scene here? The compound types are actually instances of the first type?

查看为 ClassTag 定义的 newArray 方法:

override def newArray(len: Int): Array[T] =
   runtimeClass match {
     case java.lang.Byte.TYPE      => new Array[Byte](len).asInstanceOf[Array[T]]
     case java.lang.Integer.TYPE   => new Array[Int](len).asInstanceOf[Array[T]]
     /* snip */
     case _                        => java.lang.reflect.Array.newInstance(runtimeClass, len).asInstanceOf[Array[T]]
   }

然后是你的类型:

scala> classTag[Int with String with Double].runtimeClass
res4: Class[_] = int

使用第一种类型得出的结论似乎很清楚。 Int with String with Double的runtimeClass是Int，newArray方法使用的是runtimeClass 来构建新的 Array。所以 Array 填充了默认的 Int 值。其他订单组合也是如此。

为什么运行时类是Int？好吧，Int with String with Double 不是实际的类，但 Int 是。编译器对使用哪个类的选择不能随心所欲，那么为什么不是第一个呢？

Can a compound type be instanced explicitly?

我不确定你的意思是什么。如果您考虑一下，编译器必须在这种组合中偏爱一种类型。显式 Int with String with Double 会是什么样子？ Int with String with Double with Product with Process 怎么样？我也不知道。

Each of the array elements has access to the methods of the three types: Int, String and Double

他们有，但他们没有。

scala> val arr = classTag[Int with Process].newArray(3)
arr: Array[Int with Process] = Array(0, 0, 0)

scala> arr(0).exitValue()
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Process

你实际上只是在欺骗编译器相信你有这些类型的 Array，而实际上你没有(而且不能，因为没有任何东西可以是Int 和 Process)。

Their use case is only for when the types composing the compound are related through inheritance and so on?

差不多，是的。我想不出您是否想尝试直接构建这些类型的任何情况。它们的主要用例是保证一个类型继承自其他特定类型。

例如，一个方法要求一个参数继承两个traits的方法:

trait Hello { def hello = println("Hello") }

trait Bye { def bye = println("Bye") }

def greet(hb: Hello with Bye): Unit = { hb.hello; hb.bye }

class A extends Hello

class B extends Hello with Bye

scala> greet(new A)
<console>:15: error: type mismatch;
  found   : A
  required: Hello with Bye
          greet(new A)
                ^

scala> greet(new B)
Hello
Bye