Data.Time.Clock

Types and functions for UTC and UT1

Universal Time

Time as measured by the Earth.

newtype UniversalTime

The Modified Julian Date is the day with the fraction of the day, measured from UT midnight. It's used to represent UT1, which is time as measured by the earth's rotation, adjusted for various wobbles.

Constructors

ModJulianDate

Fields

• getModJulianDate :: Rational

Instances

Eq UniversalTime

Defined in Data.Time.Clock.Internal.UniversalTime

Methods

(==) :: UniversalTime -> UniversalTime -> Bool

(/=) :: UniversalTime -> UniversalTime -> Bool

Data UniversalTime

Defined in Data.Time.Clock.Internal.UniversalTime

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniversalTime -> c UniversalTime

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UniversalTime

toConstr :: UniversalTime -> Constr

dataTypeOf :: UniversalTime -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UniversalTime)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UniversalTime)

gmapT :: (forall b. Data b => b -> b) -> UniversalTime -> UniversalTime

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniversalTime -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniversalTime -> r

gmapQ :: (forall d. Data d => d -> u) -> UniversalTime -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> UniversalTime -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniversalTime -> m UniversalTime

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniversalTime -> m UniversalTime

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniversalTime -> m UniversalTime

Ord UniversalTime

Defined in Data.Time.Clock.Internal.UniversalTime

Methods

compare :: UniversalTime -> UniversalTime -> Ordering

(<) :: UniversalTime -> UniversalTime -> Bool

(<=) :: UniversalTime -> UniversalTime -> Bool

(>) :: UniversalTime -> UniversalTime -> Bool

(>=) :: UniversalTime -> UniversalTime -> Bool

max :: UniversalTime -> UniversalTime -> UniversalTime

min :: UniversalTime -> UniversalTime -> UniversalTime

Read UniversalTime

Defined in Data.Time.Format.Parse

Methods

readsPrec :: Int -> ReadS UniversalTime

readList :: ReadS [UniversalTime]

readPrec :: ReadPrec UniversalTime

readListPrec :: ReadPrec [UniversalTime]

Show UniversalTime

Defined in Data.Time.LocalTime.Internal.LocalTime

Methods

showsPrec :: Int -> UniversalTime -> ShowS

show :: UniversalTime -> String

showList :: [UniversalTime] -> ShowS

NFData UniversalTime

Defined in Data.Time.Clock.Internal.UniversalTime

Methods

rnf :: UniversalTime -> ()

ParseTime UniversalTime

Defined in Data.Time.Format.Parse.Instances

Methods

substituteTimeSpecifier :: Proxy UniversalTime -> TimeLocale -> Char -> Maybe String

parseTimeSpecifier :: Proxy UniversalTime -> TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String

buildTime :: TimeLocale -> [(Char, String)] -> Maybe UniversalTime

FormatTime UniversalTime

Defined in Data.Time.Format.Format.Instances

Methods

formatCharacter :: Bool -> Char -> Maybe (FormatOptions -> UniversalTime -> String)

Absolute intervals

data DiffTime

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

Enum DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

succ :: DiffTime -> DiffTime

pred :: DiffTime -> DiffTime

toEnum :: Int -> DiffTime

fromEnum :: DiffTime -> Int

enumFrom :: DiffTime -> [DiffTime]

enumFromThen :: DiffTime -> DiffTime -> [DiffTime]

enumFromTo :: DiffTime -> DiffTime -> [DiffTime]

enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [DiffTime]

Eq DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(==) :: DiffTime -> DiffTime -> Bool

(/=) :: DiffTime -> DiffTime -> Bool

Fractional DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(/) :: DiffTime -> DiffTime -> DiffTime

recip :: DiffTime -> DiffTime

fromRational :: Rational -> DiffTime

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

Num DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

(+) :: DiffTime -> DiffTime -> DiffTime

(-) :: DiffTime -> DiffTime -> DiffTime

(*) :: DiffTime -> DiffTime -> DiffTime

negate :: DiffTime -> DiffTime

abs :: DiffTime -> DiffTime

signum :: DiffTime -> DiffTime

fromInteger :: Integer -> DiffTime

Ord DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

compare :: DiffTime -> DiffTime -> Ordering

(<) :: DiffTime -> DiffTime -> Bool

(<=) :: DiffTime -> DiffTime -> Bool

(>) :: DiffTime -> DiffTime -> Bool

(>=) :: DiffTime -> DiffTime -> Bool

max :: DiffTime -> DiffTime -> DiffTime

min :: DiffTime -> DiffTime -> DiffTime

Read DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

readsPrec :: Int -> ReadS DiffTime

readList :: ReadS [DiffTime]

readPrec :: ReadPrec DiffTime

readListPrec :: ReadPrec [DiffTime]

Real DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

toRational :: DiffTime -> Rational

RealFrac DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

properFraction :: Integral b => DiffTime -> (b, DiffTime)

truncate :: Integral b => DiffTime -> b

round :: Integral b => DiffTime -> b

ceiling :: Integral b => DiffTime -> b

floor :: Integral b => DiffTime -> b

Show DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

showsPrec :: Int -> DiffTime -> ShowS

show :: DiffTime -> String

showList :: [DiffTime] -> ShowS

NFData DiffTime

Defined in Data.Time.Clock.Internal.DiffTime

Methods

rnf :: DiffTime -> ()

ParseTime DiffTime

Defined in Data.Time.Format.Parse.Instances

Methods

substituteTimeSpecifier :: Proxy DiffTime -> TimeLocale -> Char -> Maybe String

parseTimeSpecifier :: Proxy DiffTime -> TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String

buildTime :: TimeLocale -> [(Char, String)] -> Maybe DiffTime

FormatTime DiffTime

Defined in Data.Time.Format.Format.Instances

Methods

formatCharacter :: Bool -> Char -> Maybe (FormatOptions -> DiffTime -> String)

secondsToDiffTime :: Integer -> DiffTime

Create a DiffTime which represents an integral number of seconds.

picosecondsToDiffTime :: Integer -> DiffTime

Create a DiffTime from a number of picoseconds.

diffTimeToPicoseconds :: DiffTime -> Integer

Get the number of picoseconds in a DiffTime.

UTC

UTC is time as measured by a clock, corrected to keep pace with the earth by adding or removing occasional seconds, known as "leap seconds". These corrections are not predictable and are announced with six month's notice. No table of these corrections is provided, as any program compiled with it would become out of date in six months.

If you don't care about leap seconds, use UTCTime and NominalDiffTime for your clock calculations, and you'll be fine.

data UTCTime

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

• utctDay :: Day

  the day

• utctDayTime :: DiffTime

  the time from midnight, 0 <= t < 86401s (because of leap-seconds)

Instances

Eq UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

(==) :: UTCTime -> UTCTime -> Bool

(/=) :: UTCTime -> UTCTime -> Bool

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

Ord UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

compare :: UTCTime -> UTCTime -> Ordering

(<) :: UTCTime -> UTCTime -> Bool

(<=) :: UTCTime -> UTCTime -> Bool

(>) :: UTCTime -> UTCTime -> Bool

(>=) :: UTCTime -> UTCTime -> Bool

max :: UTCTime -> UTCTime -> UTCTime

min :: UTCTime -> UTCTime -> UTCTime

Read UTCTime

Defined in Data.Time.Format.Parse

Methods

readsPrec :: Int -> ReadS UTCTime

readList :: ReadS [UTCTime]

readPrec :: ReadPrec UTCTime

readListPrec :: ReadPrec [UTCTime]

Show UTCTime

Defined in Data.Time.LocalTime.Internal.ZonedTime

Methods

showsPrec :: Int -> UTCTime -> ShowS

show :: UTCTime -> String

showList :: [UTCTime] -> ShowS

NFData UTCTime

Defined in Data.Time.Clock.Internal.UTCTime

Methods

rnf :: UTCTime -> ()

ParseTime UTCTime

Defined in Data.Time.Format.Parse.Instances

Methods

substituteTimeSpecifier :: Proxy UTCTime -> TimeLocale -> Char -> Maybe String

parseTimeSpecifier :: Proxy UTCTime -> TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String

buildTime :: TimeLocale -> [(Char, String)] -> Maybe UTCTime

FormatTime UTCTime

Defined in Data.Time.Format.Format.Instances

Methods

formatCharacter :: Bool -> Char -> Maybe (FormatOptions -> UTCTime -> String)

ISO8601 UTCTime

yyyy-mm-ddThh:mm:ss[.sss]Z (ISO 8601:2004(E) sec. 4.3.2 extended format)

Defined in Data.Time.Format.ISO8601

Methods

iso8601Format :: Format UTCTime

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

Enum NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

succ :: NominalDiffTime -> NominalDiffTime

pred :: NominalDiffTime -> NominalDiffTime

toEnum :: Int -> NominalDiffTime

fromEnum :: NominalDiffTime -> Int

enumFrom :: NominalDiffTime -> [NominalDiffTime]

enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]

enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]

enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]

Eq NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

(==) :: NominalDiffTime -> NominalDiffTime -> Bool

(/=) :: NominalDiffTime -> NominalDiffTime -> Bool

Fractional NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

(/) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

recip :: NominalDiffTime -> NominalDiffTime

fromRational :: Rational -> NominalDiffTime

Data NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NominalDiffTime

toConstr :: NominalDiffTime -> Constr

dataTypeOf :: NominalDiffTime -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NominalDiffTime)

gmapT :: (forall b. Data b => b -> b) -> NominalDiffTime -> NominalDiffTime

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r

gmapQ :: (forall d. Data d => d -> u) -> NominalDiffTime -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NominalDiffTime -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime

Num NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

(+) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

(-) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

(*) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

negate :: NominalDiffTime -> NominalDiffTime

abs :: NominalDiffTime -> NominalDiffTime

signum :: NominalDiffTime -> NominalDiffTime

fromInteger :: Integer -> NominalDiffTime

Ord NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

compare :: NominalDiffTime -> NominalDiffTime -> Ordering

(<) :: NominalDiffTime -> NominalDiffTime -> Bool

(<=) :: NominalDiffTime -> NominalDiffTime -> Bool

(>) :: NominalDiffTime -> NominalDiffTime -> Bool

(>=) :: NominalDiffTime -> NominalDiffTime -> Bool

max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

Read NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

readsPrec :: Int -> ReadS NominalDiffTime

readList :: ReadS [NominalDiffTime]

readPrec :: ReadPrec NominalDiffTime

readListPrec :: ReadPrec [NominalDiffTime]

Real NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

toRational :: NominalDiffTime -> Rational

RealFrac NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

properFraction :: Integral b => NominalDiffTime -> (b, NominalDiffTime)

truncate :: Integral b => NominalDiffTime -> b

round :: Integral b => NominalDiffTime -> b

ceiling :: Integral b => NominalDiffTime -> b

floor :: Integral b => NominalDiffTime -> b

Show NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

showsPrec :: Int -> NominalDiffTime -> ShowS

show :: NominalDiffTime -> String

showList :: [NominalDiffTime] -> ShowS

NFData NominalDiffTime

Defined in Data.Time.Clock.Internal.NominalDiffTime

Methods

rnf :: NominalDiffTime -> ()

ParseTime NominalDiffTime

Defined in Data.Time.Format.Parse.Instances

Methods

substituteTimeSpecifier :: Proxy NominalDiffTime -> TimeLocale -> Char -> Maybe String

parseTimeSpecifier :: Proxy NominalDiffTime -> TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String

buildTime :: TimeLocale -> [(Char, String)] -> Maybe NominalDiffTime

FormatTime NominalDiffTime

Defined in Data.Time.Format.Format.Instances

Methods

formatCharacter :: Bool -> Char -> Maybe (FormatOptions -> NominalDiffTime -> String)

secondsToNominalDiffTime :: Pico -> NominalDiffTime

Create a NominalDiffTime from a number of seconds.

Since: 1.9.1

nominalDiffTimeToSeconds :: NominalDiffTime -> Pico

Get the seconds in a NominalDiffTime.

Since: 1.9.1

nominalDay :: NominalDiffTime

One day in NominalDiffTime.

addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime

addUTCTime a b = a + b

diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime

diffUTCTime a b = a - b

getCurrentTime :: IO UTCTime

Get the current UTCTime from the system clock.

getTime_resolution :: DiffTime

The resolution of getSystemTime, getCurrentTime, getPOSIXTime. On UNIX systems this uses clock_getres, which may be wrong on WSL2.