Example of registers usage

[Truedrog]

I need to have a stateful parser in my program. I see that registers are intended for that, but could you please share some examples how then?

[Truedrog]

For example, supposing I had to parse a date string: "2023-03-14". I need to check if separators are the same, or report an parse error.
So I tried something like this

for {
      year <- yearorintp
      sep <- datesepchar
      month <- natural
      sep2 <- datesepchar
      day <- natural
      _ <- fail("Date is malformed because the separators are different.") if (sep!=sep2)
     ...
} yield ...

But that doesn't work. So I think my approach is wrong.

[Truedrog]

  val datep = {
    join(for {
      year <- yearorintp
      sep <- datesepchar
      month <- natural
      sep2 <- datesepchar
      day <- natural
      datestr = year.toString ++ sep.toString ++ month.toString ++ sep.toString ++ day.toString
      date <- pure(Try(LocalDate.of(year, month, day)).toOption)
    } yield {
      if(sep != sep2) fail("This date is malformed because the separators are different.") else {
         date match {
            case Some(d) => pure(d.toString)
            case None => fail("This date is invalid, please correct it: " ++ datestr)
          }
      }
    })
  }

So this is what I ended up with, but I am not sure I like it, right? Because join and flatmap are inefficient, so any tips for improve?

[j-mie6]

This is the sort of thing that collectMsg can be used for:

import parsley.implicits.zipped.Zipped5
import parsley.errors.combinator._
(yearorintp, datesepchar, natural, datesepchar, natural).zipped.collectMsg("This date is malformed because the separators are different.") {
  case (year, sep1, month, sep2, day) if sep1 == sep2 => Try(LocalDate.of(year, month, day)).toOption
}.collectMsg("this data is invalid, please correct it") {
  case Some(d) => d.toString
}

It has the added benefit that the error message will point at the whole of this structure!

[j-mie6]

Also, in general, zipped (with or without a function) or lift is the best way of avoiding the flatMaps in for-comprehensions

[j-mie6]

What you want is basically a charReg combinator, as I understand it:

def charReg(r: Reg[Char]): Parsley[Char] = r.gets(char(_)).flatten

The problem is that this combinator would be implemented by flatten (or join as you'd call it), and as you note this is inefficient. I haven't implemented a built-in version of charReg/satisfyReg yet, which would be efficient, but that is something I do want to add when I get some spare time again!

I would also love to add some examples of registers too, it is absolutely on my TODO list. To be clear about the charReg combinator above, I'm envisioning you'd use it like sepReg.put(datesepchar) and then use charReg(sepReg) for the second invokation.

Instead, I think what I posted above fixes your problem more directly:

import parsley.implicits.zipped.Zipped5
import parsley.errors.combinator._
(yearorintp, datesepchar, natural, datesepchar, natural).zipped.collectMsg("This date is malformed because the separators are different.") {
  case (year, sep1, month, sep2, day) if sep1 == sep2 => Try(LocalDate.of(year, month, day)).toOption
}.collectMsg("this data is invalid, please correct it") {
  case Some(d) => d.toString
}

[j-mie6]

Note that these two collectMsgs can be merged into a single one, if you switch from using a simple String as the first argument and pass a function instead: this is a bit more clumsy however, as you will need something like if (sep1 == sep2) "This date is malformed..." else "this data is invalid..." in the function, which duplicates the sep1 == sep2 logic

[j-mie6]

for completeness: https://javadoc.io/static/com.github.j-mie6/parsley_2.13/4.2.9/parsley/errors/combinator$$ErrorMethods.html#collectMsg[B](msg0:String,msgs:String*)(pf:PartialFunction[A,B]):parsley.Parsley[B] (ignore the bit about being amended/entrenched, that's outdated: oops!)

[Truedrog]

Thank you!