我应该如何在 Scala 中创建 Int 的子类型？

Question

如何创建多个本质上是 Ints 的类型，即可以获取 int 值，可以使用 + BUT 等数学运算符，但不能混合不同类型的实例。

例如：

val density1 = new Density(100)
val density2 = new Density(200)
density1 + density2 should be(new Density(300))

val variability = new Variability(1)
variability.value should be(1)
density1 + variability // does not compile

可能有数百种这样的类型，我不想在每个叶类中实现像 + 这样的运算符。

理想情况下，我想避免所有隐式转换机制（仅限个人喜好）。其他类型不应要求更改现有类型。

Answer 1

这是 Scala 3 中我认为不使用装箱/拆箱的解决方案：

object Wrappers:
  opaque type Wrapper = Int
  
  extension[T <: Wrapper](t: T)(using util.NotGiven[T =:= Wrapper]):
    def +(other: T): T = (t + other).asInstanceOf[T]
    //other methods
  
  opaque type Density <: Wrapper = Int
  def Density(i: Int): Density = i
  
  opaque type Variability <: Wrapper = Int
  def Variability(i: Int): Variability = i

Try it in Scastie

测试：

val density1 = Density(1)
val density2 = Density(2)
val density3: Density = density1 + density2    //compiles

val check1: Variability = density1 + density2  //doesn't compile

val variability = Variability(1)
val check2 = (variability: Wrapper) + density2 //doesn't compile
val check3 = variability + density2            //doesn't compile

println(density1) //1
println(density2) //2
println(density3) //3

asInstanceOf 未选中，不应影响性能。这种设计应该还可以防止Ints 被装箱，但我不能保证，这也取决于你如何使用它。另一个好处是每个新类型只需要多两行代码。为了使添加新方法更容易，您还可以创建自己的新方法来缩短 asInstanceOf[T]。

Answer 2

trait TaggedInt[T <: TaggedInt[T]] {
  val value: Int
  protected def apply(value: Int): T
  def +(other: T) = apply(value + other.value)
  // etc.
}

case class Density(value: Int) extends TaggedInt[Density] {
  override protected def apply(value: Int) = Density(value)
}

我拼命想避免一直重复override protected def apply(value: Int) = ...

然后您可以将其设为构造函数参数。效率稍低，但在实践中可能无关紧要：

abstract class TaggedInt[T <: TaggedInt[T]](constructor: Int => T) {
  val value: Int
  def +(other: T) = constructor(value + other.value)
  // etc.
}

case class Density(value: Int) extends TaggedInt[Density](Density)

我原来有

case class TaggedInt[Tag](value: Int) extends AnyVal {
  def +(other: TaggedInt[Tag]) = TaggedInt[Tag](value + other.value)
  // etc.
}

trait DensityTag
type Density = TaggedInt[DensityTag]

trait VariabilityTag
type Variability = TaggedInt[VariabilityTag]

但这个用例至少有两个问题：

1. Density(100).toString 是 TaggedInt(100) 而不是 Density(100);
2. Density(100) 等于 Variability(100)。