Headed parser.

Abstracts over explicit composition between consecutive megaparsec try blocks, providing for better error messages.

With headed parser you don't need to use try at all.

Examples

>>> :{
  let
    select :: HeadedParsec Void Text (Maybe [Either Char Int], Maybe Int)
    select = do
      head (string' "select")
      _targets <- optional (head space1 *> targets)
      _limit <- optional (head space1 *> limit)
      return (_targets, _limit)
      where
        targets = sepBy1 target commaSeparator
        target =
          head (Left <$> char '*') <|>
          head (Right <$> Lexer.decimal)
        commaSeparator = head (space *> char ',' *> space)
        limit =
          head (string' "limit" *> space1) *>
          tail Lexer.decimal
    test :: Text -> IO ()
    test = parseTest (toParsec select <* eof)
:}

>>> test "select 1, "
...
unexpected ','
...

>>> test "select limit "
...
unexpected end of input
expecting integer or white space

>>> test "select 1, 2 limit 2"
(Just [Right 1,Right 2],Just 2)

Convert headed parser into megaparsec parser.

Wrap a parser to be usable as a whole in a head block, allowing it in effect to be composed with the following parsers into a single try when executed, no matter whether it contains endHead or not.

Label a headed parser. Works the same way as megaparsec's label.

Make a parser print debugging information when evaluated. The first parameter is a custom label.

This function is a wrapper around dbg. It generates two debugging entries: one for head and one for tail.

Filter the results of parser based on a predicate, failing with a parameterized message.

Lift a megaparsec parser.

Make all the following parsers compose as tail.