Как декодировать ADT с помощью Circe без устранения неоднозначности объектов
Предположим, у меня есть 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
Общий деривация по умолчанию для Decoder[Event] экземпляр в circe ожидает, что входной 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 без обертки (желательно без необходимости писать мои кодеры и декодеры с нуля)?
(Этот вопрос возникает довольно часто - см., Например, эту дискуссию с Игорем Мазором о Гиттере сегодня утром.)
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's 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-shape:
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 находятся в сфере. Если бы мы хотели, чтобы это было более ограниченным, мы могли бы заменить общий 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 у нас есть дополнительное поле, которое указывает конструктор. Это не поведение по умолчанию, так как в нем есть странные угловые случаи (например, если один из наших классов дел имеет член с именем what_am_i), но во многих случаях это разумно и поддерживается в generic-extras с момента появления этого модуля.
Это все еще не дает нам именно то, что мы хотим, но это ближе, чем поведение по умолчанию. Я также думал об изменении withDiscriminator взять Option[String] вместо String, с None это означает, что нам не нужно дополнительное поле, указывающее конструктор, что дает нам то же поведение, что и наши экземпляры circe-shape в предыдущем разделе.
Если вы заинтересованы в том, чтобы это произошло, пожалуйста, откройте вопрос или (что еще лучше) запрос на удаление.:)
В последнее время мне приходится много работать с 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