Trait Swappable en Scala

Question

Quiero definir un rasgo Swappable con dos valores x,y y un método swap tal que llamar swap sobre un objeto que hereda de Swappable retornos otro objeto del mismo tipo con x,y conmutada. Mi mejor hasta ahora es:

trait Swappable[T] { 
    val x: T 
    val y: T 
    def swap: Swappable[T] = { 
    val (a,b) = (x,y) 
    new Swappable[T] { val x=b; val y=a } 
    } 
} 

Pero esto no es lo que quiero, porque el tipo de retorno de intercambio es cierta clase anónima, en lugar de la clase original Empecé con, por lo que tengo errores como:

def direct[S<:Swappable[Int]](s: S): S = if (s.x > s.y) s else s.swap 
<console>:32: error: type mismatch; 
found : Swappable[Int] 
required: S 
     def direct[S<:Swappable[Int]](s: S): S = if (s.x > s.y) s else s.swap 
                     ^

¿Es posible hacer lo que estoy tratando de hacer? ¿Cuál es la firma de tipo correcta para el intercambio?

Answer 1

No sé cómo hacerlo, pero creo que tal vez ayude a tener una mejor idea de qué es exactamente lo que quiere que suceda. Considere una clase como

case class Foo(x: Int, y: Int) extends Swappable[Int] { 
    val z = x 
} 

Ahora, si usted tiene f = Foo(1, 2), debe f.swap darle una Foo donde x != z? Si es así, no hay forma dentro de Scala para crear un Foo así. Si no, ¿qué significa realmente "cambiar xey"?

Tal vez lo que realmente está buscando es algo como esto:

trait Swappable[A,T] { 
    this: A => 

    val x: T 
    val y: T 
    def cons(x: T, y: T): A 

    def swap = cons(y, x) 
} 

case class Foo(x: Int, y: Int) extends Swappable[Foo,Int] { 
    val z = x 

    def cons(x: Int, y: Int) = copy(x=x, y=y) 
} 

pero no estoy seguro.

Answer 2

¿Qué pasa algo así:

trait Swappable[T] { 
    type A 
    val x: T 
    val y: T 

    def create(a: T, b: T): A 
    def swap = create(y, x) 
} 

case MySwappable[T](x: T, y: T) extends Swappable[T] { 
    type A = MySwappable 
    def create(a: T, b: T) = MySwappable(a, b) 
}