{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

{- |
Module      : Time.Types
License     : BSD-style
Copyright   : (c) 2014 Vincent Hanquez <vincent@snarc.org>

Time-related types.

In principle, some units could hold infinite values. In practice, 'Int64' for
seconds (about @+/- 9e18@) and 'Int' for years is sufficient.
-}

module Time.Types
  ( -- * Time units

    NanoSeconds (..)
  , Seconds (..)
  , Minutes (..)
  , Hours (..)
    -- * Calendar enumerations

  , Month (..)
  , WeekDay (..)
    -- * Points in time

    -- ** Elapsed time since the start of the Unix epoch

  , Elapsed (..)
  , ElapsedP (..)
    -- ** Date, time, and date and time

  , Date (..)
  , TimeOfDay (..)
  , DateTime (..)
    -- ** Local time and timezone-related

  , TimezoneOffset (..)
  , timezoneOffsetToSeconds
  , timezone_UTC
    -- * Conversion of periods of time

  , TimeInterval (..)
  ) where

import           Control.DeepSeq ( NFData (..) )
import           Data.Data ( Data )
import           Data.Int ( Int64 )
import           Data.Ratio ( (%) )
import           Time.Utils ( pad2 )

-- | Type class promising functionality for:

--

-- * converting a value of the type in question to a number of seconds; and

--

-- * converting a t'Seconds' value to a pair of a value of the type in question

--   and a remaining number of seconds.

class TimeInterval i where
  -- | For the given value, yield a corresponding number of seconds.

  toSeconds   :: i -> Seconds

  -- | For the given number of seconds, yield a pair of the corresponding value

  -- of the type in queston and a remaining number of seconds.

  fromSeconds :: Seconds -> (i, Seconds)

-- | Type representing numbers of nanoseconds.

newtype NanoSeconds = NanoSeconds Int64
  deriving (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, 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, NanoSeconds -> ()
(NanoSeconds -> ()) -> NFData NanoSeconds
forall a. (a -> ()) -> NFData a
$crnf :: NanoSeconds -> ()
rnf :: NanoSeconds -> ()
NFData, 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, 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, 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)

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)

-- | Type representing numbers of seconds.

newtype Seconds = Seconds Int64
  deriving (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, 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, 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, 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, Seconds -> ()
(Seconds -> ()) -> NFData Seconds
forall a. (a -> ()) -> NFData a
$crnf :: Seconds -> ()
rnf :: Seconds -> ()
NFData, 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, 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, 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, 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)

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)

-- | Type representing numbers of minutes.

newtype Minutes = Minutes Int64
  deriving (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, 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, 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, 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, Minutes -> ()
(Minutes -> ()) -> NFData Minutes
forall a. (a -> ()) -> NFData a
$crnf :: Minutes -> ()
rnf :: Minutes -> ()
NFData, 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, 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, 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, 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)

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

-- | Type representing numbers of hours.

newtype Hours = Hours Int64
  deriving (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, 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, 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, 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, Hours -> ()
(Hours -> ()) -> NFData Hours
forall a. (a -> ()) -> NFData a
$crnf :: Hours -> ()
rnf :: Hours -> ()
NFData, 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, 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, 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, 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)

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

-- | Type representing numbers of seconds elapsed since the start of the Unix

-- epoch (1970-01-01 00:00:00 UTC).

newtype Elapsed = Elapsed Seconds
  deriving (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, 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, Elapsed -> ()
(Elapsed -> ()) -> NFData Elapsed
forall a. (a -> ()) -> NFData a
$crnf :: Elapsed -> ()
rnf :: Elapsed -> ()
NFData, 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, 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, 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)

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

-- | Type representing numbers of seconds and nanoseconds elapsed since the

-- start of the Unix epoch (1970-01-01 00:00:00 UTC).

data ElapsedP = ElapsedP {-# UNPACK #-} !Elapsed {-# UNPACK #-} !NanoSeconds
  deriving (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, 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, 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)

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

-- | Type representing months of the Julian or Gregorian year.

data Month =
    January
  | February
  | March
  | April
  | May
  | June
  | July
  | August
  | September
  | October
  | November
  | December
  deriving (Month
Month -> Month -> Bounded Month
forall a. a -> a -> Bounded a
$cminBound :: Month
minBound :: Month
$cmaxBound :: Month
maxBound :: Month
Bounded, 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, 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, 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, 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, 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, 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)

-- | Type representing days of the week. The enumeration starts on Sunday.

data WeekDay =
    Sunday
  | Monday
  | Tuesday
  | Wednesday
  | Thursday
  | Friday
  | Saturday
  deriving (WeekDay
WeekDay -> WeekDay -> Bounded WeekDay
forall a. a -> a -> Bounded a
$cminBound :: WeekDay
minBound :: WeekDay
$cmaxBound :: WeekDay
maxBound :: WeekDay
Bounded, 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, 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, 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, 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, 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, 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)

-- | Type representing offsets in minutes against UTC to obtain local time from

-- UTC. A positive number represents a location east of where UTC is local time

-- and a negative number represents a location west of where UTC is local time.

--

-- LocalTime t (-300) -- t represents a time at UTC-5

--

-- LocalTime t (+480) -- t represents a time at UTC+8

--

-- Should be between @(-12 * 60)@ and @(+14 * 60)@.

--

-- For example, in timezone AEDT (Australian Eastern Daylight Time) (UTC+11),

-- local time is 15:47. Consequently, UTC time is 04:47 and the timezone offset

-- is v'TimezoneOffset' @660@ (in minutes).

newtype TimezoneOffset = TimezoneOffset
  { TimezoneOffset -> Int
timezoneOffsetToMinutes :: Int -- ^ The number of minutes.

  }
  deriving (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, 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, TimezoneOffset -> ()
(TimezoneOffset -> ()) -> NFData TimezoneOffset
forall a. (a -> ()) -> NFData a
$crnf :: TimezoneOffset -> ()
rnf :: TimezoneOffset -> ()
NFData, 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)

-- | For the given timezone offset, yield the corresponding number of seconds.

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.

--

-- > timezoneOffsetToMinutes timezone_UTC == 0 -- True

timezone_UTC :: TimezoneOffset
timezone_UTC :: TimezoneOffset
timezone_UTC = Int -> TimezoneOffset
TimezoneOffset Int
0

-- | Type representing dates in the proleptic Gregorian calendar (the common

-- calendar).

data Date = Date
  { Date -> Int
dateYear  :: {-# UNPACK #-} !Int
    -- ^ Year of the Common Era.

  , Date -> Month
dateMonth :: !Month
    -- ^ Month of the year.

  , Date -> Int
dateDay   :: {-# UNPACK #-} !Int
    -- ^ Day of the month, between 1 to 31.

  }
  deriving (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, 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, 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, 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)

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` ()

-- | Type representing times as hour, minutes, seconds and nanoseconds.

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 (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, 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, 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, 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)

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` ()

-- | Type representing date and time.

data DateTime = DateTime
  { DateTime -> Date
dtDate :: Date
  , DateTime -> TimeOfDay
dtTime :: TimeOfDay
  }
  deriving (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, 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, 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, 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)

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