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
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:
oh, hang on
you're absolutely right, this is what your example shows :)
well. I'm going to crash now, I'm useless in that state. Thanks for the positive feedback and interesting issues! :)