ADT Json serialization/deserialization

Question

Experimenting with Circe to serialize and deserialize Algebraic Data Types in Scala I tried out the following sample, following the doc and some samples on the web:

  sealed trait StringData
  case class Data2(f1: String, f2: String) extends StringData
  case class Data3(f1: String, f2: String, f3: String) extends StringData

  object StringData {
    // ===> does not work, always picks Data2 type
    implicit val decodeData: Decoder[Data] = Decoder[OptionsData].map[Data](identity).or(Decoder[TextData].map[Data](identity))

    implicit val encodeData: Encoder[StringData] = Encoder.instance {
      case d2 @ Data2( _,_) => d2.asJson
      case d3 @ Data3( _, _, _) => d3.asJson
    }

    def toJson(s: StringData): String = s.asJson.noSpaces
    def fromJson(s: String): Either[Error, StringData] = decode[StringData](s)
  }

  "Inheritance ADT with identical fields" should "serialize and deserialize with Circe" in {
    val d2 = Data2("a", "b")
    val d3 = Data3("1", "2", "3")

    val jd2 = StringData.toJson(d2)
    val jd3 = StringData.toJson(d3)

    val d2Decoded = StringData.fromJson(jd2)
    val d3Decoded = StringData.fromJson(jd3)

    d2Decoded.right.get should equal(d2)
    d3Decoded.right.get should equal(d3)

    println("")
  }

The problem is that the type of d3Decoded is always of type Data2 and not the desired Data3.

The solution I came up with was to replace the decoder with this one:

    implicit val decodeData: Decoder[StringData] = Decoder.instance { c =>
      c.downField("f3").as[String] match {
        case m: Either[DecodingFailure, String] if m.isLeft => c.as[Data2]
        case m: Either[DecodingFailure, String] if m.isRight => c.as[Data3]
      }
    }

This seems to me a rather ad-hoc solution. In Jackson there is the possibility to add the type to the Json. I wonder if I use Circe the right way or if this is really the way to do. Any comments very welcome.

Answer 1

Try using discriminator documented here:

import io.circe.generic.extras.auto._
import io.circe.generic.extras.Configuration
import io.circe.parser.decode

implicit val genDevConfig: Configuration =
  Configuration.default.withDiscriminator("what_am_i")

sealed trait StringData
case class Data2(f1: String, f2: String) extends StringData
case class Data3(f1: String, f2: String, f3: String) extends StringData

decode[StringData]("""{ "f1": "foo", "f2": "bar", "f3": "qux", "what_am_i": "Data3" }""")

which outputs

res0: Either[io.circe.Error,StringData] = Right(Data3(foo,bar,qux)

where

libraryDependencies ++= Seq(
      "io.circe" %% "circe-core",
      "io.circe" %% "circe-generic",
      "io.circe" %% "circe-parser",
      "io.circe" %% "circe-generic-extras",
    ).map(_ % circeVersion)