Couple of points about using
asRegex.get:- you could use
.asUnsafeRegex, which is essentially the same thing but makes it clearer you're doing something unsafe - if your regex is a string, is there a particular reason you're not using the
rx"..."syntax, much safer since regular expressions are validated at compile time?
(see https://nrinaudo.github.io/kantan.regex/tut/basics.html#regular-expression-literals for documentation on the latter)
so yeah, if you could open an issue so that I can verify that this is indeed fixed
@rubenpieters ^^
oh wait you typed a lot of other stuff in the meantime
couple of points about the code:
- use the
rx"..."syntax for such cases, it's much better than.r.pattern - you can replace all calls to
implicitly[GroupDecoder[A]]byGroupDecoder[A], both more idiomatic and faster
but thanks, it makes it pretty clear that something's wrong with generic type class instance derivation
and thanks for the tips, I'll see if I can get a good example of my second point I mentioned
but you're right, there might be something dodgy there. It's all tested, of course, but probably not quite as well as I thought
this looks like a design decision of my past self. I need to give this some thought :)
I wouldn't mind an example anyway, even if just here, I've never seen that behaviour
object KantanRegexMatchNullPointer {
val regex = rx"([0-9|-]+)".asUnsafeRegex[CCDT]
implicit val timeDecoder: GroupDecoder[LocalDate] = {
GroupDecoder[String].mapResult(s =>
DecodeResult(LocalDate.parse(s, DateTimeFormatter.ofPattern("yyyy-MM-dd")))
)
}
def main(args: Array[String]): Unit = {
"2016-07-08".evalRegex(regex)
}
}
case class CCDT(dt: LocalDate)
you're right, probably not
kantan.regex related, but still.
right, so, about your first issue. It's actually twofold
implicitly[GroupDecoder[CC4]] was never going to work. You can have a MatchDecoder[CC4], but not a GroupDecoder. Do you need me to explain why?
a
MatchDecoder decodes a match - potentially many strings
([a-z]+) ([0-9|-]+) has two groups: the first one, at least one letter, and the second one, at least one digit
you could represent matches of this regex as, for example,
(String, Int)
I'm not sure if I'm being clear - I'm actually really tired and might not be making much sense
the point is that a group is a single string and a match is a collection of strings, so a
GroupDecoder[A] is essentially a String => A where a MatchDecoder[A] is a Seq[String] => A
I'll try it just gimme a sec
ill play around a bit and try to understand it better
if it's not clear enough, that's good feedback
by documentation, I mean the site, not the scaladoc, which is dodgy at best
right, and the second aspect of your issue: you currently need a
GroupDecoder for both A and B in order to derive a MatchDecoder[(A, B)]. Since CC4 cannot have a GroupDecoder, you cannot get a MatchDecoder[(CC4, B)] for any B
I can't decide whether this makes sense or is a limitation. I'll need to think about it with a fresh brain.
yep that part I get
but conceptually speaking there is not much difference in my eyes between something like ((A, B), (C, D)) and (A, B, C, D).
so that's why I would think that .evalRegex[((A, B), (C, D)) could work just as .evalRegex[(A, B, C, D)] works
but you don't have to answer this immediately
for now I can work around this and I really appreciate your library :+1: