Scala: Los problemas con el borrado en la anulación equivalen a la función para las clases parametrizadas

Question

Tengo problemas para comprender bien cómo usar manifiestos.

Ese es mi problema: he creat una nueva clase C parametrizada y tryed para anular es igual a como esto:

override def equals(that:Any)=that match{ 
case that:C[T] => true /*do smth else not relevant*/ 
case _ => false 
} 

Por supuesto que reciba el "aviso: no variable de tipo-argumento T en patrón de tipo C [T] está desmarcado ya que se elimina por borrado ". Me tryied lo que el uso se manifiesta como yo estaba usando en muchas otras funciones:

override def equals(that:Any)(implicit manifest:Manifest[T])=that match{ 
case that:C[T] => true 
case _ => false 
} 

Pero he recibido el "error: el método es igual a las anulaciones nada" mensaje.

No sé cómo solucionarlo. ¿Podría alguien ayudarme por favor?

Answer 1

No se puede arreglar. Bienvenido a las alegrías de la fluida interoperación con Java. La única forma de mejorar equivale a def equals(x: Any): Boolean es escribir un método diferente.

Siempre trato de convencer a Martin de que debemos implementar == desugaring de manera diferente, con el objetivo de algo así como "def decentEquals [T] (x: T) (equiv implícito: Equiv [T])" con implicits por defecto y métodos de puente para hacerlo sin problemas a menos que te importe, pero él piensa que las pruebas de igualdad no deberían ser más lentas.

Answer 2

override def equals(that:Any)= { 
    that match{    
     case that:C[x] => true 
     case _ => false          
    } 
    } 

se compilará, pero no creo que haga lo que usted quiere. Estás tratando de ver si los parámetros tipo coinciden (supongo), pero no sé cómo (o si) puedes hacer eso. (Editar: leyendo más de la literatura, creo que no se puede. No se puede, por razones obvias, anular una función no consciente del manifiesto con una consciente del manifiesto).

Answer 3

Sólo un adjunto a @extempore 's respuesta; es completamente posible escribir nulo seguro es igual a los métodos que pueden ser de tipo seguro. Echar un vistazo a ScalazIdentity (and examples)

new Fruit ≠ new Orange //does not compile 
new Apple ≟ new Apple //compiles! 

Basándose en los tipos, sería requiere ninguna parametrización a ser igual también (es decir C[T] == C[U] iff T =:= U

---

Por supuesto, el problema con tratar de sustituir un método :

def foo(bar : Bar) : Baz 

Con esta:

def foo(bar : Bar) (implicit bat : Bat) : Baz 

Es esto no constituye la anulación de. Dado que el método tiene una firma diferente tiene sobrecargado método en su lugar. Por eso es bueno que Scala requiera el modificador override: de lo contrario, es posible que no hayas notado que el código no estaba haciendo lo que pensabas que era.