How can I ignore empty objects with play-json?

Question

I am new to Scala and functional programming so this question might have a very simple answer. However, I was not able to figure it out so here it is:

I have a case-class hierarchy that represents an abstract syntax tree in a compiler. At some point I have a list of statements of the form List[Statement]. This will get serialized with a Json array of objects where each object represents a statement. However, some kinds of statements are redundant so I don't want to serialize them. For example, returning void. The following code hopefully clarifies this:

sealed trait Statement

sealed trait Expression

case object Empty extends Expression

case class Return(e: Expression) extends Statement

What I want is to not serialize Return(Empty) at all. Right now I get something like:

"Return": {}

How can I simply ignore Return(Empty) ? To make it more general. I don't want to have empty objects in my json like {}. How can I make sure they don't make it to my json ?

Here is what I tried so far (and didn't work):

implicit val statementListWrites = StatementListWrites

object StatementListWrites extends Writes[List[Statement]] {
  override def writes(stms: List[Statement]) =
    JsArray(stms.filter(stm => {
      stm match {
        case Return(Empty) => false
        case _ => true
      }
    }).map(s => Json.toJson(s)))
}

Perhaps the above technique works but for some reason it is not even called to begin with as far as I understand.

Answer 1

You should be careful in such cases because you have sealed traits, so you should work in an organized way.

Let's divide the problem into smaller problems, Let's assume that you just want to write your objects into json. then we can solve the problem of removing empty objects.

I added more classes to clarify the idea:

sealed trait Expression
case object Empty extends Expression
case class NonEmptyExpression(x: Int) extends Expression

sealed trait Statement
case class Return(e: Expression) extends Statement
case class NoReturn(x: Int) extends Statement

First Step (provide writer for Expresion):

to do this you have to create writer for Empty and NonEmptyExpression, so we can do it this way:

val emptyExpressionWrites = new Writes[Empty.type] {
  override def writes(e: Empty.type) = Json.obj()
}

val nonEmptyExpressionWrites = Json.writes[NonEmptyExpression]

implicit val expressionWrites = new Writes[Expression] {
  override def writes(exp: Expression) = {
    exp match {
      case Empty => emptyExpressionWrites.writes(Empty)
      case nonEmptyExpression: NonEmptyExpression => nonEmptyExpressionWrites.writes(nonEmptyExpression)
    }
  }
}

Second Step (provide writer for Statement):

You have to provide writer for Return and NoReturn. please note that play was able to know how to create writer for Return and it has Expression, because I defined expressionWriter as implicit. so it knows how to serialize Expression now.

val returnWrites = Json.writes[Return]
val noReturnWrites = Json.writes[NoReturn]

val statementWrites = new Writes[Statement] {
  override def writes(s: Statement) = {
    s match {
      case r: Return => returnWrites.writes(r)
      case nr: NoReturn => noReturnWrites.writes(nr)
    }
  }
}

Let's test this to make sure it works fine:

val statementWithNonEmpty = Return(NonEmptyExpression(100))
println(s"statementWithNonEmpty Json: ${statementWrites.writes(statementWithNonEmpty).toString()}")

val statementWithEmpty = Return(Empty)
println(s"statementWithEmpty Json: ${statementWrites.writes(statementWithEmpty).toString()}")

Output is:

statementWithNonEmpty Json: {"e":{"x":100}}

statementWithEmpty Json: {"e":{}}

Final Step (create List writer with no Empty):

val listStatementWrites = new Writes[Seq[Statement]] {
  override def writes(o: Seq[Statement]) = {
    val listWithoutEmpty = o.filter {
      case Return(Empty) => false
      case _ => true
    }

    JsArray(listWithoutEmpty.map(statementWrites.writes))
  }
}

let's try it:

val listOfStatements = List(Return(NonEmptyExpression(100)), Return(Empty), Return(NonEmptyExpression(200)))
println(s"listOfStatements: ${listStatementWrites.writes(listOfStatements).toString()}")

the output is:

listOfStatements: [{"e":{"x":100}},{"e":{"x":200}}]