object DataRecord extends XMLStandardTypes {
private case class DataWriter[+A](
namespace: Option[String],
key: Option[String],
xstypeNamespace: Option[String],
xstypeName: Option[String],
value: A,
writer: CanWriteXML[_]) extends DataRecord[A] {
override def equals(o: Any): Boolean =
o match {
case that: DataWriter[_] =>
namespace == that.namespace &&
key == that.key &&
value == that.value
case _ => false
}
override def hashCode: Int = {
var result = 17
result = result + 31 * namespace.hashCode
result = result + 31 * key.hashCode
result = result + 31 * value.hashCode
result
}
}
I get the feeling if this is implemented properly one would have to consider how do two namespaces share the projected names, possibly via a prefix
and omitting prefixes for the default namespace
@alexarchambault / @milessabin For reasons I don't wish to delve too deeply into, I have a 45 field case class that is primarily Strings, Doubles or Options of those. I'm seeing compile times on the order of 250seconds to derive a DecodeJson, using 0.2.0-SNAPSHOT (and therefore shapeless 2.2-M6). Is that to be expected?
@AlecZorab The tests illustrates that a bit, this is how I do it:
- putting the definitions of the types you derive type classes for in a separate file (
Definitions.scala), - deriving the type classes in another file (
JsonCodecs.scala) -Shapeless._is imported only there, - and using the both from other files (
ShapelessTests.scala).
(illustrating files in https://github.com/alexarchambault/argonaut-shapeless/tree/master/src/test/scala/argonaut)
The goal is to have incremental compilation compile once the definitions and derivations, and that's it.
If you don't modify the definitions or derivations, or their dependencies, they shouldn't be recompiled. You can work freely on the other files.
If you don't modify the definitions or derivations, or their dependencies, they shouldn't be recompiled. You can work freely on the other files.
This doesn't speed up compilation per se, this just avoids unnecessary recompilations.
Development will go on towards 0.3.0, with hopefully support for shapeless 2.2 orphan derivation, and more varied / customisable codecs (ability to change the way products are encoded - e.g. to transform the keys' case, or to put the product in a json array rather than an object, or change the way coproducts are encoded - e.g. to encode eithers directly as their right or left values rather than nesting them in
(see the discussion here: alexarchambault/argonaut-shapeless#5)
{ "Left" / "Right": ... }, or to add a custom field for the type, ...)(see the discussion here: alexarchambault/argonaut-shapeless#5)
ie. something along the lines of test/orphans.
It's either
cachedImplicit or orphans :-(
OK, I'll take a look at milessabin/shapeless#391 and get back to you.
@milessabin Both scalacheck-shapeless and argonaut-shapeless (branch 0.3.x) are now fine with orphan derivations. Thumbs up for shapeless 2.2.3.
I'm working on a
Generic1 bug and I'll release as soon as I have a fix for that. Fingers X'd today or tomorrow :-)
@milessabin A quick update about nested Json (alexarchambault/argonaut-shapeless#9), I ran into what's described here,
that is different implicits being derived by
that is different implicits being derived by
Lazy compared to implicitly. Namely, implicitly find implicits from argonaut.Argonaut, whereas Lazy apparently tries to derive these as ADTs, not viewing those of argonaut.Argonaut, and fails.