Simple parsing result, that represent respectively:

• Success: the remaining unparsed data and the parsed value
• Failure: the remaining unparsed data and the error message
• Partial: that need for more input data, supply empty bytes to indicate endOfInput

Type alias for error message

A parse step consumes Bytes and produce Result.

Simple CPSed parser

A parser takes a failure continuation, and a success one, while the success continuation is usually composed by Monad instance, the failure one is more like a reader part, which can be modified via <?>. If you build parsers from ground, a pattern like this can be used:

   xxParser = do
     ensureN errMsg ...            -- make sure we have some bytes
     Parser $  kf k s inp ->      -- fail continuation, success continuation, state token and input
       ...
       ... kf errMsg (if input not OK)
       ... k s ... (if we get something useful for next parser)
 

Parse the complete input, without resupplying, return the rest bytes

Parse the complete input, without resupplying

Parse an input chunk

Type alias for a streaming parser, draw chunk from Monad m with a initial chunk, return result in Either err x.

Run a chunk parser with an initial input string, and a monadic action that can supply more input if needed.

Finish parsing and fetch result, feed empty bytes if it's Partial result.

Run a parser and keep track of all the input chunks it consumes. Once it's finished, return the final result (always Success or Failure) and all consumed chunks.

Return both the result of a parse and the portion of the input that was consumed while it was being parsed.

Ensure that there are at least n bytes available. If not, the computation will escape with Partial.

Since this parser is used in many other parsers, an extra error param is provide to attach custom error info.

Test whether all input has been consumed, i.e. there are no remaining undecoded bytes. Fail if not atEnd.

Get current input chunk, draw new chunk if neccessary. null means EOF.

Note this is different from takeRemaining, currentChunk only return what's left in current input chunk.

Test whether all input has been consumed, i.e. there are no remaining undecoded bytes.

Decode a primitive type in host byte order.

big endianess wrapper

little endianess wrapper

Decode a primitive type in little endian.

Decode a primitive type in big endian.

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 an empty string if the predicate returns Nothing on the first byte of input.

Similar to scan, but working on Bytes chunks, The predicate consumes a Bytes chunk and transforms a state argument, and each transformed state is passed to successive invocations of the predicate on each chunk of the input until one chunk got splited to Right (V.Bytes, V.Bytes) or the input ends.

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

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

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

digit = satisfy isDigit
    where isDigit w = w >= 48 && w <= 57

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.

Return a byte, this is an alias to decodePrim Word8@.

Match a specific byte.

Match a specific 8bit char.

Take a byte and return as a 8bit char.

Decode next few bytes as an UTF8 char.

Don't use this method as UTF8 decoder, it's slower than validate.

Match a specific UTF8 char.

Match a specific 7bit char.

Take a byte and return as a 7bit char, fail if exceeds 0x7F.

Skip a byte.

Match either a single newline byte '\n', or a carriage return followed by a newline byte "\r\n".

skip N bytes.

Skip past input for as long as the predicate returns True.

Skip over white space using isSpace.

Similar to take, but requires the predicate to succeed on next N bytes of input, and take N bytes(no matter if N+1 byte satisfy predicate or not).

Consume input as long as the predicate returns False or reach the end of input, and return the consumed input.

Consume input as long as the predicate returns True or reach the end of input, and return the consumed input.

Similar to takeWhile, but requires the predicate to succeed on at least one byte of input: it will fail if the predicate never returns True or reach the end of input

Take all the remaining input chunks and return as Bytes.

bytes s parses a sequence of bytes that identically match s.

Same as bytes but ignoring ASCII case.

text s parses a sequence of UTF8 bytes that identically match s.

Text version of fail.

Similar to fail`, but can produce error message with current input chunk.

Unsafely lifted an IO action into Parser.

This is only for debugging purpose(logging, etc). Don't mix compuation from realworld to parsing result, otherwise parsing is not deterministic.

Decode Word in host endian order.

Decode Word64 in host endian order.

Decode Word32 in host endian order.

Decode Word16 in host endian order.

Decode Word8 in host endian order.

Decode Int in host endian order.

Decode Int64 in host endian order.

Decode Int32 in host endian order.

Decode Int16 in host endian order.

Decode Int8 in host endian order.

Decode Double in host endian order.

Decode Float in host endian order.

Decode Word in little endian order.

Decode Word64 in little endian order.

Decode Word32 in little endian order.

Decode Word16 in little endian order.

Decode Int in little endian order.

Decode Int64 in little endian order.

Decode Int32 in little endian order.

Decode Int16 in little endian order.

Decode Double in little endian order.

Decode Float in little endian order.

Decode Word in big endian order.

Decode Word64 in big endian order.

Decode Word32 in big endian order.

Decode Word16 in big endian order.

Decode Int in big endian order.

Decode Int64 in big endian order.

Decode Int32 in big endian order.

Decode Int16 in big endian order.

Decode Double in big endian order.

Decode Float in big endian order.