hourglass-0.2.10: simple performant time related library

License | BSD-style
Maintainer | Vincent Hanquez <vincent@snarc.org>
Safe Haskell | None
Language | Haskell2010

Time.Types

Contents

- Time units
- Time enumeration
- Timezone
- Computer friendly format
  - Unix elapsed
- Human friendly format
  - Calendar time

Description

Basic times units and types.

While pratically some units could hold infinite values, for practical and efficient purpose they are limited to int64 types for seconds and int types for years.

Most units use the unix epoch referential, but by no means reduce portability. the unix referential works under the Windows platform or any other platforms.

Synopsis

- newtype NanoSeconds = NanoSeconds Int64
- newtype Seconds = Seconds Int64
- newtype Minutes = Minutes Int64
- newtype Hours = Hours Int64
- class TimeInterval i where
- data Month
  - = January
  - | February
  - | March
  - | April
  - | May
  - | June
  - | July
  - | August
  - | September
  - | October
  - | November
  - | December
- data WeekDay
  - = Sunday
  - | Monday
  - | Tuesday
  - | Wednesday
  - | Thursday
  - | Friday
  - | Saturday
- newtype TimezoneOffset = TimezoneOffset {
  - timezoneOffsetToMinutes :: Int
  }
- timezoneOffsetToSeconds :: TimezoneOffset -> Seconds
- timezone_UTC :: TimezoneOffset
- newtype Elapsed = Elapsed Seconds
- data ElapsedP = ElapsedP !Elapsed !NanoSeconds
- data Date = Date {
  - dateYear :: !Int
  - dateMonth :: !Month
  - dateDay :: !Int
  }
- data TimeOfDay = TimeOfDay {
  - todHour :: !Hours
  - todMin :: !Minutes
  - todSec :: !Seconds
  - todNSec :: !NanoSeconds
  }
- data DateTime = DateTime {
  - dtDate :: Date
  - dtTime :: TimeOfDay
  }

# Time units

newtype NanoSeconds #

Nanoseconds

Constructors

NanoSeconds Int64 |

Instances

Eq NanoSeconds # |
Methods (==) :: NanoSeconds -> NanoSeconds -> Bool # (/=) :: NanoSeconds -> NanoSeconds -> Bool #
Data NanoSeconds # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NanoSeconds -> c NanoSeconds # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NanoSeconds # toConstr :: NanoSeconds -> Constr # dataTypeOf :: NanoSeconds -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NanoSeconds) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NanoSeconds) # gmapT :: (forall b. Data b => b -> b) -> NanoSeconds -> NanoSeconds # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r # gmapQ :: (forall d. Data d => d -> u) -> NanoSeconds -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NanoSeconds -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds #
Num NanoSeconds # |
Methods (+) :: NanoSeconds -> NanoSeconds -> NanoSeconds # (-) :: NanoSeconds -> NanoSeconds -> NanoSeconds # (*) :: NanoSeconds -> NanoSeconds -> NanoSeconds # negate :: NanoSeconds -> NanoSeconds # abs :: NanoSeconds -> NanoSeconds # signum :: NanoSeconds -> NanoSeconds # fromInteger :: Integer -> NanoSeconds #
Ord NanoSeconds # |
Methods compare :: NanoSeconds -> NanoSeconds -> Ordering # (<) :: NanoSeconds -> NanoSeconds -> Bool # (<=) :: NanoSeconds -> NanoSeconds -> Bool # (>) :: NanoSeconds -> NanoSeconds -> Bool # (>=) :: NanoSeconds -> NanoSeconds -> Bool # max :: NanoSeconds -> NanoSeconds -> NanoSeconds # min :: NanoSeconds -> NanoSeconds -> NanoSeconds #
Read NanoSeconds # |
Methods readsPrec :: Int -> ReadS NanoSeconds # readList :: ReadS [NanoSeconds] # readPrec :: ReadPrec NanoSeconds # readListPrec :: ReadPrec [NanoSeconds] #
Show NanoSeconds # |
Methods showsPrec :: Int -> NanoSeconds -> ShowS # show :: NanoSeconds -> String # showList :: [NanoSeconds] -> ShowS #
NFData NanoSeconds # |
Methods rnf :: NanoSeconds -> () #
TimeInterval NanoSeconds # |
Methods toSeconds :: NanoSeconds -> Seconds # fromSeconds :: Seconds -> (NanoSeconds, Seconds) #

newtype Seconds #

Number of seconds without a referential.

Can hold a number between [-2^63,2^63-1], which should be good for some billions of years.

However, because of limitation in the calendar conversion currently used, seconds should be in the range [-2^55,2^55-1], which is good for only 1 billion of year.

Constructors

Seconds Int64 |

Instances

Enum Seconds # |
Methods succ :: Seconds -> Seconds # pred :: Seconds -> Seconds # toEnum :: Int -> Seconds # fromEnum :: Seconds -> Int # enumFrom :: Seconds -> [Seconds] # enumFromThen :: Seconds -> Seconds -> [Seconds] # enumFromTo :: Seconds -> Seconds -> [Seconds] # enumFromThenTo :: Seconds -> Seconds -> Seconds -> [Seconds] #
Eq Seconds # |
Methods (==) :: Seconds -> Seconds -> Bool # (/=) :: Seconds -> Seconds -> Bool #
Integral Seconds # |
Methods quot :: Seconds -> Seconds -> Seconds # rem :: Seconds -> Seconds -> Seconds # div :: Seconds -> Seconds -> Seconds # mod :: Seconds -> Seconds -> Seconds # quotRem :: Seconds -> Seconds -> (Seconds, Seconds) # divMod :: Seconds -> Seconds -> (Seconds, Seconds) # toInteger :: Seconds -> Integer #
Data Seconds # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Seconds -> c Seconds # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Seconds # toConstr :: Seconds -> Constr # dataTypeOf :: Seconds -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Seconds) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Seconds) # gmapT :: (forall b. Data b => b -> b) -> Seconds -> Seconds # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seconds -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seconds -> r # gmapQ :: (forall d. Data d => d -> u) -> Seconds -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Seconds -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seconds -> m Seconds # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seconds -> m Seconds # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seconds -> m Seconds #
Num Seconds # |
Methods (+) :: Seconds -> Seconds -> Seconds # (-) :: Seconds -> Seconds -> Seconds # (*) :: Seconds -> Seconds -> Seconds # negate :: Seconds -> Seconds # abs :: Seconds -> Seconds # signum :: Seconds -> Seconds # fromInteger :: Integer -> Seconds #
Ord Seconds # |
Methods compare :: Seconds -> Seconds -> Ordering # (<) :: Seconds -> Seconds -> Bool # (<=) :: Seconds -> Seconds -> Bool # (>) :: Seconds -> Seconds -> Bool # (>=) :: Seconds -> Seconds -> Bool # max :: Seconds -> Seconds -> Seconds # min :: Seconds -> Seconds -> Seconds #
Read Seconds # |
Methods readsPrec :: Int -> ReadS Seconds # readList :: ReadS [Seconds] # readPrec :: ReadPrec Seconds # readListPrec :: ReadPrec [Seconds] #
Real Seconds # |
Methods toRational :: Seconds -> Rational #
Show Seconds # |
Methods showsPrec :: Int -> Seconds -> ShowS # show :: Seconds -> String # showList :: [Seconds] -> ShowS #
NFData Seconds # |
Methods rnf :: Seconds -> () #
TimeInterval Seconds # |
Methods toSeconds :: Seconds -> Seconds # fromSeconds :: Seconds -> (Seconds, Seconds) #

newtype Minutes #

Number of minutes without a referential.

Constructors

Minutes Int64 |

Instances

Enum Minutes # |
Methods succ :: Minutes -> Minutes # pred :: Minutes -> Minutes # toEnum :: Int -> Minutes # fromEnum :: Minutes -> Int # enumFrom :: Minutes -> [Minutes] # enumFromThen :: Minutes -> Minutes -> [Minutes] # enumFromTo :: Minutes -> Minutes -> [Minutes] # enumFromThenTo :: Minutes -> Minutes -> Minutes -> [Minutes] #
Eq Minutes # |
Methods (==) :: Minutes -> Minutes -> Bool # (/=) :: Minutes -> Minutes -> Bool #
Integral Minutes # |
Methods quot :: Minutes -> Minutes -> Minutes # rem :: Minutes -> Minutes -> Minutes # div :: Minutes -> Minutes -> Minutes # mod :: Minutes -> Minutes -> Minutes # quotRem :: Minutes -> Minutes -> (Minutes, Minutes) # divMod :: Minutes -> Minutes -> (Minutes, Minutes) # toInteger :: Minutes -> Integer #
Data Minutes # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Minutes -> c Minutes # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Minutes # toConstr :: Minutes -> Constr # dataTypeOf :: Minutes -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Minutes) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Minutes) # gmapT :: (forall b. Data b => b -> b) -> Minutes -> Minutes # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Minutes -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Minutes -> r # gmapQ :: (forall d. Data d => d -> u) -> Minutes -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Minutes -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Minutes -> m Minutes # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Minutes -> m Minutes # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Minutes -> m Minutes #
Num Minutes # |
Methods (+) :: Minutes -> Minutes -> Minutes # (-) :: Minutes -> Minutes -> Minutes # (*) :: Minutes -> Minutes -> Minutes # negate :: Minutes -> Minutes # abs :: Minutes -> Minutes # signum :: Minutes -> Minutes # fromInteger :: Integer -> Minutes #
Ord Minutes # |
Methods compare :: Minutes -> Minutes -> Ordering # (<) :: Minutes -> Minutes -> Bool # (<=) :: Minutes -> Minutes -> Bool # (>) :: Minutes -> Minutes -> Bool # (>=) :: Minutes -> Minutes -> Bool # max :: Minutes -> Minutes -> Minutes # min :: Minutes -> Minutes -> Minutes #
Read Minutes # |
Methods readsPrec :: Int -> ReadS Minutes # readList :: ReadS [Minutes] # readPrec :: ReadPrec Minutes # readListPrec :: ReadPrec [Minutes] #
Real Minutes # |
Methods toRational :: Minutes -> Rational #
Show Minutes # |
Methods showsPrec :: Int -> Minutes -> ShowS # show :: Minutes -> String # showList :: [Minutes] -> ShowS #
NFData Minutes # |
Methods rnf :: Minutes -> () #
TimeInterval Minutes # |
Methods toSeconds :: Minutes -> Seconds # fromSeconds :: Seconds -> (Minutes, Seconds) #

newtype Hours #

Number of hours without a referential.

Constructors

Hours Int64 |

Instances

Enum Hours # |
Methods succ :: Hours -> Hours # pred :: Hours -> Hours # toEnum :: Int -> Hours # fromEnum :: Hours -> Int # enumFrom :: Hours -> [Hours] # enumFromThen :: Hours -> Hours -> [Hours] # enumFromTo :: Hours -> Hours -> [Hours] # enumFromThenTo :: Hours -> Hours -> Hours -> [Hours] #
Eq Hours # |
Methods (==) :: Hours -> Hours -> Bool # (/=) :: Hours -> Hours -> Bool #
Integral Hours # |
Methods quot :: Hours -> Hours -> Hours # rem :: Hours -> Hours -> Hours # div :: Hours -> Hours -> Hours # mod :: Hours -> Hours -> Hours # quotRem :: Hours -> Hours -> (Hours, Hours) # divMod :: Hours -> Hours -> (Hours, Hours) # toInteger :: Hours -> Integer #
Data Hours # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Hours -> c Hours # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Hours # toConstr :: Hours -> Constr # dataTypeOf :: Hours -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Hours) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hours) # gmapT :: (forall b. Data b => b -> b) -> Hours -> Hours # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r # gmapQ :: (forall d. Data d => d -> u) -> Hours -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Hours -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Hours -> m Hours # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Hours -> m Hours # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Hours -> m Hours #
Num Hours # |
Methods (+) :: Hours -> Hours -> Hours # (-) :: Hours -> Hours -> Hours # (*) :: Hours -> Hours -> Hours # negate :: Hours -> Hours # abs :: Hours -> Hours # signum :: Hours -> Hours # fromInteger :: Integer -> Hours #
Ord Hours # |
Methods compare :: Hours -> Hours -> Ordering # (<) :: Hours -> Hours -> Bool # (<=) :: Hours -> Hours -> Bool # (>) :: Hours -> Hours -> Bool # (>=) :: Hours -> Hours -> Bool # max :: Hours -> Hours -> Hours # min :: Hours -> Hours -> Hours #
Read Hours # |
Methods readsPrec :: Int -> ReadS Hours # readList :: ReadS [Hours] # readPrec :: ReadPrec Hours # readListPrec :: ReadPrec [Hours] #
Real Hours # |
Methods toRational :: Hours -> Rational #
Show Hours # |
Methods showsPrec :: Int -> Hours -> ShowS # show :: Hours -> String # showList :: [Hours] -> ShowS #
NFData Hours # |
Methods rnf :: Hours -> () #
TimeInterval Hours # |
Methods toSeconds :: Hours -> Seconds # fromSeconds :: Seconds -> (Hours, Seconds) #

class TimeInterval i where #

Represent any time interval that has an equivalent value to a number of seconds.

Minimal complete definition

toSeconds, fromSeconds

Methods

toSeconds :: i -> Seconds #

fromSeconds :: Seconds -> (i, Seconds) #

Instances

TimeInterval Hours # |
Methods toSeconds :: Hours -> Seconds # fromSeconds :: Seconds -> (Hours, Seconds) #
TimeInterval Minutes # |
Methods toSeconds :: Minutes -> Seconds # fromSeconds :: Seconds -> (Minutes, Seconds) #
TimeInterval Seconds # |
Methods toSeconds :: Seconds -> Seconds # fromSeconds :: Seconds -> (Seconds, Seconds) #
TimeInterval NanoSeconds # |
Methods toSeconds :: NanoSeconds -> Seconds # fromSeconds :: Seconds -> (NanoSeconds, Seconds) #
TimeInterval Duration # |
Methods toSeconds :: Duration -> Seconds # fromSeconds :: Seconds -> (Duration, Seconds) #

# Time enumeration

data Month #

Month of the year

Constructors

January |
February |
March |
April |
May |
June |
July |
August |
September |
October |
November |
December |

Instances

Bounded Month # |
Methods minBound :: Month # maxBound :: Month #
Enum Month # |
Methods succ :: Month -> Month # pred :: Month -> Month # toEnum :: Int -> Month # fromEnum :: Month -> Int # enumFrom :: Month -> [Month] # enumFromThen :: Month -> Month -> [Month] # enumFromTo :: Month -> Month -> [Month] # enumFromThenTo :: Month -> Month -> Month -> [Month] #
Eq Month # |
Methods (==) :: Month -> Month -> Bool # (/=) :: Month -> Month -> Bool #
Data Month # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Month -> c Month # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Month # toConstr :: Month -> Constr # dataTypeOf :: Month -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Month) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Month) # gmapT :: (forall b. Data b => b -> b) -> Month -> Month # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r # gmapQ :: (forall d. Data d => d -> u) -> Month -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Month -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Month -> m Month # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Month -> m Month # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Month -> m Month #
Ord Month # |
Methods compare :: Month -> Month -> Ordering # (<) :: Month -> Month -> Bool # (<=) :: Month -> Month -> Bool # (>) :: Month -> Month -> Bool # (>=) :: Month -> Month -> Bool # max :: Month -> Month -> Month # min :: Month -> Month -> Month #
Read Month # |
Methods readsPrec :: Int -> ReadS Month # readList :: ReadS [Month] # readPrec :: ReadPrec Month # readListPrec :: ReadPrec [Month] #
Show Month # |
Methods showsPrec :: Int -> Month -> ShowS # show :: Month -> String # showList :: [Month] -> ShowS #

data WeekDay #

Day of the week

the enumeration starts on Sunday.

Constructors

Sunday |
Monday |
Tuesday |
Wednesday |
Thursday |
Friday |
Saturday |

Instances

Bounded WeekDay # |
Methods minBound :: WeekDay # maxBound :: WeekDay #
Enum WeekDay # |
Methods succ :: WeekDay -> WeekDay # pred :: WeekDay -> WeekDay # toEnum :: Int -> WeekDay # fromEnum :: WeekDay -> Int # enumFrom :: WeekDay -> [WeekDay] # enumFromThen :: WeekDay -> WeekDay -> [WeekDay] # enumFromTo :: WeekDay -> WeekDay -> [WeekDay] # enumFromThenTo :: WeekDay -> WeekDay -> WeekDay -> [WeekDay] #
Eq WeekDay # |
Methods (==) :: WeekDay -> WeekDay -> Bool # (/=) :: WeekDay -> WeekDay -> Bool #
Data WeekDay # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WeekDay -> c WeekDay # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WeekDay # toConstr :: WeekDay -> Constr # dataTypeOf :: WeekDay -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c WeekDay) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WeekDay) # gmapT :: (forall b. Data b => b -> b) -> WeekDay -> WeekDay # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WeekDay -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WeekDay -> r # gmapQ :: (forall d. Data d => d -> u) -> WeekDay -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WeekDay -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay #
Ord WeekDay # |
Methods compare :: WeekDay -> WeekDay -> Ordering # (<) :: WeekDay -> WeekDay -> Bool # (<=) :: WeekDay -> WeekDay -> Bool # (>) :: WeekDay -> WeekDay -> Bool # (>=) :: WeekDay -> WeekDay -> Bool # max :: WeekDay -> WeekDay -> WeekDay # min :: WeekDay -> WeekDay -> WeekDay #
Read WeekDay # |
Methods readsPrec :: Int -> ReadS WeekDay # readList :: ReadS [WeekDay] # readPrec :: ReadPrec WeekDay # readListPrec :: ReadPrec [WeekDay] #
Show WeekDay # |
Methods showsPrec :: Int -> WeekDay -> ShowS # show :: WeekDay -> String # showList :: [WeekDay] -> ShowS #

# Timezone

newtype TimezoneOffset #

Offset against UTC in minutes to obtain from UTC time, local time.

- a positive number represent a location East of UTC.
- a negative number represent a location West of UTC.

LocalTime t (-300) = t represent a time at UTC-5 LocalTime t (+480) = t represent a time at UTC+8

should be between -11H and +14H

Example: in AUSEDT (UTC+1000 with daylight = UTC+1100), local time is 15:47; Thus, UTC time is 04:47, and TimezoneOffset is +660 (minutes)

Constructors

TimezoneOffset |
Fields timezoneOffsetToMinutes :: Int return the number of minutes

Instances

Eq TimezoneOffset # |
Methods (==) :: TimezoneOffset -> TimezoneOffset -> Bool # (/=) :: TimezoneOffset -> TimezoneOffset -> Bool #
Data TimezoneOffset # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TimezoneOffset -> c TimezoneOffset # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TimezoneOffset # toConstr :: TimezoneOffset -> Constr # dataTypeOf :: TimezoneOffset -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TimezoneOffset) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimezoneOffset) # gmapT :: (forall b. Data b => b -> b) -> TimezoneOffset -> TimezoneOffset # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r # gmapQ :: (forall d. Data d => d -> u) -> TimezoneOffset -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TimezoneOffset -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TimezoneOffset -> m TimezoneOffset # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TimezoneOffset -> m TimezoneOffset # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TimezoneOffset -> m TimezoneOffset #
Ord TimezoneOffset # |
Methods compare :: TimezoneOffset -> TimezoneOffset -> Ordering # (<) :: TimezoneOffset -> TimezoneOffset -> Bool # (<=) :: TimezoneOffset -> TimezoneOffset -> Bool # (>) :: TimezoneOffset -> TimezoneOffset -> Bool # (>=) :: TimezoneOffset -> TimezoneOffset -> Bool # max :: TimezoneOffset -> TimezoneOffset -> TimezoneOffset # min :: TimezoneOffset -> TimezoneOffset -> TimezoneOffset #
Show TimezoneOffset # |
Methods showsPrec :: Int -> TimezoneOffset -> ShowS # show :: TimezoneOffset -> String # showList :: [TimezoneOffset] -> ShowS #
NFData TimezoneOffset # |
Methods rnf :: TimezoneOffset -> () #

timezoneOffsetToSeconds :: TimezoneOffset -> Seconds #

Return the number of seconds associated with a timezone

timezone_UTC :: TimezoneOffset #

The UTC timezone. offset of 0

# Computer friendly format

## Unix elapsed

newtype Elapsed #

A number of seconds elapsed since the unix epoch.

Constructors

Elapsed Seconds |

Instances

Eq Elapsed # |
Methods (==) :: Elapsed -> Elapsed -> Bool # (/=) :: Elapsed -> Elapsed -> Bool #
Data Elapsed # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Elapsed -> c Elapsed # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Elapsed # toConstr :: Elapsed -> Constr # dataTypeOf :: Elapsed -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Elapsed) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Elapsed) # gmapT :: (forall b. Data b => b -> b) -> Elapsed -> Elapsed # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Elapsed -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Elapsed -> r # gmapQ :: (forall d. Data d => d -> u) -> Elapsed -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Elapsed -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed #
Num Elapsed # |
Methods (+) :: Elapsed -> Elapsed -> Elapsed # (-) :: Elapsed -> Elapsed -> Elapsed # (*) :: Elapsed -> Elapsed -> Elapsed # negate :: Elapsed -> Elapsed # abs :: Elapsed -> Elapsed # signum :: Elapsed -> Elapsed # fromInteger :: Integer -> Elapsed #
Ord Elapsed # |
Methods compare :: Elapsed -> Elapsed -> Ordering # (<) :: Elapsed -> Elapsed -> Bool # (<=) :: Elapsed -> Elapsed -> Bool # (>) :: Elapsed -> Elapsed -> Bool # (>=) :: Elapsed -> Elapsed -> Bool # max :: Elapsed -> Elapsed -> Elapsed # min :: Elapsed -> Elapsed -> Elapsed #
Read Elapsed # |
Methods readsPrec :: Int -> ReadS Elapsed # readList :: ReadS [Elapsed] # readPrec :: ReadPrec Elapsed # readListPrec :: ReadPrec [Elapsed] #
Show Elapsed # |
Methods showsPrec :: Int -> Elapsed -> ShowS # show :: Elapsed -> String # showList :: [Elapsed] -> ShowS #
NFData Elapsed # |
Methods rnf :: Elapsed -> () #
Time Elapsed # |
Methods timeFromElapsedP :: ElapsedP -> Elapsed # timeFromElapsed :: Elapsed -> Elapsed #
Timeable Elapsed # |
Methods timeGetElapsedP :: Elapsed -> ElapsedP # timeGetElapsed :: Elapsed -> Elapsed # timeGetNanoSeconds :: Elapsed -> NanoSeconds #

data ElapsedP #

A number of seconds and nanoseconds elapsed since the unix epoch.

Constructors

ElapsedP !Elapsed !NanoSeconds |

Instances

Eq ElapsedP # |
Methods (==) :: ElapsedP -> ElapsedP -> Bool # (/=) :: ElapsedP -> ElapsedP -> Bool #
Data ElapsedP # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ElapsedP -> c ElapsedP # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ElapsedP # toConstr :: ElapsedP -> Constr # dataTypeOf :: ElapsedP -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ElapsedP) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ElapsedP) # gmapT :: (forall b. Data b => b -> b) -> ElapsedP -> ElapsedP # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r # gmapQ :: (forall d. Data d => d -> u) -> ElapsedP -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ElapsedP -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP #
Num ElapsedP # |
Methods (+) :: ElapsedP -> ElapsedP -> ElapsedP # (-) :: ElapsedP -> ElapsedP -> ElapsedP # (*) :: ElapsedP -> ElapsedP -> ElapsedP # negate :: ElapsedP -> ElapsedP # abs :: ElapsedP -> ElapsedP # signum :: ElapsedP -> ElapsedP # fromInteger :: Integer -> ElapsedP #
Ord ElapsedP # |
Methods compare :: ElapsedP -> ElapsedP -> Ordering # (<) :: ElapsedP -> ElapsedP -> Bool # (<=) :: ElapsedP -> ElapsedP -> Bool # (>) :: ElapsedP -> ElapsedP -> Bool # (>=) :: ElapsedP -> ElapsedP -> Bool # max :: ElapsedP -> ElapsedP -> ElapsedP # min :: ElapsedP -> ElapsedP -> ElapsedP #
Read ElapsedP # |
Methods readsPrec :: Int -> ReadS ElapsedP # readList :: ReadS [ElapsedP] # readPrec :: ReadPrec ElapsedP # readListPrec :: ReadPrec [ElapsedP] #
Real ElapsedP # |
Methods toRational :: ElapsedP -> Rational #
Show ElapsedP # |
Methods showsPrec :: Int -> ElapsedP -> ShowS # show :: ElapsedP -> String # showList :: [ElapsedP] -> ShowS #
NFData ElapsedP # |
Methods rnf :: ElapsedP -> () #
Time ElapsedP # |
Methods timeFromElapsedP :: ElapsedP -> ElapsedP # timeFromElapsed :: Elapsed -> ElapsedP #
Timeable ElapsedP # |
Methods timeGetElapsedP :: ElapsedP -> ElapsedP # timeGetElapsed :: ElapsedP -> Elapsed # timeGetNanoSeconds :: ElapsedP -> NanoSeconds #

# Human friendly format

## Calendar time

data Date #

human date representation using common calendar

Constructors

Date |
Fields dateYear :: !Int year (Common Era) dateMonth :: !Month month of the year dateDay :: !Int day of the month, between 1 to 31

Instances

Eq Date # |
Methods (==) :: Date -> Date -> Bool # (/=) :: Date -> Date -> Bool #
Data Date # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Date -> c Date # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Date # toConstr :: Date -> Constr # dataTypeOf :: Date -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Date) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Date) # gmapT :: (forall b. Data b => b -> b) -> Date -> Date # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r # gmapQ :: (forall d. Data d => d -> u) -> Date -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Date -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Date -> m Date # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Date -> m Date # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Date -> m Date #
Ord Date # |
Methods compare :: Date -> Date -> Ordering # (<) :: Date -> Date -> Bool # (<=) :: Date -> Date -> Bool # (>) :: Date -> Date -> Bool # (>=) :: Date -> Date -> Bool # max :: Date -> Date -> Date # min :: Date -> Date -> Date #
Read Date # |
Methods readsPrec :: Int -> ReadS Date # readList :: ReadS [Date] # readPrec :: ReadPrec Date # readListPrec :: ReadPrec [Date] #
Show Date # |
Methods showsPrec :: Int -> Date -> ShowS # show :: Date -> String # showList :: [Date] -> ShowS #
NFData Date # |
Methods rnf :: Date -> () #
Time Date # |
Methods timeFromElapsedP :: ElapsedP -> Date # timeFromElapsed :: Elapsed -> Date #
Timeable Date # |
Methods timeGetElapsedP :: Date -> ElapsedP # timeGetElapsed :: Date -> Elapsed # timeGetNanoSeconds :: Date -> NanoSeconds #

data TimeOfDay #

human time representation of hour, minutes, seconds in a day.

Constructors

TimeOfDay |
Fields todHour :: !Hours hours, between 0 and 23 todMin :: !Minutes minutes, between 0 and 59 todSec :: !Seconds seconds, between 0 and 59. 60 when having leap second */ todNSec :: !NanoSeconds nanoseconds, between 0 and 999999999 */

Instances

Eq TimeOfDay # |
Methods (==) :: TimeOfDay -> TimeOfDay -> Bool # (/=) :: TimeOfDay -> TimeOfDay -> Bool #
Data TimeOfDay # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TimeOfDay -> c TimeOfDay # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TimeOfDay # toConstr :: TimeOfDay -> Constr # dataTypeOf :: TimeOfDay -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TimeOfDay) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeOfDay) # gmapT :: (forall b. Data b => b -> b) -> TimeOfDay -> TimeOfDay # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r # gmapQ :: (forall d. Data d => d -> u) -> TimeOfDay -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TimeOfDay -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay #
Ord TimeOfDay # |
Methods compare :: TimeOfDay -> TimeOfDay -> Ordering # (<) :: TimeOfDay -> TimeOfDay -> Bool # (<=) :: TimeOfDay -> TimeOfDay -> Bool # (>) :: TimeOfDay -> TimeOfDay -> Bool # (>=) :: TimeOfDay -> TimeOfDay -> Bool # max :: TimeOfDay -> TimeOfDay -> TimeOfDay # min :: TimeOfDay -> TimeOfDay -> TimeOfDay #
Read TimeOfDay # |
Methods readsPrec :: Int -> ReadS TimeOfDay # readList :: ReadS [TimeOfDay] # readPrec :: ReadPrec TimeOfDay # readListPrec :: ReadPrec [TimeOfDay] #
Show TimeOfDay # |
Methods showsPrec :: Int -> TimeOfDay -> ShowS # show :: TimeOfDay -> String # showList :: [TimeOfDay] -> ShowS #
NFData TimeOfDay # |
Methods rnf :: TimeOfDay -> () #

data DateTime #

Date and Time

Constructors

DateTime |
Fields dtDate :: Date dtTime :: TimeOfDay

Instances

Eq DateTime # |
Methods (==) :: DateTime -> DateTime -> Bool # (/=) :: DateTime -> DateTime -> Bool #
Data DateTime # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DateTime -> c DateTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DateTime # toConstr :: DateTime -> Constr # dataTypeOf :: DateTime -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DateTime) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateTime) # gmapT :: (forall b. Data b => b -> b) -> DateTime -> DateTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DateTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DateTime -> r # gmapQ :: (forall d. Data d => d -> u) -> DateTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DateTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DateTime -> m DateTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DateTime -> m DateTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DateTime -> m DateTime #
Ord DateTime # |
Methods compare :: DateTime -> DateTime -> Ordering # (<) :: DateTime -> DateTime -> Bool # (<=) :: DateTime -> DateTime -> Bool # (>) :: DateTime -> DateTime -> Bool # (>=) :: DateTime -> DateTime -> Bool # max :: DateTime -> DateTime -> DateTime # min :: DateTime -> DateTime -> DateTime #
Read DateTime # |
Methods readsPrec :: Int -> ReadS DateTime # readList :: ReadS [DateTime] # readPrec :: ReadPrec DateTime # readListPrec :: ReadPrec [DateTime] #
Show DateTime # |
Methods showsPrec :: Int -> DateTime -> ShowS # show :: DateTime -> String # showList :: [DateTime] -> ShowS #
NFData DateTime # |
Methods rnf :: DateTime -> () #
Time DateTime # |
Methods timeFromElapsedP :: ElapsedP -> DateTime # timeFromElapsed :: Elapsed -> DateTime #
Timeable DateTime # |
Methods timeGetElapsedP :: DateTime -> ElapsedP # timeGetElapsed :: DateTime -> Elapsed # timeGetNanoSeconds :: DateTime -> NanoSeconds #