processeur implicite pour tous les sous-types

Question

J'ai quelques types

trait Processor[+A] { 
    def handle[B >: A](a: B): Unit 
} 

trait TypeA 

case class A1() extends TypeA 

et une méthode

def process[A](a: A)(implicit processor: Processor[A]) 

je peux avoir quelque chose comme

implicit val processor = new Processor[TypeA] { 
    def handle[B >: TypeA](a: B): Unit = { 
    println(a) 
    } 
} 

afin qu'il traitera tous les sous-type de TypeA ? par exemple.

process(A1()) 

mais dans mon cas, il donne juste

scala> process(A1()) 
<console>:29: error: could not find implicit value for parameter processor: Processor[A1] 
       process(A1()) 

Answer 1

Qu'est-ce covariance est précisément le contraire: cela signifie qu'un Processor[A1] est un Processor[TypeA], donc un processeur pour un type peut gérer toutes ses supertypes.

Donc, si vous avez besoin d'un Processor pour gérer tous les sous-types d'un type à la place, vous avez besoin de contravariance. Et votre trait ressemble exactement comme il devrait en effet être contravariants (mais cela peut être dû à la simplification de la question):

trait Processor[-A] { 
    def handle(a: A): Unit 
} 

implicit val processor: Processor[TypeA] = new Processor[TypeA] { 
    def handle(a: TypeA): Unit = { 
    println(a) 
    } 
} 

Ensuite process(A1()) œuvres.