Scala Play framework 2.1 derived classes

Question

I'd like to produce JSON for a List that includes both base classes and derived classes. The code below only produces JSON for the Animal class (I do not get the breed field for the Dog type members). Some help would be appreciated.

import play.api.libs.json._

class Animal (val name:String) {
}

object Animal {
  implicit object animalWrite extends Writes[Animal] {
    def writes(ts: Animal) = JsObject(Seq("name" -> JsString(ts.name)))
  }
}

case class Dog (override val name:String, val breed: String) 
    extends Animal(name)  {
}

object Dog {
    implicit val format = Json.format[Dog]
}

case class Cat (override val name:String, val hairLength: Int) 
    extends Animal(name)  {
}

object Cat {
    implicit val format = Json.format[Cat]
}

object helloWorld extends App {
//  The list below outputs:     [{"name":"Ruff","breed":"labrador"}]
//  val l = List[Dog](Dog("Ruff", "labrador"))

//  The list below outputs:     [{"name":"Ruff"},{"name":"Fluffy"}]
//  I expect to see: [{"name":"Ruff","breed":"labrador"},{"name":"Fluffy","hairLength":3}]
    val l = List[Animal](Dog("Ruff", "labrador"), Cat("Fluffy", 3))
    println(Json.toJson(l))
}

Scala and Play newbie here, please excuse inappropriate use of terminology.

Answer 1

The json API extensively uses implicit parameters which is a feature of Scala where you can provide an "implicit" parameter list and if you don't specify those parameters the compiler will try to find an object in the current scope that is marked as implicit and matches that signature.

So if you for example would write:

implicit val s = "my implicit string"

def magicPrint(implicit message: String) { println(message) }

// and then call it
magicPrint

The compiler would select s for the parameter message since it is in scope and has the correct type (String), so after the implicit resolution the last line of code would actually look more like this

magicPrint(s)

The Format/Writer is selected by the compiler, at compile time, with an implicit parameter. If you look at the signature of the method, toJson[A](item: A)(implicit writes: Writes[A]), it takes an implicit Writes[A] which in your case is a Writes[List[Animal]] since List[Animal] is the type of your list l. Play contains a default has a writer that takes care of the collection (DefaultWrites.traversableWrites) which in turn takes an implicit Writes[A] - in your case Writes[Animal], so the compiler will select and pass your animalWrites.

That your list contains different types of animals is something that happens at runtime and the compiler has no way of knowing that from the type information available at your Json.toJson(l)

So, as you see you cannot achieve what you want in the way you thought, but you can do it in almost the same way by letting the animal writer know about the subtypes, for example:

implicit object animalWrite extends Writes[Animal] {
  def writes(ts: Animal) = ts match {
    // this will get an implicit Writes[Dog] since d is a Dog
    case d: Dog => Json.toJson(d) 
    // this will get an implicit Writes[Cat] since c is a Cat
    case c: Cat => Json.toJson(c) 
    case x => throw new RuntimeException(s"Unknown animal $x")
  }
}

Hope this helped!