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

Nanoseconds

Constructors

NanoSeconds Int64 |

Instances

Eq NanoSeconds Source # |
Methods (==) :: NanoSeconds -> NanoSeconds -> Bool # (/=) :: NanoSeconds -> NanoSeconds -> Bool #
Data NanoSeconds Source # |

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 Source # |
Methods (+) :: NanoSeconds -> NanoSeconds -> NanoSeconds # (-) :: NanoSeconds -> NanoSeconds -> NanoSeconds # (*) :: NanoSeconds -> NanoSeconds -> NanoSeconds # negate :: NanoSeconds -> NanoSeconds # abs :: NanoSeconds -> NanoSeconds # signum :: NanoSeconds -> NanoSeconds # fromInteger :: Integer -> NanoSeconds #
Ord NanoSeconds Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS NanoSeconds # readList :: ReadS [NanoSeconds] # readPrec :: ReadPrec NanoSeconds # readListPrec :: ReadPrec [NanoSeconds] #
Show NanoSeconds Source # |
Methods showsPrec :: Int -> NanoSeconds -> ShowS # show :: NanoSeconds -> String # showList :: [NanoSeconds] -> ShowS #
NFData NanoSeconds Source # |
Methods rnf :: NanoSeconds -> () #
TimeInterval NanoSeconds Source # |
Methods toSeconds :: NanoSeconds -> Seconds Source # fromSeconds :: Seconds -> (NanoSeconds, Seconds) Source #

newtype Seconds Source #

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 Source # |
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 Source # |
Methods (==) :: Seconds -> Seconds -> Bool # (/=) :: Seconds -> Seconds -> Bool #
Integral Seconds Source # |
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 Source # |

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 Source # |
Methods (+) :: Seconds -> Seconds -> Seconds # (-) :: Seconds -> Seconds -> Seconds # (*) :: Seconds -> Seconds -> Seconds # negate :: Seconds -> Seconds # abs :: Seconds -> Seconds # signum :: Seconds -> Seconds # fromInteger :: Integer -> Seconds #
Ord Seconds Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS Seconds # readList :: ReadS [Seconds] # readPrec :: ReadPrec Seconds # readListPrec :: ReadPrec [Seconds] #
Real Seconds Source # |
Methods toRational :: Seconds -> Rational #
Show Seconds Source # |
Methods showsPrec :: Int -> Seconds -> ShowS # show :: Seconds -> String # showList :: [Seconds] -> ShowS #
NFData Seconds Source # |
Methods rnf :: Seconds -> () #
TimeInterval Seconds Source # |
Methods toSeconds :: Seconds -> Seconds Source # fromSeconds :: Seconds -> (Seconds, Seconds) Source #

newtype Minutes Source #

Number of minutes without a referential.

Constructors

Minutes Int64 |

Instances

Enum Minutes Source # |
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 Source # |
Methods (==) :: Minutes -> Minutes -> Bool # (/=) :: Minutes -> Minutes -> Bool #
Integral Minutes Source # |
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 Source # |

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 Source # |
Methods (+) :: Minutes -> Minutes -> Minutes # (-) :: Minutes -> Minutes -> Minutes # (*) :: Minutes -> Minutes -> Minutes # negate :: Minutes -> Minutes # abs :: Minutes -> Minutes # signum :: Minutes -> Minutes # fromInteger :: Integer -> Minutes #
Ord Minutes Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS Minutes # readList :: ReadS [Minutes] # readPrec :: ReadPrec Minutes # readListPrec :: ReadPrec [Minutes] #
Real Minutes Source # |
Methods toRational :: Minutes -> Rational #
Show Minutes Source # |
Methods showsPrec :: Int -> Minutes -> ShowS # show :: Minutes -> String # showList :: [Minutes] -> ShowS #
NFData Minutes Source # |
Methods rnf :: Minutes -> () #
TimeInterval Minutes Source # |
Methods toSeconds :: Minutes -> Seconds Source # fromSeconds :: Seconds -> (Minutes, Seconds) Source #

newtype Hours Source #

Number of hours without a referential.

Constructors

Hours Int64 |

Instances

Enum Hours Source # |
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 Source # |
Methods (==) :: Hours -> Hours -> Bool # (/=) :: Hours -> Hours -> Bool #
Integral Hours Source # |
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 Source # |

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 Source # |
Methods (+) :: Hours -> Hours -> Hours # (-) :: Hours -> Hours -> Hours # (*) :: Hours -> Hours -> Hours # negate :: Hours -> Hours # abs :: Hours -> Hours # signum :: Hours -> Hours # fromInteger :: Integer -> Hours #
Ord Hours Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS Hours # readList :: ReadS [Hours] # readPrec :: ReadPrec Hours # readListPrec :: ReadPrec [Hours] #
Real Hours Source # |
Methods toRational :: Hours -> Rational #
Show Hours Source # |
Methods showsPrec :: Int -> Hours -> ShowS # show :: Hours -> String # showList :: [Hours] -> ShowS #
NFData Hours Source # |
Methods rnf :: Hours -> () #
TimeInterval Hours Source # |
Methods toSeconds :: Hours -> Seconds Source # fromSeconds :: Seconds -> (Hours, Seconds) Source #

class TimeInterval i where Source #

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

Minimal complete definition

toSeconds, fromSeconds

Methods

toSeconds :: i -> Seconds Source #

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

Instances

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

# Time enumeration

data Month Source #

Month of the year

Constructors

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

Instances

Bounded Month Source # |
Methods minBound :: Month # maxBound :: Month #
Enum Month Source # |
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 Source # |
Methods (==) :: Month -> Month -> Bool # (/=) :: Month -> Month -> Bool #
Data Month Source # |

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 Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS Month # readList :: ReadS [Month] # readPrec :: ReadPrec Month # readListPrec :: ReadPrec [Month] #
Show Month Source # |
Methods showsPrec :: Int -> Month -> ShowS # show :: Month -> String # showList :: [Month] -> ShowS #

data WeekDay Source #

Day of the week

the enumeration starts on Sunday.

Constructors

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

Instances

Bounded WeekDay Source # |
Methods minBound :: WeekDay # maxBound :: WeekDay #
Enum WeekDay Source # |
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 Source # |
Methods (==) :: WeekDay -> WeekDay -> Bool # (/=) :: WeekDay -> WeekDay -> Bool #
Data WeekDay Source # |

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 Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS WeekDay # readList :: ReadS [WeekDay] # readPrec :: ReadPrec WeekDay # readListPrec :: ReadPrec [WeekDay] #
Show WeekDay Source # |
Methods showsPrec :: Int -> WeekDay -> ShowS # show :: WeekDay -> String # showList :: [WeekDay] -> ShowS #

# Timezone

newtype TimezoneOffset Source #

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 Source # |
Methods (==) :: TimezoneOffset -> TimezoneOffset -> Bool # (/=) :: TimezoneOffset -> TimezoneOffset -> Bool #
Data TimezoneOffset Source # |

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 Source # |
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 Source # |
Methods showsPrec :: Int -> TimezoneOffset -> ShowS # show :: TimezoneOffset -> String # showList :: [TimezoneOffset] -> ShowS #
NFData TimezoneOffset Source # |
Methods rnf :: TimezoneOffset -> () #

timezoneOffsetToSeconds :: TimezoneOffset -> Seconds Source #

Return the number of seconds associated with a timezone

timezone_UTC :: TimezoneOffset Source #

The UTC timezone. offset of 0

# Computer friendly format

## Unix elapsed

newtype Elapsed Source #

A number of seconds elapsed since the unix epoch.

Constructors

Elapsed Seconds |

Instances

Eq Elapsed Source # |
Methods (==) :: Elapsed -> Elapsed -> Bool # (/=) :: Elapsed -> Elapsed -> Bool #
Data Elapsed Source # |

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 Source # |
Methods (+) :: Elapsed -> Elapsed -> Elapsed # (-) :: Elapsed -> Elapsed -> Elapsed # (*) :: Elapsed -> Elapsed -> Elapsed # negate :: Elapsed -> Elapsed # abs :: Elapsed -> Elapsed # signum :: Elapsed -> Elapsed # fromInteger :: Integer -> Elapsed #
Ord Elapsed Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS Elapsed # readList :: ReadS [Elapsed] # readPrec :: ReadPrec Elapsed # readListPrec :: ReadPrec [Elapsed] #
Show Elapsed Source # |
Methods showsPrec :: Int -> Elapsed -> ShowS # show :: Elapsed -> String # showList :: [Elapsed] -> ShowS #
NFData Elapsed Source # |
Methods rnf :: Elapsed -> () #
Time Elapsed Source # |
Methods timeFromElapsedP :: ElapsedP -> Elapsed Source # timeFromElapsed :: Elapsed -> Elapsed Source #
Timeable Elapsed Source # |
Methods timeGetElapsedP :: Elapsed -> ElapsedP Source # timeGetElapsed :: Elapsed -> Elapsed Source # timeGetNanoSeconds :: Elapsed -> NanoSeconds Source #

data ElapsedP Source #

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

Constructors

ElapsedP !Elapsed !NanoSeconds |

Instances

Eq ElapsedP Source # |
Methods (==) :: ElapsedP -> ElapsedP -> Bool # (/=) :: ElapsedP -> ElapsedP -> Bool #
Data ElapsedP Source # |

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 Source # |
Methods (+) :: ElapsedP -> ElapsedP -> ElapsedP # (-) :: ElapsedP -> ElapsedP -> ElapsedP # (*) :: ElapsedP -> ElapsedP -> ElapsedP # negate :: ElapsedP -> ElapsedP # abs :: ElapsedP -> ElapsedP # signum :: ElapsedP -> ElapsedP # fromInteger :: Integer -> ElapsedP #
Ord ElapsedP Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS ElapsedP # readList :: ReadS [ElapsedP] # readPrec :: ReadPrec ElapsedP # readListPrec :: ReadPrec [ElapsedP] #
Real ElapsedP Source # |
Methods toRational :: ElapsedP -> Rational #
Show ElapsedP Source # |
Methods showsPrec :: Int -> ElapsedP -> ShowS # show :: ElapsedP -> String # showList :: [ElapsedP] -> ShowS #
NFData ElapsedP Source # |
Methods rnf :: ElapsedP -> () #
Time ElapsedP Source # |
Methods timeFromElapsedP :: ElapsedP -> ElapsedP Source # timeFromElapsed :: Elapsed -> ElapsedP Source #
Timeable ElapsedP Source # |
Methods timeGetElapsedP :: ElapsedP -> ElapsedP Source # timeGetElapsed :: ElapsedP -> Elapsed Source # timeGetNanoSeconds :: ElapsedP -> NanoSeconds Source #

# Human friendly format

## Calendar time

data Date Source #

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 Source # |
Methods (==) :: Date -> Date -> Bool # (/=) :: Date -> Date -> Bool #
Data Date Source # |

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 Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS Date # readList :: ReadS [Date] # readPrec :: ReadPrec Date # readListPrec :: ReadPrec [Date] #
Show Date Source # |
Methods showsPrec :: Int -> Date -> ShowS # show :: Date -> String # showList :: [Date] -> ShowS #
NFData Date Source # |
Methods rnf :: Date -> () #
Time Date Source # |
Methods timeFromElapsedP :: ElapsedP -> Date Source # timeFromElapsed :: Elapsed -> Date Source #
Timeable Date Source # |
Methods timeGetElapsedP :: Date -> ElapsedP Source # timeGetElapsed :: Date -> Elapsed Source # timeGetNanoSeconds :: Date -> NanoSeconds Source #

data TimeOfDay Source #

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 Source # |
Methods (==) :: TimeOfDay -> TimeOfDay -> Bool # (/=) :: TimeOfDay -> TimeOfDay -> Bool #
Data TimeOfDay Source # |

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 Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS TimeOfDay # readList :: ReadS [TimeOfDay] # readPrec :: ReadPrec TimeOfDay # readListPrec :: ReadPrec [TimeOfDay] #
Show TimeOfDay Source # |
Methods showsPrec :: Int -> TimeOfDay -> ShowS # show :: TimeOfDay -> String # showList :: [TimeOfDay] -> ShowS #
NFData TimeOfDay Source # |
Methods rnf :: TimeOfDay -> () #

data DateTime Source #

Date and Time

Constructors

DateTime |

Fields

- dtDate :: Date
- dtTime :: TimeOfDay

Instances

Eq DateTime Source # |
Methods (==) :: DateTime -> DateTime -> Bool # (/=) :: DateTime -> DateTime -> Bool #
Data DateTime Source # |

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 Source # |
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 Source # |
Methods readsPrec :: Int -> ReadS DateTime # readList :: ReadS [DateTime] # readPrec :: ReadPrec DateTime # readListPrec :: ReadPrec [DateTime] #
Show DateTime Source # |
Methods showsPrec :: Int -> DateTime -> ShowS # show :: DateTime -> String # showList :: [DateTime] -> ShowS #
NFData DateTime Source # |
Methods rnf :: DateTime -> () #
Time DateTime Source # |
Methods timeFromElapsedP :: ElapsedP -> DateTime Source # timeFromElapsed :: Elapsed -> DateTime Source #
Timeable DateTime Source # |
Methods timeGetElapsedP :: DateTime -> ElapsedP Source # timeGetElapsed :: DateTime -> Elapsed Source # timeGetNanoSeconds :: DateTime -> NanoSeconds Source #