Scala中的A[B[C]]类型，即嵌套类型构造函数

下面的代码编译

case class A(s:Int)
case class B(s:Int)
case class Box[T](t:T)

object DoublyNestedTypes extends App {
  println("hello")
  val l=List(Box(A(1)))
  val l2=Box(A(2))::l
  println(l2)
  val l3=Box(B(1))::l2
  println(l3)    
}

并生产：

hello
List(Box(A(2)), Box(A(1)))
List(Box(B(1)), Box(A(2)), Box(A(1)))

有人能解释一下这是怎么回事吗？ 为什么汇编没有失败？还是运行时的执行

我原以为这会失败，因为

l

的类型是

List[Box[A]]

while

Box（B（1））

的类型是

Box[B]

，那么我如何将

Box[B]

预先添加到

List[Box[A]

现在是什么类型的

l3

这与类型擦除有关吗

---

在Haskell中，等效代码在编译时会失败吗？（我的感觉是这样的。）

当有

a

类型的值

a

和

B

类型元素的列表

l

时，

a：：l

不会失败，而是产生一个

列表[C]

类型列表，其中

C

是

a

和

B

类型的最小上界，也就是说，它们最特殊最常见的超类型。如果类型

A

和

B

是完全不相关的，您将得到一个

列表[Any]

。这反映在

：

操作符的签名上（

a:：l

相当于

l.：（a）

）：

你是对的，这样的东西不会在Haskell中编译，这只是因为Haskell中没有子类型，所以最小上界的概念没有任何意义

---

Scala这样做是好是坏是一个非常有争议的问题。

这是基于子类型。。可比较的哈斯克尔代码可能是一些邪恶的东西，涉及存在或a

data Super=SupA | SupB B

类型构造

sealed abstract class List[+A] {
  def ::[B >: A] (x: B): List[B] = ...
}