Welcome! Got a question? Do you have -Ypartial-unification turned on? Other FAQs: http://typelevel.org/cats/faq.html
ohhh neat, https://github.com/slamdata/matryoshka
object Fix2 {
type Fix2_1[F1[_, _], F2[_, _]]
type Fix2_2[F1[_, _], F2[_, _]]
final class Subst[F1[_, _], F2[_, _]] {
type Apply[H[_[_, _], _[_, _]]] = H[F1, F2]
type ApplyF[H[_, _]] = H[Apply[Fix2_1], Apply[Fix2_2]]
def _1[H[_]](f: H[Apply[Fix2_1]]): H[ApplyF[F1]] = f.asInstanceOf[H[ApplyF[F1]]]
def _2[H[_]](f: H[Apply[Fix2_2]]): H[ApplyF[F2]] = f.asInstanceOf[H[ApplyF[F2]]]
}
private[this] val _subst = new Subst[Any, Any]
def subst[F1[_, _], F2[_, _]]: Subst[F1, F2] = _subst.asInstanceOf[Subst[F1, F2]]
}
I don't think it will be pleasant in Scala, but who knows
when you have multiple mutually recursive types you need multirec
but, learning recursion schemes is a good investment regardless :smile:
Just want to make sure I understand. The fact that
queries have expressions and expressions have expressions and queries makes this a type with multiple mutually recursive types? And furthermore, matryoshka does not support multiple mutually recursive types, but multirec does?
final case class Query(e: Expr)
final case class Expr(e: Query)
// this will work with matryoshka
// can recurse only over one part at a time
final case class QueryF[Q](e: Expr[Q])
final case class Expr[Q](e: Q)
// this requires something like multirec
final case class QueryF[Q, E](e: E)
final case class ExprF[Q, E](e: Q)
So, given that multirec is a haskell library and I'm in Scala, looks like I can't define recursive schemes for this data type. Am I going to be able to use any other type classes from cats at all?
I'm running regex replacements to transform
underscored_keys into camelCasedKeys and back
like using camelcased keys or underscored keys
see https://circe.github.io/circe/codecs/custom-codecs.html#custom-key-mappings-via-annotations
e.g.
e.g.
implicit val config: Configuration = Configuration.default.withSnakeCaseMemberNames with semiauto decoding/encoding should work
and you could provide your own
Configuration with a custom key renaming strategy. Probably better than manually traversing the jsons
both videos show how to create really minimalistic actors
in your place I'd go for Akka Typed Actors: https://www.slideshare.net/ktoso/networks-and-types-the-future-of-akka-scaladays-nyc-2018
anyway, I think you should tell your boss what you have found. Explain what you have understood and what you haven't. And decide which one to dig deeper
In that it would probably make sense to ask some follow up questions.
val keyCorrectionReg: Regex = """_([a-z])""".r
val keyDeCorrectionReg: Regex = """([A-Z])""".r
implicit val config: Configuration = Configuration.default.withSnakeCaseMemberNames.copy(transformMemberNames = s => {
keyDeCorrectionReg.replaceAllIn(s, m => "_" + m.group(1).toLowerCase)
})
looks like
keyCorrectionReg isn't used in this
it'd be best if you could provide an example of
- the JSON that comes in
- the case class you want to have after decoding
I see Travis said the same thing :P
you should write tests for your usecase anyways, so you can see if that's enough
r.e. recursion schemes -- I'm creating the corresponding NodeF[A] for my Node type, but what's the right way to generalize something like
sealed trait Node
final case class Name(value: String) extends Node
sealed trait Expression extends Node
final case class Block(name: Name, exprs: List[Expression]) extends Nodewhere I want to keep the more narrow type for some values? because I currently have
sealed trait NodeF[A]
final case class NameF(value: String) extends NodeF[A]
sealed trait ExpressionF[A] extends NodeF[A]
final case class BlockF[A](name: A, exprs: List[A]) extends NodeF[A]