Scala: come definire un tipo strutturale che si riferisce a se stesso?

Question

Sto cercando di scrivere un interpolate metodo generico che funziona su qualsiasi tipo che ha due metodi, un * e +, come questo:

trait Container { 
    type V = { 
    def *(t: Double): V 
    def +(v: V): V 
    } 

    def interpolate(t: Double, a: V, b: V): V = a * (1.0 - t) + b * t 
} 

Questo non funziona se (sulla Scala 2.8.0 .RC7), ricevo i seguenti messaggi di errore:

<console>:8: error: recursive method + needs result type 
      def +(v: V): V 
         ^
<console>:7: error: recursive method * needs result type 
      def *(t: Double): V 
          ^

Come si specifica il tipo di struttura in modo corretto? (O c'è un modo migliore per farlo?)

Answer 1

Sicuramente si potrebbe risolvere questo problema utilizzando il typeclasses approccio (ad esempio di Scalaz):

trait Multipliable[X] { 
    def *(d : Double) : X 
} 

trait Addable[X] { 
    def +(x : X) : X 
} 

trait Interpolable[X] extends Multipliable[X] with Addable[X] 

def interpolate[X <% Interpolable[X]](t : Double, a : X, b : X) 
    = a * (1.0 - t) + b * t 

Poi, ovviamente, si avrebbe bisogno di un (implicito) typeclass conversione portata per tutti i tipi che si preoccupava:

implicit def int2interpolable(i : Int) = new Interpolable[Int] { 
    def *(t : Double) = (i * t).toInt 
    def +(j : Int) = i + j 
} 

Allora questo può essere eseguito con facilità:

def main(args: Array[String]) { 
    import Interpolable._ 
    val i = 2 
    val j : Int = interpolate(i, 4, 5) 

    println(j) //prints 6 
} 

Answer 2

AFAIK, questo non è possibile. Questo era uno dei miei first questions.