circe-generic is the older, more mature, more principled version, but it can result in slow compile times.
for the most common usage style (
deriveDecoder and deriveEncoder) they do exactly the same thing.
in your case you'd write:
implicit val decodeThing: Decoder[Thing] = deriveDecoderwith one of the following imports:
import io.circe.generic.semiauto.deriveDecoder
import io.circe.derivation.deriveDecoder
I'd probably recommend starting with circe-derivation
to do it right you need some kind of fancy prioritization trick, since you don't want derived instances to override explicitly defined instances.
caching instances is tricky (and circe-generic doesn't do it), which means it's really easy to blow up compile times.
jsoniter-scala does full-auto derivation and is able to override custom codecs from the implicit definitions using the following routine with a cache of resolved codecs under-hood: https://github.com/plokhotnyuk/jsoniter-scala/blob/master/jsoniter-scala-macros/src/main/scala/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMaker.scala#L322
how do you handle the "imports smash everything" problem?
sorry, just meant the issue that if a user has
case case Foo(x: String)
object Foo {
implicit val decodeFoo: Decoder[Foo] = // custom instance here
}
case class Bar(y: Int, foo: Foo)and they want to use fully-automatic derivation for Bar, any straightforward solution will result in the custom instance for Foo being ignored.
circe-generic gets around this with its own miniature version of the export-hook solution (which requires a macro on the generic instance definition side)
this case works for jsoniter-scala properly, just look and play with a test for the following data structure declaration: https://github.com/plokhotnyuk/jsoniter-scala/blob/master/jsoniter-scala-macros/src/test/scala/com/github/plokhotnyuk/jsoniter_scala/macros/JsonCodecMakerSpec.scala#L1886-L1906
Does anyone have a simple gist kicking around of deriving encoders/decoders when using the Refined library? I can only find an encoding example in the docstring here: https://github.com/circe/circe/blob/master/modules/refined/shared/src/main/scala/io/circe/refined/package.scala
@truongio just wrote this up: https://stackoverflow.com/a/57919949/334519
Sorry, I forgot about this. Thank you so much @travisbrown! It worked great.
I have to do some boilerplate to get refined decoders to work. Hopefully I'm missing some easier syntax? E.g. for the non empty string name field of some User case class
val name = hc.downField("name").as[String].flatMap(s => refineV[NonEmpty](s).leftMap(m => DecodingFailure(m, List()))) I can't seem to get any easier syntax to work (e.g. semi-automatic decoders).
@matfournier can you give a complete example? it should just work
scala> import eu.timepit.refined._, api.Refined, numeric.Positive
import eu.timepit.refined._
import api.Refined
import numeric.Positive
scala> import io.circe.generic.semiauto._, io.circe.refined._
import io.circe.generic.semiauto._
import io.circe.refined._
scala> case class Foo(x: Refined[Int, Positive])
defined class Foo
scala> implicit val decodeFoo: io.circe.Decoder[Foo] = deriveDecoder
decodeFoo: io.circe.Decoder[Foo] = io.circe.generic.decoding.DerivedDecoder$$anon$1@65c53a66
scala> io.circe.jawn.decode[Foo]("""{"x": 1}""")
res0: Either[io.circe.Error,Foo] = Right(Foo(1))
scala> io.circe.jawn.decode[Foo]("""{"x": 0}""")
res1: Either[io.circe.Error,Foo] = Left(DecodingFailure(Predicate failed: (0 > 0)., List(DownField(x))))
Facepalm. I know what my problem is. I forgot to add circe-refined to my deps in build.sbt. All good here folks, just me being an idiot.
Thank you for that example though. Now that I've fixed my build.sbt, it's all working as expected.
In case of circe-derivation pay attention that all your fields are circe serializable.
are you using special typeclassing? otherwise I suggest you to use @JsonCodec annotation to generate your codecs
It can be easy implemented as an optional printing of a message with prettified code to the compiler output before returning of the result expression from macros like here
@travisbrown I created an issue with a small example. @aparo thats what I am currently doing. I use for most of my case classes the annotation. For the one which causes the error I clean the null values like this:
implicit val myDecoder: Decoder[MyData] = deriveDecoder.prepare(_.withFocus(_.dropNullValues))but thats more of a workaround..
I'm having some issues getting my decoder to compile for an
enumeratum enumimport enumeratum.values.{ StringEnum, StringEnumEntry }
import io.circe._
import scala.collection.immutable
sealed abstract class MyThing(val value: String, val name: String) extends StringEnumEntry
case object MyThing extends StringEnum[MyThing] {
case object Foo extends MyThing(value = "123", name = "some token")
case object Bar extends MyThing(value = "456", name = "some other token")
val values: immutable.IndexedSeq[MyThing] = findValues
}
object MyThingCodecs {
implicit val encode: Encoder[MyThing] = new Encoder[MyThing] {
final def apply(l: MyThing): Json = Json.fromString(l.name)
}
implicit val decode: Decoder[MyThing] = new Decoder[MyThing] {
final def apply(c: HCursor): Decoder.Result[MyThing] =
for {
name <- c.downField("name").as[String]
} yield
MyThing
.withValueOpt(name)
.map(x => Right(x))
.getOrElse(Left(DecodingFailure("Unable to parse into MyThing", List.empty)))
}
}
from the circe library it looks like
Result[A] is a type alias for an Either[DecodingFailure, A]
which I've provided, however it still is saying
exprected Decoder.Result got Either
is there a simpler way to handle this decoding?
also should I be using
c.history for the List[CursorOps]?
figured it out
implicit val decode: Decoder[MyThing] = new Decoder[MyThing] {
final def apply(c: HCursor): Decoder.Result[MyThing] =
c.downField("value")
.as[String]
.flatMap { foo =>
MyThing.withValueOpt(foo) match {
case Some(f) => Right(f)
case None => Left(DecodingFailure("error", c.history))
}
}
}
@travisbrown I was through circe-derivation and I noticed that while the readme says it’s not at feature parity due to not supporting ADT’s the merging of circe-derivation/#100 suggests that message is out of date. So is circe-derivation at feature parity with circe-generic?