Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
Synopsis
- type NumericPadOption = Maybe Char
- class FormatTime t where
- formatTime :: FormatTime t => TimeLocale -> String -> t -> String
- parseTimeM :: (Monad m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
- parseTimeOrError :: ParseTime t => Bool -> TimeLocale -> String -> String -> t
- readSTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadS t
- readPTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadP t
- parseTime :: ParseTime t => TimeLocale -> String -> String -> Maybe t
- readTime :: ParseTime t => TimeLocale -> String -> String -> t
- readsTime :: ParseTime t => TimeLocale -> String -> ReadS t
- class ParseTime t where
- data TimeLocale = TimeLocale {}
- defaultTimeLocale :: TimeLocale
- iso8601DateFormat :: Maybe String -> String
- rfc822DateFormat :: String
UNIX-style formatting
type NumericPadOption = Maybe Char Source #
class FormatTime t where Source #
formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> t -> String) Source #
Instances
formatTime :: FormatTime t => TimeLocale -> String -> t -> String Source #
Substitute various time-related information for each %-code in the string, as per formatCharacter
.
The general form is %<modifier><width><specifier>
, where <modifier>
and <width>
are optional.
<modifier>
glibc-style modifiers can be used before the specifier (here marked as z
):
%-z
- no padding
%_z
- pad with spaces
%0z
- pad with zeros
%^z
- convert to upper case
%#z
- convert to lower case (consistently, unlike glibc)
<width>
Width digits can also be used after any modifiers and before the specifier (here marked as z
), for example:
%4z
- pad to 4 characters (with default padding character)
%_12z
- pad with spaces to 12 characters
<specifier>
For all types (note these three are done by formatTime
, not by formatCharacter
):
%%
%
%t
- tab
%n
- newline
TimeZone
For TimeZone
(and ZonedTime
and UTCTime
):
%z
- timezone offset in the format
-HHMM
. %Z
- timezone name
LocalTime
For LocalTime
(and ZonedTime
and UTCTime
and UniversalTime
):
%c
- as
dateTimeFmt
locale
(e.g.%a %b %e %H:%M:%S %Z %Y
)
TimeOfDay
For TimeOfDay
(and LocalTime
and ZonedTime
and UTCTime
and UniversalTime
):
%R
- same as
%H:%M
%T
- same as
%H:%M:%S
%X
- as
timeFmt
locale
(e.g.%H:%M:%S
) %r
- as
time12Fmt
locale
(e.g.%I:%M:%S %p
) %P
- day-half of day from (
amPm
locale
), converted to lowercase,am
,pm
%p
- day-half of day from (
amPm
locale
),AM
,PM
%H
- hour of day (24-hour), 0-padded to two chars,
00
-23
%k
- hour of day (24-hour), space-padded to two chars,
0
-23
%I
- hour of day-half (12-hour), 0-padded to two chars,
01
-12
%l
- hour of day-half (12-hour), space-padded to two chars,
1
-12
%M
- minute of hour, 0-padded to two chars,
00
-59
%S
- second of minute (without decimal part), 0-padded to two chars,
00
-60
%q
- picosecond of second, 0-padded to twelve chars,
000000000000
-999999999999
. %Q
- decimal point and fraction of second, up to 12 second decimals, without trailing zeros.
For a whole number of seconds,
%Q
omits the decimal point unless padding is specified.
UTCTime
and ZonedTime
%s
- number of whole seconds since the Unix epoch. For times before
the Unix epoch, this is a negative number. Note that in
%s.%q
and%s%Q
the decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as-1.1
with%s%Q
.
Day
For Day
(and LocalTime
and ZonedTime
and UTCTime
and UniversalTime
):
%D
- same as
%m/%d/%y
%F
- same as
%Y-%m-%d
%x
- as
dateFmt
locale
(e.g.%m/%d/%y
) %Y
- year, no padding. Note
%0Y
and%_Y
pad to four chars %y
- year of century, 0-padded to two chars,
00
-99
%C
- century, no padding. Note
%0C
and%_C
pad to two chars %B
- month name, long form (
fst
frommonths
locale
),January
-December
%b
,%h
- month name, short form (
snd
frommonths
locale
),Jan
-Dec
%m
- month of year, 0-padded to two chars,
01
-12
%d
- day of month, 0-padded to two chars,
01
-31
%e
- day of month, space-padded to two chars,
1
-31
%j
- day of year, 0-padded to three chars,
001
-366
%f
- century for Week Date format, no padding. Note
%0f
and%_f
pad to two chars %V
- week of year for Week Date format, 0-padded to two chars,
01
-53
%u
- day of week for Week Date format,
1
-7
%a
- day of week, short form (
snd
fromwDays
locale
),Sun
-Sat
%A
- day of week, long form (
fst
fromwDays
locale
),Sunday
-Saturday
%U
- week of year where weeks start on Sunday (as
sundayStartWeek
), 0-padded to two chars,00
-53
%w
- day of week number,
0
(= Sunday) -6
(= Saturday) %W
- week of year where weeks start on Monday (as
mondayStartWeek
), 0-padded to two chars,00
-53
UNIX-style parsing
:: (Monad m, ParseTime t) | |
=> Bool | Accept leading and trailing whitespace? |
-> TimeLocale | Time locale. |
-> String | Format string. |
-> String | Input string. |
-> m t | Return the time value, or fail if the input could not be parsed using the given format. |
Parses a time value given a format string.
Supports the same %-codes as formatTime
, including %-
, %_
and %0
modifiers, however padding widths are not supported.
Case is not significant in the input string.
Some variations in the input are accepted:
%z
- accepts any of
-HHMM
or-HH:MM
. %Z
- accepts any string of letters, or any of the formats accepted by
%z
. %0Y
- accepts exactly four digits.
%0G
- accepts exactly four digits.
%0C
- accepts exactly two digits.
%0f
- accepts exactly two digits.
:: ParseTime t | |
=> Bool | Accept leading and trailing whitespace? |
-> TimeLocale | Time locale. |
-> String | Format string. |
-> String | Input string. |
-> t | The time value. |
Parse a time value given a format string. Fails if the input could
not be parsed using the given format. See parseTimeM
for details.
:: ParseTime t | |
=> Bool | Accept leading whitespace? |
-> TimeLocale | Time locale. |
-> String | Format string |
-> ReadS t |
Parse a time value given a format string. See parseTimeM
for details.
:: ParseTime t | |
=> Bool | Accept leading whitespace? |
-> TimeLocale | Time locale. |
-> String | Format string |
-> ReadP t |
Parse a time value given a format string. See parseTimeM
for details.
:: ParseTime t | |
=> TimeLocale | Time locale. |
-> String | Format string. |
-> String | Input string. |
-> Maybe t | The time value, or |
Deprecated: use "parseTimeM True" instead
:: ParseTime t | |
=> TimeLocale | Time locale. |
-> String | Format string. |
-> String | Input string. |
-> t | The time value. |
Deprecated: use "parseTimeOrError True" instead
:: ParseTime t | |
=> TimeLocale | Time locale. |
-> String | Format string |
-> ReadS t |
Deprecated: use "readSTime True" instead
class ParseTime t where Source #
The class of types which can be parsed given a UNIX-style time format string.
:: TimeLocale | The time locale. |
-> [(Char, String)] | Pairs of format characters and the corresponding part of the input. |
-> Maybe t |
Builds a time value from a parsed input string.
If the input does not include all the information needed to
construct a complete value, any missing parts should be taken
from 1970-01-01 00:00:00 +0000 (which was a Thursday).
In the absence of %C
or %Y
, century is 1969 - 2068.
Instances
ParseTime Day Source # | |
Defined in Data.Time.Format.Parse | |
ParseTime UTCTime Source # | |
Defined in Data.Time.Format.Parse | |
ParseTime UniversalTime Source # | |
Defined in Data.Time.Format.Parse buildTime :: TimeLocale -> [(Char, String)] -> Maybe UniversalTime Source # | |
ParseTime TimeZone Source # | |
Defined in Data.Time.Format.Parse | |
ParseTime TimeOfDay Source # | |
Defined in Data.Time.Format.Parse | |
ParseTime LocalTime Source # | |
Defined in Data.Time.Format.Parse | |
ParseTime ZonedTime Source # | |
Defined in Data.Time.Format.Parse |
Locale
data TimeLocale Source #
Instances
Eq TimeLocale Source # | |
Defined in Data.Time.Format.Locale (==) :: TimeLocale -> TimeLocale -> Bool # (/=) :: TimeLocale -> TimeLocale -> Bool # | |
Ord TimeLocale Source # | |
Defined in Data.Time.Format.Locale compare :: TimeLocale -> TimeLocale -> Ordering # (<) :: TimeLocale -> TimeLocale -> Bool # (<=) :: TimeLocale -> TimeLocale -> Bool # (>) :: TimeLocale -> TimeLocale -> Bool # (>=) :: TimeLocale -> TimeLocale -> Bool # max :: TimeLocale -> TimeLocale -> TimeLocale # min :: TimeLocale -> TimeLocale -> TimeLocale # | |
Show TimeLocale Source # | |
Defined in Data.Time.Format.Locale |
defaultTimeLocale :: TimeLocale Source #
Locale representing American usage.
knownTimeZones
contains only the ten time-zones mentioned in RFC 822 sec. 5:
"UT", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT".
Note that the parsing functions will regardless parse single-letter military time-zones and +HHMM format.
iso8601DateFormat :: Maybe String -> String Source #
Construct format string according to ISO-8601.
The Maybe String
argument allows to supply an optional time specification. E.g.:
iso8601DateFormat
Nothing == "%Y-%m-%d" -- i.e.YYYY-MM-DD
iso8601DateFormat
(Just "%H:%M:%S") == "%Y-%m-%dT%H:%M:%S" -- i.e.YYYY-MM-DDTHH:MM:SS
rfc822DateFormat :: String Source #
Format string according to RFC822.