hourglass-0.2.11: 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 Source #

Nanoseconds

Constructors

NanoSeconds Int64 

Instances

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

Methods

rnf :: NanoSeconds -> () #

TimeInterval NanoSeconds 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 # 
Eq Seconds Source # 

Methods

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

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

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

Methods

rnf :: Seconds -> () #

TimeInterval Seconds Source # 

newtype Minutes Source #

Number of minutes without a referential.

Constructors

Minutes Int64 

Instances

Enum Minutes Source # 
Eq Minutes Source # 

Methods

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

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

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

Methods

rnf :: Minutes -> () #

TimeInterval Minutes Source # 

newtype Hours Source #

Number of hours without a referential.

Constructors

Hours Int64 

Instances

Enum Hours Source # 
Eq Hours Source # 

Methods

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

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

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

Time enumeration

data Month Source #

Month of the year

Instances

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

Instances

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

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

Instances

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

Methods

rnf :: Elapsed -> () #

Time Elapsed Source # 
Timeable Elapsed Source # 

data ElapsedP Source #

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

Constructors

ElapsedP !Elapsed !NanoSeconds 

Instances

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

Methods

rnf :: ElapsedP -> () #

Time ElapsedP Source # 
Timeable ElapsedP Source # 

Human friendly format

Calendar time

data Date Source #

human date representation using common calendar

Constructors

Date 

Fields

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

Methods

showsPrec :: Int -> Date -> ShowS #

show :: Date -> String #

showList :: [Date] -> ShowS #

NFData Date Source # 

Methods

rnf :: Date -> () #

Time Date Source # 
Timeable Date Source # 

data TimeOfDay Source #

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

Constructors

TimeOfDay 

Fields

Instances

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

Methods

rnf :: TimeOfDay -> () #

data DateTime Source #

Date and Time

Constructors

DateTime 

Fields

Instances

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

Methods

rnf :: DateTime -> () #

Time DateTime Source # 
Timeable DateTime Source #