A non-resumable parser.

The result of running a parser.

Slicing metadata (an offset and a length) accompanied by a value. This does not represent a slice into the value. This type is intended to be used as the result of an executed parser. In this context the slicing metadata describe a slice into to the array (or byte array) that from which the value was parsed.

It is often useful to check the length when a parser succeeds since a non-zero length indicates that there was additional unconsumed input. The offset is only ever needed to construct a new slice (via Bytes or SmallVector) from the remaining input.

Variant of parseBytes that accepts an unsliced ByteArray.

Parse a byte sequence. This can succeed even if the entire slice was not consumed by the parser.

Variant of parseBytes that allows the parser to be run as part of an existing effectful context.

Variant of parseBytes that discards the new offset and the remaining length. This does not, however, require the remaining length to be zero. Use endOfInput to accomplish that.

Variant of parseBytesEither that discards the error message on failure. Just like parseBytesEither, this does not impose any checks on the length of the remaining input.

Consumes and returns the next byte in the input. Fails if no characters are left.

Take the given number of bytes. Fails if there is not enough remaining input.

Take while the predicate is matched. This is always inlined. This always succeeds.

Take bytes until the specified byte is encountered. Consumes the matched byte as well. Fails if the byte is not present. Visually, the cursor advancement and resulting Bytes for takeTrailedBy 0x19 look like this:

 0x10 0x13 0x08 0x15 0x19 0x23 0x17 | input
|---->---->---->---->----|          | cursor
{----*----*----*----}               | result bytes

Skip while the predicate is matched. This is always inlined.

Skip all characters until the character from the is encountered and then consume the matching byte as well.

Skip all bytes until either of the bytes in encountered. Then, consume the matched byte. True indicates that the first argument byte was encountered. False indicates that the second argument byte was encountered.

Consume input matching the byte sequence.

The parser satisfy p succeeds for any byte for which the predicate p returns True. Returns the byte that is actually parsed.

The parser satisfyWith f p transforms a byte, and succeeds if the predicate p returns True on the transformed value. The parser returns the transformed byte that was parsed.

Consume input matching the NUL-terminated C String.

Fails if there is still more input remaining.

Returns true if there are no more bytes in the input. Returns false otherwise. Always succeeds.

Consume all remaining bytes in the input.

Return all remaining bytes in the input without consuming them.

A stateful scanner. The predicate consumes and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each byte of the input until one returns Nothing or the input ends.

This parser does not fail. It will return the initial state if the predicate returns Nothing on the first byte of input.

Note: Because this parser does not fail, do not use it with combinators such a many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

Match any byte, to perform lookahead. Returns Nothing if end of input has been reached. Does not consume any input.

Note: Because this parser does not fail, do not use it with combinators such as many, because such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

Match any byte, to perform lookahead. Does not consume any input, but will fail if end of input has been reached.

Fail with the provided error message.

There is a law-abiding instance of Alternative for Parser. However, it is not terribly useful since error messages seldom have a Monoid instance. This function is a variant of <|> that is right-biased in its treatment of error messages. Consequently, orElse lacks an identity. See attoparsec issue #122 for more discussion of this topic.

Annotate a parser. If the parser fails, the error will be returned.

Infix version of annotate.

Replicate a parser n times, writing the results into an array of length n. For Array and SmallArray, this is lazy in the elements, so be sure the they result of the parser is evaluated appropriately to avoid unwanted thunks.

Run a parser in a delimited context, failing if the requested number of bytes are not available or if the delimited parser does not consume all input. This combinator can be understood as a composition of take, effect, parseBytesEffectfully, and endOfInput. It is provided as a single combinator because for convenience and because it is easy to make mistakes when manually assembling the aforementioned parsers. The pattern of prefixing an encoding with its length is common. This is discussed more in attoparsec issue #129.

delimit e1 e2 n remaining === take e1 n

Augment a parser with the number of bytes that were consume while it executed.

Run a parser and discard the result, returning instead the number of bytes that the parser consumed.

Variant of measure_ with an unboxed result.

Lift an effectful computation into a parser.

Convert a Word# parser to a Word32 parser. Precondition: the argument parser only returns words less than 4294967296.

Convert a (, Int) parser to a (Int,Int) parser.

Convert a Word32 parser to a Word# parser.

Convert a (Int,Int) parser to a (, Int) parser.