Scala - play json trait serialisation - json

Question

In scala, I have the following trait and classes defined (names used only for illustrative purposes):
trait Entity {
def x() : Collection
}
case class X(x : Int, y : Int) extends Entity {
def x() : Collection = XCollection()
}
case class Y(x : Int, y : Int) extends Entity {
def x() : Collection = YCollection()
}
While the class instances are created by parsing the response from a web service REST API.
Although the approach using the play-json library works in the case parsing the response, and returning a class representation of the response, I've been struggling with the following: having a generic function taking a type parameter, whereas T : Entity, and returning an instance of type T.
For example, consider the following:
def parse[T <: Entity](json : String) : Option[T] = Json.parse(json).asOpt[T](Variants.format[T])
Given a type T, I would like to parse the JSON string and produce an instance of type T, whereas the instance is a derivation of the trait Entity. However, I keep getting a compile error in regard to the reflection API:
Error:(25, 96) exception during macro expansion:
scala.ScalaReflectionException: type T is not a class
at scala.reflect.api.Symbols$SymbolApi$class.asClass(Symbols.scala:323)
at scala.reflect.internal.Symbols$SymbolContextApiImpl.asClass(Symbols.scala:73)
at julienrf.variants.Variants$Impl$.baseAndVariants(Variants.scala:132)
at julienrf.variants.Variants$Impl$.formatDiscriminator(Variants.scala:99)
at julienrf.variants.Variants$Impl$.format(Variants.scala:94)
def parse[T <: Entity](json : String) : Option[T] = Json.parse(json).asOpt[T](Variants.format[T])
^
Therefore, I would appreciate for some help!
Thanks

Answer 1

You better allow implicits solve your format requirements, than using some kind of factory:
def parse[T <: Entity](json: String)(implicit r: Reads[T]): Option[T] =
Json.parse(json).asOpt[T]
Then if you have a format in current context implicitly defined, parse will work:
implicit val XFormat = Json.format[X]
parse[X](Json.stringify(Json.toJson(X(1, 2))) // returns X(1, 2)
Update
You can make it as a factory, if you really want it. I would question whether it's worth doing that, but in theory I could imagine some distinct situations where you would not want to use implicit mechanics. Still I think if implicits does not work for you, you might have an architecture problem in your code
import play.api.libs.json.{Json, Reads}
import scala.reflect.runtime.universe._
trait Entity
case class X(x : Int, y : Int) extends Entity
case class Y(x : Int, y : Int) extends Entity
val mapping = Map[Type, Reads[_]](typeOf[X] -> Json.format[X], typeOf[Y] -> Json.format[Y])
def getFormat[T](tpe: Type): Reads[T] =
mapping(tpe).asInstanceOf[Reads[T]]
def parse[T : TypeTag](json: String): Option[T] = {
val map = mapping(implicitly[TypeTag[T]].tpe)
Json.parse(json).asOpt[T](getFormat(implicitly[TypeTag[T]].tpe))
}
println(parse[X]("""{"x": 5, "y": 6}"""))
println(parse[Y]("""{"x": 5, "y": 6}"""))