Streamly.Internal.Unicode.Parser · streamly-core-0.2.2

Setup

0 declarations

To execute the code examples provided in this module in ghci, please run the following commands first.

Example3 expressions

>>> :m>>> import qualified Streamly.Data.Stream as Stream>>> import qualified Streamly.Unicode.Parser as Unicode

For APIs that have not been released yet.

Example1 expression

>>> import qualified Streamly.Internal.Unicode.Parser as Unicode (number, mkDouble)

Generic

2 declarations

valuechar :: Monad m => Char -> Parser Char m Char

#

Match a specific character.

valuecharIgnoreCase :: Monad m => Char -> Parser Char m Char

#

Match a specific character ignoring case.

Sequences

4 declarations

valuestring :: Monad m => String -> Parser Char m String

#

Match the input with the supplied string and return it if successful.

valuestringIgnoreCase :: Monad m => String -> Parser Char m String

#

Match the input with the supplied string and return it if successful.

valuedropSpace :: Monad m => Parser Char m ()

#

Drop zero or more white space characters.

valuedropSpace1 :: Monad m => Parser Char m ()

#

Drop one or more white space characters.

Classes

19 declarations

valuealpha :: Monad m => Parser Char m Char

#

Match any character that satisfies isAlpha

valuealphaNum :: Monad m => Parser Char m Char

#

Match any character that satisfies isAlphaNum

valueletter :: Monad m => Parser Char m Char

#

Match any character that satisfies isLetter

valueascii :: Monad m => Parser Char m Char

#

Match any character that satisfies isAscii

valueasciiLower :: Monad m => Parser Char m Char

#

Match any character that satisfies isAsciiLower

valueasciiUpper :: Monad m => Parser Char m Char

#

Match any character that satisfies isAsciiUpper

valuelatin1 :: Monad m => Parser Char m Char

#

Match any character that satisfies isLatin1

valuelower :: Monad m => Parser Char m Char

#

Match any character that satisfies isLower

valueupper :: Monad m => Parser Char m Char

#

Match any character that satisfies isUpper

valuemark :: Monad m => Parser Char m Char

#

Match any character that satisfies isMark

valueprintable :: Monad m => Parser Char m Char

#

Match any character that satisfies isPrint

valuepunctuation :: Monad m => Parser Char m Char

#

Match any character that satisfies isPunctuation

valueseparator :: Monad m => Parser Char m Char

#

Match any character that satisfies isSeparator

valuespace :: Monad m => Parser Char m Char

#

Match any character that satisfies isSpace

valuesymbol :: Monad m => Parser Char m Char

#

Match any character that satisfies isSymbol

valuedigit :: Monad m => Parser Char m Char

#

Match any character that satisfies isDigit

valueoctDigit :: Monad m => Parser Char m Char

#

Match any character that satisfies isOctDigit

valuehexDigit :: Monad m => Parser Char m Char

#

Match any character that satisfies isHexDigit

valuenumeric :: Monad m => Parser Char m Char

#

Match any character that satisfies isNumber

Numeric

6 declarations

valuesigned :: (Num a, Monad m) => Parser Char m a -> Parser Char m a

#

Allow an optional leading '+' or '-' sign character before any parser.

valuenumber :: Monad m => Parser Char m (Integer, Int)

#

A generic parser for scientific notation of numbers. Returns (mantissa, exponent) tuple. The result can be mapped to Double or any other number representation e.g. Scientific.

For example, using the scientific package: >> parserScientific = uncurry Data.Scientific.scientific $ number

valuedoubleParser :: Monad m => Parser Char m (Int, Int)

#

A fast, custom parser for double precision flaoting point numbers. Returns (mantissa, exponent) tuple. This is much faster than number because it assumes the number will fit in a Double type and uses Int representation to store mantissa.

Number larger than Double may overflow. Int overflow is not checked in the exponent.

valuedouble :: Monad m => Parser Char m Double

#

Parse a decimal Double value. This parser accepts an optional sign (+ or -) followed by at least one decimal digit. Decimal digits are optionally followed by a decimal point and at least one decimal digit after the point. This parser accepts the maximal valid input as long as it gives a valid number. Specifcally a trailing decimal point is allowed but not consumed. This function does not accept "NaN" or "Infinity" string representations of double values.

Definition:

Example1 expression

>>> double = uncurry Unicode.mkDouble <$> Unicode.number

Examples:

Example1 expression

>>> p = Stream.parse Unicode.double . Stream.fromList

Example1 expression

>>> p "-1.23e-123"Right (-1.23e-123)

Trailing input examples:

Example1 expression

>>> p "1."Right 1.0

Example1 expression

>>> p "1.2.3"Right 1.2

Example1 expression

>>> p "1e"Right 1.0

Example1 expression

>>> p "1e2.3"Right 100.0

Example1 expression

>>> p "1+2"Right 1.0

Error cases:

Example1 expression

>>> p ""Left (ParseError "number: expecting sign or decimal digit, got end of input")

Example1 expression

>>> p ".1"Left (ParseError "number: expecting sign or decimal digit, got '.'")

Example1 expression

>>> p "+"Left (ParseError "number: expecting decimal digit, got end of input")

valuedecimal :: (Monad m, Integral a) => Parser Char m a

#

Parse and decode an unsigned integral decimal number.

valuehexadecimal :: (Monad m, Integral a, Bits a) => Parser Char m a

#

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

Note: This parser does not accept a leading "0x" string.

Utilities

1 declaration

valuemkDouble :: Integer -> Int -> Double

#

mkDouble mantissa exponent converts a mantissa and exponent to a Double value equivalent to mantissa * 10^exponent. It does not check for overflow, powers more than 308 will overflow.