hourglass-0.2.10: simple performant time related library

LicenseBSD-style
MaintainerVincent Hanquez <vincent@snarc.org>
Safe HaskellNone
LanguageHaskell2010

Time.Types

Contents

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

Time units

newtype NanoSeconds #

Nanoseconds

Constructors

NanoSeconds Int64 

Instances

Eq NanoSeconds # 
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 # 
Ord NanoSeconds # 
Read NanoSeconds # 
Show NanoSeconds # 
NFData NanoSeconds # 

Methods

rnf :: NanoSeconds -> () #

TimeInterval NanoSeconds # 

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 # 
Eq Seconds # 

Methods

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

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

Integral Seconds # 
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 # 
Ord Seconds # 
Read Seconds # 
Real Seconds # 
Show Seconds # 
NFData Seconds # 

Methods

rnf :: Seconds -> () #

TimeInterval Seconds # 

newtype Minutes #

Number of minutes without a referential.

Constructors

Minutes Int64 

Instances

Enum Minutes # 
Eq Minutes # 

Methods

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

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

Integral Minutes # 
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 # 
Ord Minutes # 
Read Minutes # 
Real Minutes # 
Show Minutes # 
NFData Minutes # 

Methods

rnf :: Minutes -> () #

TimeInterval Minutes # 

newtype Hours #

Number of hours without a referential.

Constructors

Hours Int64 

Instances

Enum Hours # 
Eq Hours # 

Methods

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

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

Integral Hours # 
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 # 
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 # 
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 # 

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

Time enumeration

data Month #

Month of the year

Instances

Bounded Month # 
Enum 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 # 
Show Month # 

Methods

showsPrec :: Int -> Month -> ShowS #

show :: Month -> String #

showList :: [Month] -> ShowS #

data WeekDay #

Day of the week

the enumeration starts on Sunday.

Instances

Bounded WeekDay # 
Enum 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 # 
Read WeekDay # 
Show WeekDay # 

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

Instances

Eq TimezoneOffset # 
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 # 
Show TimezoneOffset # 
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 # 
Ord Elapsed # 
Read Elapsed # 
Show Elapsed # 
NFData Elapsed # 

Methods

rnf :: Elapsed -> () #

Time Elapsed # 
Timeable Elapsed # 

data ElapsedP #

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

Constructors

ElapsedP !Elapsed !NanoSeconds 

Instances

Eq ElapsedP # 
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 # 
Ord ElapsedP # 
Read ElapsedP # 
Real ElapsedP # 
Show ElapsedP # 
NFData ElapsedP # 

Methods

rnf :: ElapsedP -> () #

Time ElapsedP # 
Timeable ElapsedP # 

Human friendly format

Calendar time

data Date #

human date representation using common calendar

Constructors

Date 

Fields

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 # 
Show Date # 

Methods

showsPrec :: Int -> Date -> ShowS #

show :: Date -> String #

showList :: [Date] -> ShowS #

NFData Date # 

Methods

rnf :: Date -> () #

Time Date # 
Timeable Date # 

data TimeOfDay #

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

Constructors

TimeOfDay 

Fields

Instances

Eq TimeOfDay # 
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 # 
Read TimeOfDay # 
Show TimeOfDay # 
NFData TimeOfDay # 

Methods

rnf :: TimeOfDay -> () #

data DateTime #

Date and Time

Constructors

DateTime 

Fields

Instances

Eq DateTime # 
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 # 
Read DateTime # 
Show DateTime # 
NFData DateTime # 

Methods

rnf :: DateTime -> () #

Time DateTime # 
Timeable DateTime #