thyme-0.3.5.5: A faster time library

Safe HaskellNone
LanguageHaskell2010

Data.Thyme.Clock

Contents

Description

Types and functions for UTC and UT1.

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

Num, Real, Fractional and RealFrac instances for DiffTime and NominalDiffTime are only available by importing Data.Thyme.Time. In their stead are instances of AdditiveGroup, HasBasis and VectorSpace, with Scalar DiffTimeScalar NominalDiffTimeRational.

Using fromSeconds and toSeconds to convert between TimeDiffs and other numeric types. If you really must coerce between DiffTime and NominalDiffTime, view (microseconds . from microseconds).

UTCTime is an instance of AffineSpace, with Diff UTCTimeNominalDiffTime.

UTCTime is not Y294K-compliant. Please file a bug report on GitHub when this becomes a problem.

Synopsis

Universal Time

data UniversalTime Source #

The principal form of universal time, namely UT1.

UniversalTime is defined by the rotation of the Earth around its axis relative to the Sun. Thus the length of a day by this definition varies from one to the next, and is never exactly 86400 SI seconds unlike TAI or AbsoluteTime. The difference between UT1 and UTC is DUT1.

Instances

Bounded UniversalTime Source # 
Enum UniversalTime Source # 
Eq UniversalTime Source # 
Data UniversalTime Source # 

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 :: (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 Source # 
Ix UniversalTime Source # 
Generic UniversalTime Source # 

Associated Types

type Rep UniversalTime :: * -> * #

Arbitrary UniversalTime Source # 
CoArbitrary UniversalTime Source # 

Methods

coarbitrary :: UniversalTime -> Gen b -> Gen b #

NFData UniversalTime Source # 

Methods

rnf :: UniversalTime -> () #

Random UniversalTime Source # 
Unbox UniversalTime Source # 
ParseTime UniversalTime Source # 
FormatTime UniversalTime Source # 
Vector Vector UniversalTime Source # 
MVector MVector UniversalTime Source # 

Methods

basicLength :: MVector s UniversalTime -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s UniversalTime -> MVector s UniversalTime #

basicOverlaps :: MVector s UniversalTime -> MVector s UniversalTime -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) UniversalTime) #

basicInitialize :: PrimMonad m => MVector (PrimState m) UniversalTime -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> UniversalTime -> m (MVector (PrimState m) UniversalTime) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) UniversalTime -> Int -> m UniversalTime #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) UniversalTime -> Int -> UniversalTime -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) UniversalTime -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) UniversalTime -> UniversalTime -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) UniversalTime -> MVector (PrimState m) UniversalTime -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) UniversalTime -> MVector (PrimState m) UniversalTime -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) UniversalTime -> Int -> m (MVector (PrimState m) UniversalTime) #

Thyme UniversalTime UniversalTime Source # 
type Rep UniversalTime Source # 
type Rep UniversalTime = D1 * (MetaData "UniversalTime" "Data.Thyme.Clock.Internal" "thyme-0.3.5.5-J1ErmNbLmoGE4Ys0FAccE5" True) (C1 * (MetaCons "UniversalRep" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NominalDiffTime)))
data Vector UniversalTime Source # 
data MVector s UniversalTime Source # 

modJulianDate :: Iso' UniversalTime Rational Source #

View UniversalTime as a fractional number of days since the Modified Julian Date epoch.

Absolute intervals

data DiffTime Source #

An absolute time interval as measured by a clock.

DiffTime forms an AdditiveGroup―so can be added using ^+^ (or ^-^ for subtraction), and also an instance of VectorSpace―so can be scaled using *^, where

type Scalar DiffTime = Rational

Instances

Bounded DiffTime Source # 
Enum DiffTime Source # 
Eq DiffTime Source # 
Data DiffTime Source # 

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

Ord DiffTime Source # 
Read DiffTime Source # 
Show DiffTime Source # 
Ix DiffTime Source # 
Generic DiffTime Source # 

Associated Types

type Rep DiffTime :: * -> * #

Methods

from :: DiffTime -> Rep DiffTime x #

to :: Rep DiffTime x -> DiffTime #

Arbitrary DiffTime Source # 
CoArbitrary DiffTime Source # 

Methods

coarbitrary :: DiffTime -> Gen b -> Gen b #

NFData DiffTime Source # 

Methods

rnf :: DiffTime -> () #

Random DiffTime Source # 
Unbox DiffTime Source # 
HasBasis DiffTime Source # 
VectorSpace DiffTime Source # 

Associated Types

type Scalar DiffTime :: * #

AdditiveGroup DiffTime Source # 
TimeDiff DiffTime Source # 
Vector Vector DiffTime Source # 

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) DiffTime -> m (Vector DiffTime) #

basicUnsafeThaw :: PrimMonad m => Vector DiffTime -> m (Mutable Vector (PrimState m) DiffTime) #

basicLength :: Vector DiffTime -> Int #

basicUnsafeSlice :: Int -> Int -> Vector DiffTime -> Vector DiffTime #

basicUnsafeIndexM :: Monad m => Vector DiffTime -> Int -> m DiffTime #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) DiffTime -> Vector DiffTime -> m () #

elemseq :: Vector DiffTime -> DiffTime -> b -> b #

MVector MVector DiffTime Source # 

Methods

basicLength :: MVector s DiffTime -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s DiffTime -> MVector s DiffTime #

basicOverlaps :: MVector s DiffTime -> MVector s DiffTime -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) DiffTime) #

basicInitialize :: PrimMonad m => MVector (PrimState m) DiffTime -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> DiffTime -> m (MVector (PrimState m) DiffTime) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) DiffTime -> Int -> m DiffTime #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) DiffTime -> Int -> DiffTime -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) DiffTime -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) DiffTime -> DiffTime -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) DiffTime -> MVector (PrimState m) DiffTime -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) DiffTime -> MVector (PrimState m) DiffTime -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) DiffTime -> Int -> m (MVector (PrimState m) DiffTime) #

Thyme DiffTime DiffTime Source # 

Methods

thyme :: Iso' DiffTime DiffTime Source #

type Rep DiffTime Source # 
type Rep DiffTime = D1 * (MetaData "DiffTime" "Data.Thyme.Clock.Internal" "thyme-0.3.5.5-J1ErmNbLmoGE4Ys0FAccE5" True) (C1 * (MetaCons "DiffTime" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Micro)))
data Vector DiffTime Source # 
type Basis DiffTime Source # 
type Basis DiffTime = ()
type Scalar DiffTime Source # 
data MVector s DiffTime Source # 

UTC

data UTCTime Source #

Coördinated universal time: the most common form of universal time for civil timekeeping. It is synchronised with AbsoluteTime and both tick in increments of SI seconds, but UTC includes occasional leap-seconds so that it does not drift too far from UniversalTime.

UTCTime is an instance of AffineSpace, with

type Diff UTCTime = NominalDiffTime

Use .+^ to add (or .-^ to subtract) time intervals of type NominalDiffTime, and .-. to get the interval between UTCTimes.

Performance
Internally this is a 64-bit count of microseconds since the MJD epoch, so .+^, .-^ and .-. ought to be fairly fast.
Issues
UTCTime currently cannot represent leap seconds.

Instances

Bounded UTCTime Source # 
Enum UTCTime Source # 
Eq UTCTime Source # 

Methods

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

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

Data UTCTime Source # 

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 :: (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 Source # 
Ix UTCTime Source # 
Generic UTCTime Source # 

Associated Types

type Rep UTCTime :: * -> * #

Methods

from :: UTCTime -> Rep UTCTime x #

to :: Rep UTCTime x -> UTCTime #

Arbitrary UTCTime Source # 
CoArbitrary UTCTime Source # 

Methods

coarbitrary :: UTCTime -> Gen b -> Gen b #

NFData UTCTime Source # 

Methods

rnf :: UTCTime -> () #

Random UTCTime Source # 

Methods

randomR :: RandomGen g => (UTCTime, UTCTime) -> g -> (UTCTime, g) #

random :: RandomGen g => g -> (UTCTime, g) #

randomRs :: RandomGen g => (UTCTime, UTCTime) -> g -> [UTCTime] #

randoms :: RandomGen g => g -> [UTCTime] #

randomRIO :: (UTCTime, UTCTime) -> IO UTCTime #

randomIO :: IO UTCTime #

Unbox UTCTime Source # 
AffineSpace UTCTime Source # 

Associated Types

type Diff UTCTime :: * #

ParseTime UTCTime Source # 
FormatTime UTCTime Source # 

Methods

showsTime :: TimeLocale -> UTCTime -> (Char -> ShowS) -> Char -> ShowS Source #

Vector Vector UTCTime Source # 

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) UTCTime -> m (Vector UTCTime) #

basicUnsafeThaw :: PrimMonad m => Vector UTCTime -> m (Mutable Vector (PrimState m) UTCTime) #

basicLength :: Vector UTCTime -> Int #

basicUnsafeSlice :: Int -> Int -> Vector UTCTime -> Vector UTCTime #

basicUnsafeIndexM :: Monad m => Vector UTCTime -> Int -> m UTCTime #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) UTCTime -> Vector UTCTime -> m () #

elemseq :: Vector UTCTime -> UTCTime -> b -> b #

MVector MVector UTCTime Source # 

Methods

basicLength :: MVector s UTCTime -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s UTCTime -> MVector s UTCTime #

basicOverlaps :: MVector s UTCTime -> MVector s UTCTime -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) UTCTime) #

basicInitialize :: PrimMonad m => MVector (PrimState m) UTCTime -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> UTCTime -> m (MVector (PrimState m) UTCTime) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) UTCTime -> Int -> m UTCTime #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) UTCTime -> Int -> UTCTime -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) UTCTime -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) UTCTime -> UTCTime -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) UTCTime -> MVector (PrimState m) UTCTime -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) UTCTime -> MVector (PrimState m) UTCTime -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) UTCTime -> Int -> m (MVector (PrimState m) UTCTime) #

Thyme UTCTime UTCTime Source # 

Methods

thyme :: Iso' UTCTime UTCTime Source #

type Rep UTCTime Source # 
type Rep UTCTime = D1 * (MetaData "UTCTime" "Data.Thyme.Clock.Internal" "thyme-0.3.5.5-J1ErmNbLmoGE4Ys0FAccE5" True) (C1 * (MetaCons "UTCRep" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NominalDiffTime)))
data Vector UTCTime Source # 
type Diff UTCTime Source # 
data MVector s UTCTime Source # 

data UTCView Source #

Unpacked UTCTime, partly for compatibility with time.

Constructors

UTCTime 

Fields

Instances

Eq UTCView Source # 

Methods

(==) :: UTCView -> UTCView -> Bool #

(/=) :: UTCView -> UTCView -> Bool #

Data UTCView Source # 

Methods

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

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

toConstr :: UTCView -> Constr #

dataTypeOf :: UTCView -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UTCView) #

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

gmapT :: (forall b. Data b => b -> b) -> UTCView -> UTCView #

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

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

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

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

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

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

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

Ord UTCView Source # 
Show UTCView Source # 
Generic UTCView Source # 

Associated Types

type Rep UTCView :: * -> * #

Methods

from :: UTCView -> Rep UTCView x #

to :: Rep UTCView x -> UTCView #

NFData UTCView Source # 

Methods

rnf :: UTCView -> () #

Unbox UTCView Source # 
Vector Vector UTCView Source # 

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) UTCView -> m (Vector UTCView) #

basicUnsafeThaw :: PrimMonad m => Vector UTCView -> m (Mutable Vector (PrimState m) UTCView) #

basicLength :: Vector UTCView -> Int #

basicUnsafeSlice :: Int -> Int -> Vector UTCView -> Vector UTCView #

basicUnsafeIndexM :: Monad m => Vector UTCView -> Int -> m UTCView #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) UTCView -> Vector UTCView -> m () #

elemseq :: Vector UTCView -> UTCView -> b -> b #

MVector MVector UTCView Source # 

Methods

basicLength :: MVector s UTCView -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s UTCView -> MVector s UTCView #

basicOverlaps :: MVector s UTCView -> MVector s UTCView -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) UTCView) #

basicInitialize :: PrimMonad m => MVector (PrimState m) UTCView -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> UTCView -> m (MVector (PrimState m) UTCView) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) UTCView -> Int -> m UTCView #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) UTCView -> Int -> UTCView -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) UTCView -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) UTCView -> UTCView -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) UTCView -> MVector (PrimState m) UTCView -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) UTCView -> MVector (PrimState m) UTCView -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) UTCView -> Int -> m (MVector (PrimState m) UTCView) #

Thyme UTCTime UTCView Source # 

Methods

thyme :: Iso' UTCTime UTCView Source #

type Rep UTCView Source # 
type Rep UTCView = D1 * (MetaData "UTCView" "Data.Thyme.Clock.Internal" "thyme-0.3.5.5-J1ErmNbLmoGE4Ys0FAccE5" False) (C1 * (MetaCons "UTCTime" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "utctDay") SourceUnpack SourceStrict DecidedStrict) (Rec0 * Day)) (S1 * (MetaSel (Just Symbol "utctDayTime") SourceUnpack SourceStrict DecidedStrict) (Rec0 * DiffTime))))
data Vector UTCView Source # 
data MVector s UTCView Source # 

utcTime :: Iso' UTCTime UTCView Source #

View UTCTime as an UTCView, comprising a Day along with a DiffTime offset since midnight.

This is an improper lens: utctDayTime offsets outside the range of [zeroV, posixDayLength) will carry over into the day part, with the expected behaviour.

data NominalDiffTime Source #

A time interval as measured by UTC, that does not take leap-seconds into account.

For instance, the difference between 23:59:59 and 00:00:01 on the following day is always 2 seconds of NominalDiffTime, regardless of whether a leap-second took place.

NominalDiffTime forms an AdditiveGroup―so can be added using ^+^ (or ^-^ for subtraction), and also an instance of VectorSpace―so can be scaled using *^, where

type Scalar NominalDiffTime = Rational

Instances

Bounded NominalDiffTime Source # 
Enum NominalDiffTime Source # 
Eq NominalDiffTime Source # 
Data NominalDiffTime Source # 

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

Ord NominalDiffTime Source # 
Read NominalDiffTime Source # 
Show NominalDiffTime Source # 
Ix NominalDiffTime Source # 
Generic NominalDiffTime Source # 
Arbitrary NominalDiffTime Source # 
CoArbitrary NominalDiffTime Source # 

Methods

coarbitrary :: NominalDiffTime -> Gen b -> Gen b #

NFData NominalDiffTime Source # 

Methods

rnf :: NominalDiffTime -> () #

Random NominalDiffTime Source # 
Unbox NominalDiffTime Source # 
HasBasis NominalDiffTime Source # 
VectorSpace NominalDiffTime Source # 
AdditiveGroup NominalDiffTime Source # 
TimeDiff NominalDiffTime Source # 
Vector Vector NominalDiffTime Source # 
MVector MVector NominalDiffTime Source # 

Methods

basicLength :: MVector s NominalDiffTime -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s NominalDiffTime -> MVector s NominalDiffTime #

basicOverlaps :: MVector s NominalDiffTime -> MVector s NominalDiffTime -> Bool #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) NominalDiffTime) #

basicInitialize :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> m () #

basicUnsafeReplicate :: PrimMonad m => Int -> NominalDiffTime -> m (MVector (PrimState m) NominalDiffTime) #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> Int -> m NominalDiffTime #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> Int -> NominalDiffTime -> m () #

basicClear :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> m () #

basicSet :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> NominalDiffTime -> m () #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> MVector (PrimState m) NominalDiffTime -> m () #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> MVector (PrimState m) NominalDiffTime -> m () #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) NominalDiffTime -> Int -> m (MVector (PrimState m) NominalDiffTime) #

Thyme NominalDiffTime NominalDiffTime Source # 
type Rep NominalDiffTime Source # 
type Rep NominalDiffTime = D1 * (MetaData "NominalDiffTime" "Data.Thyme.Clock.Internal" "thyme-0.3.5.5-J1ErmNbLmoGE4Ys0FAccE5" True) (C1 * (MetaCons "NominalDiffTime" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Micro)))
data Vector NominalDiffTime Source # 
type Basis NominalDiffTime Source # 
type Scalar NominalDiffTime Source # 
data MVector s NominalDiffTime Source # 

getCurrentTime :: IO UTCTime Source #

Get the current UTC time from the system clock.

Time interval conversion

class (HasBasis t, Basis t ~ (), Scalar t ~ Rational) => TimeDiff t where Source #

Time intervals, encompassing both DiffTime and NominalDiffTime.

Issues
Still affected by http://hackage.haskell.org/trac/ghc/ticket/7611?

Minimal complete definition

microseconds

Methods

microseconds :: Iso' t Int64 Source #

Escape hatch; avoid.

toSeconds :: (TimeDiff t, Fractional n) => t -> n Source #

Convert a time interval to some Fractional type.

fromSeconds :: (Real n, TimeDiff t) => n -> t Source #

Make a time interval from some Real type.

Performance
Try to make sure n is one of Float, Double, Int, Int64 or Integer, for which rewrite RULES have been provided.

toSeconds' :: TimeDiff t => t -> Rational Source #

Type-restricted toSeconds to avoid constraint-defaulting warnings.

fromSeconds' :: TimeDiff t => Rational -> t Source #

Type-restricted fromSeconds to avoid constraint-defaulting warnings.

Lenses

_utctDay :: Lens' UTCTime Day Source #

Lens' for the Day component of an UTCTime.

_utctDayTime :: Lens' UTCTime DiffTime Source #

Lens' for the time-of-day component of an UTCTime.