Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Synopsis
- char :: Parser Char
- text :: Parser Text
- utf8Bytes :: Parser ByteString
- bool :: Parser Bool
- signedIntegral :: Integral a => Parser a
- unsignedIntegral :: Integral a => Parser a
- double :: Parser Double
- scientific :: Parser Scientific
- string :: Parser String
- uuid :: Parser UUID
- show :: Parser Text
- timeOfDayInISO8601 :: Parser TimeOfDay
- dayInISO8601 :: Parser Day
- timeZoneInISO8601 :: Parser TimeZone
- utcTimeInISO8601 :: Parser UTCTime
- diffTime :: Parser DiffTime
- nominalDiffTime :: Parser NominalDiffTime
- class LenientParser a where
- lenientParser :: Parser a
Explicit
utf8Bytes :: Parser ByteString Source #
Consumes all the remaining input, encoding it using UTF8.
Accepts any string interpretable as a boolean: "1" or "0", "true" or "false", "yes" or "no", "y" or "n", "t" or "f". Case-insensitive.
signedIntegral :: Integral a => Parser a Source #
Signed decimal.
unsignedIntegral :: Integral a => Parser a Source #
Unsigned decimal.
Parse a Double
.
This parser accepts an optional leading sign character, followed by
at most one decimal digit. The syntax is similar to that accepted by
the read
function, with the exception that a trailing '.'
is
consumed.
Examples
These examples use this helper:
r ::Parser
a ->Text
->Result
a r p s =feed
(parse
p s)mempty
Examples with behaviour identical to read
, if you feed an empty
continuation to the first result:
r double "3" == Done "" 3.0 r double "3.1" == Done "" 3.1 r double "3e4" == Done "" 30000.0 r double "3.1e4" == Done "" 31000.0 r double "3e" == Done "e" 3.0
Examples with behaviour identical to read
:
r double ".3" == Fail ".3" _ _ r double "e3" == Fail "e3" _ _
Example of difference from read
:
r double "3.foo" == Done "foo" 3.0
This function does not accept string representations of "NaN" or "Infinity".
scientific :: Parser Scientific #
Parse a scientific number.
The syntax accepted by this parser is the same as for double
.
Time
timeOfDayInISO8601 :: Parser TimeOfDay #
>>>
parseOnly timeOfDayInISO8601 "05:03:58"
Right 05:03:58
>>>
parseOnly timeOfDayInISO8601 "05:03:58.02"
Right 05:03:58.02
>>>
parseOnly timeOfDayInISO8601 "05:03:58.020"
Right 05:03:58.02
Checks the elements to be within a proper range:
>>>
parseOnly timeOfDayInISO8601 "24:00:00"
Left "timeOfDayInISO8601 > hour: Failed reading: Validator \"hour\" failed on the following input: 24"
>>>
parseOnly timeOfDayInISO8601 "00:00:60"
Left "timeOfDayInISO8601 > second: Failed reading: Validator \"second\" failed on the following input: 60.000000000000"
Checks the elements to be of proper length:
>>>
parseOnly timeOfDayInISO8601 "1:00:00"
Left "timeOfDayInISO8601 > hour: Failed reading: Invalid decimal length"
>>>
parseOnly timeOfDayInISO8601 "01:1:00"
Left "timeOfDayInISO8601 > minute: Failed reading: Invalid decimal length"
dayInISO8601 :: Parser Day #
>>>
parseOnly dayInISO8601 "2017-02-01"
Right 2017-02-01
Checks the elements to be in proper range:
>>>
parseOnly dayInISO8601 "2017-13-01"
Left "dayInISO8601: Failed reading: Invalid combination of year month and day: (2017,13,1)"
That is accounting for leap year:
>>>
parseOnly dayInISO8601 "2017-02-29"
Left "dayInISO8601: Failed reading: Invalid combination of year month and day: (2017,2,29)"
>>>
parseOnly dayInISO8601 "2016-02-29"
Right 2016-02-29
timeZoneInISO8601 :: Parser TimeZone #
>>>
parseOnly timeZoneInISO8601 "+01:00"
Right +0100
>>>
parseOnly timeZoneInISO8601 "+0100"
Right +0100
>>>
parseOnly timeZoneInISO8601 "-0100"
Right -0100
>>>
parseOnly timeZoneInISO8601 "Z"
Right UTC
utcTimeInISO8601 :: Parser UTCTime #
>>>
parseOnly utcTimeInISO8601 "2017-02-01T05:03:58+01:00"
Right 2017-02-01 04:03:58 UTC
No suffix implies the "seconds" unit:
>>>
parseOnly diffTime "10"
Right 10s
Various units (seconds, minutes, hours, days):
>>>
parseOnly diffTime "10s"
Right 10s
>>>
parseOnly diffTime "10m"
Right 600s
>>>
parseOnly diffTime "10h"
Right 36000s
>>>
parseOnly diffTime "10d"
Right 864000s
Metric prefixes to seconds (down to Pico):
>>>
parseOnly diffTime "10ms"
Right 0.01s
>>>
parseOnly diffTime "10μs"
Right 0.00001s
>>>
parseOnly diffTime "10us"
Right 0.00001s
>>>
parseOnly diffTime "10ns"
Right 0.00000001s
>>>
parseOnly diffTime "10ps"
Right 0.00000000001s
Negative values:
>>>
parseOnly diffTime "-1s"
Right -1s
Unsupported units:
>>>
parseOnly diffTime "1k"
Left "diffTime: Failed reading: Unsupported unit: \"k\""
nominalDiffTime :: Parser NominalDiffTime #
No suffix implies the "seconds" unit:
>>>
parseOnly nominalDiffTime "10"
Right 10s
Various units (seconds, minutes, hours, days):
>>>
parseOnly nominalDiffTime "10s"
Right 10s
>>>
parseOnly nominalDiffTime "10m"
Right 600s
>>>
parseOnly nominalDiffTime "10h"
Right 36000s
>>>
parseOnly nominalDiffTime "10d"
Right 864000s
Metric prefixes to seconds (down to Pico):
>>>
parseOnly nominalDiffTime "10ms"
Right 0.01s
>>>
parseOnly nominalDiffTime "10μs"
Right 0.00001s
>>>
parseOnly nominalDiffTime "10us"
Right 0.00001s
>>>
parseOnly nominalDiffTime "10ns"
Right 0.00000001s
>>>
parseOnly nominalDiffTime "10ps"
Right 0.00000000001s
Negative values:
>>>
parseOnly nominalDiffTime "-1s"
Right -1s
Unsupported units:
>>>
parseOnly nominalDiffTime "1k"
Left "nominalDiffTime: Failed reading: Unsupported unit: \"k\""
Implicit
class LenientParser a where Source #
Provides the default lenient parser for a type.
By convention, the parser should not check for the end of input.
lenientParser :: Parser a Source #