@phdoerfler: you can represent that as a
Tuple2[Double, String]import io.circe.syntax._
Tuple2(1234.123, "test").asJson
// [
// 1234.123,
// "test"
// ]
import io.circe.parser._
decode[Tuple2[Double, String]](""" [ 1234.123, "test" ] """)
// Right((1234.123,test))@phdoerfler:
if you also want it in a case class, that's straightforward, too 🙂
import io.circe._
case class MyResponse(double: Double, string: String)
object MyResponse {
implicit val codec: Codec[MyResponse] = Codec.from(
implicitly[Decoder[Tuple2[Double, String]]].map((MyResponse.apply _).tupled),
implicitly[Encoder[Tuple2[Double, String]]].contramap(r => (r.double, r.string))
)
}
decode[MyResponse](""" [ 1234.123, "test" ] """)
// Right(MyResponse(1234.123,test))
Yeah, I didn't know about this, either. It just worked – lucky guess =)
Yeah, it does take time and patience to learn.
And it does pay off afterwards :)
(I still have some things to figure out...)
And it does pay off afterwards :)
(I still have some things to figure out...)
I think at some point I discovered it by accident, too
Anyway, glad that
decode[(Double, String)] does the trick
there's the whole thing. It's still WIP but I use it and it takes out a lot of frustration :) hope this helps!
@yurique:nowhere.chat I turned your code into a snippet for VS Code: https://gist.github.com/phdoerfler/22623b64fbc11e556078641855cdea40 :)
Good point! I love Scastie and use it all the time! However, the snippet I made lets you specify the name of the case class, its two fields and the types of the two fields and it does all that right within VS Code for ultimate convenience. Scastie can't quite compete with that I'm afraid ;)
So, I have fairly large ADT of case classes representing error conditions. They have different shapes but all of them have an
errorCode val. The default derivation wasn't including that member so I customised it to include the errorCode. That is working fine in https://scastie.scala-lang.org/8Bjn1eDBSXCQPlZ3fKuk9A , but, what I really wanted was the name of the jsonObject to be the error code. I'm struggling a bit with the shapeless-foo. Help is much appreciated. Comments in the scastie snippet. Thanking you legends in advance.
@vlfig: Does https://circe.github.io/circe/codecs/adt.html#the-future (circe-generic-extras) solve your problem?
You can set the discriminator as errorCode and it should give you something like:
{
"errorCode": "MayOrMayNotExist",
"address": "..."
}You can update transformConstructorName of the Configuration object to change the constant each type maps to. (e.g. snake case may_or_may_not_exist)
I’m trying to use Cats and Circe, but I need to deserialize a
NonEmptyChain[HeaderValidationError] to json and I’m not sure how.sealed trait HeaderValidationError {
def errorMessage: String
}
final case class ExpectUUIDHeaderError(key: String, value: String) extends HeaderValidationError {
def errorMessage: String = s"Missing Header $key, UUID required, got $value"
}
final case class MissingHeaderError(value: String) extends HeaderValidationError {
def errorMessage: String = s"Missing Header $value"
}import cats.data._
import io.circe.generic.semiauto.deriveEncoder
import io.circe.syntax._
import io.circe.Encoder
implicit val encodeHeaderValidationError: Encoder[NonEmptyChain[HeaderValidationError]] =
deriveEncoder[NonEmptyChain[HeaderValidationError]]could not find Lazy implicit value of type io.circe.generic.encoding.DerivedAsObjectEncoder[cats.data.NonEmptyChain[HeaderValidationError]]
@justinallenreeves: Check https://circe.github.io/circe/codecs/adt.html, it explains how you can handle ADTs like yours. And note that circe has a built-in
Encoder for NonEmptyChain, so need to derive something there. Just make sure you have an Encoder[HeaderValidationError], then the NEC version comes "for free".
One comment on the first example on that page though: Rather don't use auto derivation, but define the instances in the companion objects using semi-automatic derivation.
It should (I haven't tried myself), but I've seen some issues posted here though e.g. https://matrix.to/#/!dipkpQThLPKgogRBWx:gitter.im/$GUoKlfZ1hULhdmeqn4XhiunzpNqYyIQv623157x409o?via=gitter.im&via=matrix.org&via=nowhere.chat
import io.circe._, io.circe.generic.semiauto._
case class Huh(str: String)
implicit val huhEncoder: Encoder[Huh] = deriveEncoder[Huh]
I think I saw a Dotty issue filed that may address this, but I guess it hasn't been fixed yet.
The error, for reference, is this:
could not find Lazy implicit value of type io.circe.generic.encoding.DerivedAsObjectEncoder[Huh].
I found:
shapeless.Lazy.mkLazy[I]
But method mkLazy in object Lazy does not match type shapeless.Lazy[io.circe.generic.encoding.DerivedAsObjectEncoder[Huh]].
One of the following imports might make progress towards fixing the problem:
import shapeless.~?>.idKeyWitness
import shapeless.~?>.idValueWitness
import shapeless.~?>.witness
Spoiler alert: the following imports made progress towards fixing the problem in that including an import removed it from the error message.
hm you shouldn't be seeing anything related to shapeless. According to the release notes circe-generic does not depend on shapeless for scala 3
My
dependencyTree tells me this:
[info] +-io.circe:circe-generic_2.13:0.14.0-M5 [S]
[info] | +-com.chuusai:shapeless_2.13:2.3.3 [S]
Hmm... wait a second...
They have never lied to me. I have a very trusting and fruitful friendship with them ;)
Is there a better way to understand errors with Auto and SemiAuto encoding:
I understand that something has missing encoder within the object but I'm rather dealing with a complicated one and looking at all the different classes it should be ok :D
could not find Lazy implicit value of type io.circe.generic.encoding.DerivedAsObjectEncoderI understand that something has missing encoder within the object but I'm rather dealing with a complicated one and looking at all the different classes it should be ok :D
@TheCodingPenguin: Not until Scala 3 unfortunately. Scala 2's implicit derivation error is not very helpful.
To debug it, I'd try to see if each field has an Encoder.
implicitly[Encoder[Field1]] etc
@KannarFr: you will have to write the encoder manually. derivation only look at the case class constructor fields so that's why you only see field
b
Hello, is there a way to compare if two Json have the same elements? Key order for objects should not matter. And value order in arrays should not matter either.
Right, I've implemented my own function to do that. Is there a reason why JObject, JArray, JNumber and such are private? If they were public it would've made pattern matching much simpler.
I believe it is to make it easier to change the AST under the hood, so hiding it makes it easier to maintain binary compatibility reasons. It might be a decision inherited from Argonaut I think?