Documentation

Generates a Handler to parse input from the given list of items.

Tries each action from the given list in turn, stopping with the first one which successfully parses the input. A parse failure in the action or the continuation results in backtracking to the original location in the input, and reverts the state of any more deeply nested effects.

Returns and consumes the next item from the input. Fails if there is no more input to be consumed.

Returns and consumes the next item from the input, provided it satisfies a predicate. Fails if there is no more input, or if the predicate function evaluates to False.

Zero-width positive lookahead assertion. Runs the given action against the current input without consuming it. A parse failure in the action causes the lookahead to fail; otherwise, the result of the action is returned.

Zero-width negative lookahead assertion. Runs the given action against the current input without consuming it. A parse failure in the action causes the lookahead to succeed; otherwise, the lookahead fails.

Prevents backtracking into the middle of the given action. This can be used to create actions which always consume as much or as little of the input as possible, even if that would cause a later match to fail. Note that backtracking is still possible within the action, or across the entire noBacktrack action.

Examples:

  noBacktrack p $ oneOf [return (), item p >> return ()]  -- never consumes any input
  noBacktrack p $ parseMany p $ itemIf p (=='a')          -- always consumes all the 'a's

A parser which always fails.

A parser which succeeds only when there is no more input.

Try the given parser; returns Just the result on success, or Nothing otherwise.

Apply the given parser zero or more times, and return a list of the results.

Like parseMany, but fails if there isn't at least one match.

A non-greedy version of parseOpt which prefers to match Nothing.

A non-greedy version of parseMany which matches as few times as possible.

A non-greedy version of parseMany1 which matches as few times as possible (but at least once).