适用于原始类型的Scala上型边界

Question

I am new to Scala and I want to write a generic class that overload operators. But I want to limit the types to Int, Long and Double. Is it possible to create an upper type bound for primitive types?

Here is what I have done for Int. I need to make this class generic and it should only accept Int, Long and Double. If this is not the right approach I hope someone can give an alternative solution for the problem.

class MyClass(value: Int) {
  def +(operand: Int): MyClass = { 
    return new MyClass(value+operand);
  }

  def -(operand: Int): MyClass = {
    return new MyClass(value-operand);
  }

  def *(operand: Int): MyClass = {
    return new MyClass(value*operand);
  }

  def /(operand: Int): MyClass = {
    return new MyClass(value/operand);
  }
} 

Answer 1

You could use the Type Class Pattern . I would require an implicit MyClassOperators[T] to be in scope, and implement it only for the desired Int , Long and Double .

Define the trait implementing the operations:

object MyClassImplicits {
  trait MyClassOperators[T <: AnyVal] {
    def +(firstOperand: T, secondOperand: T): MyClass[T]

    def -(firstOperand: T, secondOperand: T): MyClass[T]

    def *(firstOperand: T, secondOperand: T): MyClass[T]

    def /(firstOperand: T, secondOperand: T): MyClass[T]
  }

Now lets provide a concrete implementation for Int :

implicit object MyClassIntOperators extends MyClassOperators[Int] {
  override def +(firstOperand: Int, secondOperand: Int): MyClass[Int] = new MyClass[Int](firstOperand + secondOperand)

  override def -(firstOperand: Int, secondOperand: Int): MyClass[Int] = new MyClass[Int](firstOperand - secondOperand)

  override def *(firstOperand: Int, secondOperand: Int): MyClass[Int] = new MyClass[Int](firstOperand * secondOperand)

  override def /(firstOperand: Int, secondOperand: Int): MyClass[Int] = new MyClass[Int](firstOperand / secondOperand)
}

And change the definition of MyClass to require the implicit MyClassOperators[T] to be in scope:

class MyClass[T <: AnyVal : MyClassOperators](val value: T) {
    def doSomeAddition(otherValue: T): MyClass[T] = {
      implicitly[MyClassOperators[T]].+(value, otherValue)
    }
}

When we run this with an Int instance:

def main(args: Array[String]): Unit = {
  val myClassOfInt = new MyClass[Int](1)
  println(myClassOfInt.doSomeAddition(2).value)
}

Yields:

3

But when we try this with a Double instance (which isn't implemented yet):

[error] could not find implicit value for evidence parameter of type tests.NewTest.MyClassImplicits.MyClassOperators[Double]
[error]     val myClassOfInt = new MyClass[Double](1.0)
[error]                        ^
[error] one error found