Use alternative parser based on type annotation

[theophile-scrive]

Hi @brandonchinn178 it's me again. :)

I am trying to distinguish user input based on type annotation, for what would be either a text literal or a reference. I plan on using type annotations to label strings, and parse those as separate data types.
However using (naïvely I must confess) the (<|>) operator does not seem to give the expected results.

Here is a an excerpt from the reproducer, that you can run with cabal run Repro.hs:

myNodeDecoder :: DecodeArrow NodeList () (Either Var Text)
myNodeDecoder =
  KDL.nodeWith "node" $
    (Right <$> KDL.argWith' ["text"] KDL.text)
      <|> (Left <$> KDL.argWith' ["var"] (Var <$> KDL.text))

Should I drop to a lower parsing level to make the distinction?

Repro.hs

[brandonchinn178]

Ah I see. So conceptually, a DecodeArrow is a parser like Megaparsec, where you "consume" arguments/props/nodes as you decode a tree. This lets us throw an error if there's any extra stuff that you haven't handled (e.g. maybe the user made a typo?), by simply checking if anything is not consumed.

So in argWith', it successfully consumed an argument, making the subsequent type ann check a fatal error. We take Megaparsec's parsing semantics here because it gives better error messages than always backtracking all the way back. If we were to continue going down that path, we would want the equivalent of try here.

I was never 100% on board with this fatal-if-consumed behavior, though. I think what I actually want (i.e. what I think is more intuitive) is get rid of the fatal/non-fatal distinction and always backtrack, but keep track of the error that "got the furthest" and throw that. I'm not sure when I'll be able to get to that, but I think that's where we should go. If you have any spare time, I'd appreciate a PR.

To unblock you now, though, I would recommend doing

KDL.argWith' ["text", "var"] $
  KDL.withDecoder KDL.any $ \val -> do
    s <- case val.data_ of
      KDL.String s -> pure s
      _ -> KDL.failM "Expected string"
    case (.identifier.value) <$> val.ann of
      Just "var" -> pure . Left $ Var s
      -- Nothing or Just "text"
      _ -> pure . Right $ s

FYI You should replace DecodeArrow NodeList () (Either Var Text) with NodeListDecoder (Either Var Text), to avoid the KDL.Decoder.Internal.Decoder import.

[theophile-scrive]

@brandonchinn178 Thanks a lot! Unfortunately parsing libraries are beyond my skill set at the moment, although I'd love to pair with you on this. It's never too late to learn.

[brandonchinn178]

Let's leave this open so I can fix this when I get time!