Typeclasses et sous-types

Question

J'ai le code suivant définissant une classe de type.

trait Foo[T] { 
    def toFoo(x: T): String 
} 

trait Foos { 
    def toFoo[T](f: T => String): Foo[T] = new Foo[T] { 
    def toFoo(x: T): String = f(x) 
    } 
} 

object Foo extends Foos { 
    def toFoo[A: Foo](a: A) = implicitly[Foo[A]].toFoo(a) 
    implicit def AToFoo: Foo[A] = toFoo { c => 
    "A" 
    } 
    implicit def BToFoo[T]: Foo[B] = toFoo { c => 
    "B" 
    } 

    implicit def ListToFoo[T: Foo]: Foo[List[T]] = toFoo { c => 
    c.map(toFoo(_)). 
    } 
} 

class A 
class B extends A 

Maintenant, si je fais si je toFoo(List(new A, new B) je reçois List("A", "A") au lieu de List("A", "B"). Comment puis-je m'assurer que la méthode BtoFoo est utilisée plutôt que AToFoo pour les classes de type B?

Answer 1

La résolution implicite est un mécanisme de compilation pure. Le moyen facile de faire la distinction entre les sous-types ici est de faire correspondre à l'intérieur de l'implicite. Retirer BToFoo tout à fait et ont plutôt l'accord version A avec les deux cas

implicit val AIsFoo : Foo[A] = toFoo { 
    case b: B => "B" 
    case a: A => "A" 
} 

Bien sûr, il est également possible de déléguer à une méthode pour une partie de la hiérarchie. Vous pouvez déléguer à une méthode dans A, overidde dans B, et toujours avoir le type de classe de travail pour la liste, où vous ne pouvez pas ajouter une méthode.

Vous pouvez également envisager de déclarer Foo contravariant.