Jak zakodować tę metodę za pomocą niejawnej grupy parametrów zawierającej typ zależny?

Question

Biorąc pod uwagę typeclass Printer z zależną typu Show[A]:

trait Printer { 
    type Show[A] 
    def show[A](x: A)(implicit z: Show[A]): String 
} 

object Printer { 
    // the intent here is this is the dumb fallback 
    // and a user can have a better alternative in scope 
    implicit val dumbPrinter: Printer = new Printer { 
    type Show[A] = DummyImplicit 
    def show[A](x: A)(implicit z: DummyImplicit): String = x.toString 
    } 
} 

Jak mogę kodować tą metodą:

def r[A](x: A)(implicit printer: Printer, show: printer.Show[A]): String = 
    printer.show(x)(show) 

Próbowałem dostosować kod do pracy w @ MilesSabin na Gist https://gist.github.com/milessabin/cadd73b7756fe4097ca0 i @ Blog TravisBrown: https://meta.plasm.us/posts/2015/07/11/roll-your-own-scala/, ale nie mogę znaleźć kodowania, które działa.

Answer 1

Można wymusić wnioskowanie typu jeden krok na raz, wprowadzając kontekst pośrednich:

object example { 

    trait AnyPrinter { 
    type Show <: AnyShow 
    } 

    trait AnyShow { 
    type X 
    def apply(x: X): String 
    } 

    def print[P <: AnyPrinter](implicit p: P): print[P] = new print[P] 

    class print[P <: AnyPrinter] { 
    def it[E](e: E)(implicit s: P#Show { type X = E }): String = s(e) 
    } 

    // the intent here is this is the dumb fallback 
    // and a user can have a better alternative in scope 
    implicit object DumbPrinter extends AnyPrinter { 
    type Show = AnyDumbShow 
    } 
    trait AnyDumbShow extends AnyShow { 
    def apply(x: X): String = x.toString 
    } 
    case class DumbShow[Z]() extends AnyDumbShow { type X = Z } 
    implicit def dumbShow[Z]:DumbShow[Z] = DumbShow() 

    val buh: String = print.it(2) 
}