{-# LANGUAGE Trustworthy #-}

module Data.Time.Clock.Internal.NominalDiffTime (
    NominalDiffTime,
    secondsToNominalDiffTime,
    nominalDiffTimeToSeconds,
    nominalDay,
) where

import Control.DeepSeq
import Data.Data
import Data.Fixed
import GHC.Read
import Text.ParserCombinators.ReadP
import Text.ParserCombinators.ReadPrec

-- | This is a length of time, as measured by UTC.
-- It has a precision of 10^-12 s.
--
-- Conversion functions such as 'fromInteger' and 'realToFrac' will treat it as seconds.
-- For example, @(0.010 :: NominalDiffTime)@ corresponds to 10 milliseconds.
--
-- It has a precision of one picosecond (= 10^-12 s). Enumeration functions will treat it as picoseconds.
--
-- It ignores leap-seconds, so it's not necessarily a fixed amount of clock time.
-- For instance, 23:00 UTC + 2 hours of NominalDiffTime = 01:00 UTC (+ 1 day),
-- regardless of whether a leap-second intervened.
newtype NominalDiffTime
    = MkNominalDiffTime Pico
    deriving (NominalDiffTime -> NominalDiffTime -> Bool
(NominalDiffTime -> NominalDiffTime -> Bool)
-> (NominalDiffTime -> NominalDiffTime -> Bool)
-> Eq NominalDiffTime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NominalDiffTime -> NominalDiffTime -> Bool
== :: NominalDiffTime -> NominalDiffTime -> Bool
$c/= :: NominalDiffTime -> NominalDiffTime -> Bool
/= :: NominalDiffTime -> NominalDiffTime -> Bool
Eq, Eq NominalDiffTime
Eq NominalDiffTime =>
(NominalDiffTime -> NominalDiffTime -> Ordering)
-> (NominalDiffTime -> NominalDiffTime -> Bool)
-> (NominalDiffTime -> NominalDiffTime -> Bool)
-> (NominalDiffTime -> NominalDiffTime -> Bool)
-> (NominalDiffTime -> NominalDiffTime -> Bool)
-> (NominalDiffTime -> NominalDiffTime -> NominalDiffTime)
-> (NominalDiffTime -> NominalDiffTime -> NominalDiffTime)
-> Ord NominalDiffTime
NominalDiffTime -> NominalDiffTime -> Bool
NominalDiffTime -> NominalDiffTime -> Ordering
NominalDiffTime -> NominalDiffTime -> NominalDiffTime
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 :: NominalDiffTime -> NominalDiffTime -> Ordering
compare :: NominalDiffTime -> NominalDiffTime -> Ordering
$c< :: NominalDiffTime -> NominalDiffTime -> Bool
< :: NominalDiffTime -> NominalDiffTime -> Bool
$c<= :: NominalDiffTime -> NominalDiffTime -> Bool
<= :: NominalDiffTime -> NominalDiffTime -> Bool
$c> :: NominalDiffTime -> NominalDiffTime -> Bool
> :: NominalDiffTime -> NominalDiffTime -> Bool
$c>= :: NominalDiffTime -> NominalDiffTime -> Bool
>= :: NominalDiffTime -> NominalDiffTime -> Bool
$cmax :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
$cmin :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
Ord, Typeable NominalDiffTime
Typeable NominalDiffTime =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NominalDiffTime)
-> (NominalDiffTime -> Constr)
-> (NominalDiffTime -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NominalDiffTime))
-> ((forall b. Data b => b -> b)
    -> NominalDiffTime -> NominalDiffTime)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> NominalDiffTime -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NominalDiffTime -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NominalDiffTime -> m NominalDiffTime)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NominalDiffTime -> m NominalDiffTime)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NominalDiffTime -> m NominalDiffTime)
-> Data NominalDiffTime
NominalDiffTime -> Constr
NominalDiffTime -> DataType
(forall b. Data b => b -> b) -> NominalDiffTime -> NominalDiffTime
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) -> NominalDiffTime -> u
forall u. (forall d. Data d => d -> u) -> NominalDiffTime -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NominalDiffTime
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NominalDiffTime)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NominalDiffTime
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NominalDiffTime
$ctoConstr :: NominalDiffTime -> Constr
toConstr :: NominalDiffTime -> Constr
$cdataTypeOf :: NominalDiffTime -> DataType
dataTypeOf :: NominalDiffTime -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NominalDiffTime)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NominalDiffTime)
$cgmapT :: (forall b. Data b => b -> b) -> NominalDiffTime -> NominalDiffTime
gmapT :: (forall b. Data b => b -> b) -> NominalDiffTime -> NominalDiffTime
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NominalDiffTime -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NominalDiffTime -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NominalDiffTime -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NominalDiffTime -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NominalDiffTime -> m NominalDiffTime
Data, Typeable)

-- | Create a 'NominalDiffTime' from a number of seconds.
--
-- @since 1.9.1
secondsToNominalDiffTime :: Pico -> NominalDiffTime
secondsToNominalDiffTime :: Pico -> NominalDiffTime
secondsToNominalDiffTime = Pico -> NominalDiffTime
MkNominalDiffTime

-- | Get the seconds in a 'NominalDiffTime'.
--
-- @since 1.9.1
nominalDiffTimeToSeconds :: NominalDiffTime -> Pico
nominalDiffTimeToSeconds :: NominalDiffTime -> Pico
nominalDiffTimeToSeconds (MkNominalDiffTime Pico
t) = Pico
t

instance NFData NominalDiffTime where
    rnf :: NominalDiffTime -> ()
rnf (MkNominalDiffTime Pico
t) = Pico -> ()
forall a. NFData a => a -> ()
rnf Pico
t

instance Enum NominalDiffTime where
    succ :: NominalDiffTime -> NominalDiffTime
succ (MkNominalDiffTime Pico
a) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico
forall a. Enum a => a -> a
succ Pico
a)
    pred :: NominalDiffTime -> NominalDiffTime
pred (MkNominalDiffTime Pico
a) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico
forall a. Enum a => a -> a
pred Pico
a)
    toEnum :: Int -> NominalDiffTime
toEnum = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> NominalDiffTime)
-> (Int -> Pico) -> Int -> NominalDiffTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Pico
forall a. Enum a => Int -> a
toEnum
    fromEnum :: NominalDiffTime -> Int
fromEnum (MkNominalDiffTime Pico
a) = Pico -> Int
forall a. Enum a => a -> Int
fromEnum Pico
a
    enumFrom :: NominalDiffTime -> [NominalDiffTime]
enumFrom (MkNominalDiffTime Pico
a) = (Pico -> NominalDiffTime) -> [Pico] -> [NominalDiffTime]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> [Pico]
forall a. Enum a => a -> [a]
enumFrom Pico
a)
    enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]
enumFromThen (MkNominalDiffTime Pico
a) (MkNominalDiffTime Pico
b) = (Pico -> NominalDiffTime) -> [Pico] -> [NominalDiffTime]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico -> [Pico]
forall a. Enum a => a -> a -> [a]
enumFromThen Pico
a Pico
b)
    enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]
enumFromTo (MkNominalDiffTime Pico
a) (MkNominalDiffTime Pico
b) = (Pico -> NominalDiffTime) -> [Pico] -> [NominalDiffTime]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico -> [Pico]
forall a. Enum a => a -> a -> [a]
enumFromTo Pico
a Pico
b)
    enumFromThenTo :: NominalDiffTime
-> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime]
enumFromThenTo (MkNominalDiffTime Pico
a) (MkNominalDiffTime Pico
b) (MkNominalDiffTime Pico
c) =
        (Pico -> NominalDiffTime) -> [Pico] -> [NominalDiffTime]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico -> Pico -> [Pico]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Pico
a Pico
b Pico
c)

instance Show NominalDiffTime where
    show :: NominalDiffTime -> String
show (MkNominalDiffTime Pico
t) = (Bool -> Pico -> String
forall {k} (a :: k). HasResolution a => Bool -> Fixed a -> String
showFixed Bool
True Pico
t) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"s"

instance Read NominalDiffTime where
    readPrec :: ReadPrec NominalDiffTime
readPrec = do
        Pico
t <- ReadPrec Pico
forall a. Read a => ReadPrec a
readPrec
        Char
_ <- ReadP Char -> ReadPrec Char
forall a. ReadP a -> ReadPrec a
lift (ReadP Char -> ReadPrec Char) -> ReadP Char -> ReadPrec Char
forall a b. (a -> b) -> a -> b
$ Char -> ReadP Char
char Char
's'
        NominalDiffTime -> ReadPrec NominalDiffTime
forall a. a -> ReadPrec a
forall (m :: * -> *) a. Monad m => a -> m a
return (NominalDiffTime -> ReadPrec NominalDiffTime)
-> NominalDiffTime -> ReadPrec NominalDiffTime
forall a b. (a -> b) -> a -> b
$ Pico -> NominalDiffTime
MkNominalDiffTime Pico
t

instance Num NominalDiffTime where
    (MkNominalDiffTime Pico
a) + :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
+ (MkNominalDiffTime Pico
b) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico
a Pico -> Pico -> Pico
forall a. Num a => a -> a -> a
+ Pico
b)
    (MkNominalDiffTime Pico
a) - :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
- (MkNominalDiffTime Pico
b) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico
a Pico -> Pico -> Pico
forall a. Num a => a -> a -> a
- Pico
b)
    (MkNominalDiffTime Pico
a) * :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
* (MkNominalDiffTime Pico
b) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico
a Pico -> Pico -> Pico
forall a. Num a => a -> a -> a
* Pico
b)
    negate :: NominalDiffTime -> NominalDiffTime
negate (MkNominalDiffTime Pico
a) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico
forall a. Num a => a -> a
negate Pico
a)
    abs :: NominalDiffTime -> NominalDiffTime
abs (MkNominalDiffTime Pico
a) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico
forall a. Num a => a -> a
abs Pico
a)
    signum :: NominalDiffTime -> NominalDiffTime
signum (MkNominalDiffTime Pico
a) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico
forall a. Num a => a -> a
signum Pico
a)
    fromInteger :: Integer -> NominalDiffTime
fromInteger Integer
i = Pico -> NominalDiffTime
MkNominalDiffTime (Integer -> Pico
forall a. Num a => Integer -> a
fromInteger Integer
i)

instance Real NominalDiffTime where
    toRational :: NominalDiffTime -> Rational
toRational (MkNominalDiffTime Pico
a) = Pico -> Rational
forall a. Real a => a -> Rational
toRational Pico
a

instance Fractional NominalDiffTime where
    (MkNominalDiffTime Pico
a) / :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime
/ (MkNominalDiffTime Pico
b) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico
a Pico -> Pico -> Pico
forall a. Fractional a => a -> a -> a
/ Pico
b)
    recip :: NominalDiffTime -> NominalDiffTime
recip (MkNominalDiffTime Pico
a) = Pico -> NominalDiffTime
MkNominalDiffTime (Pico -> Pico
forall a. Fractional a => a -> a
recip Pico
a)
    fromRational :: Rational -> NominalDiffTime
fromRational Rational
r = Pico -> NominalDiffTime
MkNominalDiffTime (Rational -> Pico
forall a. Fractional a => Rational -> a
fromRational Rational
r)

instance RealFrac NominalDiffTime where
    properFraction :: forall b. Integral b => NominalDiffTime -> (b, NominalDiffTime)
properFraction (MkNominalDiffTime Pico
a) = (b
i, Pico -> NominalDiffTime
MkNominalDiffTime Pico
f)
      where
        (b
i, Pico
f) = Pico -> (b, Pico)
forall b. Integral b => Pico -> (b, Pico)
forall a b. (RealFrac a, Integral b) => a -> (b, a)
properFraction Pico
a
    truncate :: forall b. Integral b => NominalDiffTime -> b
truncate (MkNominalDiffTime Pico
a) = Pico -> b
forall b. Integral b => Pico -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate Pico
a
    round :: forall b. Integral b => NominalDiffTime -> b
round (MkNominalDiffTime Pico
a) = Pico -> b
forall b. Integral b => Pico -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Pico
a
    ceiling :: forall b. Integral b => NominalDiffTime -> b
ceiling (MkNominalDiffTime Pico
a) = Pico -> b
forall b. Integral b => Pico -> b
forall a b. (RealFrac a, Integral b) => a -> b
ceiling Pico
a
    floor :: forall b. Integral b => NominalDiffTime -> b
floor (MkNominalDiffTime Pico
a) = Pico -> b
forall b. Integral b => Pico -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor Pico
a

{-# RULES
"realToFrac/DiffTime->NominalDiffTime"
    realToFrac =
        \dt -> MkNominalDiffTime (realToFrac dt)
"realToFrac/NominalDiffTime->DiffTime"
    realToFrac =
        \(MkNominalDiffTime ps) -> realToFrac ps
"realToFrac/NominalDiffTime->Pico"
    realToFrac =
        \(MkNominalDiffTime ps) -> ps
"realToFrac/Pico->NominalDiffTime" realToFrac = MkNominalDiffTime
    #-}

-- | One day in 'NominalDiffTime'.
nominalDay :: NominalDiffTime
nominalDay :: NominalDiffTime
nominalDay = NominalDiffTime
86400