| Safe Haskell | None | 
|---|
Data.Time.Format
- type NumericPadOption = Maybe Char
- class  FormatTime t  where- formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> t -> String)
 
- formatTime :: FormatTime t => TimeLocale -> String -> t -> String
- 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- buildTime :: TimeLocale -> [(Char, String)] -> t
 
UNIX-style formatting
type NumericPadOption = Maybe Char
class FormatTime t where
Methods
formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> t -> String)
formatTime :: FormatTime t => TimeLocale -> String -> t -> String
Substitute various time-related information for each %-code in the string, as per formatCharacter.
For all types (note these three are done here, not by formatCharacter):
- %%
-  %
- %t
- tab
- %n
- newline
glibc-style modifiers can be used before the letter (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)
For TimeZone (and ZonedTime and UTCTime):
- %z
-  timezone offset in the format -HHMM.
- %Z
- timezone name
For LocalTime (and ZonedTime and UTCTime):
- %c
-  as dateTimeFmtlocale(e.g.%a %b %e %H:%M:%S %Z %Y)
For TimeOfDay (and LocalTime and ZonedTime and UTCTime):
- %R
-  same as %H:%M
- %T
-  same as %H:%M:%S
- %X
-  as timeFmtlocale(e.g.%H:%M:%S)
- %r
-  as time12Fmtlocale(e.g.%I:%M:%S %p)
- %P
-  day half from (amPmlocale), converted to lowercase,am,pm
- %p
-  day half from (amPmlocale),AM,PM
- %H
-  hour, 24-hour, leading 0 as needed, 00-23
- %I
-  hour, 12-hour, leading 0 as needed, 01-12
- %k
-  hour, 24-hour, leading space as needed, 0-23
- %l
-  hour, 12-hour, leading space as needed, 1-12
- %M
-  minute, 00-59
- %S
-  second, without decimal part, 00-60
- %q
-  picosecond, including trailing zeros, 000000000000-999999999999.
- %Q
-  decimal point and up to 12 second decimals, without trailing zeros.
 For a whole number of seconds, %Qproduces the empty string.
- %s
-  number of whole seconds since the Unix epoch. For times before
 the Unix epoch, this is a negative number. Note that in %s.%qand%s%Qthe decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as-1.1with%s%Q.
For Day (and LocalTime and ZonedTime and UTCTime):
- %D
-  same as %m/%d/%y
- %F
-  same as %Y-%m-%d
- %x
-  as dateFmtlocale(e.g.%m/%d/%y)
- %Y
- year
- %y
-  last two digits of year, 00-99
- %C
-  century (being the first two digits of the year), 00-99
- %B
-  month name, long form (fstfrommonthslocale),January-December
- %b,- %h
-  month name, short form (sndfrommonthslocale),Jan-Dec
- %m
-  month of year, leading 0 as needed, 01-12
- %d
-  day of month, leading 0 as needed, 01-31
- %e
-  day of month, leading space as needed,  1-31
- %j
-  day of year for Ordinal Date format, 001-366
- %G
- year for Week Date format
- %g
-  last two digits of year for Week Date format, 00-99
- %f
-  century (first two digits of year) for Week Date format, 00-99
- %V
-  week for Week Date format, 01-53
- %u
-  day for Week Date format, 1-7
- %a
-  day of week, short form (sndfromwDayslocale),Sun-Sat
- %A
-  day of week, long form (fstfromwDayslocale),Sunday-Saturday
- %U
-  week number of year, where weeks start on Sunday (as sundayStartWeek),00-53
- %w
-  day of week number, 0(= Sunday) -6(= Saturday)
- %W
-  week number of year, where weeks start on Monday (as mondayStartWeek),00-53
UNIX-style parsing
Arguments
| :: ParseTime t | |
| => TimeLocale | Time locale. | 
| -> String | Format string. | 
| -> String | Input string. | 
| -> Maybe t | The time value, or  | 
Parses a time value given a format string.
 Supports the same %-codes as formatTime, including %-, %_ and %0 modifiers.
 Leading and trailing whitespace is accepted. Case is not significant.
 Some variations in the input are accepted:
- %z
-  accepts any of -HHMMor-HH:MM.
- %Z
-  accepts any string of letters, or any of the formats accepted by %z.
Arguments
| :: ParseTime t | |
| => 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 parseTime for details.
Arguments
| :: ParseTime t | |
| => TimeLocale | Time locale. | 
| -> String | Format string | 
| -> ReadS t | 
Parse a time value given a format string.  See parseTime for details.
class ParseTime t where
The class of types which can be parsed given a UNIX-style time format string.
Methods
Arguments
| :: TimeLocale | The time locale. | 
| -> [(Char, String)] | Pairs of format characters and the corresponding part of the input. | 
| -> 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.