Codec for coproducts with discriminator - scala

Question

We're trying to have circe codecs for shapeless coproducts whith a class name as the discriminator :
object CoproductCodecWrong extends App {
import io.circe.Codec
import shapeless.{ :+:, CNil, Coproduct }
import io.circe.shapes._
import io.circe.literal._
case class A()
case class B(a: String)
type AB = A :+: B :+: CNil
case class H(ab: AB)
implicit val encodeA: Codec[A] = io.circe.generic.semiauto.deriveCodec
implicit val encodeB: Codec[B] = io.circe.generic.semiauto.deriveCodec
implicit val hCodec: Codec.AsObject[H] = io.circe.generic.semiauto.deriveCodec[H]
val hA: H = H(Coproduct[AB](A()))
val hB: H = H(Coproduct[AB](B("q")))
}
It doesn't work because by default the encoder doesn't produce any information that allows to distinguish both cases:
println("hA:\n" + hCodec.apply(hA).toString())
println("hB:\n" + hCodec.apply(hB).toString())
...
hA:
{
"ab" : {
}
}
hB:
{
"ab" : {
"a" : "q"
}
}
Decoding:
println(hCodec.decodeJson(json"""{"ab" : {}}"""))
println(hCodec.decodeJson(json"""{"ab" : {"a" : "q"}}"""))
...
Right(H(Inl(A())))
Right(H(Inl(A())))
It's always A that is found, which is very dangerous as it's working seemingly correctly but should be failing.
We've found a solution using Unions:
import io.circe.{ CursorOp, Decoder, DecodingFailure, Encoder }
import shapeless.ops.coproduct.Folder
import shapeless.ops.union.Values
import shapeless.union.Union
import shapeless.Poly1
type ABL = Union.`'A->A,'B->B`.T
object ABPoly extends Poly1 {
implicit val atA: Case.Aux[A, ABL] = at[A] { z =>
Union[ABL](A = z)
}
implicit val atB: Case.Aux[B, ABL] = at[B] { z =>
Union[ABL](B = z)
}
}
def coproductToLabeledCoproduct[Co <: Coproduct, Labeled <: Coproduct](t: Poly1)(
implicit E: Encoder[Labeled],
D: Decoder[Labeled],
V: Values.Aux[Labeled, Co],
F: Folder.Aux[t.type, Co, Labeled]
): Codec[Co] = {
import io.circe.syntax._
Codec.from(
Decoder.instance { input =>
input.focus
.map(_.as[Labeled].map(x => shapeless.union.unionOps(x).values: Co))
.getOrElse(Left(DecodingFailure("Should be available", { List(CursorOp.DownField("coproduct instance")) })))
},
Encoder.instance(a => a.fold(t).asJson)
)
}
implicit val abToABL: Codec[AB] = coproductToLabeledCoproduct[AB, ABL](ABPoly)
implicit val hCodec: Codec.AsObject[H] = io.circe.generic.semiauto.deriveCodec[H]
The result of encoding/decoding is correct now:
hA:
{
"ab" : {
"A" : {
}
}
}
hB:
{
"ab" : {
"B" : {
"a" : "q"
}
}
}
Right(H(Inl(A())))
Right(H(Inr(Inl(B(q)))))
But it's a bit complex, and hard to maintain for multiple classes.
Is there a better way?
EDIT:
circe-generic-extras doesn't work as it doesn't have a support for coproducts, only for sealed traits and enums. This gives the same result without a discriminator:
implicit val configuration: Configuration = Configuration.default.withDiscriminator("tag")
implicit val encodeA: Codec[A] = io.circe.generic.extras.semiauto.deriveConfiguredCodec
implicit val encodeB: Codec[B] = io.circe.generic.extras.semiauto.deriveConfiguredCodec
implicit val hCodec: Codec.AsObject[H] = io.circe.generic.extras.semiauto.deriveConfiguredCodec[H]

Answer 1

If you are using HLists and Coproducts directly then I guess something is broken in the code that requires that but I would probably use something like:
import shapeless._
import io.circe._
import io.circe.syntax._
class Discriminator(val fieldName: String, val classNameMapper: String => String)
implicit def cnilCodec: Codec[CNil] =
Codec.from(Decoder.instance[CNil](_ => Left(DecodingFailure("should never happen", Nil))), Encoder.instance(_ => ???))
implicit def coproductCodec[LeftLabel, LeftType: Codec, Right <: Coproduct: Codec](
implicit label: Witness.Aux[LeftLabel],
discriminator: Discriminator
): Codec[FieldType[LeftLabel, LeftType] :+: Right] = {
val thisLabel = discriminator.classNameMapper(label.value.toString)
val decoder = Decoder.instance[FieldType[LeftLabel, LeftType] :+: Right] { hcursor =>
hcursor
.get[String](discriminator.fieldName)
.leftMap(_.copy(message = s"Expected discriminator key ${discriminator.fieldName}"))
.flatMap { thisLabel =>
if (thisLabel == thisLabel) Decoder[LeftType].apply(hcursor).map(_.asInstanceOf[FieldType[LeftLabel, LeftType]]).map(Inl(_))
else Decoder[Right].apply(hcursor).map(Inr(_))
}
}
val encoder = Encoder.instance[FieldType[LeftLabel, LeftType] :+: Right] {
case Inl(value) => (value: LeftType).asJson.deepMerge(Json.fromFields(Seq(discriminator.fieldName -> thisLabel.asJson)))
case Inr(tail) => tail.asJson
}
Codec.from(decoder, encoder)
}
Whether it's simpler or more complicated it's a matter of taste.
For me personally this would be a red flag in deciding whether or not use the library in my code. Especially considering that you are forced to use shapeless directly with Circe, which supports sealed hierarchies out of the box.
I would use Circe Generic Extras with a sealed hierarchy.
It allows defining discriminator field name and format, providing support for auto- and semiauto derivation as well as macro annotations (#ConfiguredJsonCodec instead of #JsonCodec).
And then I would just translate this into this sad internal representation with:
def rewriteForCoproduct[A: Codec, ARepr <: Coproduct](implicit gen: LabelledGeneric.Aux[A, ARepr]): Codec[ARepr] =
Codec.from(Codec[A].map[ARepr](gen.to), Codec[A].contramap[ARepr](gen.from))