non riusciva a trovare valore implicito per il parametro e

Question

case class Cat(name: String) 

object CuterImplicits { 
    implicit class CatCuteChecker(c: Cat) { 
    def isCute(c: Cat) = true 
    } 
} 

trait CuteChecker[A] { 
    def isCute(a: A): Boolean 
} 

object CheckingForCuteness { 
    def isItCute[A](a: A) = implicitly[CuteChecker[A]].isCute(a) 
} 

object Main extends App { 
    CheckingForCuteness.isItCute[Cat](Cat("funny")) 
} 

come risolvere il problema:

Error:(17, 37) could not find implicit value for parameter e: CuteChecker[A] def isItCute[A](a: A) = implicitly[CuteChecker[A]].isCute(a) ^

Answer 1

Se si utilizza implicitly che fa semplicemente a value implicitly in scope "explicitly" available. Così il vostro metodo di isItCute dovrebbe essere uno dei seguenti due varianti:

def isItCute[A: CuteChecker](a: A) = implicitly[CuteChecker[A]].isCute(a) 

def isItCute[A](a: A)(implicit cc: CuteChecker[A]) = cc.isCute(a) 

successiva che si desidera un'istanza implicita per Cat. Il implicit class non ti aiuta qui perché richiede un valore non implicito di tipo Cat. Puoi vedere che questo approccio è sbagliato perché il parametro costruttore non è mai usato. È possibile utilizzare un implicit object:

implicit object CatCuteChecker extends CuteChecker[Cat] { 
    def isCute(c: Cat) = true 
} 

Infine, si forniscono impliciti in oggetto CuterImplicits. Per loro di essere visibili a Main, è necessario import the contents:

object Main extends App { 
    import CuterImplicits._ 
    CheckingForCuteness.isItCute[Cat](Cat("funny")) 
} 

Answer 2

Ci

a molteplici problemi nella vostra situazione. La chiamata implicitly prevede un'istanza del tratto CuteChecker, mentre CatCuteChecker non è un'istanza né non estende questa caratteristica. Inoltre, il parametro di classe c non è necessario.

È possibile risolvere il problema, dichiarando che il rapporto subtyping e fornendo un valoreimplicit:

object CuterImplicits 
{ 
    class CatCuteChecker with CuteChecker 
    { 
     def isCute(c: Cat) = true 
    } 

    implicit val catCuteChecker = new CatCuteChecker 
} 

Answer 3

impliciti devono essere visibili qualificato nel punto di invocazione. I diversi modi in cui è possibile visualizzare gli impliciti possono essere meglio descritti in questa risposta: https://stackoverflow.com/a/5598107/843348.

Non è inoltre del tutto chiaro cosa si sta cercando di ottenere e ci sono un certo numero di modi possibili per ottenere qualcosa come nell'esempio.

Una possibilità è scimmia patch Cat utilizzando una classe implicita:

case class Cat(name: String) 

object CuteImplicits { 
    implicit class CuteCat(c: Cat){ 
    def isCute = true 
    } 
} 

object Main extends App { 
    import CuteImplicits._ 
    Cat("funny").isCute 
} 

Hai messo impliciti nell'oggetto compagna di un tipo associato e che è visibile automaticamente.

case class Cat(name: String) 

object Cat { 
    implicit class CuteCat(c: Cat){ 
    def isCute = true 
    } 
} 

object Main extends App { 
    Cat("funny").isCute 
} 

Nel esempio minimo come questo non è chiaro il motivo per cui non si potrebbe costruire la funzionalità direttamente in Cat.