Ayant des problèmes avec la conversion implicite dans scala

Question

Avoir ce code

case class Workspace(ident: Long, name: String) 
case class Project(ident: Long, name: String) 

implicit def workspaceJSON: JSONR[Workspace] = new JSONR[Workspace] { 
    def read(json: JValue) = 
    Workspace.applyJSON(field[Long]("id"), field[String]("name"))(json) 
} 

implicit def projectJSON: JSONR[Project] = new JSONR[Project] { 
    def read(json: JValue) = 
    Project.applyJSON(field[Long]("id"), field[String]("name"))(json) 
} 

def parseEnt[T: JSONR](json: JValue): Either[String, T] = 
    fromJSON[T](json).toEither.left.map{ _.toString } 

def fetchProjects(ws: Workspace): Either[String, Project] = { 
    parseEnt(parse("some text")) 
} 

qui ne parvient pas à compiler sur parseEnt(parse("some text")) avec

ambiguous implicit values: both method taskJSON in class Fetcher of type => 
Fetcher.this.JSONR[types.Task] and method workspaceJSON in class Fetcher of type => 
Fetcher.this.JSONR[Fetcher.this.Workspace] match expected type Fetcher.this.JSONR[T] 

Y at-il un moyen d'assurer scala, que dans ce cas je veux variable de type T pour être un Project et choisissez la fonction projectJSON pour l'analyser? Ou si je le fais mal, alors comment le faire correctement?

Answer 1

Le compilateur essaie de déduire automatiquement le type T, qui doit être quelque chose qui peut être produit à partir d'un String (plus ou moins, mais les détails d'une importance ici)

Malheureusement, il ne peut pas réussir, puisque vous fournissez plusieurs conversions implicites allant de String à Project et Workspace. La solution simple est d'indiquer explicitement le type que vous essayez de produire:

parseEnt[Project](parse("some text")) 

Ce modèle est assez commun avec les classes de type sérialisation, où vous mappage de plusieurs types spécifiques à un générique (String dans ce cas) .