Alternative to parsing json with option [ either [A,B ] ] in scala

Question

For example, here payload is optional and it has 3 variants:

How can I parse the json with types like option[either[A,B,C]] but to use abstract data type using things sealed trait or sum type?

Below is a minimal example with some boiler plate:

https://scalafiddle.io/sf/K6RUWqk/1

// Start writing your ScalaFiddle code here
val json =
  """[
       {
         "id": 1,
         "payload" : "data"
       },
       {
         "id": 2.1,
         "payload" : {
           "field1" : "field1",
           "field2" : 5,
           "field3" : true
         }
       },
      {
         "id": 2.2,
         "payload" : {
           "field1" : "field1",
         }
       },
       {
         "id": 3,
          payload" : 4
       },
       {
         "id":4,
          "
       }
     ]"""

final case class Data(field1: String, field2: Option[Int])
type Payload = Either[String, Data]
final case class Record(id: Int, payload: Option[Payload])

import io.circe.Decoder
import io.circe.generic.semiauto.deriveDecoder

implicit final val dataDecoder: Decoder[Data] = deriveDecoder
implicit final val payloadDecoder: Decoder[Payload] = Decoder[String] either Decoder[Data]
implicit final val recordDecoder: Decoder[Record] = deriveDecoder

val result = io.circe.parser.decode[List[Record]](json)
println(result)

Answer 1

Your code is almost fine, you have just syntax issues in your json and Record.id should be Double instead of Int - because it is how this field present in your json ( "id": 2.1 ). Please, find fixed version below:

val json =
      s"""[
       {
         "id": 1,
         "payload" : "data"
       },
       {
         "id": 2.1,
         "payload" : {
           "field1" : "field1",
           "field2" : 5,
           "field3" : true
         }
       },
       {
         "id": 2.2,
         "payload" : {
           "field1" : "field1"
         }
       },    





       {
         "id": 3,
         "payload" : 4
       },





       {
         "id": 4
       }
     ]"""

    type Payload = Either[String, Data]
    final case class Data(field1: String, field2: Option[Int])
    final case class Record(id: Double, payload: Option[Payload]) // id is a Double in your json in some cases

    import io.circe.Decoder
    import io.circe.generic.semiauto.deriveDecoder

    implicit val dataDecoder: Decoder[Data] = deriveDecoder
    implicit val payloadDecoder: Decoder[Payload] = Decoder[String] either Decoder[Data]
    implicit val recordDecoder: Decoder[Record] = deriveDecoder

    val result = io.circe.parser.decode[List[Record]](json)
    println(result)

Which produced in my case:

Right(List(Record(1.0,Some(Left(data))), Record(2.1,Some(Right(Data(field1,Some(5))))), Record(2.2,Some(Right(Data(field1,None)))), Record(3.0,Some(Left(4))), Record(4.0,None)))

UPDATE:

The more general approach would be to use so-called Sum Types or in simple words - general sealed trait with several different implementations. Please, see for more details next Circe doc page : https://circe.github.io/circe/codecs/adt.html

In your case it can be achieved something like this:

import cats.syntax.functor._
  import io.circe.Decoder
  import io.circe.generic.semiauto.deriveDecoder

  sealed trait Payload

  object Payload {
    implicit val decoder: Decoder[Payload] = {
      List[Decoder[Payload]](
        Decoder[StringPayload].widen,
        Decoder[IntPayload].widen,
        Decoder[ObjectPayload].widen
      ).reduce(_ or _)
    }
  }

  case class StringPayload(value: String) extends Payload

  object StringPayload {
    implicit val decoder: Decoder[StringPayload] = Decoder[String].map(StringPayload.apply)
  }

  case class IntPayload(value: Int) extends Payload

  object IntPayload {
    implicit val decoder: Decoder[IntPayload] = Decoder[Int].map(IntPayload.apply)
  }

  case class ObjectPayload(field1: String, field2: Option[Int]) extends Payload

  object ObjectPayload {
    implicit val decoder: Decoder[ObjectPayload] = deriveDecoder
  }

  final case class Record(id: Double, payload: Option[Payload])

  object Record {
    implicit val decoder: Decoder[Record] = deriveDecoder
  }

  def main(args: Array[String]): Unit = {
    val json =
      s"""[
       {
         "id": 1,
         "payload" : "data"
       },
       {
         "id": 2.1,
         "payload" : {
           "field1" : "field1",
           "field2" : 5,
           "field3" : true
         }
       },
       {
         "id": 2.2,
         "payload" : {
           "field1" : "field1"
         }
       },
       {
         "id": 3,
         "payload" : "4"
       },
       {
         "id": 4
       }
     ]"""

    val result = io.circe.parser.decode[List[Record]](json)
    println(result)
  }

which produced in my case next output:

Right(List(Record(1.0,Some(StringPayload(data))), Record(2.1,Some(ObjectPayload(field1,Some(5)))), Record(2.2,Some(ObjectPayload(field1,None))), Record(3.0,Some(StringPayload(4))), Record(4.0,None)))

Hope this helps!