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

Simple CPSed parser

Parse the complete input, without resupplying

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

Parse an input chunk

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

Note, once the monadic action return empty bytes, parsers will stop drawing more bytes (take it as endOfInput).

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

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

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

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

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.

Match a specific byte.

Match any 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.

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

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

Same as bytes but ignoring case.

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

Parse and decode an unsigned decimal number.

Parse a decimal number with an optional leading '+' or '-' sign character.

Parse and decode an unsigned hex number. The hex digits 'a' through 'f' may be upper or lower case.

This parser does not accept a leading "0x" string, and consider sign bit part of the binary hex nibbles, i.e. 'parse hex "0xFF" == Right (-1 :: Int8)'

Parse a rational number.

The syntax accepted by this parser is the same as for double.

Note: this parser is not safe for use with inputs from untrusted sources. An input with a suitably large exponent such as "1e1000000000" will cause a huge Integer to be allocated, resulting in what is effectively a denial-of-service attack.

In most cases, it is better to use double or scientific instead.

Parse a rational number and round to Float.

Single precision version of double.

Parse a rational number and round to Double.

This parser accepts an optional leading sign character, followed by at least one decimal digit. The syntax similar to that accepted by the read function, with the exception that a trailing '.' or 'e' not followed by a number is not consumed.

Examples with behaviour identical to read:

parseOnly double "3"     == Right ("",1,3.0)
parseOnly double "3.1"   == Right ("",3,3.1)
parseOnly double "3e4"   == Right ("",3,30000.0)
parseOnly double "3.1e4" == Right ("",5,31000.0)

parseOnly double ".3"    == Left (".3",0,"takeWhile1")
parseOnly double "e3"    == Left ("e3",0,"takeWhile1")

Examples of differences from read:

parseOnly double "3.foo" == Right (".foo",1,3.0)
parseOnly double "3e"    == Right ("e",1,3.0)

This function does not accept string representations of "NaN" or "Infinity".

Parse a scientific number.

The syntax accepted by this parser is the same as for double.

Parse a scientific number and convert to result using a user supply function.

The syntax accepted by this parser is the same as for double.