Problème de conversion implicite dans Scala

Question

J'améliore le support Scala dans Querydsl et j'ai rencontré le problème suivant. Voici un extrait de code qui illustre le problème:

// framework types 
class RelationalPath[T] 
class RelationalPathAdapter[T, R <: RelationalPath[T]](p: R) { def someMethod = {} } 

// domain types 
class User 
class QUser extends RelationalPath[User] 

implicit def toAdapter[T, R <: RelationalPath[T]](p: R) = new RelationalPathAdapter[T,R](p) 

val path = new QUser() 

toAdapter(path).someMethod // DOESN'T COMPILE 

path.someMethod // DOESN'T COMPILE 

Comment faire correspondre un type dans une conversion implicite en plus de ses arguments de type. Je peux correspondre séparément, mais pas les deux.

Answer 1

Dans ce cas précis, le changement suivant fonctionne:

implicit def toAdapter[T, R <: RelationalPath[T]](p: RelationalPath[T] with R) = 
    new RelationalPathAdapter[T,R](p) 

Answer 2

Ce n'est pas vraiment un problème de conversion implicite plutôt un problème d'inférence de type. Quand vous appelez toAdapter (chemin), il n'y a rien d'implicite.

Si vous passez le paramètre de type, cela fonctionne.

toAdapter[User, QUser](path).someMethod 

Il peut même travailler avec une conversion implicite:

(path: RelationalPathAdapter[User, QUser]).someMethod 

mais bien sûr, cela est plutôt inutile.

La bonne façon d'écrire l'implicite est

implicit def toAdapter[T, R[X] <: RelationalPath[X]](p: R[T]) 
    = new RelationalPathAdapter[T, R[T]](p)