scala特征或抽象類型或參數類型還是什么？

Question

我希望交替使用幾個類，所有這些類都實現了一個方法“add”，所以我開始寫一個特性：

trait CanAdd{
  def add(that: CanAdd): CanAdd
}

然后實現我的類並遇到問題：我不能添加任何其他“CanAdd”，它們需要屬於同一個類。 我用一些依賴於“isInstanceOf”的丑陋代碼解決了這個問題：

class A(val value: Int) extends CanAdd{      
  def add(that: CanAdd): CanAdd = {          
    if(!that.isInstanceOf[A]) sys.error("")  
    val thatA: A = that.asInstanceOf[A]      
    new A(value + thatA.value)               
  }                                          
}                                            
class B(val value: Boolean) extends CanAdd{  
  def add(that: CanAdd): CanAdd = {          
    if(!that.isInstanceOf[B]) sys.error("")  
    val thatB: B = that.asInstanceOf[B]      
    new B(value ^ thatB.value)               
  }                                          
}                                            

最后，我使用如下類：

class User(val stuff: Array[CanAdd]) {                                            
  def add(that: User): User = {                                                   
    assume(stuff.length==that.stuff.length)                                       
    val out = new Array[CanAdd](stuff.length)                                     
    for( i <- 0 until stuff.length) out(i) = stuff(i).add(that.stuff(i))          
    new User(out)                                                                 
  }                                                                               
}              
val u1=new User(Array(new A(0)))                                           
val u2=new User(Array(new B(false)))                                       
val u3 = u1.add(u1)                                                        
val u4 = u1.add(u2) //should fail, ideally, should not even compile        

我不喜歡它，因為首先用“isInstanceOf”寫鍋爐板代碼是一種負擔，其次是因為它在運行時而不是編譯時失敗。

我的問題：你會如何做到這一點，考慮到一些計划實現更多的方法，而不僅僅是“添加”，並可能實現幾個具有非常不同的內部表示的其他類？

Answer 1

trait CanAdd[T <: CanAdd[T]] { 
  def add(a: T): T 
}

class A(val value:Int) extends CanAdd[A] {
  def add(that:A) = new A(value+that.value)
}

class B(val value:Boolean) extends CanAdd[B] {
  def add(that:B) = new B(value ^ that.value)
}

class User[X <: CanAdd[X] : Manifest](val stuff:Array[X]) extends CanAdd[User[X]]{
  def add(that:User[X]):User[X] = {
    assume(stuff.length==that.stuff.length)
    new User(stuff.zip(that.stuff).map(t => t._1.add(t._2)) toArray)
  }
}

val u1 = new User(Array(new A(0)))
val u2 = new User(Array(new B(false)))
val u3 = u1.add(u1)
val u4 = u1.add(u2)  // compile error: type mismatch