Typeclasses и подтипирование

Question

У меня есть следующий код, определяющий класс типа.

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 

Теперь, если у меня есть, если я toFoo(List(new A, new B) я получаю List("A", "A") вместо List("A", "B"). Как я могу убедиться, что используется метод BtoFoo, а не AToFoo для классов с типом B?

Answer 1

неявное разрешение - это чисто механизм компиляции. Легкий способ отличить подтипы здесь - это совпадение внутри неявного. Удалить BToFoo вообще и иметь вместо этого A версии сделки с обоих случаях

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

Конечно, это также можно делегировать к способу части иерархии. Вы можете делегировать метод в A, overidde в B и все еще иметь работу с классом для списка, где вы не можете добавить метод.

Вы также можете рассмотреть вопрос об объявлении Foo контравариантным.