scala - 未装箱的标记类型安全吗？

Question

我最近听说了 scala 中的未装箱标记类型，当我试图了解它到底是如何工作的时，我发现了这个 question这指出了 scalaz 中的实现存在的问题。修复的后果之一是必须显式解开标记类型:

def bmi(mass: Double @@ Kg, height: Double @@ M): Double =
  Tag.unwrap(mass) / pow(Tag.unwrap(height), 2)

然后我考虑了最初的想法，我可以做这样的事情:

type Tagged[U] = { type Tag = U }
type @@[T, U] = T with Tagged[U]

trait Kilogram
trait Meter
type Kg = Double @@ Kilogram
type M = Double @@ Meter

def bmi(mass: Kg, height: M): Double = mass / pow(height, 2)  

所以现在我想知道以前在 scalaz 中发现的问题是否特定于它的方法，或者简单的实现是否也可能存在删除、数组或可变参数的问题。问题是我还在学习 scala，所以我对它的类型系统的理解非常有限，我自己无法弄清楚。

Answer 1

从类型安全的角度来看，这是不安全的。 T @@ U 是 T 的子类型，并且 T @@ U 的实例可以用在 T 实例的任何地方 是必需的，即使它是偶然的。考虑以下因素

type Tagged[U] = { type Tag = U }
type @@[T, U] = T with Tagged[U]
object Tag {
  def apply[@specialized A, T](a: A): A @@ T = a.asInstanceOf[A @@ T]
}

trait Compare[A] { def compare(a1: A, a2: A): Int }

def useCompare[A: Compare](l: List[A]): Option[A] = 
  l.foldLeft(Option.empty[A])((xs, x) => 
    xs.fold(Some(x))(xxs => 
      if (implicitly[Compare[A]].compare(xxs, x) <= 0) Some(xxs) 
      else Some(x)))

implicit def intCompare: Compare[Int] = new Compare[Int] {
  def compare(a1: Int, a2: Int): Int = 
    a1.compareTo(a2)
}

trait Max
implicit def intCompareMax: Compare[Int @@ Max] = new Compare[Int @@ Max] {
  def compare(a1: Int @@ Max, a2: Int @@ Max): Int = 
    a1.compareTo(a2) * -1
}

scala> val listInts: List[Int] = List(1, 2, 3, 4)
listInts: List[Int] = List(1, 2, 3, 4)

scala> val min = useCompare(listInts)
min: Option[Int] = Some(1)

scala> val listIntMaxs: List[Int @@ Max] = listInts.map(Tag[Int, Max])
listIntMaxs: List[@@[Int,Max]] = List(1, 2, 3, 4)

scala> val max = useCompare(listIntMaxs)
max: Option[@@[Int,Max]] = Some(4)

好吧，一切都很酷，对吧？这就是 T @@ U 存在的原因。我们希望能够创建一个新类型并为其定义新的类型类。不幸的是，当您的同事出现并执行一些有效的重构并意外破坏您的业务逻辑时，一切都不好。

scala> val max = useCompare(listIntMaxs ::: List.empty[Int])
max: Option[Int] = Some(1)

哎呀

在本例中，子类型的使用与 List[+A] 类型参数上的协方差相结合导致了错误。只要需要 List[Int]，就可以用 List[Int @@ Max] 进行替换。