Safe Haskell	Trustworthy
Language	Haskell2010

Data.Time.Format.Compat

Contents

UNIX-style formatting
UNIX-style parsing
- Note in compat mode acceptWS argument is ignored, it's always True.
Locale

Synopsis

class FormatTime t
formatTime :: FormatTime t => TimeLocale -> String -> t -> String
parseTimeM :: (MonadFail 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
data TimeLocale = TimeLocale {
- wDays :: [(String, String)]
- months :: [(String, String)]
- amPm :: (String, String)
- dateTimeFmt :: String
- dateFmt :: String
- timeFmt :: String
- time12Fmt :: String
- knownTimeZones :: [TimeZone]
}
defaultTimeLocale :: TimeLocale
iso8601DateFormat :: Maybe String -> String
rfc822DateFormat :: String

UNIX-style formatting

class FormatTime t #

Minimal complete definition

formatCharacter

Instances

FormatTime ZonedTime
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> ZonedTime -> String) #
FormatTime LocalTime
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> LocalTime -> String) #
FormatTime TimeOfDay
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> TimeOfDay -> String) #
FormatTime TimeZone
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> TimeZone -> String) #
FormatTime UniversalTime
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> UniversalTime -> String) #
FormatTime UTCTime
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> UTCTime -> String) #
FormatTime Day
Instance details Defined in Data.Time.Format Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> Day -> String) #
FormatTime DayOfWeek Source #
Instance details Defined in Data.Time.Calendar.Compat Methods formatCharacter :: Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> DayOfWeek -> String) #

formatTime :: FormatTime t => TimeLocale -> String -> t -> String #

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`

For 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 from months locale), January - December
%b, %h: month name, short form (snd from months 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 from wDays locale), Sun - Sat
%A: day of week, long form (fst from wDays 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

Note in compat mode acceptWS argument is ignored, it's always `True`.

parseTimeM Source #

Arguments

:: (MonadFail 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 in

Parses a time value given a format string.

This variant from time-compat has always MonadFail constraint.

Look at parseTimeM for documentation.

parseTimeOrError #

Arguments

:: 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.

readSTime #

Arguments

:: 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.

readPTime #

Arguments

:: 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 #

Arguments

:: ParseTime t
=> TimeLocale	Time locale.
-> String	Format string.
-> String	Input string.
-> Maybe t	The time value, or `Nothing` if the input could not be parsed using the given format.

readTime #

Arguments

:: ParseTime t
=> TimeLocale	Time locale.
-> String	Format string.
-> String	Input string.
-> t	The time value.

readsTime #

Arguments

:: ParseTime t
=> TimeLocale	Time locale.
-> String	Format string
-> ReadS t

class ParseTime t #

The class of types which can be parsed given a UNIX-style time format string.

Minimal complete definition

buildTime

Instances

ParseTime ZonedTime
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe ZonedTime #
ParseTime LocalTime
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe LocalTime #
ParseTime TimeOfDay
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe TimeOfDay #
ParseTime TimeZone
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe TimeZone #
ParseTime UniversalTime
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe UniversalTime #
ParseTime UTCTime
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe UTCTime #
ParseTime Day
Instance details Defined in Data.Time.Format.Parse Methods buildTime :: TimeLocale -> [(Char, String)] -> Maybe Day #

Locale

data TimeLocale #

Constructors

TimeLocale
Fields wDays :: [(String, String)] full and abbreviated week days, starting with Sunday months :: [(String, String)] full and abbreviated months amPm :: (String, String) AM/PM symbols dateTimeFmt :: String formatting strings dateFmt :: String formatting strings timeFmt :: String formatting strings time12Fmt :: String formatting strings knownTimeZones :: [TimeZone] time zones known by name

Instances

Eq TimeLocale
Instance details Defined in Data.Time.Format.Locale Methods (==) :: TimeLocale -> TimeLocale -> Bool # (/=) :: TimeLocale -> TimeLocale -> Bool #
Ord TimeLocale
Instance details Defined in Data.Time.Format.Locale Methods 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
Instance details Defined in Data.Time.Format.Locale Methods showsPrec :: Int -> TimeLocale -> ShowS # show :: TimeLocale -> String # showList :: [TimeLocale] -> ShowS #

defaultTimeLocale :: TimeLocale #

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 #

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 #

Format string according to RFC822.

UNIX-style formatting

<modifier>

<width>

<specifier>

TimeZone

LocalTime

TimeOfDay

UTCTime and ZonedTime

Day

UNIX-style parsing

Note in compat mode acceptWS argument is ignored, it's always True.

Locale

`<modifier>`

`<width>`

`<specifier>`

`TimeZone`

`LocalTime`

`TimeOfDay`

`UTCTime` and `ZonedTime`

`Day`

Note in compat mode acceptWS argument is ignored, it's always `True`.