| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Prolude.Time
Synopsis
- toGregorian :: Day -> (Year, MonthOfYear, DayOfMonth)
- fromGregorian :: Year -> MonthOfYear -> DayOfMonth -> Day
- data Day
- data UTCTime = UTCTime {
- utctDay :: Day
- utctDayTime :: DiffTime
- data DiffTime
- addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime
- data NominalDiffTime
- utcTimeToPOSIXSeconds :: UTCTime -> POSIXTime
- posixSecondsToUTCTime :: POSIXTime -> UTCTime
- getPOSIXTime :: IO POSIXTime
- type POSIXTime = NominalDiffTime
- formatTime :: FormatTime t => TimeLocale -> String -> t -> String
- defaultTimeLocale :: TimeLocale
- getCurrentTime :: MonadIO m => m UTCTime
Data.Time.Calendar re-exports
toGregorian :: Day -> (Year, MonthOfYear, DayOfMonth) #
Convert to proleptic Gregorian calendar.
fromGregorian :: Year -> MonthOfYear -> DayOfMonth -> Day #
Convert from proleptic Gregorian calendar. Invalid values will be clipped to the correct range, month first, then day.
The Modified Julian Day is a standard count of days, with zero being the day 1858-11-17.
Instances
| FromJSON Day | |
| FromJSONKey Day | |
Defined in Data.Aeson.Types.FromJSON | |
| ToJSON Day | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey Day | |
Defined in Data.Aeson.Types.ToJSON | |
| Data Day | |
Defined in Data.Time.Calendar.Days Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Day -> c Day # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Day # dataTypeOf :: Day -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Day) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Day) # gmapT :: (forall b. Data b => b -> b) -> Day -> Day # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Day -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Day -> r # gmapQ :: (forall d. Data d => d -> u) -> Day -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Day -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Day -> m Day # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Day -> m Day # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Day -> m Day # | |
| Enum Day | |
| Ix Day | |
| NFData Day | |
Defined in Data.Time.Calendar.Days | |
| Eq Day | |
| Ord Day | |
| FromFormKey Day | |
Defined in Web.Internal.FormUrlEncoded | |
| ToFormKey Day | |
Defined in Web.Internal.FormUrlEncoded | |
| FromHttpApiData Day |
|
Defined in Web.Internal.HttpApiData | |
| ToHttpApiData Day |
|
Defined in Web.Internal.HttpApiData Methods toUrlPiece :: Day -> Text # toEncodedUrlPiece :: Day -> Builder # toHeader :: Day -> ByteString # toQueryParam :: Day -> Text # | |
| PersistField Day | |
Defined in Database.Persist.Class.PersistField | |
| PersistFieldSql Day | |
| ToParamSchema Day | Format |
Defined in Data.Swagger.Internal.ParamSchema Methods toParamSchema :: forall (t :: SwaggerKind Type). Proxy Day -> ParamSchema t # | |
| ToSchema Day | Format |
Defined in Data.Swagger.Internal.Schema Methods declareNamedSchema :: Proxy Day -> Declare (Definitions Schema) NamedSchema # | |
Data.Time.Clock re-exports
This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.
Constructors
| UTCTime | |
Fields
| |
Instances
| FromJSON UTCTime | |
| FromJSONKey UTCTime | |
Defined in Data.Aeson.Types.FromJSON Methods | |
| ToJSON UTCTime | |
Defined in Data.Aeson.Types.ToJSON | |
| ToJSONKey UTCTime | |
Defined in Data.Aeson.Types.ToJSON | |
| Data UTCTime | |
Defined in Data.Time.Clock.Internal.UTCTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTCTime -> c UTCTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UTCTime # toConstr :: UTCTime -> Constr # dataTypeOf :: UTCTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UTCTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTCTime) # gmapT :: (forall b. Data b => b -> b) -> UTCTime -> UTCTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQ :: (forall d. Data d => d -> u) -> UTCTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UTCTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # | |
| Val UTCTime | |
| NFData UTCTime | |
Defined in Data.Time.Clock.Internal.UTCTime | |
| Eq UTCTime | |
| Ord UTCTime | |
Defined in Data.Time.Clock.Internal.UTCTime | |
| FromFormKey UTCTime | |
Defined in Web.Internal.FormUrlEncoded | |
| ToFormKey UTCTime | |
Defined in Web.Internal.FormUrlEncoded | |
| FromHttpApiData UTCTime |
|
Defined in Web.Internal.HttpApiData Methods parseUrlPiece :: Text -> Either Text UTCTime # parseHeader :: ByteString -> Either Text UTCTime # | |
| ToHttpApiData UTCTime |
|
Defined in Web.Internal.HttpApiData Methods toUrlPiece :: UTCTime -> Text # toEncodedUrlPiece :: UTCTime -> Builder # toHeader :: UTCTime -> ByteString # toQueryParam :: UTCTime -> Text # | |
| PersistField UTCTime | |
Defined in Database.Persist.Class.PersistField Methods toPersistValue :: UTCTime -> PersistValue # | |
| PersistFieldSql UTCTime | |
| ToParamSchema UTCTime |
|
Defined in Data.Swagger.Internal.ParamSchema Methods toParamSchema :: forall (t :: SwaggerKind Type). Proxy UTCTime -> ParamSchema t # | |
| ToSchema UTCTime |
|
Defined in Data.Swagger.Internal.Schema Methods declareNamedSchema :: Proxy UTCTime -> Declare (Definitions Schema) NamedSchema # | |
This is a length of time, as measured by a clock.
Conversion functions such as fromInteger and realToFrac will treat it as seconds.
For example, (0.010 :: DiffTime) corresponds to 10 milliseconds.
It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.
Instances
| FromJSON DiffTime | This instance includes a bounds check to prevent maliciously
large inputs to fill up the memory of the target system. You can
newtype |
| ToJSON DiffTime | |
Defined in Data.Aeson.Types.ToJSON | |
| Data DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DiffTime -> c DiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DiffTime # toConstr :: DiffTime -> Constr # dataTypeOf :: DiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DiffTime) # gmapT :: (forall b. Data b => b -> b) -> DiffTime -> DiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> DiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # | |
| Enum DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Num DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Read DiffTime | |
| Fractional DiffTime | |
| Real DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods toRational :: DiffTime -> Rational # | |
| RealFrac DiffTime | |
| Show DiffTime | |
| NFData DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Eq DiffTime | |
| Ord DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime #
addUTCTime a b = a + b
data NominalDiffTime #
This is a length of time, as measured by UTC. It has a precision of 10^-12 s.
Conversion functions such as fromInteger and realToFrac will treat it as seconds.
For example, (0.010 :: NominalDiffTime) corresponds to 10 milliseconds.
It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.
It ignores leap-seconds, so it's not necessarily a fixed amount of clock time. For instance, 23:00 UTC + 2 hours of NominalDiffTime = 01:00 UTC (+ 1 day), regardless of whether a leap-second intervened.
Instances
getPOSIXTime :: IO POSIXTime #
Get the current POSIX time from the system clock.
type POSIXTime = NominalDiffTime #
POSIX time is the nominal time since 1970-01-01 00:00 UTC
To convert from a CTime or System.Posix.EpochTime, use realToFrac.
Data.Time.Format re-exports
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><alternate><specifier>, where <modifier>, <width>, and <alternate> 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
<alternate>
An optional E character indicates an alternate formatting. Currently this only affects %Z and %z.
%Ez- alternate formatting
<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 %Ez- timezone offset in the format
±HH:MM %Z- timezone name (or else offset in the format
±HHMM) %EZ- timezone name (or else offset in the format
±HH:MM)
LocalTime
For LocalTime (and ZonedTime and UTCTime and UniversalTime):
%c- as
dateTimeFmtlocale(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
timeFmtlocale(e.g.%H:%M:%S) %r- as
time12Fmtlocale(e.g.%I:%M:%S %p) %P- day-half of day from (
amPmlocale), converted to lowercase,am,pm %p- day-half of day from (
amPmlocale),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,
%Qomits 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.%qand%s%Qthe decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as-1.1with%s%Q.
DayOfWeek
For DayOfWeek (and Day and LocalTime and ZonedTime and UTCTime and UniversalTime):
%u- day of week number for Week Date format,
1(= Monday) -7(= Sunday) %w- day of week number,
0(= Sunday) -6(= Saturday) %a- day of week, short form (
sndfromwDayslocale),Sun-Sat %A- day of week, long form (
fstfromwDayslocale),Sunday-Saturday
Month
For Month (and Day and LocalTime and ZonedTime and UTCTime and UniversalTime):
%Y- year, no padding. Note
%0Yand%_Ypad to four chars %y- year of century, 0-padded to two chars,
00-99 %C- century, no padding. Note
%0Cand%_Cpad to two chars %B- month name, long form (
fstfrommonthslocale),January-December %b,%h- month name, short form (
sndfrommonthslocale),Jan-Dec %m- month of year, 0-padded to two chars,
01-12
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
dateFmtlocale(e.g.%m/%d/%y) %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
%0fand%_fpad to two chars %V- week of year for Week Date format, 0-padded to two chars,
01-53 %U- week of year where weeks start on Sunday (as
sundayStartWeek), 0-padded to two chars,00-53 %W- week of year where weeks start on Monday (as
mondayStartWeek), 0-padded to two chars,00-53
Duration types
The specifiers for DiffTime, NominalDiffTime, CalendarDiffDays, and CalendarDiffTime are semantically
separate from the other types.
Specifiers on negative time differences will generally be negative (think rem rather than mod).
NominalDiffTime and DiffTime
Note that a "minute" of DiffTime is simply 60 SI seconds, rather than a minute of civil time.
Use NominalDiffTime to work with civil time, ignoring any leap seconds.
For NominalDiffTime and DiffTime:
%w- total whole weeks
%d- total whole days
%D- whole days of week
%h- total whole hours
%H- whole hours of day
%m- total whole minutes
%M- whole minutes of hour
%s- total whole seconds
%Es- total seconds, with decimal point and up to <width> (default 12) decimal places, without trailing zeros.
For a whole number of seconds,
%Esomits the decimal point unless padding is specified. %0Es- total seconds, with decimal point and <width> (default 12) decimal places.
%S- whole seconds of minute
%ES- seconds of minute, with decimal point and up to <width> (default 12) decimal places, without trailing zeros.
For a whole number of seconds,
%ESomits the decimal point unless padding is specified. %0ES- seconds of minute as two digits, with decimal point and <width> (default 12) decimal places.
CalendarDiffDays
For CalendarDiffDays (and CalendarDiffTime):
%y- total years
%b- total months
%B- months of year
%w- total weeks, not including months
%d- total days, not including months
%D- days of week
CalendarDiffTime
For CalendarDiffTime:
%h- total hours, not including months
%H- hours of day
%m- total minutes, not including months
%M- minutes of hour
%s- total whole seconds, not including months
%Es- total seconds, not including months, with decimal point and up to <width> (default 12) decimal places, without trailing zeros.
For a whole number of seconds,
%Esomits the decimal point unless padding is specified. %0Es- total seconds, not including months, with decimal point and <width> (default 12) decimal places.
%S- whole seconds of minute
%ES- seconds of minute, with decimal point and up to <width> (default 12) decimal places, without trailing zeros.
For a whole number of seconds,
%ESomits the decimal point unless padding is specified. %0ES- seconds of minute as two digits, with decimal point and <width> (default 12) decimal places.
defaultTimeLocale :: TimeLocale #
Locale representing American usage.
knownTimeZones contains only the ten time-zones mentioned in RFC 802 sec. 5:
"UT", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT".
Note that the parsing functions will regardless parse "UTC", single-letter military time-zones, and +HHMM format.
Functions
getCurrentTime :: MonadIO m => m UTCTime Source #
Returns now