Text.ParserCombinators.Parsec.Number

adjusted and portable number parsers stolen from Text.ParserCombinators.Parsec.Token

The basic top-level number parsers are decimal, nat, int, fractional, decimalFract, natFract, floating, decimalFloat, natFloat.

natFloat parses numeric literals as defined for Haskell. All numbers are unsigned, i.e. non-negative. Leading zeros are allowed. At least a single digit is required. A decimal point must be preceded and followed by at least one digit.

A result type (Either Integer Double) can be converted to a final Double using (either fromIntegral id).

The parser nat, natFract and natFloat parse hexadecimal and octal integrals (beginning with 0x, 0X, 0o or 0O) that are disallowed when using decimal, decimalFract and decimalFloat.

The parsers decimalFract and natFract only allow a decimal point, whereas decimalFloat and natFloat also allow the exponent notation using e or E.

The parser fractional requires a decimal point between at least two digits and floating requires either a decimal point or the exponent notation using e or E. (Both parsers do not return integral values and do not support hexadecimal or octal values).

Signed numbers can be parsed using "ap sign" as is done for the int parser.

Note that all top-level parsers succeed on a string like "1.0e-100", but only the floating point parsers consume the whole string. The fractional parsers stop before the exponent and the integral parsers before the decimal point. You may which to check for the end of a string using eof, i.e. liftM2 const nat eof.

floats

floating :: Floating f => CharParser st f

parse a decimal unsigned floating point number containing a dot, e or E

decimalFloat :: (Integral i, Floating f) => CharParser st (Either i f)

same as floating but returns a non-negative integral wrapped by Left if a fractional part and exponent is missing

natFloat :: (Integral i, Floating f) => CharParser st (Either i f)

parse hexadecimal, octal or decimal integrals or floating

float parts

zeroNumFloat :: (Integral i, Floating f) => CharParser st (Either i f)

parse any hexadecimal, octal, decimal or floating point number following a zero

fractFloat :: (Integral i, Floating f) => i -> CharParser st (Either i f)

same as fractExponent, returns a f wrapped by Right

fractExponent :: (Integral i, Floating f) => i -> CharParser st f

parse a floating point number given the number before a dot, e or E

exponentFactor :: Floating f => CharParser st (f -> f)

parse a floating point exponent starting with e or E

exponentValue :: Floating f => Integer -> f

compute the factor given by the number following e or E. This implementation uses ** rather than ^ for more efficiency for large integers.

fractional numbers (with just a decimal point between digits)

fractional :: Fractional f => CharParser st f

parse a fractional number containing a decimal dot

decimalFract :: (Integral i, Fractional f) => CharParser st (Either i f)

same as fractional but returns a non-negative integral wrapped by Left if a fractional part is missing

natFract :: (Integral i, Fractional f) => CharParser st (Either i f)

parse hexadecimal, octal or decimal integrals or fractional

zeroNumFract :: (Integral i, Fractional f) => CharParser st (Either i f)

parse any hexadecimal, octal, decimal or fractional number following a zero

fractional parts

fractFract :: (Integral i, Fractional f) => i -> CharParser st f

parse a fractional number given the number before the dot

fraction :: Fractional f => CharParser st f

parse a dot followed by digits as fractional part

fractionValue :: Fractional f => String -> f

compute the fraction given by a sequence of digits following the dot

integers and naturals

int :: Integral i => CharParser st i

parse an optional sign immediately followed by a nat. Note, that in Daan Leijen's code the sign was wrapped as lexeme in order to skip comments and spaces in between.

sign :: Num a => CharParser st (a -> a)

parse an optional plus or minus sign, returning negate or id

decimal :: Integral i => CharParser st i

parse plain non-negative decimal numbers given by a non-empty sequence of digits

nat :: Integral i => CharParser st i

parse non-negative hexadecimal, octal or decimal numbers

natural parts

zeroNumber :: Integral i => CharParser st i

parse a nat syntactically starting with a zero

hexadecimal :: Integral i => CharParser st i

parse a hexadecimal number preceded by an x or X character

octal :: Integral i => CharParser st i

parse an octal number preceded by an o or O character

number :: Integral i => Int -> GenParser tok st Char -> GenParser tok st i

parse a non-negative number given a base and a parser for the digits

numberValue :: Integral i => Int -> String -> i

compute the value from a string of digits using a base