0

Recently, I am reading the source code of Spray-json. I noted that the following hierarchy relation in JsonFormat.scala, please see below code snippet

/**
* A special JsonFormat signaling that the format produces a legal JSON root 
*  object, i.e. either a JSON array
* or a JSON object.
*/
trait RootJsonFormat[T] extends JsonFormat[T] with RootJsonReader[T] with RootJsonWriter[T]

To express the confusion more convenient, I draw the following diagram of hierarchy:

enter image description here

According to my limited knowledge of Scala, I think the JsonFormat[T] with should be removed from the above code. Then I cloned the repository of Spary-json, and comment the code JsonFormat[T] with

trait RootJsonFormat[T] extends RootJsonReader[T] with RootJsonWriter[T]

Then I compile it in SBT(use package/compile command) and it passed to the compiling process and generates a spray-json_2.11-1.3.4.jar successfully.

enter image description here

However, when I run the test cases via test command of SBT, it failed.

enter image description here

So I would like to know why. Thanks in advance.

xyz
  • 413
  • 2
  • 19

1 Answers1

1

I suggest you to not think of it in terms of OOP. Think of it in terms of type classes. In case when some entity must be serialized and deserialized at the same time, there is a type class JsonFormat that includes both JsonWriter and JsonReader. This is convenient since you don't need to search for 2 type class instances when you need both capabilities. But in order for this approach to work, there has to be an instance of JsonFormat type class. This is why you can't just throw it away from hierarchy. For instance:

def myMethod[T](t: T)(implicit format: JsonFormat[T]): Unit = { 
  format.read(format.write(t))
}

If you want this method to work properly there has to be a direct descendant of JsonFormat and a concrete implicit instance of it for a specific type T.

UPD: By creating an instance of the JsonFormat type class, you get instances for JsonWriter and JsonReader type classes automatically (in case when you need both). So this is also a way to reduce boilerplate.

Zyoma
  • 1,528
  • 10
  • 17
  • Thanks for your explanation. Can I think that `RootJsonFormat` is redudant? Because the `JsonFormat` has owned the two capacities, `JsReader` and `JsWriter`. – xyz Dec 29 '17 at 13:29
  • 1
    Yes, `RootJsonFormat` seems a bit redundant, nonetheless it serves its own purpose. The `JsonFormat` defines (de)serialization behavior for ANY entity, including primitives like integer or string. `RootJsonFormat` on the other hand serves a purpose of the *marker* which tells that this format produces *root* objects like array `[]` or JSON object `{}`. Described here: https://github.com/spray/spray-json/blob/7277ddc103d345e2ca42d6f39a21bbe8c453049b/src/main/scala/spray/json/JsonFormat.scala#L67-L71. So the `RootJsonFormat` is a subset of `JsonFormat` but with more strict guarantees. – Zyoma Dec 31 '17 at 18:51
  • Thanks for your help @Zyoma – xyz Jan 01 '18 at 15:09