如何使用circe解码ADT而不消除对象的歧义

Question

假设我有这样的ADT:

sealed trait Event

case class Foo(i: Int) extends Event
case class Bar(s: String) extends Event
case class Baz(c: Char) extends Event
case class Qux(values: List[String]) extends Event

circe中Decoder[Event]实例的默认泛型推导要求输入JSON包含一个包装器对象,该对象指示表示的是哪个case类:

scala> import io.circe.generic.auto._, io.circe.parser.decode, io.circe.syntax._
import io.circe.generic.auto._
import io.circe.parser.decode
import io.circe.syntax._

scala> decode[Event]("""{ "i": 1000 }""")
res0: Either[io.circe.Error,Event] = Left(DecodingFailure(CNil, List()))

scala> decode[Event]("""{ "Foo": { "i": 1000 }}""")
res1: Either[io.circe.Error,Event] = Right(Foo(1000))

scala> (Foo(100): Event).asJson.noSpaces
res2: String = {"Foo":{"i":100}}

这种行为意味着如果两个或多个案例类具有相同的成员名称,我们就不必担心含糊不清,但它并不总是我们想要的 - 有时我们知道展开的编码是明确的,或者我们想要通过指定顺序来消除歧义应该尝试每个案例类,或者我们只是不在乎.

如何在Event没有包装器的情况下对ADT 进行编码和解码(最好不必从头开始编写我的编码器和解码器)？

(这个问题经常出现 - 例如今天早上与 Gitter的Igor Mazor讨论.)

Answer 1

枚举ADT构造函数

获得所需表示的最直接方法是对案例类使用泛型派生,但为ADT类型显式定义实例:

import cats.syntax.functor._
import io.circe.{ Decoder, Encoder }, io.circe.generic.auto._
import io.circe.syntax._

sealed trait Event

case class Foo(i: Int) extends Event
case class Bar(s: String) extends Event
case class Baz(c: Char) extends Event
case class Qux(values: List[String]) extends Event

object Event {
  implicit val encodeEvent: Encoder[Event] = Encoder.instance {
    case foo @ Foo(_) => foo.asJson
    case bar @ Bar(_) => bar.asJson
    case baz @ Baz(_) => baz.asJson
    case qux @ Qux(_) => qux.asJson
  }

  implicit val decodeEvent: Decoder[Event] =
    List[Decoder[Event]](
      Decoder[Foo].widen,
      Decoder[Bar].widen,
      Decoder[Baz].widen,
      Decoder[Qux].widen
    ).reduceLeft(_ or _)
}

请注意,我们必须在解码器上调用widen(由Cats的Functor语法提供,我们将其带入第一次导入的范围),因为Decoder类型类不是协变的.circe类型类的不变性是一个争议的问题(例如Argonaut已经从不变量变为协变而后退),但它有足够的好处,它不太可能改变,这意味着我们偶尔需要这样的解决方法.

值得注意的是,我们的显式Encoder和Decoder实例将优先于我们从io.circe.generic.auto._导入中获得的一般派生实例(请参阅我的幻灯片,以获得有关此优先级如何工作的一些讨论).

我们可以像这样使用这些实例:

scala> import io.circe.parser.decode
import io.circe.parser.decode

scala> decode[Event]("""{ "i": 1000 }""")
res0: Either[io.circe.Error,Event] = Right(Foo(1000))

scala> (Foo(100): Event).asJson.noSpaces
res1: String = {"i":100}

这是有效的,如果您需要能够指定尝试ADT构造函数的顺序,那么它是目前最好的解决方案.但是,必须枚举这样的构造函数显然并不理想,即使我们免费获得case类实例.

更通用的解决方案

正如我在Gitter上所说,我们可以通过使用circe-shapes模块来避免写出所有情况的大惊小怪:

import io.circe.{ Decoder, Encoder }, io.circe.generic.auto._
import io.circe.shapes
import shapeless.{ Coproduct, Generic }

implicit def encodeAdtNoDiscr[A, Repr <: Coproduct](implicit
  gen: Generic.Aux[A, Repr],
  encodeRepr: Encoder[Repr]
): Encoder[A] = encodeRepr.contramap(gen.to)

implicit def decodeAdtNoDiscr[A, Repr <: Coproduct](implicit
  gen: Generic.Aux[A, Repr],
  decodeRepr: Decoder[Repr]
): Decoder[A] = decodeRepr.map(gen.from)

sealed trait Event

case class Foo(i: Int) extends Event
case class Bar(s: String) extends Event
case class Baz(c: Char) extends Event
case class Qux(values: List[String]) extends Event

然后:

scala> import io.circe.parser.decode, io.circe.syntax._
import io.circe.parser.decode
import io.circe.syntax._

scala> decode[Event]("""{ "i": 1000 }""")
res0: Either[io.circe.Error,Event] = Right(Foo(1000))

scala> (Foo(100): Event).asJson.noSpaces
res1: String = {"i":100}

这适用于范围内encodeAdtNoDiscr和decodeAdtNoDiscr范围内的任何ADT .如果我们希望它更受限制,我们可以用A这些定义中的ADT类型替换泛型,或者我们可以使定义非隐式,并为我们想要以这种方式编码的ADT明确定义隐式实例.

这种方法的主要缺点(除了额外的circe-shapes依赖性)是构造函数将按字母顺序进行尝试,如果我们有不明确的case类(其中成员名称和类型相同),这可能不是我们想要的).

未来

generic-extras模块在这方面提供了更多的可配置性.我们可以写下面的内容,例如:

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

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

sealed trait Event

case class Foo(i: Int) extends Event
case class Bar(s: String) extends Event
case class Baz(c: Char) extends Event
case class Qux(values: List[String]) extends Event

然后:

scala> import io.circe.parser.decode, io.circe.syntax._
import io.circe.parser.decode
import io.circe.syntax._

scala> (Foo(100): Event).asJson.noSpaces
res0: String = {"i":100,"what_am_i":"Foo"}

scala> decode[Event]("""{ "i": 1000, "what_am_i": "Foo" }""")
res1: Either[io.circe.Error,Event] = Right(Foo(1000))

我们有一个额外的字段来指示构造函数,而不是JSON中的包装器对象.这不是默认行为,因为它有一些奇怪的极端情况(例如,如果我们的一个案例类有一个名为的成员what_am_i),但在许多情况下它是合理的,并且自引入该模块以来它在泛型附加中得到支持.

这仍然不能让我们得到我们想要的东西,但它比默认行为更接近.我也一直在考虑withDiscriminator改为取Option[String]而不是a String,None表示我们不想要一个额外的字段来指示构造函数,给我们与上一节中的circe-shapes实例相同的行为.

如果您有兴趣看到这种情况,请打开一个问题,或者(甚至更好)拉取请求.:)