¿Es posible usar evidencia implícita para forzar la compatibilidad de tipo estático entre tipos abstractos?

Question

asumir el rasgo siguiente:

trait A { 
    type B 
    def +(a:A):A 
} 

utilizo un tipo abstracto porque no quiero arrastrar alrededor de la B en el tipo de firma cada vez que necesito una A. ¿Es todavía posible añadir ninguna evidencia implícita (utilizando =: =, <: <, etc.) con el método + para que el compilador pueda exigir la aceptación de: A con B idénticas.

Mi primer instinto es decir que no, pero Scala me ha sorprendido gratamente antes. Cualquier ayuda sería apreciada.

Answer 1

No hay necesidad de pruebas implícita ... se puede usar un refinamiento explícita,

trait A { 
    self => 
    type Self = A { type B = self.B } 
    type B 
    def +(a : Self) : Self 
} 

(nótese el uso de una anotación de tipo auto para proporcionar un alias para el exterior 'esto' permitiendo que la define y la definición B's para ser distinguido en la definición de tipo Self).

transcripción REPL,

scala> trait A { self => type Self = A { type B = self.B } ; type B ; def +(a : Self) : Self } 
defined trait A 

scala> val ai = new A { type B = Int ; def +(a : Self) : Self = this } 
ai: java.lang.Object with A{type B = Int} = $anon$1@67f797 

scala> val ad = new A { type B = Double ; def +(a : Self) : Self = this } 
ad: java.lang.Object with A{type B = Double} = $anon$1@7cb66a 

scala> ai + ai 
res0: ai.Self = $anon$1@67f797 

scala> ad + ad 
res1: ad.Self = $anon$1@7cb66a 

scala> ai + ad 
<console>:9: error: type mismatch; 
found : ab.type (with underlying type java.lang.Object with A{type B = Double}) 
required: ai.Self 
     ai + ab