Core parser type.

Parses an index set.

  - "{1, 2, 3}"
  - "{1 .. 3}"
  - "{1, 4..6}"

Parses a single index i.e. a positive integer.

Represents a "fatal" parse error i.e. we should not try any other parsers. This exists for better error messages.

Suppose we try parsers p1 and p2 on some text. If p1 fails, normally we will try p2, and if that fails, use its error message. However, it may be the case that p1 has the "real" failure, and its error message would be better.

For example, when parsing nodes, we attempt to parse, in order:

• Sets: "{2,3}"
• Arrow ranges: "2..3"
• Positive integers: "3"

Suppose we parse '{3..2}'. This is a set, but the set parser will fail due to a bad range error. Normally, we will then try arrow ranges and positive integers, which will both fail, and the positive integer error will be reported. This is misleading though, as the real problem was deep in the set parser i.e. the range.

Hence we report this as a "fatal error", and have special logic that only tries other parsers when no fatal errors have been encountered.

Like asum, except the combinator is runFatalError. The first parser is the default when all fail, intended for a better error message.

Like runFatalErrors but with no default error. For when we want the underlying error to be used.

Fails with the given error message if the given parser is next. Does not consume the parser, for better carets in the error message.

Clears a parser label.

Optional + try i.e. returns Just iff the parser succeeds, otherwise backtracks.

Runs the parser if iff a comma is not encountered. If a comma is encountered, it is not consumed, and the default value is returned.

Consumes char and trailing whitespace.

Consumes string and trailing whitespace.

Modifies a parser to consume trailing whitespace.

Parses a comma.

Parses two dots.

Returns true iff eof is not succesfully parsed.