是否可以用Scala表示以下内容；型式试验=任一[列表[试验]，T]“试验”；_Scala_Types

是否可以用Scala表示以下内容；型式试验=任一[列表[试验]，T]“试验”；

scala types

是否可以用Scala表示以下内容；型式试验=任一[列表[试验]，T]“试验”；,scala,types,Scala,Types,在Scala中是否可以像下面这样表示递归类型定义 type test = Either[List[test], Int] 更新我的意图是表达如下函数： def flatten[T](list: List[Either[List[T], T]]): List[T] = list flatMap { case Left(list) => list case Right(element) => List(element) } 但是它可以接受任意深度的类

在Scala中是否可以像下面这样表示递归类型定义

type test = Either[List[test], Int]

更新

我的意图是表达如下函数：

def flatten[T](list: List[Either[List[T], T]]): List[T] = list flatMap {
    case Left(list)         => list
    case Right(element) => List(element)
}

但是它可以接受任意深度的类似结构。那么，您可以这样做：

type test[T <: test[T]] = Either[List[T], Int]

scala> val x: test[Nothing] = Right(1)
x: test[Nothing] = Right(1)

scala> val y: test[test[Nothing]] = Left(List(x))
y: test[test[Nothing]] = Left(List(Right(1)))

scala> val z: test[_] = y
z: test[_] = Left(List(Right(1)))

type test[T val x:test[Nothing]=右（1）
x:测试[无]=正确（1）
scala>valy:test[test[Nothing]=Left（列表（x））
y:test[test[Nothing]=左（列表（右（1）））
scala>valz:test[]=y
z：测试[z]=左（列表（右（1）））

但我不知道你为什么要这样做。

好吧，你可以这样做：

type test[T <: test[T]] = Either[List[T], Int]

scala> val x: test[Nothing] = Right(1)
x: test[Nothing] = Right(1)

scala> val y: test[test[Nothing]] = Left(List(x))
y: test[test[Nothing]] = Left(List(Right(1)))

scala> val z: test[_] = y
z: test[_] = Left(List(Right(1)))

type test[T val x:test[Nothing]=右（1）
x:测试[无]=正确（1）
scala>valy:test[test[Nothing]=Left（列表（x））
y:test[test[Nothing]=左（列表（右（1）））
scala>valz:test[]=y
z：测试[z]=左（列表（右（1）））

但不确定您为什么需要这样做。

您不能有这样的递归类型别名。但如果您创建单独的类，则没有问题：

case class Test[+T](value: Either[List[Test[T]], T]) {
  def flatten: List[T] = value match {
    case Left(list)         => list.flatMap(_.flatten);
    case Right(element)     => List(element);
  }
}

（编程中最有趣的类实际上是递归的。）

您不能拥有像您这样的递归

类型

别名的原因是编译器需要展开

类型

别名，以判断某个对象是否具有该类型

type test = Either[List[test], Int]

扩展到无穷大：

Either[List[test], Int]
Either[List[Either[List[test], Int]], Int]
Either[List[Either[List[Either[List[test], Int]], Int]], Int]
...

对于类，这种情况不会发生，因为类将递归值“包装”到定义良好的类型中（如本例中的

Test[t]

），类型的“扩展”仅在引用内部的内容时发生（在本例中为

value

）.

您不能有这样的递归类型别名。但如果您创建一个单独的类，则没有问题：

case class Test[+T](value: Either[List[Test[T]], T]) {
  def flatten: List[T] = value match {
    case Left(list)         => list.flatMap(_.flatten);
    case Right(element)     => List(element);
  }
}