web-dev-qa-db-ja.com

オブジェクトを明確にすることなく、CircleでADTをデコードする方法

次のような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}}

この動作は、2つ以上のケースクラスが同じメンバー名を持っている場合でも、あいまいさを心配する必要がないことを意味しますが、常にそうであるとは限りません。ラップされたエンコーディングが明確であることがわかっている場合や、順序を指定してあいまいさを解消したい場合があります。各ケースクラスを試す必要があります。そうしないと、気にしません。

ラッパーなしでEvent ADTをエンコードおよびデコードするにはどうすればよいですか（できれば、エンコーダーとデコーダーを最初から作成する必要がない）。

（この質問はかなり頻繁に出てきます。たとえば、今朝Gitterで このIgor Mazorとの議論 を参照してください。）

jsonscalaalgebraic-data-typescircegeneric-derivation
26
Travis Brown

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タイプのクラスは共変ではないため、デコーダーでFunctor（Catsの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コンストラクターが試行される順序を指定できるようにする必要がある場合は、現時点でこれが最良の解決策です。このようなコンストラクタを列挙する必要があることは、ケースクラスのインスタンスを無料で取得したとしても、明らかに理想的ではありません。

より一般的なソリューション

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の暗黙インスタンスを明示的に定義します。

このアプローチの主な欠点（追加の円形状依存関係は別として）は、コンストラクターがアルファベット順に試行されることです。これは、あいまいなケースクラス（メンバー名と型が同じである）がある場合に必要なことではない可能性があります。 ）。

未来

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のラッパーオブジェクトの代わりに、コンストラクターを示す追加のフィールドがあります。これは、いくつかの奇妙なコーナーケースがあるため（たとえば、ケースクラスの1つにwhat_am_iという名前のメンバーがあった場合）、デフォルトの動作ではありませんが、多くの場合それは合理的であり、そのモジュール以降、generic-extrasでサポートされています紹介されました。

これでもまだ希望どおりの結果にはなりませんが、デフォルトの動作よりも近くなっています。 withDiscriminatorの代わりにOption[String]を取るようにStringを変更することも検討してきました。Noneは、コンストラクタを示す追加のフィールドが不要であることを示しており、前のセクション。

これが発生するのを確認したい場合は、 問題 、または プルリクエスト を開いてください。 :)

38
Travis Brown

最近、JSONに対して大量のADTを処理する必要があるため、独自の拡張ライブラリを維持することを決定します。これにより、注釈とマクロを使用して解決するための少し異なる方法が提供されます。

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

0
abdolence