{-# LANGUAGE CPP              #-}
{-# LANGUAGE FlexibleContexts #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Test.QuickCheck.Instances.Time () where

import Prelude ()
import Test.QuickCheck.Instances.CustomPrelude

import Test.QuickCheck

import qualified Data.Time.Calendar.Compat         as Time
import qualified Data.Time.Calendar.Month.Compat   as Time
import qualified Data.Time.Calendar.Quarter.Compat as Time
import qualified Data.Time.Clock.Compat            as Time
import qualified Data.Time.Clock.System.Compat     as Time
import qualified Data.Time.Clock.TAI.Compat        as Time
import qualified Data.Time.LocalTime.Compat        as Time

-------------------------------------------------------------------------------
-- time
-------------------------------------------------------------------------------

instance Arbitrary Time.Day where
    arbitrary :: Gen Day
arbitrary = Integer -> Day
Time.ModifiedJulianDay forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Integer
2000 forall a. Num a => a -> a -> a
+) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
    shrink :: Day -> [Day]
shrink    = (Integer -> Day
Time.ModifiedJulianDay forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Arbitrary a => a -> [a]
shrink forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> Integer
Time.toModifiedJulianDay

instance CoArbitrary Time.Day where
    coarbitrary :: forall b. Day -> Gen b -> Gen b
coarbitrary = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> Integer
Time.toModifiedJulianDay

instance Function Time.Day where
    function :: forall b. (Day -> b) -> Day :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap Day -> Integer
Time.toModifiedJulianDay Integer -> Day
Time.ModifiedJulianDay

instance Arbitrary Time.UniversalTime where
    arbitrary :: Gen UniversalTime
arbitrary = Rational -> UniversalTime
Time.ModJulianDate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Rational
2000 forall a. Num a => a -> a -> a
+) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
    shrink :: UniversalTime -> [UniversalTime]
shrink    = (Rational -> UniversalTime
Time.ModJulianDate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Arbitrary a => a -> [a]
shrink forall b c a. (b -> c) -> (a -> b) -> a -> c
. UniversalTime -> Rational
Time.getModJulianDate

instance CoArbitrary Time.UniversalTime where
    coarbitrary :: forall b. UniversalTime -> Gen b -> Gen b
coarbitrary = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary forall b c a. (b -> c) -> (a -> b) -> a -> c
. UniversalTime -> Rational
Time.getModJulianDate

instance Arbitrary Time.DiffTime where
    arbitrary :: Gen DiffTime
arbitrary = forall a. Fractional a => Gen a
arbitrarySizedFractional
#if MIN_VERSION_time(1,3,0)
    shrink :: DiffTime -> [DiffTime]
shrink    = forall a. RealFrac a => a -> [a]
shrinkRealFrac
#else
    shrink    = (fromRational <$>) . shrink . toRational
#endif

instance CoArbitrary Time.DiffTime where
    coarbitrary :: forall b. DiffTime -> Gen b -> Gen b
coarbitrary = forall a b. Real a => a -> Gen b -> Gen b
coarbitraryReal

instance Function Time.DiffTime where
    function :: forall b. (DiffTime -> b) -> DiffTime :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap forall a. Real a => a -> Rational
toRational forall a. Fractional a => Rational -> a
fromRational

instance Arbitrary Time.UTCTime where
    arbitrary :: Gen UTCTime
arbitrary =
        Day -> DiffTime -> UTCTime
Time.UTCTime
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall a. Fractional a => Rational -> a
fromRational forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Real a => a -> Rational
toRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Random a => (a, a) -> Gen a
choose (Double
0::Double, Double
86400))
    shrink :: UTCTime -> [UTCTime]
shrink ut :: UTCTime
ut@(Time.UTCTime Day
day DiffTime
dayTime) =
        [ UTCTime
ut { utctDay :: Day
Time.utctDay     = Day
d' } | Day
d' <- forall a. Arbitrary a => a -> [a]
shrink Day
day     ] forall a. [a] -> [a] -> [a]
++
        [ UTCTime
ut { utctDayTime :: DiffTime
Time.utctDayTime = DiffTime
t' } | DiffTime
t' <- forall a. Arbitrary a => a -> [a]
shrink DiffTime
dayTime ]

instance CoArbitrary Time.UTCTime where
    coarbitrary :: forall b. UTCTime -> Gen b -> Gen b
coarbitrary (Time.UTCTime Day
day DiffTime
dayTime) =
        forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Day
day forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary DiffTime
dayTime

instance Function Time.UTCTime where
    function :: forall b. (UTCTime -> b) -> UTCTime :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap (\(Time.UTCTime Day
day DiffTime
dt) -> (Day
day,DiffTime
dt))
                           (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Day -> DiffTime -> UTCTime
Time.UTCTime)

instance Arbitrary Time.NominalDiffTime where
    arbitrary :: Gen NominalDiffTime
arbitrary = forall a. Fractional a => Gen a
arbitrarySizedFractional
    shrink :: NominalDiffTime -> [NominalDiffTime]
shrink    = forall a. RealFrac a => a -> [a]
shrinkRealFrac

instance CoArbitrary Time.NominalDiffTime where
    coarbitrary :: forall b. NominalDiffTime -> Gen b -> Gen b
coarbitrary = forall a b. Real a => a -> Gen b -> Gen b
coarbitraryReal

instance Function Time.NominalDiffTime where
    function :: forall b. (NominalDiffTime -> b) -> NominalDiffTime :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap forall a. Real a => a -> Rational
toRational forall a. Fractional a => Rational -> a
fromRational

instance Arbitrary Time.TimeZone where
    arbitrary :: Gen TimeZone
arbitrary =
        Int -> Bool -> String -> TimeZone
Time.TimeZone
         forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Random a => (a, a) -> Gen a
choose (-Int
12forall a. Num a => a -> a -> a
*Int
60,Int
14forall a. Num a => a -> a -> a
*Int
60) -- utc offset (m)
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary -- is summer time
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> a -> [a]
replicate Int
4 forall a b. (a -> b) -> a -> b
$ forall a. Random a => (a, a) -> Gen a
choose (Char
'A',Char
'Z'))
    shrink :: TimeZone -> [TimeZone]
shrink tz :: TimeZone
tz@(Time.TimeZone Int
minutes Bool
summerOnly String
name) =
        [ TimeZone
tz { timeZoneMinutes :: Int
Time.timeZoneMinutes    = Int
m' } | Int
m' <- forall a. Arbitrary a => a -> [a]
shrink Int
minutes    ] forall a. [a] -> [a] -> [a]
++
        [ TimeZone
tz { timeZoneSummerOnly :: Bool
Time.timeZoneSummerOnly = Bool
s' } | Bool
s' <- forall a. Arbitrary a => a -> [a]
shrink Bool
summerOnly ] forall a. [a] -> [a] -> [a]
++
        [ TimeZone
tz { timeZoneName :: String
Time.timeZoneName       = String
n' } | String
n' <- forall a. Arbitrary a => a -> [a]
shrink String
name       ]

instance CoArbitrary Time.TimeZone where
    coarbitrary :: forall b. TimeZone -> Gen b -> Gen b
coarbitrary (Time.TimeZone Int
minutes Bool
summerOnly String
name) =
        forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Int
minutes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Bool
summerOnly forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary String
name

instance Arbitrary Time.TimeOfDay where
    arbitrary :: Gen TimeOfDay
arbitrary =
        Int -> Int -> Pico -> TimeOfDay
Time.TimeOfDay
         forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Random a => (a, a) -> Gen a
choose (Int
0, Int
23) -- hour
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Random a => (a, a) -> Gen a
choose (Int
0, Int
59) -- minute
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall a. Fractional a => Rational -> a
fromRational forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Real a => a -> Rational
toRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Random a => (a, a) -> Gen a
choose (Double
0::Double, Double
60)) -- picoseconds, via double
    shrink :: TimeOfDay -> [TimeOfDay]
shrink tod :: TimeOfDay
tod@(Time.TimeOfDay Int
hour Int
minute Pico
sec) =
        [ TimeOfDay
tod { todHour :: Int
Time.todHour = Int
h' } | Int
h' <- forall a. Arbitrary a => a -> [a]
shrink Int
hour   ] forall a. [a] -> [a] -> [a]
++
        [ TimeOfDay
tod { todMin :: Int
Time.todMin  = Int
m' } | Int
m' <- forall a. Arbitrary a => a -> [a]
shrink Int
minute ] forall a. [a] -> [a] -> [a]
++
        [ TimeOfDay
tod { todSec :: Pico
Time.todSec  = Pico
s' } | Pico
s' <- forall a. Arbitrary a => a -> [a]
shrink Pico
sec    ]

instance CoArbitrary Time.TimeOfDay where
    coarbitrary :: forall b. TimeOfDay -> Gen b -> Gen b
coarbitrary (Time.TimeOfDay Int
hour Int
minute Pico
sec) =
        forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Int
hour forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Int
minute forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Pico
sec

instance Arbitrary Time.LocalTime where
    arbitrary :: Gen LocalTime
arbitrary =
        Day -> TimeOfDay -> LocalTime
Time.LocalTime
         forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary
    shrink :: LocalTime -> [LocalTime]
shrink lt :: LocalTime
lt@(Time.LocalTime Day
day TimeOfDay
tod) =
        [ LocalTime
lt { localDay :: Day
Time.localDay       = Day
d' } | Day
d' <- forall a. Arbitrary a => a -> [a]
shrink Day
day ] forall a. [a] -> [a] -> [a]
++
        [ LocalTime
lt { localTimeOfDay :: TimeOfDay
Time.localTimeOfDay = TimeOfDay
t' } | TimeOfDay
t' <- forall a. Arbitrary a => a -> [a]
shrink TimeOfDay
tod ]

instance CoArbitrary Time.LocalTime where
    coarbitrary :: forall b. LocalTime -> Gen b -> Gen b
coarbitrary (Time.LocalTime Day
day TimeOfDay
tod) =
        forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Day
day forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary TimeOfDay
tod

instance Arbitrary Time.ZonedTime where
    arbitrary :: Gen ZonedTime
arbitrary =
        LocalTime -> TimeZone -> ZonedTime
Time.ZonedTime
         forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary
    shrink :: ZonedTime -> [ZonedTime]
shrink zt :: ZonedTime
zt@(Time.ZonedTime LocalTime
lt TimeZone
zone) =
        [ ZonedTime
zt { zonedTimeToLocalTime :: LocalTime
Time.zonedTimeToLocalTime = LocalTime
l' } | LocalTime
l' <- forall a. Arbitrary a => a -> [a]
shrink LocalTime
lt   ] forall a. [a] -> [a] -> [a]
++
        [ ZonedTime
zt { zonedTimeZone :: TimeZone
Time.zonedTimeZone        = TimeZone
z' } | TimeZone
z' <- forall a. Arbitrary a => a -> [a]
shrink TimeZone
zone ]

instance CoArbitrary Time.ZonedTime where
    coarbitrary :: forall b. ZonedTime -> Gen b -> Gen b
coarbitrary (Time.ZonedTime LocalTime
lt TimeZone
zone) =
        forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary LocalTime
lt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary TimeZone
zone

instance Arbitrary Time.AbsoluteTime where
    arbitrary :: Gen AbsoluteTime
arbitrary =
        DiffTime -> AbsoluteTime -> AbsoluteTime
Time.addAbsoluteTime
         forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return AbsoluteTime
Time.taiEpoch
    shrink :: AbsoluteTime -> [AbsoluteTime]
shrink AbsoluteTime
at =
        (DiffTime -> AbsoluteTime -> AbsoluteTime
`Time.addAbsoluteTime` AbsoluteTime
at) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => a -> [a]
shrink (AbsoluteTime -> AbsoluteTime -> DiffTime
Time.diffAbsoluteTime AbsoluteTime
at AbsoluteTime
Time.taiEpoch)

instance CoArbitrary Time.AbsoluteTime where
    coarbitrary :: forall b. AbsoluteTime -> Gen b -> Gen b
coarbitrary = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip AbsoluteTime -> AbsoluteTime -> DiffTime
Time.diffAbsoluteTime AbsoluteTime
Time.taiEpoch

instance Arbitrary Time.DayOfWeek where
    arbitrary :: Gen DayOfWeek
arbitrary = forall a. [a] -> Gen a
elements [DayOfWeek
Time.Monday .. DayOfWeek
Time.Sunday]
instance CoArbitrary Time.DayOfWeek where
    coarbitrary :: forall b. DayOfWeek -> Gen b -> Gen b
coarbitrary = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum
instance Function Time.DayOfWeek where
    function :: forall b. (DayOfWeek -> b) -> DayOfWeek :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap forall a. Enum a => a -> Int
fromEnum forall a. Enum a => Int -> a
toEnum

instance Arbitrary Time.SystemTime where
    arbitrary :: Gen SystemTime
arbitrary = Int64 -> Word32 -> SystemTime
Time.MkSystemTime forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Word32
nano where
        -- generate 0 often.
        nano :: Gen Word32
nano = forall a. [(Int, Gen a)] -> Gen a
frequency
            [ (Int
1, forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0)
            , (Int
15, forall a. Random a => (a, a) -> Gen a
choose (Word32
0, Word32
999999999))
            ]
    shrink :: SystemTime -> [SystemTime]
shrink (Time.MkSystemTime Int64
s Word32
n) = forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int64 -> Word32 -> SystemTime
Time.MkSystemTime) (forall a. Arbitrary a => a -> [a]
shrink (Int64
s, Word32
n))
instance CoArbitrary Time.SystemTime where
    coarbitrary :: forall b. SystemTime -> Gen b -> Gen b
coarbitrary (Time.MkSystemTime Int64
s Word32
n) = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Int64
s, Word32
n)
instance Function Time.SystemTime where
    function :: forall b. (SystemTime -> b) -> SystemTime :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap
        (\(Time.MkSystemTime Int64
s Word32
n) -> (Int64
s, Word32
n))
        (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int64 -> Word32 -> SystemTime
Time.MkSystemTime)

instance Arbitrary Time.CalendarDiffDays where
    arbitrary :: Gen CalendarDiffDays
arbitrary = Integer -> Integer -> CalendarDiffDays
Time.CalendarDiffDays forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary
    shrink :: CalendarDiffDays -> [CalendarDiffDays]
shrink (Time.CalendarDiffDays Integer
m Integer
d) = forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Integer -> Integer -> CalendarDiffDays
Time.CalendarDiffDays) (forall a. Arbitrary a => a -> [a]
shrink (Integer
m, Integer
d))
instance CoArbitrary Time.CalendarDiffDays where
    coarbitrary :: forall b. CalendarDiffDays -> Gen b -> Gen b
coarbitrary (Time.CalendarDiffDays Integer
m Integer
d) = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Integer
m, Integer
d)
instance Function Time.CalendarDiffDays where
    function :: forall b. (CalendarDiffDays -> b) -> CalendarDiffDays :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap
        (\(Time.CalendarDiffDays Integer
m Integer
d) -> (Integer
m, Integer
d))
        (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Integer -> Integer -> CalendarDiffDays
Time.CalendarDiffDays)

instance Arbitrary Time.CalendarDiffTime where
    arbitrary :: Gen CalendarDiffTime
arbitrary = Integer -> NominalDiffTime -> CalendarDiffTime
Time.CalendarDiffTime forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary
    shrink :: CalendarDiffTime -> [CalendarDiffTime]
shrink (Time.CalendarDiffTime Integer
m NominalDiffTime
d) = forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Integer -> NominalDiffTime -> CalendarDiffTime
Time.CalendarDiffTime) (forall a. Arbitrary a => a -> [a]
shrink (Integer
m, NominalDiffTime
d))
instance CoArbitrary Time.CalendarDiffTime where
    coarbitrary :: forall b. CalendarDiffTime -> Gen b -> Gen b
coarbitrary (Time.CalendarDiffTime Integer
m NominalDiffTime
nt) = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Integer
m, NominalDiffTime
nt)
instance Function Time.CalendarDiffTime where
    function :: forall b. (CalendarDiffTime -> b) -> CalendarDiffTime :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap
        (\(Time.CalendarDiffTime Integer
m NominalDiffTime
nt) -> (Integer
m, NominalDiffTime
nt))
        (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Integer -> NominalDiffTime -> CalendarDiffTime
Time.CalendarDiffTime)

instance Arbitrary Time.Month where
    arbitrary :: Gen Month
arbitrary = do
        Integer
y <- forall a. Arbitrary a => Gen a
arbitrary
        Int
m <- (Int, Int) -> Gen Int
chooseInt (Int
1,Int
12)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Int -> Month
Time.fromYearMonth (Integer
y forall a. Num a => a -> a -> a
+ Integer
2000) Int
m)
    shrink :: Month -> [Month]
shrink Month
mm = case Month -> (Integer, Int)
Time.toYearMonth Month
mm of
        (Integer
y, Int
m) -> do
            (Integer
y', Int
m') <- forall a. Arbitrary a => a -> [a]
shrink (Integer
y forall a. Num a => a -> a -> a
- Integer
2000, Int
m)
            forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Int -> Month
Time.fromYearMonth (Integer
y' forall a. Num a => a -> a -> a
+ Integer
2000) Int
m')
instance CoArbitrary Time.Month where
    coarbitrary :: forall b. Month -> Gen b -> Gen b
coarbitrary (Time.MkMonth Integer
m) = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Integer
m
instance Function Time.Month where
    function :: forall b. (Month -> b) -> Month :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap
        (\(Time.MkMonth Integer
m) -> Integer
m)
        Integer -> Month
Time.MkMonth

instance Arbitrary Time.QuarterOfYear where
    arbitrary :: Gen QuarterOfYear
arbitrary = forall a. [a] -> Gen a
elements [ QuarterOfYear
Time.Q1 .. QuarterOfYear
Time.Q4 ]
instance CoArbitrary Time.QuarterOfYear where
    coarbitrary :: forall b. QuarterOfYear -> Gen b -> Gen b
coarbitrary = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum
instance Function Time.QuarterOfYear where
    function :: forall b. (QuarterOfYear -> b) -> QuarterOfYear :-> b
function = forall a b. (Eq a, Bounded a, Enum a) => (a -> b) -> a :-> b
functionBoundedEnum

instance Arbitrary Time.Quarter where
    arbitrary :: Gen Quarter
arbitrary = do
        Integer
y <- forall a. Arbitrary a => Gen a
arbitrary
        QuarterOfYear
q <- forall a. Arbitrary a => Gen a
arbitrary
        forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> QuarterOfYear -> Quarter
Time.fromYearQuarter (Integer
y forall a. Num a => a -> a -> a
+ Integer
2000) QuarterOfYear
q)
    shrink :: Quarter -> [Quarter]
shrink Quarter
qq = case Quarter -> (Integer, QuarterOfYear)
Time.toYearQuarter Quarter
qq of
        (Integer
y, QuarterOfYear
q) -> do
            (Integer
y', QuarterOfYear
q') <- forall a. Arbitrary a => a -> [a]
shrink (Integer
y forall a. Num a => a -> a -> a
- Integer
2000, QuarterOfYear
q)
            forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> QuarterOfYear -> Quarter
Time.fromYearQuarter (Integer
y' forall a. Num a => a -> a -> a
+ Integer
2000) QuarterOfYear
q')
instance CoArbitrary Time.Quarter where
    coarbitrary :: forall b. Quarter -> Gen b -> Gen b
coarbitrary (Time.MkQuarter Integer
x) = forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Integer
x
instance Function Time.Quarter where
    function :: forall b. (Quarter -> b) -> Quarter :-> b
function = forall b a c.
Function b =>
(a -> b) -> (b -> a) -> (a -> c) -> a :-> c
functionMap
        (\(Time.MkQuarter Integer
x) -> Integer
x)
        Integer -> Quarter
Time.MkQuarter