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

Question

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

jsonscalaalgebraic-data-typescircegeneric-derivation

33

假设我有这样一个抽象数据类型（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 class：

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的讨论。）

- Travis Brown

2个回答

1

我最近需要处理很多ADT转JSON的工作，所以决定维护自己的扩展库，它提供了一种使用注释和宏来解决问题的不同方式：

ADT定义：

import org.latestbit.circe.adt.codec._


sealed trait TestEvent

@JsonAdt("my-event-1") 
case class MyEvent1(anyYourField : String /*, ...*/) extends TestEvent

@JsonAdt("my-event-2")
case class MyEvent2(anyOtherField : Long /*, ...*/) extends TestEvent

使用方法：


import io.circe._
import io.circe.parser._
import io.circe.syntax._

// This example uses auto coding for case classes. 
// You decide here if you need auto/semi/custom coders for your case classes.
import io.circe.generic.auto._ 

// One import for this ADT/JSON codec
import org.latestbit.circe.adt.codec._

// Encoding

implicit val encoder : Encoder[TestEvent] = 
  JsonTaggedAdtCodec.createEncoder[TestEvent]("type")

val testEvent : TestEvent = TestEvent1("test")
val testJsonString : String = testEvent.asJson.dropNullValues.noSpaces

// Decoding
implicit val decoder : Decoder[TestEvent] = 
  JsonTaggedAdtCodec.createDecoder[TestEvent] ("type")

decode[TestEvent] (testJsonString) match {
   case Right(model : TestEvent) => // ...
}

详情：https://github.com/abdolence/circe-tagged-adt-codec

- abdolence

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Travis Brown · Accepted Answer

枚举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}

这将适用于任何ADT，只要encodeAdtNoDiscr和decodeAdtNoDiscr在范围内。如果我们希望它更加有限制，我们可以用我们的ADT类型替换那些定义中的通用A，或者我们可以使定义非隐式，为我们想要以这种方式编码的ADT明确定义隐式实例。

这种方法的主要缺点（除了额外的circe-shapes依赖）是构造函数将按字母顺序尝试，如果我们有模棱两可的case class（成员名称和类型相同），这可能不是我们想要的。

未来

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中，我们有一个额外的字段来表示构造函数，而不是一个包装对象。这不是默认行为，因为它有一些奇怪的边角情况（例如，如果我们的其中一个case类有一个名为what_am_i的成员），但在许多情况下它是合理的，并且自从引入了generic-extras模块以来得到了支持。

这仍然不能完全满足我们的需求，但比默认行为更接近。我还考虑将withDiscriminator更改为使用Option[String]而不是String，其中None表示我们不想要一个额外的字段来表示构造函数，从而使我们拥有与前面一节中的circe-shapes实例相同的行为。

如果您有兴趣看到这种情况发生，请打开一个问题或（更好的是）一个拉取请求。 :)