debug function

[flip111]

for attoparsec i was using this debug function

debug :: Parser a -> Parser a
debug p = do
  (consumed, a) <- match p
  remaining <- lookAhead takeText
  traceM ("consumed: " ++ show consumed)
  traceM ("remaining: " ++ show remaining)
  return a

I couldn't find an equivalent function for match and takeText. How can i debug a parser written with megaparsec?

[mrkkrp]

Thank you for opening the issue. Indeed such functions are missing, but we should add them. I'll get to it pretty soon I guess. Support for debugging will be added in version 5.1.0.

[flip111]

Is this moving to 5.2 now? This function would still be very valuable. Is there any other way to debug in the meantime?

[mrkkrp]

I just decided that there are other priorities for 5.1 right now (given my limited free time these days). I do think that function(s) for debugging are a useful addition, but I would like to think more about which exactly functions to add.

[mrkkrp]

The debug function is coming to Megaparsec in version 5.1.0. It will be in form of a primitive combinator to allow to see what's going on on lower level. This should be quite convenient.

[mrkkrp]

BTW, equivalent of takeText as called getInput. There is no proper equivalent to match though.

[mrkkrp]

Now there is the dbg function that should be quite useful in debugging, see here.

[flip111]

Enhancement idea 1:
When you have a parser of type Parser Foo where Foo has an instance of typeable. Is it possible to use show $ typeOf foo to make a string instead of manually providing a string for the first argument of dbg?

Enhancement idea 2:
Would it be possible to make a version of the dbg function that turns the given parser function into a strict evaluation parsing function? This way the debug output would be in line with how you would read the grammar rules. For example in the blog post starting with open is understandable, but then you would expect lit and not close. If you want to read it as a rule like rule = open (lit | del)* close, you will read it in the order from left to right. Lazy evaluation is a property of haskell but it's also useful to be able to read the debug output in the way you would read the grammar rules.
I asked around a little bit and this was suggested (for a possible implementation):

debugM :: Monad m => String -> m ()
you insert it between statements of do notation, it might come in an order you like more, but again, this will cause the monad actions to evaluate in a different order. because you need to implement it with a ! or seq

Should i open up new issues for this?

[mrkkrp]

What if you have two different parsers that parse the same type of data?