{-# 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
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)
forall (f :: * -> *) a b. Applicative f => 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 (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)
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)
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))
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
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