Play Scala JSON Writes & Inheritance - json

Question

//Item.scala
package model
trait Item {val id: String}
class MItem(override val id: String, val name: String) extends Item
class DItem(override val id: String, override val name: String, val name2: String)
extends MItem(valid, name, name2)
object ItemWrites {
implicit val MItemWrites = new Writes[MItem] {
def writes(dItem: MItem) = Json.obj(
"id" -> mItem.id,
"name" -> mItem.name
)
}
implicit val DItemWrites = new Writes[DItem] {
def writes(dItem: DItem) = Json.obj(
"id" -> dItem.id,
"name" -> dItem.name,
"name2" -> dItem.name2
)
}
}
//Response.scala
package model
import ItemWrites.MItemWrites
import ItemWRites.DItemWrites
trait Response {
val title : String,
val items : Seq[Item],
}
case class MResponse(title: String, items: Seq[MItem]) extends Response
case class DResponse(title: String, items: Seq[DItem]) extends Response
object ResponseWrites {
implicit val mResponseWrite = new Writes[MResponse] {
def writes(mResponse: MResponse) = Json.obj(
"title" -> mResponse.title,
"items" -> mResponse.items
)
}
implicit val dResponseWrite = new Writes[DResponse] {
def writes(dResponse: DResponse) = Json.obj(
"title" -> dResponse.title,
"items" -> dResponse.items // **compile time error**
)
}
}
I get compile time error on line dResponse.items.
> [error] Note: implicit value dtcTopicPageResponseWrite is not
> applicable here because it comes after the application point and it
> lacks an explicit result type
> [error] "items" -> dResponse.items
Seems that this is happening as DItem inherits form MItem and the compile is getting confused between subclass and super class. How do i get around this.

Answer 1

I was able to get your code compiling in Scala 2.11, Play 2.5.x by explicitly stating the types of the Writes you've declared in ItemWrites - namely:
object ItemWrites {
implicit val MItemWrites:Writes[MItem] = new Writes[MItem] {
def writes(mItem: MItem) = Json.obj(
"id" -> mItem.id,
"name" -> mItem.name
)
}
implicit val DItemWrites:Writes[DItem] = new Writes[DItem] {
def writes(dItem: DItem) = Json.obj(
"id" -> dItem.id,
"name" -> dItem.name,
"name2" -> dItem.name2
)
}
}
Once I did that, Scala was able to find out which implicit was right and away it went.

Answer 2

You should explicitly set which Writer[T] is going to be used because they use inheritance. I didn't test the code below but it should compile and work;
implicit val dResponseWrite = new Writes[DResponse] {
import ItemWrites.DItemWrites
def writes(dResponse: DResponse) = Json.obj(
"title" -> dResponse.title,
"items" -> Json.toJson(dResponse.items) // **compile time error**
)
}

Answer 3

I think it's better for you to have a Writes for the super type Item that will just do match case to check it's type and do toJson. Don't forget to have it implicitly imported
object ItemWrites {
implicit val MItemWrites = new Writes[MItem] {
def writes(dItem: MItem) = Json.obj(
"id" -> mItem.id,
"name" -> mItem.name
)
}
implicit val DItemWrites = new Writes[DItem] {
def writes(dItem: DItem) = Json.obj(
"id" -> dItem.id,
"name" -> dItem.name,
"name2" -> dItem.name2
)
}
implicit val ItemWrites = new Writes[Item] {
def writes(item: Item) = item match {
case i: DItem => i.toJson //code for converting DItem to Json
case i: MItem => i.toJson //code to convert MItem to Json
case _ => throws new RuntimeException("Unsupported Type.")
}
}
}