    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    -- |
    -- Module      : Time.Types
    -- License     : BSD-style
    -- Maintainer  : Vincent Hanquez <vincent@snarc.org>
    --
    -- 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.
    --
    module Time.Types
        (
        -- * Time units
          NanoSeconds(..)
        , Seconds(..)
        , Minutes(..)
        , Hours(..)
        , TimeInterval(..)
        -- * Time enumeration
        , Month(..)
        , WeekDay(..)
        -- * Timezone
        , TimezoneOffset(..)
        , timezoneOffsetToSeconds
        , timezone_UTC
        -- * Computer friendly format
        -- ** Unix elapsed
        , Elapsed(..)
        , ElapsedP(..)
        -- * Human friendly format
        -- ** Calendar time
        , Date(..)
        , TimeOfDay(..)
        , DateTime(..)
        ) where

    import Data.Int
    import Data.Data
    import Data.Ratio
    import Control.DeepSeq
    import Data.Hourglass.Utils (pad2)

    -- | Represent any time interval that has an
    -- equivalent value to a number of seconds.
    class TimeInterval i where
        toSeconds   :: i -> Seconds
        fromSeconds :: Seconds -> (i, Seconds)

    -- | Nanoseconds
    newtype NanoSeconds = NanoSeconds Int64
        deriving (ReadPrec [NanoSeconds]
    ReadPrec NanoSeconds
    Int -> ReadS NanoSeconds
    ReadS [NanoSeconds]
    (Int -> ReadS NanoSeconds)
    -> ReadS [NanoSeconds]
    -> ReadPrec NanoSeconds
    -> ReadPrec [NanoSeconds]
    -> Read NanoSeconds
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS NanoSeconds
    readsPrec :: Int -> ReadS NanoSeconds
    $creadList :: ReadS [NanoSeconds]
    readList :: ReadS [NanoSeconds]
    $creadPrec :: ReadPrec NanoSeconds
    readPrec :: ReadPrec NanoSeconds
    $creadListPrec :: ReadPrec [NanoSeconds]
    readListPrec :: ReadPrec [NanoSeconds]
    Read,NanoSeconds -> NanoSeconds -> Bool
    (NanoSeconds -> NanoSeconds -> Bool)
    -> (NanoSeconds -> NanoSeconds -> Bool) -> Eq NanoSeconds
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NanoSeconds -> NanoSeconds -> Bool
    == :: NanoSeconds -> NanoSeconds -> Bool
    $c/= :: NanoSeconds -> NanoSeconds -> Bool
    /= :: NanoSeconds -> NanoSeconds -> Bool
    Eq,Eq NanoSeconds
    Eq NanoSeconds
    -> (NanoSeconds -> NanoSeconds -> Ordering)
    -> (NanoSeconds -> NanoSeconds -> Bool)
    -> (NanoSeconds -> NanoSeconds -> Bool)
    -> (NanoSeconds -> NanoSeconds -> Bool)
    -> (NanoSeconds -> NanoSeconds -> Bool)
    -> (NanoSeconds -> NanoSeconds -> NanoSeconds)
    -> (NanoSeconds -> NanoSeconds -> NanoSeconds)
    -> Ord NanoSeconds
    NanoSeconds -> NanoSeconds -> Bool
    NanoSeconds -> NanoSeconds -> Ordering
    NanoSeconds -> NanoSeconds -> NanoSeconds
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: NanoSeconds -> NanoSeconds -> Ordering
    compare :: NanoSeconds -> NanoSeconds -> Ordering
    $c< :: NanoSeconds -> NanoSeconds -> Bool
    < :: NanoSeconds -> NanoSeconds -> Bool
    $c<= :: NanoSeconds -> NanoSeconds -> Bool
    <= :: NanoSeconds -> NanoSeconds -> Bool
    $c> :: NanoSeconds -> NanoSeconds -> Bool
    > :: NanoSeconds -> NanoSeconds -> Bool
    $c>= :: NanoSeconds -> NanoSeconds -> Bool
    >= :: NanoSeconds -> NanoSeconds -> Bool
    $cmax :: NanoSeconds -> NanoSeconds -> NanoSeconds
    max :: NanoSeconds -> NanoSeconds -> NanoSeconds
    $cmin :: NanoSeconds -> NanoSeconds -> NanoSeconds
    min :: NanoSeconds -> NanoSeconds -> NanoSeconds
    Ord,Integer -> NanoSeconds
    NanoSeconds -> NanoSeconds
    NanoSeconds -> NanoSeconds -> NanoSeconds
    (NanoSeconds -> NanoSeconds -> NanoSeconds)
    -> (NanoSeconds -> NanoSeconds -> NanoSeconds)
    -> (NanoSeconds -> NanoSeconds -> NanoSeconds)
    -> (NanoSeconds -> NanoSeconds)
    -> (NanoSeconds -> NanoSeconds)
    -> (NanoSeconds -> NanoSeconds)
    -> (Integer -> NanoSeconds)
    -> Num NanoSeconds
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: NanoSeconds -> NanoSeconds -> NanoSeconds
    + :: NanoSeconds -> NanoSeconds -> NanoSeconds
    $c- :: NanoSeconds -> NanoSeconds -> NanoSeconds
    - :: NanoSeconds -> NanoSeconds -> NanoSeconds
    $c* :: NanoSeconds -> NanoSeconds -> NanoSeconds
    * :: NanoSeconds -> NanoSeconds -> NanoSeconds
    $cnegate :: NanoSeconds -> NanoSeconds
    negate :: NanoSeconds -> NanoSeconds
    $cabs :: NanoSeconds -> NanoSeconds
    abs :: NanoSeconds -> NanoSeconds
    $csignum :: NanoSeconds -> NanoSeconds
    signum :: NanoSeconds -> NanoSeconds
    $cfromInteger :: Integer -> NanoSeconds
    fromInteger :: Integer -> NanoSeconds
    Num,Typeable NanoSeconds
    Typeable NanoSeconds
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> NanoSeconds -> c NanoSeconds)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NanoSeconds)
    -> (NanoSeconds -> Constr)
    -> (NanoSeconds -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NanoSeconds))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c NanoSeconds))
    -> ((forall b. Data b => b -> b) -> NanoSeconds -> NanoSeconds)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NanoSeconds -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> NanoSeconds -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds)
    -> Data NanoSeconds
    NanoSeconds -> Constr
    NanoSeconds -> DataType
    (forall b. Data b => b -> b) -> NanoSeconds -> NanoSeconds
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> NanoSeconds -> u
    forall u. (forall d. Data d => d -> u) -> NanoSeconds -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NanoSeconds
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NanoSeconds -> c NanoSeconds
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NanoSeconds)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NanoSeconds)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NanoSeconds -> c NanoSeconds
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NanoSeconds -> c NanoSeconds
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NanoSeconds
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NanoSeconds
    $ctoConstr :: NanoSeconds -> Constr
    toConstr :: NanoSeconds -> Constr
    $cdataTypeOf :: NanoSeconds -> DataType
    dataTypeOf :: NanoSeconds -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NanoSeconds)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NanoSeconds)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NanoSeconds)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NanoSeconds)
    $cgmapT :: (forall b. Data b => b -> b) -> NanoSeconds -> NanoSeconds
    gmapT :: (forall b. Data b => b -> b) -> NanoSeconds -> NanoSeconds
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NanoSeconds -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NanoSeconds -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NanoSeconds -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NanoSeconds -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NanoSeconds -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NanoSeconds -> m NanoSeconds
    Data,Typeable,NanoSeconds -> ()
    (NanoSeconds -> ()) -> NFData NanoSeconds
    forall a. (a -> ()) -> NFData a
    $crnf :: NanoSeconds -> ()
    rnf :: NanoSeconds -> ()
    NFData)

    instance Show NanoSeconds where
        show :: NanoSeconds -> String
    show (NanoSeconds Int64
    v) = Int64 -> ShowS
    forall a. Show a => a -> ShowS
    shows Int64
    v String
    "ns"

    instance TimeInterval NanoSeconds where
        toSeconds :: NanoSeconds -> Seconds
    toSeconds (NanoSeconds Int64
    ns) = Int64 -> Seconds
    Seconds (Int64
    ns Int64 -> Int64 -> Int64
    forall a. Integral a => a -> a -> a
    `div` Int64
    1000000000)
        fromSeconds :: Seconds -> (NanoSeconds, Seconds)
    fromSeconds (Seconds Int64
    s) = (Int64 -> NanoSeconds
    NanoSeconds (Int64
    s Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    * Int64
    1000000000), Seconds
    0)

    -- | 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.
    newtype Seconds = Seconds Int64
        deriving (ReadPrec [Seconds]
    ReadPrec Seconds
    Int -> ReadS Seconds
    ReadS [Seconds]
    (Int -> ReadS Seconds)
    -> ReadS [Seconds]
    -> ReadPrec Seconds
    -> ReadPrec [Seconds]
    -> Read Seconds
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Seconds
    readsPrec :: Int -> ReadS Seconds
    $creadList :: ReadS [Seconds]
    readList :: ReadS [Seconds]
    $creadPrec :: ReadPrec Seconds
    readPrec :: ReadPrec Seconds
    $creadListPrec :: ReadPrec [Seconds]
    readListPrec :: ReadPrec [Seconds]
    Read,Seconds -> Seconds -> Bool
    (Seconds -> Seconds -> Bool)
    -> (Seconds -> Seconds -> Bool) -> Eq Seconds
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Seconds -> Seconds -> Bool
    == :: Seconds -> Seconds -> Bool
    $c/= :: Seconds -> Seconds -> Bool
    /= :: Seconds -> Seconds -> Bool
    Eq,Eq Seconds
    Eq Seconds
    -> (Seconds -> Seconds -> Ordering)
    -> (Seconds -> Seconds -> Bool)
    -> (Seconds -> Seconds -> Bool)
    -> (Seconds -> Seconds -> Bool)
    -> (Seconds -> Seconds -> Bool)
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> Seconds)
    -> Ord Seconds
    Seconds -> Seconds -> Bool
    Seconds -> Seconds -> Ordering
    Seconds -> Seconds -> Seconds
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Seconds -> Seconds -> Ordering
    compare :: Seconds -> Seconds -> Ordering
    $c< :: Seconds -> Seconds -> Bool
    < :: Seconds -> Seconds -> Bool
    $c<= :: Seconds -> Seconds -> Bool
    <= :: Seconds -> Seconds -> Bool
    $c> :: Seconds -> Seconds -> Bool
    > :: Seconds -> Seconds -> Bool
    $c>= :: Seconds -> Seconds -> Bool
    >= :: Seconds -> Seconds -> Bool
    $cmax :: Seconds -> Seconds -> Seconds
    max :: Seconds -> Seconds -> Seconds
    $cmin :: Seconds -> Seconds -> Seconds
    min :: Seconds -> Seconds -> Seconds
    Ord,Int -> Seconds
    Seconds -> Int
    Seconds -> [Seconds]
    Seconds -> Seconds
    Seconds -> Seconds -> [Seconds]
    Seconds -> Seconds -> Seconds -> [Seconds]
    (Seconds -> Seconds)
    -> (Seconds -> Seconds)
    -> (Int -> Seconds)
    -> (Seconds -> Int)
    -> (Seconds -> [Seconds])
    -> (Seconds -> Seconds -> [Seconds])
    -> (Seconds -> Seconds -> [Seconds])
    -> (Seconds -> Seconds -> Seconds -> [Seconds])
    -> Enum Seconds
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Seconds -> Seconds
    succ :: Seconds -> Seconds
    $cpred :: Seconds -> Seconds
    pred :: Seconds -> Seconds
    $ctoEnum :: Int -> Seconds
    toEnum :: Int -> Seconds
    $cfromEnum :: Seconds -> Int
    fromEnum :: Seconds -> Int
    $cenumFrom :: Seconds -> [Seconds]
    enumFrom :: Seconds -> [Seconds]
    $cenumFromThen :: Seconds -> Seconds -> [Seconds]
    enumFromThen :: Seconds -> Seconds -> [Seconds]
    $cenumFromTo :: Seconds -> Seconds -> [Seconds]
    enumFromTo :: Seconds -> Seconds -> [Seconds]
    $cenumFromThenTo :: Seconds -> Seconds -> Seconds -> [Seconds]
    enumFromThenTo :: Seconds -> Seconds -> Seconds -> [Seconds]
    Enum,Integer -> Seconds
    Seconds -> Seconds
    Seconds -> Seconds -> Seconds
    (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds)
    -> (Seconds -> Seconds)
    -> (Seconds -> Seconds)
    -> (Integer -> Seconds)
    -> Num Seconds
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: Seconds -> Seconds -> Seconds
    + :: Seconds -> Seconds -> Seconds
    $c- :: Seconds -> Seconds -> Seconds
    - :: Seconds -> Seconds -> Seconds
    $c* :: Seconds -> Seconds -> Seconds
    * :: Seconds -> Seconds -> Seconds
    $cnegate :: Seconds -> Seconds
    negate :: Seconds -> Seconds
    $cabs :: Seconds -> Seconds
    abs :: Seconds -> Seconds
    $csignum :: Seconds -> Seconds
    signum :: Seconds -> Seconds
    $cfromInteger :: Integer -> Seconds
    fromInteger :: Integer -> Seconds
    Num,Num Seconds
    Ord Seconds
    Num Seconds -> Ord Seconds -> (Seconds -> Rational) -> Real Seconds
    Seconds -> Rational
    forall a. Num a -> Ord a -> (a -> Rational) -> Real a
    $ctoRational :: Seconds -> Rational
    toRational :: Seconds -> Rational
    Real,Enum Seconds
    Real Seconds
    Real Seconds
    -> Enum Seconds
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> Seconds)
    -> (Seconds -> Seconds -> (Seconds, Seconds))
    -> (Seconds -> Seconds -> (Seconds, Seconds))
    -> (Seconds -> Integer)
    -> Integral Seconds
    Seconds -> Integer
    Seconds -> Seconds -> (Seconds, Seconds)
    Seconds -> Seconds -> Seconds
    forall a.
    Real a
    -> Enum a
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: Seconds -> Seconds -> Seconds
    quot :: Seconds -> Seconds -> Seconds
    $crem :: Seconds -> Seconds -> Seconds
    rem :: Seconds -> Seconds -> Seconds
    $cdiv :: Seconds -> Seconds -> Seconds
    div :: Seconds -> Seconds -> Seconds
    $cmod :: Seconds -> Seconds -> Seconds
    mod :: Seconds -> Seconds -> Seconds
    $cquotRem :: Seconds -> Seconds -> (Seconds, Seconds)
    quotRem :: Seconds -> Seconds -> (Seconds, Seconds)
    $cdivMod :: Seconds -> Seconds -> (Seconds, Seconds)
    divMod :: Seconds -> Seconds -> (Seconds, Seconds)
    $ctoInteger :: Seconds -> Integer
    toInteger :: Seconds -> Integer
    Integral,Typeable Seconds
    Typeable Seconds
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Seconds -> c Seconds)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Seconds)
    -> (Seconds -> Constr)
    -> (Seconds -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Seconds))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Seconds))
    -> ((forall b. Data b => b -> b) -> Seconds -> Seconds)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Seconds -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Seconds -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Seconds -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Seconds -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Seconds -> m Seconds)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Seconds -> m Seconds)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Seconds -> m Seconds)
    -> Data Seconds
    Seconds -> Constr
    Seconds -> DataType
    (forall b. Data b => b -> b) -> Seconds -> Seconds
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Seconds -> u
    forall u. (forall d. Data d => d -> u) -> Seconds -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Seconds -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Seconds -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Seconds
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Seconds -> c Seconds
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Seconds)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Seconds)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Seconds -> c Seconds
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Seconds -> c Seconds
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Seconds
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Seconds
    $ctoConstr :: Seconds -> Constr
    toConstr :: Seconds -> Constr
    $cdataTypeOf :: Seconds -> DataType
    dataTypeOf :: Seconds -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Seconds)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Seconds)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Seconds)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Seconds)
    $cgmapT :: (forall b. Data b => b -> b) -> Seconds -> Seconds
    gmapT :: (forall b. Data b => b -> b) -> Seconds -> Seconds
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Seconds -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Seconds -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Seconds -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Seconds -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Seconds -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Seconds -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Seconds -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Seconds -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Seconds -> m Seconds
    Data,Typeable,Seconds -> ()
    (Seconds -> ()) -> NFData Seconds
    forall a. (a -> ()) -> NFData a
    $crnf :: Seconds -> ()
    rnf :: Seconds -> ()
    NFData)

    instance Show Seconds where
        show :: Seconds -> String
    show (Seconds Int64
    s) = Int64 -> ShowS
    forall a. Show a => a -> ShowS
    shows Int64
    s String
    "s"

    instance TimeInterval Seconds where
        toSeconds :: Seconds -> Seconds
    toSeconds   = Seconds -> Seconds
    forall a. a -> a
    id
        fromSeconds :: Seconds -> (Seconds, Seconds)
    fromSeconds Seconds
    s = (Seconds
    s,Seconds
    0)

    -- | Number of minutes without a referential.
    newtype Minutes = Minutes Int64
        deriving (ReadPrec [Minutes]
    ReadPrec Minutes
    Int -> ReadS Minutes
    ReadS [Minutes]
    (Int -> ReadS Minutes)
    -> ReadS [Minutes]
    -> ReadPrec Minutes
    -> ReadPrec [Minutes]
    -> Read Minutes
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Minutes
    readsPrec :: Int -> ReadS Minutes
    $creadList :: ReadS [Minutes]
    readList :: ReadS [Minutes]
    $creadPrec :: ReadPrec Minutes
    readPrec :: ReadPrec Minutes
    $creadListPrec :: ReadPrec [Minutes]
    readListPrec :: ReadPrec [Minutes]
    Read,Minutes -> Minutes -> Bool
    (Minutes -> Minutes -> Bool)
    -> (Minutes -> Minutes -> Bool) -> Eq Minutes
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Minutes -> Minutes -> Bool
    == :: Minutes -> Minutes -> Bool
    $c/= :: Minutes -> Minutes -> Bool
    /= :: Minutes -> Minutes -> Bool
    Eq,Eq Minutes
    Eq Minutes
    -> (Minutes -> Minutes -> Ordering)
    -> (Minutes -> Minutes -> Bool)
    -> (Minutes -> Minutes -> Bool)
    -> (Minutes -> Minutes -> Bool)
    -> (Minutes -> Minutes -> Bool)
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> Minutes)
    -> Ord Minutes
    Minutes -> Minutes -> Bool
    Minutes -> Minutes -> Ordering
    Minutes -> Minutes -> Minutes
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Minutes -> Minutes -> Ordering
    compare :: Minutes -> Minutes -> Ordering
    $c< :: Minutes -> Minutes -> Bool
    < :: Minutes -> Minutes -> Bool
    $c<= :: Minutes -> Minutes -> Bool
    <= :: Minutes -> Minutes -> Bool
    $c> :: Minutes -> Minutes -> Bool
    > :: Minutes -> Minutes -> Bool
    $c>= :: Minutes -> Minutes -> Bool
    >= :: Minutes -> Minutes -> Bool
    $cmax :: Minutes -> Minutes -> Minutes
    max :: Minutes -> Minutes -> Minutes
    $cmin :: Minutes -> Minutes -> Minutes
    min :: Minutes -> Minutes -> Minutes
    Ord,Int -> Minutes
    Minutes -> Int
    Minutes -> [Minutes]
    Minutes -> Minutes
    Minutes -> Minutes -> [Minutes]
    Minutes -> Minutes -> Minutes -> [Minutes]
    (Minutes -> Minutes)
    -> (Minutes -> Minutes)
    -> (Int -> Minutes)
    -> (Minutes -> Int)
    -> (Minutes -> [Minutes])
    -> (Minutes -> Minutes -> [Minutes])
    -> (Minutes -> Minutes -> [Minutes])
    -> (Minutes -> Minutes -> Minutes -> [Minutes])
    -> Enum Minutes
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Minutes -> Minutes
    succ :: Minutes -> Minutes
    $cpred :: Minutes -> Minutes
    pred :: Minutes -> Minutes
    $ctoEnum :: Int -> Minutes
    toEnum :: Int -> Minutes
    $cfromEnum :: Minutes -> Int
    fromEnum :: Minutes -> Int
    $cenumFrom :: Minutes -> [Minutes]
    enumFrom :: Minutes -> [Minutes]
    $cenumFromThen :: Minutes -> Minutes -> [Minutes]
    enumFromThen :: Minutes -> Minutes -> [Minutes]
    $cenumFromTo :: Minutes -> Minutes -> [Minutes]
    enumFromTo :: Minutes -> Minutes -> [Minutes]
    $cenumFromThenTo :: Minutes -> Minutes -> Minutes -> [Minutes]
    enumFromThenTo :: Minutes -> Minutes -> Minutes -> [Minutes]
    Enum,Integer -> Minutes
    Minutes -> Minutes
    Minutes -> Minutes -> Minutes
    (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes)
    -> (Minutes -> Minutes)
    -> (Minutes -> Minutes)
    -> (Integer -> Minutes)
    -> Num Minutes
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: Minutes -> Minutes -> Minutes
    + :: Minutes -> Minutes -> Minutes
    $c- :: Minutes -> Minutes -> Minutes
    - :: Minutes -> Minutes -> Minutes
    $c* :: Minutes -> Minutes -> Minutes
    * :: Minutes -> Minutes -> Minutes
    $cnegate :: Minutes -> Minutes
    negate :: Minutes -> Minutes
    $cabs :: Minutes -> Minutes
    abs :: Minutes -> Minutes
    $csignum :: Minutes -> Minutes
    signum :: Minutes -> Minutes
    $cfromInteger :: Integer -> Minutes
    fromInteger :: Integer -> Minutes
    Num,Num Minutes
    Ord Minutes
    Num Minutes -> Ord Minutes -> (Minutes -> Rational) -> Real Minutes
    Minutes -> Rational
    forall a. Num a -> Ord a -> (a -> Rational) -> Real a
    $ctoRational :: Minutes -> Rational
    toRational :: Minutes -> Rational
    Real,Enum Minutes
    Real Minutes
    Real Minutes
    -> Enum Minutes
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> Minutes)
    -> (Minutes -> Minutes -> (Minutes, Minutes))
    -> (Minutes -> Minutes -> (Minutes, Minutes))
    -> (Minutes -> Integer)
    -> Integral Minutes
    Minutes -> Integer
    Minutes -> Minutes -> (Minutes, Minutes)
    Minutes -> Minutes -> Minutes
    forall a.
    Real a
    -> Enum a
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: Minutes -> Minutes -> Minutes
    quot :: Minutes -> Minutes -> Minutes
    $crem :: Minutes -> Minutes -> Minutes
    rem :: Minutes -> Minutes -> Minutes
    $cdiv :: Minutes -> Minutes -> Minutes
    div :: Minutes -> Minutes -> Minutes
    $cmod :: Minutes -> Minutes -> Minutes
    mod :: Minutes -> Minutes -> Minutes
    $cquotRem :: Minutes -> Minutes -> (Minutes, Minutes)
    quotRem :: Minutes -> Minutes -> (Minutes, Minutes)
    $cdivMod :: Minutes -> Minutes -> (Minutes, Minutes)
    divMod :: Minutes -> Minutes -> (Minutes, Minutes)
    $ctoInteger :: Minutes -> Integer
    toInteger :: Minutes -> Integer
    Integral,Typeable Minutes
    Typeable Minutes
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Minutes -> c Minutes)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Minutes)
    -> (Minutes -> Constr)
    -> (Minutes -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Minutes))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Minutes))
    -> ((forall b. Data b => b -> b) -> Minutes -> Minutes)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Minutes -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Minutes -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Minutes -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Minutes -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Minutes -> m Minutes)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Minutes -> m Minutes)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Minutes -> m Minutes)
    -> Data Minutes
    Minutes -> Constr
    Minutes -> DataType
    (forall b. Data b => b -> b) -> Minutes -> Minutes
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Minutes -> u
    forall u. (forall d. Data d => d -> u) -> Minutes -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Minutes -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Minutes -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Minutes
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Minutes -> c Minutes
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Minutes)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Minutes)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Minutes -> c Minutes
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Minutes -> c Minutes
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Minutes
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Minutes
    $ctoConstr :: Minutes -> Constr
    toConstr :: Minutes -> Constr
    $cdataTypeOf :: Minutes -> DataType
    dataTypeOf :: Minutes -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Minutes)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Minutes)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Minutes)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Minutes)
    $cgmapT :: (forall b. Data b => b -> b) -> Minutes -> Minutes
    gmapT :: (forall b. Data b => b -> b) -> Minutes -> Minutes
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Minutes -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Minutes -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Minutes -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Minutes -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Minutes -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Minutes -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Minutes -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Minutes -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Minutes -> m Minutes
    Data,Typeable,Minutes -> ()
    (Minutes -> ()) -> NFData Minutes
    forall a. (a -> ()) -> NFData a
    $crnf :: Minutes -> ()
    rnf :: Minutes -> ()
    NFData)

    instance Show Minutes where
        show :: Minutes -> String
    show (Minutes Int64
    s) = Int64 -> ShowS
    forall a. Show a => a -> ShowS
    shows Int64
    s String
    "m"

    instance TimeInterval Minutes where
        toSeconds :: Minutes -> Seconds
    toSeconds (Minutes Int64
    m)   = Int64 -> Seconds
    Seconds (Int64
    m Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    * Int64
    60)
        fromSeconds :: Seconds -> (Minutes, Seconds)
    fromSeconds (Seconds Int64
    s) = (Int64 -> Minutes
    Minutes Int64
    m, Int64 -> Seconds
    Seconds Int64
    s')
          where (Int64
    m, Int64
    s') = Int64
    s Int64 -> Int64 -> (Int64, Int64)
    forall a. Integral a => a -> a -> (a, a)
    `divMod` Int64
    60

    -- | Number of hours without a referential.
    newtype Hours = Hours Int64
        deriving (ReadPrec [Hours]
    ReadPrec Hours
    Int -> ReadS Hours
    ReadS [Hours]
    (Int -> ReadS Hours)
    -> ReadS [Hours]
    -> ReadPrec Hours
    -> ReadPrec [Hours]
    -> Read Hours
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Hours
    readsPrec :: Int -> ReadS Hours
    $creadList :: ReadS [Hours]
    readList :: ReadS [Hours]
    $creadPrec :: ReadPrec Hours
    readPrec :: ReadPrec Hours
    $creadListPrec :: ReadPrec [Hours]
    readListPrec :: ReadPrec [Hours]
    Read,Hours -> Hours -> Bool
    (Hours -> Hours -> Bool) -> (Hours -> Hours -> Bool) -> Eq Hours
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Hours -> Hours -> Bool
    == :: Hours -> Hours -> Bool
    $c/= :: Hours -> Hours -> Bool
    /= :: Hours -> Hours -> Bool
    Eq,Eq Hours
    Eq Hours
    -> (Hours -> Hours -> Ordering)
    -> (Hours -> Hours -> Bool)
    -> (Hours -> Hours -> Bool)
    -> (Hours -> Hours -> Bool)
    -> (Hours -> Hours -> Bool)
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> Hours)
    -> Ord Hours
    Hours -> Hours -> Bool
    Hours -> Hours -> Ordering
    Hours -> Hours -> Hours
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Hours -> Hours -> Ordering
    compare :: Hours -> Hours -> Ordering
    $c< :: Hours -> Hours -> Bool
    < :: Hours -> Hours -> Bool
    $c<= :: Hours -> Hours -> Bool
    <= :: Hours -> Hours -> Bool
    $c> :: Hours -> Hours -> Bool
    > :: Hours -> Hours -> Bool
    $c>= :: Hours -> Hours -> Bool
    >= :: Hours -> Hours -> Bool
    $cmax :: Hours -> Hours -> Hours
    max :: Hours -> Hours -> Hours
    $cmin :: Hours -> Hours -> Hours
    min :: Hours -> Hours -> Hours
    Ord,Int -> Hours
    Hours -> Int
    Hours -> [Hours]
    Hours -> Hours
    Hours -> Hours -> [Hours]
    Hours -> Hours -> Hours -> [Hours]
    (Hours -> Hours)
    -> (Hours -> Hours)
    -> (Int -> Hours)
    -> (Hours -> Int)
    -> (Hours -> [Hours])
    -> (Hours -> Hours -> [Hours])
    -> (Hours -> Hours -> [Hours])
    -> (Hours -> Hours -> Hours -> [Hours])
    -> Enum Hours
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Hours -> Hours
    succ :: Hours -> Hours
    $cpred :: Hours -> Hours
    pred :: Hours -> Hours
    $ctoEnum :: Int -> Hours
    toEnum :: Int -> Hours
    $cfromEnum :: Hours -> Int
    fromEnum :: Hours -> Int
    $cenumFrom :: Hours -> [Hours]
    enumFrom :: Hours -> [Hours]
    $cenumFromThen :: Hours -> Hours -> [Hours]
    enumFromThen :: Hours -> Hours -> [Hours]
    $cenumFromTo :: Hours -> Hours -> [Hours]
    enumFromTo :: Hours -> Hours -> [Hours]
    $cenumFromThenTo :: Hours -> Hours -> Hours -> [Hours]
    enumFromThenTo :: Hours -> Hours -> Hours -> [Hours]
    Enum,Integer -> Hours
    Hours -> Hours
    Hours -> Hours -> Hours
    (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours)
    -> (Hours -> Hours)
    -> (Hours -> Hours)
    -> (Integer -> Hours)
    -> Num Hours
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: Hours -> Hours -> Hours
    + :: Hours -> Hours -> Hours
    $c- :: Hours -> Hours -> Hours
    - :: Hours -> Hours -> Hours
    $c* :: Hours -> Hours -> Hours
    * :: Hours -> Hours -> Hours
    $cnegate :: Hours -> Hours
    negate :: Hours -> Hours
    $cabs :: Hours -> Hours
    abs :: Hours -> Hours
    $csignum :: Hours -> Hours
    signum :: Hours -> Hours
    $cfromInteger :: Integer -> Hours
    fromInteger :: Integer -> Hours
    Num,Num Hours
    Ord Hours
    Num Hours -> Ord Hours -> (Hours -> Rational) -> Real Hours
    Hours -> Rational
    forall a. Num a -> Ord a -> (a -> Rational) -> Real a
    $ctoRational :: Hours -> Rational
    toRational :: Hours -> Rational
    Real,Enum Hours
    Real Hours
    Real Hours
    -> Enum Hours
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> Hours)
    -> (Hours -> Hours -> (Hours, Hours))
    -> (Hours -> Hours -> (Hours, Hours))
    -> (Hours -> Integer)
    -> Integral Hours
    Hours -> Integer
    Hours -> Hours -> (Hours, Hours)
    Hours -> Hours -> Hours
    forall a.
    Real a
    -> Enum a
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: Hours -> Hours -> Hours
    quot :: Hours -> Hours -> Hours
    $crem :: Hours -> Hours -> Hours
    rem :: Hours -> Hours -> Hours
    $cdiv :: Hours -> Hours -> Hours
    div :: Hours -> Hours -> Hours
    $cmod :: Hours -> Hours -> Hours
    mod :: Hours -> Hours -> Hours
    $cquotRem :: Hours -> Hours -> (Hours, Hours)
    quotRem :: Hours -> Hours -> (Hours, Hours)
    $cdivMod :: Hours -> Hours -> (Hours, Hours)
    divMod :: Hours -> Hours -> (Hours, Hours)
    $ctoInteger :: Hours -> Integer
    toInteger :: Hours -> Integer
    Integral,Typeable Hours
    Typeable Hours
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Hours -> c Hours)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Hours)
    -> (Hours -> Constr)
    -> (Hours -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Hours))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hours))
    -> ((forall b. Data b => b -> b) -> Hours -> Hours)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Hours -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Hours -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Hours -> m Hours)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Hours -> m Hours)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Hours -> m Hours)
    -> Data Hours
    Hours -> Constr
    Hours -> DataType
    (forall b. Data b => b -> b) -> Hours -> Hours
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Hours -> u
    forall u. (forall d. Data d => d -> u) -> Hours -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Hours
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Hours -> c Hours
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Hours)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hours)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Hours -> c Hours
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Hours -> c Hours
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Hours
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Hours
    $ctoConstr :: Hours -> Constr
    toConstr :: Hours -> Constr
    $cdataTypeOf :: Hours -> DataType
    dataTypeOf :: Hours -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Hours)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Hours)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hours)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hours)
    $cgmapT :: (forall b. Data b => b -> b) -> Hours -> Hours
    gmapT :: (forall b. Data b => b -> b) -> Hours -> Hours
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hours -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Hours -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Hours -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Hours -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Hours -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hours -> m Hours
    Data,Typeable,Hours -> ()
    (Hours -> ()) -> NFData Hours
    forall a. (a -> ()) -> NFData a
    $crnf :: Hours -> ()
    rnf :: Hours -> ()
    NFData)

    instance Show Hours where
        show :: Hours -> String
    show (Hours Int64
    s) = Int64 -> ShowS
    forall a. Show a => a -> ShowS
    shows Int64
    s String
    "h"

    instance TimeInterval Hours where
        toSeconds :: Hours -> Seconds
    toSeconds (Hours Int64
    h)     = Int64 -> Seconds
    Seconds (Int64
    h Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    * Int64
    3600)
        fromSeconds :: Seconds -> (Hours, Seconds)
    fromSeconds (Seconds Int64
    s) = (Int64 -> Hours
    Hours Int64
    h, Int64 -> Seconds
    Seconds Int64
    s')
          where (Int64
    h, Int64
    s') = Int64
    s Int64 -> Int64 -> (Int64, Int64)
    forall a. Integral a => a -> a -> (a, a)
    `divMod` Int64
    3600

    -- | A number of seconds elapsed since the unix epoch.
    newtype Elapsed = Elapsed Seconds
        deriving (ReadPrec [Elapsed]
    ReadPrec Elapsed
    Int -> ReadS Elapsed
    ReadS [Elapsed]
    (Int -> ReadS Elapsed)
    -> ReadS [Elapsed]
    -> ReadPrec Elapsed
    -> ReadPrec [Elapsed]
    -> Read Elapsed
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Elapsed
    readsPrec :: Int -> ReadS Elapsed
    $creadList :: ReadS [Elapsed]
    readList :: ReadS [Elapsed]
    $creadPrec :: ReadPrec Elapsed
    readPrec :: ReadPrec Elapsed
    $creadListPrec :: ReadPrec [Elapsed]
    readListPrec :: ReadPrec [Elapsed]
    Read,Elapsed -> Elapsed -> Bool
    (Elapsed -> Elapsed -> Bool)
    -> (Elapsed -> Elapsed -> Bool) -> Eq Elapsed
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Elapsed -> Elapsed -> Bool
    == :: Elapsed -> Elapsed -> Bool
    $c/= :: Elapsed -> Elapsed -> Bool
    /= :: Elapsed -> Elapsed -> Bool
    Eq,Eq Elapsed
    Eq Elapsed
    -> (Elapsed -> Elapsed -> Ordering)
    -> (Elapsed -> Elapsed -> Bool)
    -> (Elapsed -> Elapsed -> Bool)
    -> (Elapsed -> Elapsed -> Bool)
    -> (Elapsed -> Elapsed -> Bool)
    -> (Elapsed -> Elapsed -> Elapsed)
    -> (Elapsed -> Elapsed -> Elapsed)
    -> Ord Elapsed
    Elapsed -> Elapsed -> Bool
    Elapsed -> Elapsed -> Ordering
    Elapsed -> Elapsed -> Elapsed
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Elapsed -> Elapsed -> Ordering
    compare :: Elapsed -> Elapsed -> Ordering
    $c< :: Elapsed -> Elapsed -> Bool
    < :: Elapsed -> Elapsed -> Bool
    $c<= :: Elapsed -> Elapsed -> Bool
    <= :: Elapsed -> Elapsed -> Bool
    $c> :: Elapsed -> Elapsed -> Bool
    > :: Elapsed -> Elapsed -> Bool
    $c>= :: Elapsed -> Elapsed -> Bool
    >= :: Elapsed -> Elapsed -> Bool
    $cmax :: Elapsed -> Elapsed -> Elapsed
    max :: Elapsed -> Elapsed -> Elapsed
    $cmin :: Elapsed -> Elapsed -> Elapsed
    min :: Elapsed -> Elapsed -> Elapsed
    Ord,Integer -> Elapsed
    Elapsed -> Elapsed
    Elapsed -> Elapsed -> Elapsed
    (Elapsed -> Elapsed -> Elapsed)
    -> (Elapsed -> Elapsed -> Elapsed)
    -> (Elapsed -> Elapsed -> Elapsed)
    -> (Elapsed -> Elapsed)
    -> (Elapsed -> Elapsed)
    -> (Elapsed -> Elapsed)
    -> (Integer -> Elapsed)
    -> Num Elapsed
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: Elapsed -> Elapsed -> Elapsed
    + :: Elapsed -> Elapsed -> Elapsed
    $c- :: Elapsed -> Elapsed -> Elapsed
    - :: Elapsed -> Elapsed -> Elapsed
    $c* :: Elapsed -> Elapsed -> Elapsed
    * :: Elapsed -> Elapsed -> Elapsed
    $cnegate :: Elapsed -> Elapsed
    negate :: Elapsed -> Elapsed
    $cabs :: Elapsed -> Elapsed
    abs :: Elapsed -> Elapsed
    $csignum :: Elapsed -> Elapsed
    signum :: Elapsed -> Elapsed
    $cfromInteger :: Integer -> Elapsed
    fromInteger :: Integer -> Elapsed
    Num,Typeable Elapsed
    Typeable Elapsed
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Elapsed -> c Elapsed)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Elapsed)
    -> (Elapsed -> Constr)
    -> (Elapsed -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Elapsed))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Elapsed))
    -> ((forall b. Data b => b -> b) -> Elapsed -> Elapsed)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Elapsed -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Elapsed -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Elapsed -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Elapsed -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed)
    -> Data Elapsed
    Elapsed -> Constr
    Elapsed -> DataType
    (forall b. Data b => b -> b) -> Elapsed -> Elapsed
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Elapsed -> u
    forall u. (forall d. Data d => d -> u) -> Elapsed -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Elapsed -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Elapsed -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Elapsed
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Elapsed -> c Elapsed
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Elapsed)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Elapsed)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Elapsed -> c Elapsed
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Elapsed -> c Elapsed
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Elapsed
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Elapsed
    $ctoConstr :: Elapsed -> Constr
    toConstr :: Elapsed -> Constr
    $cdataTypeOf :: Elapsed -> DataType
    dataTypeOf :: Elapsed -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Elapsed)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Elapsed)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Elapsed)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Elapsed)
    $cgmapT :: (forall b. Data b => b -> b) -> Elapsed -> Elapsed
    gmapT :: (forall b. Data b => b -> b) -> Elapsed -> Elapsed
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Elapsed -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Elapsed -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Elapsed -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Elapsed -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Elapsed -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Elapsed -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Elapsed -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Elapsed -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Elapsed -> m Elapsed
    Data,Typeable,Elapsed -> ()
    (Elapsed -> ()) -> NFData Elapsed
    forall a. (a -> ()) -> NFData a
    $crnf :: Elapsed -> ()
    rnf :: Elapsed -> ()
    NFData)

    instance Show Elapsed where
        show :: Elapsed -> String
    show (Elapsed Seconds
    s) = Seconds -> String
    forall a. Show a => a -> String
    show Seconds
    s

    -- | A number of seconds and nanoseconds elapsed since the unix epoch.
    data ElapsedP = ElapsedP {-# UNPACK #-} !Elapsed {-# UNPACK #-} !NanoSeconds
        deriving (ReadPrec [ElapsedP]
    ReadPrec ElapsedP
    Int -> ReadS ElapsedP
    ReadS [ElapsedP]
    (Int -> ReadS ElapsedP)
    -> ReadS [ElapsedP]
    -> ReadPrec ElapsedP
    -> ReadPrec [ElapsedP]
    -> Read ElapsedP
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS ElapsedP
    readsPrec :: Int -> ReadS ElapsedP
    $creadList :: ReadS [ElapsedP]
    readList :: ReadS [ElapsedP]
    $creadPrec :: ReadPrec ElapsedP
    readPrec :: ReadPrec ElapsedP
    $creadListPrec :: ReadPrec [ElapsedP]
    readListPrec :: ReadPrec [ElapsedP]
    Read,ElapsedP -> ElapsedP -> Bool
    (ElapsedP -> ElapsedP -> Bool)
    -> (ElapsedP -> ElapsedP -> Bool) -> Eq ElapsedP
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ElapsedP -> ElapsedP -> Bool
    == :: ElapsedP -> ElapsedP -> Bool
    $c/= :: ElapsedP -> ElapsedP -> Bool
    /= :: ElapsedP -> ElapsedP -> Bool
    Eq,Eq ElapsedP
    Eq ElapsedP
    -> (ElapsedP -> ElapsedP -> Ordering)
    -> (ElapsedP -> ElapsedP -> Bool)
    -> (ElapsedP -> ElapsedP -> Bool)
    -> (ElapsedP -> ElapsedP -> Bool)
    -> (ElapsedP -> ElapsedP -> Bool)
    -> (ElapsedP -> ElapsedP -> ElapsedP)
    -> (ElapsedP -> ElapsedP -> ElapsedP)
    -> Ord ElapsedP
    ElapsedP -> ElapsedP -> Bool
    ElapsedP -> ElapsedP -> Ordering
    ElapsedP -> ElapsedP -> ElapsedP
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: ElapsedP -> ElapsedP -> Ordering
    compare :: ElapsedP -> ElapsedP -> Ordering
    $c< :: ElapsedP -> ElapsedP -> Bool
    < :: ElapsedP -> ElapsedP -> Bool
    $c<= :: ElapsedP -> ElapsedP -> Bool
    <= :: ElapsedP -> ElapsedP -> Bool
    $c> :: ElapsedP -> ElapsedP -> Bool
    > :: ElapsedP -> ElapsedP -> Bool
    $c>= :: ElapsedP -> ElapsedP -> Bool
    >= :: ElapsedP -> ElapsedP -> Bool
    $cmax :: ElapsedP -> ElapsedP -> ElapsedP
    max :: ElapsedP -> ElapsedP -> ElapsedP
    $cmin :: ElapsedP -> ElapsedP -> ElapsedP
    min :: ElapsedP -> ElapsedP -> ElapsedP
    Ord,Typeable ElapsedP
    Typeable ElapsedP
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> ElapsedP -> c ElapsedP)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ElapsedP)
    -> (ElapsedP -> Constr)
    -> (ElapsedP -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ElapsedP))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ElapsedP))
    -> ((forall b. Data b => b -> b) -> ElapsedP -> ElapsedP)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ElapsedP -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> ElapsedP -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP)
    -> Data ElapsedP
    ElapsedP -> Constr
    ElapsedP -> DataType
    (forall b. Data b => b -> b) -> ElapsedP -> ElapsedP
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ElapsedP -> u
    forall u. (forall d. Data d => d -> u) -> ElapsedP -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ElapsedP
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ElapsedP -> c ElapsedP
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ElapsedP)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ElapsedP)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ElapsedP -> c ElapsedP
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ElapsedP -> c ElapsedP
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ElapsedP
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ElapsedP
    $ctoConstr :: ElapsedP -> Constr
    toConstr :: ElapsedP -> Constr
    $cdataTypeOf :: ElapsedP -> DataType
    dataTypeOf :: ElapsedP -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ElapsedP)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ElapsedP)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ElapsedP)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ElapsedP)
    $cgmapT :: (forall b. Data b => b -> b) -> ElapsedP -> ElapsedP
    gmapT :: (forall b. Data b => b -> b) -> ElapsedP -> ElapsedP
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ElapsedP -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ElapsedP -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ElapsedP -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ElapsedP -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ElapsedP -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ElapsedP -> m ElapsedP
    Data,Typeable)

    instance Show ElapsedP where
        show :: ElapsedP -> String
    show (ElapsedP Elapsed
    e NanoSeconds
    ns) = Elapsed -> ShowS
    forall a. Show a => a -> ShowS
    shows Elapsed
    e (Char
    '.' Char -> ShowS
    forall a. a -> [a] -> [a]
    : NanoSeconds -> String
    forall a. Show a => a -> String
    show NanoSeconds
    ns)

    instance NFData ElapsedP where rnf :: ElapsedP -> ()
    rnf ElapsedP
    e = ElapsedP
    e ElapsedP -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    instance Num ElapsedP where
        + :: ElapsedP -> ElapsedP -> ElapsedP
    (+) = ElapsedP -> ElapsedP -> ElapsedP
    addElapsedP
        (-) = ElapsedP -> ElapsedP -> ElapsedP
    subElapsedP
        (ElapsedP Elapsed
    e1 NanoSeconds
    ns1) * :: ElapsedP -> ElapsedP -> ElapsedP
    * (ElapsedP Elapsed
    e2 NanoSeconds
    ns2) = Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Elapsed
    e1Elapsed -> Elapsed -> Elapsed
    forall a. Num a => a -> a -> a
    *Elapsed
    e2) (NanoSeconds
    ns1NanoSeconds -> NanoSeconds -> NanoSeconds
    forall a. Num a => a -> a -> a
    *NanoSeconds
    ns2)
        negate :: ElapsedP -> ElapsedP
    negate (ElapsedP Elapsed
    e NanoSeconds
    ns) = Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Elapsed -> Elapsed
    forall a. Num a => a -> a
    negate Elapsed
    e) NanoSeconds
    ns
        abs :: ElapsedP -> ElapsedP
    abs (ElapsedP Elapsed
    e NanoSeconds
    ns)    = Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Elapsed -> Elapsed
    forall a. Num a => a -> a
    abs Elapsed
    e) NanoSeconds
    ns
        signum :: ElapsedP -> ElapsedP
    signum (ElapsedP Elapsed
    e NanoSeconds
    ns) = Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Elapsed -> Elapsed
    forall a. Num a => a -> a
    signum Elapsed
    e) NanoSeconds
    ns
        fromInteger :: Integer -> ElapsedP
    fromInteger Integer
    i          = Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Seconds -> Elapsed
    Elapsed (Integer -> Seconds
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Integer
    i)) NanoSeconds
    0

    addElapsedP :: ElapsedP -> ElapsedP -> ElapsedP
    addElapsedP :: ElapsedP -> ElapsedP -> ElapsedP
    addElapsedP (ElapsedP Elapsed
    e1 (NanoSeconds Int64
    ns1)) (ElapsedP Elapsed
    e2 (NanoSeconds Int64
    ns2)) =
        let notNormalizedNS :: Int64
    notNormalizedNS = Int64
    ns1 Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    + Int64
    ns2
            (Int64
    retainedNS, Int64
    ns) = Int64
    notNormalizedNS Int64 -> Int64 -> (Int64, Int64)
    forall a. Integral a => a -> a -> (a, a)
    `divMod` Int64
    1000000000
        in  Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Elapsed
    e1 Elapsed -> Elapsed -> Elapsed
    forall a. Num a => a -> a -> a
    + Elapsed
    e2 Elapsed -> Elapsed -> Elapsed
    forall a. Num a => a -> a -> a
    + (Seconds -> Elapsed
    Elapsed (Seconds -> Elapsed) -> Seconds -> Elapsed
    forall a b. (a -> b) -> a -> b
    $ Int64 -> Seconds
    Seconds Int64
    retainedNS)) (Int64 -> NanoSeconds
    NanoSeconds Int64
    ns)

    subElapsedP :: ElapsedP -> ElapsedP -> ElapsedP
    subElapsedP :: ElapsedP -> ElapsedP -> ElapsedP
    subElapsedP (ElapsedP Elapsed
    e1 (NanoSeconds Int64
    ns1)) (ElapsedP Elapsed
    e2 (NanoSeconds Int64
    ns2)) =
        let notNormalizedNS :: Int64
    notNormalizedNS = Int64
    ns1 Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    - Int64
    ns2
            notNormalizedS :: Elapsed
    notNormalizedS  = Elapsed
    e1 Elapsed -> Elapsed -> Elapsed
    forall a. Num a => a -> a -> a
    - Elapsed
    e2
        in  if Int64
    notNormalizedNS Int64 -> Int64 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int64
    0
                then Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP (Elapsed
    notNormalizedS Elapsed -> Elapsed -> Elapsed
    forall a. Num a => a -> a -> a
    - Elapsed
    oneSecond) (Int64 -> NanoSeconds
    NanoSeconds (Int64
    1000000000 Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    + Int64
    notNormalizedNS))
                else Elapsed -> NanoSeconds -> ElapsedP
    ElapsedP Elapsed
    notNormalizedS (Int64 -> NanoSeconds
    NanoSeconds Int64
    notNormalizedNS)
      where
        oneSecond :: Elapsed
        oneSecond :: Elapsed
    oneSecond = Seconds -> Elapsed
    Elapsed (Seconds -> Elapsed) -> Seconds -> Elapsed
    forall a b. (a -> b) -> a -> b
    $ Int64 -> Seconds
    Seconds Int64
    1

    instance Real ElapsedP where
        toRational :: ElapsedP -> Rational
    toRational (ElapsedP (Elapsed (Seconds Int64
    s)) (NanoSeconds Int64
    0)) =
            Int64 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int64
    s
        toRational (ElapsedP (Elapsed (Seconds Int64
    s)) (NanoSeconds Int64
    ns)) =
            Int64 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int64
    s Rational -> Rational -> Rational
    forall a. Num a => a -> a -> a
    + (Int64 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int64
    ns Integer -> Integer -> Rational
    forall a. Integral a => a -> a -> Ratio a
    % Integer
    1000000000)

    -- | Month of the year
    data Month =
          January
        | February
        | March
        | April
        | May
        | June
        | July
        | August
        | September
        | October
        | November
        | December
        deriving (Int -> Month -> ShowS
    [Month] -> ShowS
    Month -> String
    (Int -> Month -> ShowS)
    -> (Month -> String) -> ([Month] -> ShowS) -> Show Month
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Month -> ShowS
    showsPrec :: Int -> Month -> ShowS
    $cshow :: Month -> String
    show :: Month -> String
    $cshowList :: [Month] -> ShowS
    showList :: [Month] -> ShowS
    Show,ReadPrec [Month]
    ReadPrec Month
    Int -> ReadS Month
    ReadS [Month]
    (Int -> ReadS Month)
    -> ReadS [Month]
    -> ReadPrec Month
    -> ReadPrec [Month]
    -> Read Month
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Month
    readsPrec :: Int -> ReadS Month
    $creadList :: ReadS [Month]
    readList :: ReadS [Month]
    $creadPrec :: ReadPrec Month
    readPrec :: ReadPrec Month
    $creadListPrec :: ReadPrec [Month]
    readListPrec :: ReadPrec [Month]
    Read,Month -> Month -> Bool
    (Month -> Month -> Bool) -> (Month -> Month -> Bool) -> Eq Month
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Month -> Month -> Bool
    == :: Month -> Month -> Bool
    $c/= :: Month -> Month -> Bool
    /= :: Month -> Month -> Bool
    Eq,Eq Month
    Eq Month
    -> (Month -> Month -> Ordering)
    -> (Month -> Month -> Bool)
    -> (Month -> Month -> Bool)
    -> (Month -> Month -> Bool)
    -> (Month -> Month -> Bool)
    -> (Month -> Month -> Month)
    -> (Month -> Month -> Month)
    -> Ord Month
    Month -> Month -> Bool
    Month -> Month -> Ordering
    Month -> Month -> Month
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Month -> Month -> Ordering
    compare :: Month -> Month -> Ordering
    $c< :: Month -> Month -> Bool
    < :: Month -> Month -> Bool
    $c<= :: Month -> Month -> Bool
    <= :: Month -> Month -> Bool
    $c> :: Month -> Month -> Bool
    > :: Month -> Month -> Bool
    $c>= :: Month -> Month -> Bool
    >= :: Month -> Month -> Bool
    $cmax :: Month -> Month -> Month
    max :: Month -> Month -> Month
    $cmin :: Month -> Month -> Month
    min :: Month -> Month -> Month
    Ord,Int -> Month
    Month -> Int
    Month -> [Month]
    Month -> Month
    Month -> Month -> [Month]
    Month -> Month -> Month -> [Month]
    (Month -> Month)
    -> (Month -> Month)
    -> (Int -> Month)
    -> (Month -> Int)
    -> (Month -> [Month])
    -> (Month -> Month -> [Month])
    -> (Month -> Month -> [Month])
    -> (Month -> Month -> Month -> [Month])
    -> Enum Month
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Month -> Month
    succ :: Month -> Month
    $cpred :: Month -> Month
    pred :: Month -> Month
    $ctoEnum :: Int -> Month
    toEnum :: Int -> Month
    $cfromEnum :: Month -> Int
    fromEnum :: Month -> Int
    $cenumFrom :: Month -> [Month]
    enumFrom :: Month -> [Month]
    $cenumFromThen :: Month -> Month -> [Month]
    enumFromThen :: Month -> Month -> [Month]
    $cenumFromTo :: Month -> Month -> [Month]
    enumFromTo :: Month -> Month -> [Month]
    $cenumFromThenTo :: Month -> Month -> Month -> [Month]
    enumFromThenTo :: Month -> Month -> Month -> [Month]
    Enum,Typeable Month
    Typeable Month
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Month -> c Month)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Month)
    -> (Month -> Constr)
    -> (Month -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Month))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Month))
    -> ((forall b. Data b => b -> b) -> Month -> Month)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Month -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Month -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Month -> m Month)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Month -> m Month)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Month -> m Month)
    -> Data Month
    Month -> Constr
    Month -> DataType
    (forall b. Data b => b -> b) -> Month -> Month
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Month -> u
    forall u. (forall d. Data d => d -> u) -> Month -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Month
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Month -> c Month
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Month)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Month)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Month -> c Month
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Month -> c Month
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Month
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Month
    $ctoConstr :: Month -> Constr
    toConstr :: Month -> Constr
    $cdataTypeOf :: Month -> DataType
    dataTypeOf :: Month -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Month)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Month)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Month)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Month)
    $cgmapT :: (forall b. Data b => b -> b) -> Month -> Month
    gmapT :: (forall b. Data b => b -> b) -> Month -> Month
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Month -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Month -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Month -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Month -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Month -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Month -> m Month
    Data,Typeable,Month
    Month -> Month -> Bounded Month
    forall a. a -> a -> Bounded a
    $cminBound :: Month
    minBound :: Month
    $cmaxBound :: Month
    maxBound :: Month
    Bounded)

    -- | Day of the week
    --
    -- the enumeration starts on Sunday.
    data WeekDay =
          Sunday
        | Monday
        | Tuesday
        | Wednesday
        | Thursday
        | Friday
        | Saturday
        deriving (Int -> WeekDay -> ShowS
    [WeekDay] -> ShowS
    WeekDay -> String
    (Int -> WeekDay -> ShowS)
    -> (WeekDay -> String) -> ([WeekDay] -> ShowS) -> Show WeekDay
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WeekDay -> ShowS
    showsPrec :: Int -> WeekDay -> ShowS
    $cshow :: WeekDay -> String
    show :: WeekDay -> String
    $cshowList :: [WeekDay] -> ShowS
    showList :: [WeekDay] -> ShowS
    Show,ReadPrec [WeekDay]
    ReadPrec WeekDay
    Int -> ReadS WeekDay
    ReadS [WeekDay]
    (Int -> ReadS WeekDay)
    -> ReadS [WeekDay]
    -> ReadPrec WeekDay
    -> ReadPrec [WeekDay]
    -> Read WeekDay
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS WeekDay
    readsPrec :: Int -> ReadS WeekDay
    $creadList :: ReadS [WeekDay]
    readList :: ReadS [WeekDay]
    $creadPrec :: ReadPrec WeekDay
    readPrec :: ReadPrec WeekDay
    $creadListPrec :: ReadPrec [WeekDay]
    readListPrec :: ReadPrec [WeekDay]
    Read,WeekDay -> WeekDay -> Bool
    (WeekDay -> WeekDay -> Bool)
    -> (WeekDay -> WeekDay -> Bool) -> Eq WeekDay
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WeekDay -> WeekDay -> Bool
    == :: WeekDay -> WeekDay -> Bool
    $c/= :: WeekDay -> WeekDay -> Bool
    /= :: WeekDay -> WeekDay -> Bool
    Eq,Eq WeekDay
    Eq WeekDay
    -> (WeekDay -> WeekDay -> Ordering)
    -> (WeekDay -> WeekDay -> Bool)
    -> (WeekDay -> WeekDay -> Bool)
    -> (WeekDay -> WeekDay -> Bool)
    -> (WeekDay -> WeekDay -> Bool)
    -> (WeekDay -> WeekDay -> WeekDay)
    -> (WeekDay -> WeekDay -> WeekDay)
    -> Ord WeekDay
    WeekDay -> WeekDay -> Bool
    WeekDay -> WeekDay -> Ordering
    WeekDay -> WeekDay -> WeekDay
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: WeekDay -> WeekDay -> Ordering
    compare :: WeekDay -> WeekDay -> Ordering
    $c< :: WeekDay -> WeekDay -> Bool
    < :: WeekDay -> WeekDay -> Bool
    $c<= :: WeekDay -> WeekDay -> Bool
    <= :: WeekDay -> WeekDay -> Bool
    $c> :: WeekDay -> WeekDay -> Bool
    > :: WeekDay -> WeekDay -> Bool
    $c>= :: WeekDay -> WeekDay -> Bool
    >= :: WeekDay -> WeekDay -> Bool
    $cmax :: WeekDay -> WeekDay -> WeekDay
    max :: WeekDay -> WeekDay -> WeekDay
    $cmin :: WeekDay -> WeekDay -> WeekDay
    min :: WeekDay -> WeekDay -> WeekDay
    Ord,Int -> WeekDay
    WeekDay -> Int
    WeekDay -> [WeekDay]
    WeekDay -> WeekDay
    WeekDay -> WeekDay -> [WeekDay]
    WeekDay -> WeekDay -> WeekDay -> [WeekDay]
    (WeekDay -> WeekDay)
    -> (WeekDay -> WeekDay)
    -> (Int -> WeekDay)
    -> (WeekDay -> Int)
    -> (WeekDay -> [WeekDay])
    -> (WeekDay -> WeekDay -> [WeekDay])
    -> (WeekDay -> WeekDay -> [WeekDay])
    -> (WeekDay -> WeekDay -> WeekDay -> [WeekDay])
    -> Enum WeekDay
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: WeekDay -> WeekDay
    succ :: WeekDay -> WeekDay
    $cpred :: WeekDay -> WeekDay
    pred :: WeekDay -> WeekDay
    $ctoEnum :: Int -> WeekDay
    toEnum :: Int -> WeekDay
    $cfromEnum :: WeekDay -> Int
    fromEnum :: WeekDay -> Int
    $cenumFrom :: WeekDay -> [WeekDay]
    enumFrom :: WeekDay -> [WeekDay]
    $cenumFromThen :: WeekDay -> WeekDay -> [WeekDay]
    enumFromThen :: WeekDay -> WeekDay -> [WeekDay]
    $cenumFromTo :: WeekDay -> WeekDay -> [WeekDay]
    enumFromTo :: WeekDay -> WeekDay -> [WeekDay]
    $cenumFromThenTo :: WeekDay -> WeekDay -> WeekDay -> [WeekDay]
    enumFromThenTo :: WeekDay -> WeekDay -> WeekDay -> [WeekDay]
    Enum,Typeable WeekDay
    Typeable WeekDay
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> WeekDay -> c WeekDay)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c WeekDay)
    -> (WeekDay -> Constr)
    -> (WeekDay -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c WeekDay))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WeekDay))
    -> ((forall b. Data b => b -> b) -> WeekDay -> WeekDay)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> WeekDay -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> WeekDay -> r)
    -> (forall u. (forall d. Data d => d -> u) -> WeekDay -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> WeekDay -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay)
    -> Data WeekDay
    WeekDay -> Constr
    WeekDay -> DataType
    (forall b. Data b => b -> b) -> WeekDay -> WeekDay
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> WeekDay -> u
    forall u. (forall d. Data d => d -> u) -> WeekDay -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WeekDay -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WeekDay -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WeekDay
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WeekDay -> c WeekDay
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WeekDay)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WeekDay)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WeekDay -> c WeekDay
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WeekDay -> c WeekDay
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WeekDay
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WeekDay
    $ctoConstr :: WeekDay -> Constr
    toConstr :: WeekDay -> Constr
    $cdataTypeOf :: WeekDay -> DataType
    dataTypeOf :: WeekDay -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WeekDay)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WeekDay)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WeekDay)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WeekDay)
    $cgmapT :: (forall b. Data b => b -> b) -> WeekDay -> WeekDay
    gmapT :: (forall b. Data b => b -> b) -> WeekDay -> WeekDay
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WeekDay -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WeekDay -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WeekDay -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WeekDay -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> WeekDay -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> WeekDay -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WeekDay -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WeekDay -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WeekDay -> m WeekDay
    Data,Typeable,WeekDay
    WeekDay -> WeekDay -> Bounded WeekDay
    forall a. a -> a -> Bounded a
    $cminBound :: WeekDay
    minBound :: WeekDay
    $cmaxBound :: WeekDay
    maxBound :: WeekDay
    Bounded)

    -- | 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)
    --
    newtype TimezoneOffset = TimezoneOffset
        { TimezoneOffset -> Int
    timezoneOffsetToMinutes :: Int -- ^ return the number of minutes
        } deriving (TimezoneOffset -> TimezoneOffset -> Bool
    (TimezoneOffset -> TimezoneOffset -> Bool)
    -> (TimezoneOffset -> TimezoneOffset -> Bool) -> Eq TimezoneOffset
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TimezoneOffset -> TimezoneOffset -> Bool
    == :: TimezoneOffset -> TimezoneOffset -> Bool
    $c/= :: TimezoneOffset -> TimezoneOffset -> Bool
    /= :: TimezoneOffset -> TimezoneOffset -> Bool
    Eq,Eq TimezoneOffset
    Eq TimezoneOffset
    -> (TimezoneOffset -> TimezoneOffset -> Ordering)
    -> (TimezoneOffset -> TimezoneOffset -> Bool)
    -> (TimezoneOffset -> TimezoneOffset -> Bool)
    -> (TimezoneOffset -> TimezoneOffset -> Bool)
    -> (TimezoneOffset -> TimezoneOffset -> Bool)
    -> (TimezoneOffset -> TimezoneOffset -> TimezoneOffset)
    -> (TimezoneOffset -> TimezoneOffset -> TimezoneOffset)
    -> Ord TimezoneOffset
    TimezoneOffset -> TimezoneOffset -> Bool
    TimezoneOffset -> TimezoneOffset -> Ordering
    TimezoneOffset -> TimezoneOffset -> TimezoneOffset
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: TimezoneOffset -> TimezoneOffset -> Ordering
    compare :: TimezoneOffset -> TimezoneOffset -> Ordering
    $c< :: TimezoneOffset -> TimezoneOffset -> Bool
    < :: TimezoneOffset -> TimezoneOffset -> Bool
    $c<= :: TimezoneOffset -> TimezoneOffset -> Bool
    <= :: TimezoneOffset -> TimezoneOffset -> Bool
    $c> :: TimezoneOffset -> TimezoneOffset -> Bool
    > :: TimezoneOffset -> TimezoneOffset -> Bool
    $c>= :: TimezoneOffset -> TimezoneOffset -> Bool
    >= :: TimezoneOffset -> TimezoneOffset -> Bool
    $cmax :: TimezoneOffset -> TimezoneOffset -> TimezoneOffset
    max :: TimezoneOffset -> TimezoneOffset -> TimezoneOffset
    $cmin :: TimezoneOffset -> TimezoneOffset -> TimezoneOffset
    min :: TimezoneOffset -> TimezoneOffset -> TimezoneOffset
    Ord,Typeable TimezoneOffset
    Typeable TimezoneOffset
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TimezoneOffset -> c TimezoneOffset)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TimezoneOffset)
    -> (TimezoneOffset -> Constr)
    -> (TimezoneOffset -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TimezoneOffset))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c TimezoneOffset))
    -> ((forall b. Data b => b -> b)
        -> TimezoneOffset -> TimezoneOffset)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> TimezoneOffset -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TimezoneOffset -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> TimezoneOffset -> m TimezoneOffset)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> TimezoneOffset -> m TimezoneOffset)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> TimezoneOffset -> m TimezoneOffset)
    -> Data TimezoneOffset
    TimezoneOffset -> Constr
    TimezoneOffset -> DataType
    (forall b. Data b => b -> b) -> TimezoneOffset -> TimezoneOffset
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> TimezoneOffset -> u
    forall u. (forall d. Data d => d -> u) -> TimezoneOffset -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TimezoneOffset
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TimezoneOffset -> c TimezoneOffset
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TimezoneOffset)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TimezoneOffset)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TimezoneOffset -> c TimezoneOffset
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TimezoneOffset -> c TimezoneOffset
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TimezoneOffset
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TimezoneOffset
    $ctoConstr :: TimezoneOffset -> Constr
    toConstr :: TimezoneOffset -> Constr
    $cdataTypeOf :: TimezoneOffset -> DataType
    dataTypeOf :: TimezoneOffset -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TimezoneOffset)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TimezoneOffset)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TimezoneOffset)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TimezoneOffset)
    $cgmapT :: (forall b. Data b => b -> b) -> TimezoneOffset -> TimezoneOffset
    gmapT :: (forall b. Data b => b -> b) -> TimezoneOffset -> TimezoneOffset
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TimezoneOffset -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TimezoneOffset -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TimezoneOffset -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> TimezoneOffset -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> TimezoneOffset -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TimezoneOffset -> m TimezoneOffset
    Data,Typeable,TimezoneOffset -> ()
    (TimezoneOffset -> ()) -> NFData TimezoneOffset
    forall a. (a -> ()) -> NFData a
    $crnf :: TimezoneOffset -> ()
    rnf :: TimezoneOffset -> ()
    NFData)

    -- | Return the number of seconds associated with a timezone
    timezoneOffsetToSeconds :: TimezoneOffset -> Seconds
    timezoneOffsetToSeconds :: TimezoneOffset -> Seconds
    timezoneOffsetToSeconds (TimezoneOffset Int
    ofs) = Int64 -> Seconds
    Seconds (Int -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    ofs Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    * Int64
    60)

    instance Show TimezoneOffset where
        show :: TimezoneOffset -> String
    show (TimezoneOffset Int
    tz) =
            [String] -> String
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [if Int
    tz Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    0 then String
    "-" else String
    "+", Int -> String
    forall a. (Show a, Ord a, Num a, Integral a) => a -> String
    pad2 Int
    tzH, Int -> String
    forall a. (Show a, Ord a, Num a, Integral a) => a -> String
    pad2 Int
    tzM]
          where (Int
    tzH, Int
    tzM) = Int -> Int
    forall a. Num a => a -> a
    abs Int
    tz Int -> Int -> (Int, Int)
    forall a. Integral a => a -> a -> (a, a)
    `divMod` Int
    60

    -- | The UTC timezone. offset of 0
    timezone_UTC :: TimezoneOffset
    timezone_UTC :: TimezoneOffset
    timezone_UTC = Int -> TimezoneOffset
    TimezoneOffset Int
    0

    -- | human date representation using common calendar
    data Date = Date
        { Date -> Int
    dateYear  :: {-# UNPACK #-} !Int   -- ^ year (Common Era)
        , Date -> Month
    dateMonth :: !Month                -- ^ month of the year
        , Date -> Int
    dateDay   :: {-# UNPACK #-} !Int   -- ^ day of the month, between 1 to 31
        } deriving (Int -> Date -> ShowS
    [Date] -> ShowS
    Date -> String
    (Int -> Date -> ShowS)
    -> (Date -> String) -> ([Date] -> ShowS) -> Show Date
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Date -> ShowS
    showsPrec :: Int -> Date -> ShowS
    $cshow :: Date -> String
    show :: Date -> String
    $cshowList :: [Date] -> ShowS
    showList :: [Date] -> ShowS
    Show,ReadPrec [Date]
    ReadPrec Date
    Int -> ReadS Date
    ReadS [Date]
    (Int -> ReadS Date)
    -> ReadS [Date] -> ReadPrec Date -> ReadPrec [Date] -> Read Date
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Date
    readsPrec :: Int -> ReadS Date
    $creadList :: ReadS [Date]
    readList :: ReadS [Date]
    $creadPrec :: ReadPrec Date
    readPrec :: ReadPrec Date
    $creadListPrec :: ReadPrec [Date]
    readListPrec :: ReadPrec [Date]
    Read,Date -> Date -> Bool
    (Date -> Date -> Bool) -> (Date -> Date -> Bool) -> Eq Date
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Date -> Date -> Bool
    == :: Date -> Date -> Bool
    $c/= :: Date -> Date -> Bool
    /= :: Date -> Date -> Bool
    Eq,Eq Date
    Eq Date
    -> (Date -> Date -> Ordering)
    -> (Date -> Date -> Bool)
    -> (Date -> Date -> Bool)
    -> (Date -> Date -> Bool)
    -> (Date -> Date -> Bool)
    -> (Date -> Date -> Date)
    -> (Date -> Date -> Date)
    -> Ord Date
    Date -> Date -> Bool
    Date -> Date -> Ordering
    Date -> Date -> Date
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Date -> Date -> Ordering
    compare :: Date -> Date -> Ordering
    $c< :: Date -> Date -> Bool
    < :: Date -> Date -> Bool
    $c<= :: Date -> Date -> Bool
    <= :: Date -> Date -> Bool
    $c> :: Date -> Date -> Bool
    > :: Date -> Date -> Bool
    $c>= :: Date -> Date -> Bool
    >= :: Date -> Date -> Bool
    $cmax :: Date -> Date -> Date
    max :: Date -> Date -> Date
    $cmin :: Date -> Date -> Date
    min :: Date -> Date -> Date
    Ord,Typeable Date
    Typeable Date
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> Date -> c Date)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Date)
    -> (Date -> Constr)
    -> (Date -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Date))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Date))
    -> ((forall b. Data b => b -> b) -> Date -> Date)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Date -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Date -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Date -> m Date)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Date -> m Date)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Date -> m Date)
    -> Data Date
    Date -> Constr
    Date -> DataType
    (forall b. Data b => b -> b) -> Date -> Date
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Date -> u
    forall u. (forall d. Data d => d -> u) -> Date -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Date
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Date -> c Date
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Date)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Date)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Date -> c Date
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Date -> c Date
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Date
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Date
    $ctoConstr :: Date -> Constr
    toConstr :: Date -> Constr
    $cdataTypeOf :: Date -> DataType
    dataTypeOf :: Date -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Date)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Date)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Date)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Date)
    $cgmapT :: (forall b. Data b => b -> b) -> Date -> Date
    gmapT :: (forall b. Data b => b -> b) -> Date -> Date
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Date -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Date -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Date -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Date -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Date -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Date -> m Date
    Data,Typeable)

    instance NFData Date where
        rnf :: Date -> ()
    rnf (Date Int
    y Month
    m Int
    d) = Int
    y Int -> () -> ()
    forall a b. a -> b -> b
    `seq` Month
    m Month -> () -> ()
    forall a b. a -> b -> b
    `seq` Int
    d Int -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | human time representation of hour, minutes, seconds in a day.
    data TimeOfDay = TimeOfDay
        { TimeOfDay -> Hours
    todHour :: {-# UNPACK #-} !Hours   -- ^ hours, between 0 and 23
        , TimeOfDay -> Minutes
    todMin  :: {-# UNPACK #-} !Minutes -- ^ minutes, between 0 and 59
        , TimeOfDay -> Seconds
    todSec  :: {-# UNPACK #-} !Seconds -- ^ seconds, between 0 and 59. 60 when having leap second */
        , TimeOfDay -> NanoSeconds
    todNSec :: {-# UNPACK #-} !NanoSeconds -- ^ nanoseconds, between 0 and 999999999 */
        } deriving (Int -> TimeOfDay -> ShowS
    [TimeOfDay] -> ShowS
    TimeOfDay -> String
    (Int -> TimeOfDay -> ShowS)
    -> (TimeOfDay -> String)
    -> ([TimeOfDay] -> ShowS)
    -> Show TimeOfDay
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TimeOfDay -> ShowS
    showsPrec :: Int -> TimeOfDay -> ShowS
    $cshow :: TimeOfDay -> String
    show :: TimeOfDay -> String
    $cshowList :: [TimeOfDay] -> ShowS
    showList :: [TimeOfDay] -> ShowS
    Show,ReadPrec [TimeOfDay]
    ReadPrec TimeOfDay
    Int -> ReadS TimeOfDay
    ReadS [TimeOfDay]
    (Int -> ReadS TimeOfDay)
    -> ReadS [TimeOfDay]
    -> ReadPrec TimeOfDay
    -> ReadPrec [TimeOfDay]
    -> Read TimeOfDay
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS TimeOfDay
    readsPrec :: Int -> ReadS TimeOfDay
    $creadList :: ReadS [TimeOfDay]
    readList :: ReadS [TimeOfDay]
    $creadPrec :: ReadPrec TimeOfDay
    readPrec :: ReadPrec TimeOfDay
    $creadListPrec :: ReadPrec [TimeOfDay]
    readListPrec :: ReadPrec [TimeOfDay]
    Read,TimeOfDay -> TimeOfDay -> Bool
    (TimeOfDay -> TimeOfDay -> Bool)
    -> (TimeOfDay -> TimeOfDay -> Bool) -> Eq TimeOfDay
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TimeOfDay -> TimeOfDay -> Bool
    == :: TimeOfDay -> TimeOfDay -> Bool
    $c/= :: TimeOfDay -> TimeOfDay -> Bool
    /= :: TimeOfDay -> TimeOfDay -> Bool
    Eq,Eq TimeOfDay
    Eq TimeOfDay
    -> (TimeOfDay -> TimeOfDay -> Ordering)
    -> (TimeOfDay -> TimeOfDay -> Bool)
    -> (TimeOfDay -> TimeOfDay -> Bool)
    -> (TimeOfDay -> TimeOfDay -> Bool)
    -> (TimeOfDay -> TimeOfDay -> Bool)
    -> (TimeOfDay -> TimeOfDay -> TimeOfDay)
    -> (TimeOfDay -> TimeOfDay -> TimeOfDay)
    -> Ord TimeOfDay
    TimeOfDay -> TimeOfDay -> Bool
    TimeOfDay -> TimeOfDay -> Ordering
    TimeOfDay -> TimeOfDay -> TimeOfDay
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: TimeOfDay -> TimeOfDay -> Ordering
    compare :: TimeOfDay -> TimeOfDay -> Ordering
    $c< :: TimeOfDay -> TimeOfDay -> Bool
    < :: TimeOfDay -> TimeOfDay -> Bool
    $c<= :: TimeOfDay -> TimeOfDay -> Bool
    <= :: TimeOfDay -> TimeOfDay -> Bool
    $c> :: TimeOfDay -> TimeOfDay -> Bool
    > :: TimeOfDay -> TimeOfDay -> Bool
    $c>= :: TimeOfDay -> TimeOfDay -> Bool
    >= :: TimeOfDay -> TimeOfDay -> Bool
    $cmax :: TimeOfDay -> TimeOfDay -> TimeOfDay
    max :: TimeOfDay -> TimeOfDay -> TimeOfDay
    $cmin :: TimeOfDay -> TimeOfDay -> TimeOfDay
    min :: TimeOfDay -> TimeOfDay -> TimeOfDay
    Ord,Typeable TimeOfDay
    Typeable TimeOfDay
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> TimeOfDay -> c TimeOfDay)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c TimeOfDay)
    -> (TimeOfDay -> Constr)
    -> (TimeOfDay -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c TimeOfDay))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeOfDay))
    -> ((forall b. Data b => b -> b) -> TimeOfDay -> TimeOfDay)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r)
    -> (forall u. (forall d. Data d => d -> u) -> TimeOfDay -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> TimeOfDay -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay)
    -> Data TimeOfDay
    TimeOfDay -> Constr
    TimeOfDay -> DataType
    (forall b. Data b => b -> b) -> TimeOfDay -> TimeOfDay
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> TimeOfDay -> u
    forall u. (forall d. Data d => d -> u) -> TimeOfDay -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TimeOfDay
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TimeOfDay -> c TimeOfDay
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TimeOfDay)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeOfDay)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TimeOfDay -> c TimeOfDay
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TimeOfDay -> c TimeOfDay
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TimeOfDay
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TimeOfDay
    $ctoConstr :: TimeOfDay -> Constr
    toConstr :: TimeOfDay -> Constr
    $cdataTypeOf :: TimeOfDay -> DataType
    dataTypeOf :: TimeOfDay -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TimeOfDay)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TimeOfDay)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeOfDay)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TimeOfDay)
    $cgmapT :: (forall b. Data b => b -> b) -> TimeOfDay -> TimeOfDay
    gmapT :: (forall b. Data b => b -> b) -> TimeOfDay -> TimeOfDay
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TimeOfDay -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> TimeOfDay -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> TimeOfDay -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TimeOfDay -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TimeOfDay -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TimeOfDay -> m TimeOfDay
    Data,Typeable)

    instance NFData TimeOfDay where
        rnf :: TimeOfDay -> ()
    rnf (TimeOfDay Hours
    h Minutes
    m Seconds
    s NanoSeconds
    ns) = Hours
    h Hours -> () -> ()
    forall a b. a -> b -> b
    `seq` Minutes
    m Minutes -> () -> ()
    forall a b. a -> b -> b
    `seq` Seconds
    s Seconds -> () -> ()
    forall a b. a -> b -> b
    `seq` NanoSeconds
    ns NanoSeconds -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Date and Time
    data DateTime = DateTime
        { DateTime -> Date
    dtDate :: Date
        , DateTime -> TimeOfDay
    dtTime :: TimeOfDay
        } deriving (Int -> DateTime -> ShowS
    [DateTime] -> ShowS
    DateTime -> String
    (Int -> DateTime -> ShowS)
    -> (DateTime -> String) -> ([DateTime] -> ShowS) -> Show DateTime
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DateTime -> ShowS
    showsPrec :: Int -> DateTime -> ShowS
    $cshow :: DateTime -> String
    show :: DateTime -> String
    $cshowList :: [DateTime] -> ShowS
    showList :: [DateTime] -> ShowS
    Show,ReadPrec [DateTime]
    ReadPrec DateTime
    Int -> ReadS DateTime
    ReadS [DateTime]
    (Int -> ReadS DateTime)
    -> ReadS [DateTime]
    -> ReadPrec DateTime
    -> ReadPrec [DateTime]
    -> Read DateTime
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS DateTime
    readsPrec :: Int -> ReadS DateTime
    $creadList :: ReadS [DateTime]
    readList :: ReadS [DateTime]
    $creadPrec :: ReadPrec DateTime
    readPrec :: ReadPrec DateTime
    $creadListPrec :: ReadPrec [DateTime]
    readListPrec :: ReadPrec [DateTime]
    Read,DateTime -> DateTime -> Bool
    (DateTime -> DateTime -> Bool)
    -> (DateTime -> DateTime -> Bool) -> Eq DateTime
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DateTime -> DateTime -> Bool
    == :: DateTime -> DateTime -> Bool
    $c/= :: DateTime -> DateTime -> Bool
    /= :: DateTime -> DateTime -> Bool
    Eq,Eq DateTime
    Eq DateTime
    -> (DateTime -> DateTime -> Ordering)
    -> (DateTime -> DateTime -> Bool)
    -> (DateTime -> DateTime -> Bool)
    -> (DateTime -> DateTime -> Bool)
    -> (DateTime -> DateTime -> Bool)
    -> (DateTime -> DateTime -> DateTime)
    -> (DateTime -> DateTime -> DateTime)
    -> Ord DateTime
    DateTime -> DateTime -> Bool
    DateTime -> DateTime -> Ordering
    DateTime -> DateTime -> DateTime
    forall a.
    Eq a
    -> (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: DateTime -> DateTime -> Ordering
    compare :: DateTime -> DateTime -> Ordering
    $c< :: DateTime -> DateTime -> Bool
    < :: DateTime -> DateTime -> Bool
    $c<= :: DateTime -> DateTime -> Bool
    <= :: DateTime -> DateTime -> Bool
    $c> :: DateTime -> DateTime -> Bool
    > :: DateTime -> DateTime -> Bool
    $c>= :: DateTime -> DateTime -> Bool
    >= :: DateTime -> DateTime -> Bool
    $cmax :: DateTime -> DateTime -> DateTime
    max :: DateTime -> DateTime -> DateTime
    $cmin :: DateTime -> DateTime -> DateTime
    min :: DateTime -> DateTime -> DateTime
    Ord,Typeable DateTime
    Typeable DateTime
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> DateTime -> c DateTime)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DateTime)
    -> (DateTime -> Constr)
    -> (DateTime -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DateTime))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateTime))
    -> ((forall b. Data b => b -> b) -> DateTime -> DateTime)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DateTime -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DateTime -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DateTime -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DateTime -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DateTime -> m DateTime)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DateTime -> m DateTime)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DateTime -> m DateTime)
    -> Data DateTime
    DateTime -> Constr
    DateTime -> DataType
    (forall b. Data b => b -> b) -> DateTime -> DateTime
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> DateTime -> u
    forall u. (forall d. Data d => d -> u) -> DateTime -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DateTime -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DateTime -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DateTime
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DateTime -> c DateTime
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DateTime)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateTime)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DateTime -> c DateTime
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DateTime -> c DateTime
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DateTime
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DateTime
    $ctoConstr :: DateTime -> Constr
    toConstr :: DateTime -> Constr
    $cdataTypeOf :: DateTime -> DataType
    dataTypeOf :: DateTime -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DateTime)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DateTime)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateTime)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateTime)
    $cgmapT :: (forall b. Data b => b -> b) -> DateTime -> DateTime
    gmapT :: (forall b. Data b => b -> b) -> DateTime -> DateTime
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DateTime -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DateTime -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DateTime -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DateTime -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DateTime -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DateTime -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DateTime -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DateTime -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateTime -> m DateTime
    Data,Typeable)

    instance NFData DateTime where
        rnf :: DateTime -> ()
    rnf (DateTime Date
    d TimeOfDay
    t) = Date -> ()
    forall a. NFData a => a -> ()
    rnf Date
    d () -> () -> ()
    forall a b. a -> b -> b
    `seq` TimeOfDay -> ()
    forall a. NFData a => a -> ()
    rnf TimeOfDay
    t () -> () -> ()
    forall a b. a -> b -> b
    `seq` ()