如何在不消除对象歧义的情况下使用 circe 解码 ADT

Posted

技术标签:

【中文标题】如何在不消除对象歧义的情况下使用 circe 解码 ADT【英文标题】:How to decode an ADT with circe without disambiguating objects 【发布时间】:2017-06-29 03:50:54 【问题描述】:

假设我有这样的 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 包含一个包装器对象,该对象指示表示哪个案例类:

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 上的 this discussion with Igor Mazor。)

【问题讨论】:

【参考方案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 的类型类的不变性是 some controversy 的问题(例如 Argonaut 已经从不变变为协变并返回),但它有足够的好处,它不太可能改变,这意味着我们偶尔需要这样的解决方法。

还值得注意的是,我们显式的 EncoderDecoder 实例将优先于我们从 io.circe.generic.auto._ 导入中获得的泛型派生实例(请参阅我的幻灯片 here,了解有关如何此优先级有效)。

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

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 构造函数的尝试顺序,这是目前最好的解决方案。但是,必须像这样枚举构造函数显然并不理想,即使我们免费获得了案例类实例。

更通用的解决方案

正如我注意到的on 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

这适用于 encodeAdtNoDiscrdecodeAdtNoDiscr 范围内的任何 ADT。如果我们希望它受到更多限制,我们可以在这些定义中将通用 A 替换为我们的 ADT 类型,或者我们可以使定义为非隐式并为我们希望以这种方式编码的 ADT 显式定义隐式实例。

这种方法的主要缺点(除了额外的 circe-shapes 依赖)是构造函数将按字母顺序尝试,如果我们有模棱两可的案例类(其中成员名称和类型),这可能不是我们想要的是一样的)。

未来

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 的成员),但在许多情况下,它是合理的,并且自引入该模块以来它在 generic-extras 中得到支持.

这仍然没有得到我们想要的,但它比默认行为更接近。我也一直在考虑将withDiscriminator 更改为采用Option[String] 而不是StringNone 表示我们不想要一个指示构造函数的额外字段,从而为我们提供与我们的circe-相同的行为上一节中的形状实例。

如果您有兴趣看到这种情况发生,请打开an issue,或者(甚至更好)pull request。 :)

【讨论】:

最后一个选项看起来确实很有希望。与往常一样,我很想知道是否有任何关于性能的主要警告。 我多次遇到这个问题,这个解决方案正是我所需要的。我已经使用此解决方案制作了sample project,以供将来参考。 我似乎无法让中间的圆形示例为我工作。我注意到这篇文章已被复制到文档中:circe.github.io/circe/codecs/adt.html 我假设import io.circe.shapes 应该是import io.circe.shapes._。我在github.com/LeifW/CirceSumTypes/blob/master/src/main/scala/… 举了一个例子,但我得到的是: "Animal" : "sodium" : 5 而不是:"sodium": 5 我尝试了 0.12 和 0.13,以及 generic-extras,结果相同。 哦,它适用于auto,但不适用于semiauto。小时。 事实证明它确实适用于 semiauto - 很抱歉产生噪音。只是 shapes._encodeAdtNoDiscr 在包含类中调用 deriveEncoder 时需要在范围内 - 我假设在 sum 类型本身中调用 deriveEncoder 时它们需要在范围内。所以对于sealed trait SumType = A | B | Ccase class ContainingType(things: List[SumType]),当在 ContainingType 的伴随对象中调用 deriveEncoder 时,这些额外的东西需要在范围内 - 它们在 SumType 的范围内无效。【参考方案2】:

我最近要处理很多 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

【讨论】:

以上是关于如何在不消除对象歧义的情况下使用 circe 解码 ADT的主要内容,如果未能解决你的问题,请参考以下文章

使用 circe 解码 JSON 对象时捕获未使用的字段

如何在不消除坐标的情况下对浮点坐标进行排序? [关闭]

如何在circe中编码/解码json的时间戳?

如何在不损失精度的情况下解码 NSDecimalNumber?

有没有办法在不创建***结构的情况下将 JSON 解码为结构

无法使用Circe JSON解析器创建遍历JSON字符串的对象