    {-# LANGUAGE Safe #-}

    module Data.Time.Calendar.Types where

    -- | Year of Common Era (when positive).
    type Year = Integer

    -- | Also known as Anno Domini.
    pattern CommonEra :: Integer -> Year
    pattern $mCommonEra :: forall {r}. Year -> (Year -> r) -> ((# #) -> r) -> r
    $bCommonEra :: Year -> Year
    CommonEra n <-
        ((\Year
    y -> if Year
    y Year -> Year -> Bool
    forall a. Ord a => a -> a -> Bool
    > Year
    0 then Year -> Maybe Year
    forall a. a -> Maybe a
    Just Year
    y else Maybe Year
    forall a. Maybe a
    Nothing) -> Just n)
        where
            CommonEra Year
    n = Year
    n

    -- | Also known as Before Christ.
    -- Note that Year 1 = 1 CE, and the previous Year 0 = 1 BCE.
    -- 'CommonEra' and 'BeforeCommonEra' form a @COMPLETE@ set.
    pattern BeforeCommonEra :: Integer -> Year
    pattern $mBeforeCommonEra :: forall {r}. Year -> (Year -> r) -> ((# #) -> r) -> r
    $bBeforeCommonEra :: Year -> Year
    BeforeCommonEra n <-
        ((\Year
    y -> if Year
    y Year -> Year -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Year
    0 then Year -> Maybe Year
    forall a. a -> Maybe a
    Just (Year
    1 Year -> Year -> Year
    forall a. Num a => a -> a -> a
    - Year
    y) else Maybe Year
    forall a. Maybe a
    Nothing) -> Just n)
        where
            BeforeCommonEra Year
    n = Year
    1 Year -> Year -> Year
    forall a. Num a => a -> a -> a
    - Year
    n

    {-# COMPLETE CommonEra, BeforeCommonEra #-}

    -- | Month of year, in range 1 (January) to 12 (December).
    type MonthOfYear = Int

    pattern January :: MonthOfYear
    pattern $mJanuary :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bJanuary :: MonthOfYear
    January = 1

    pattern February :: MonthOfYear
    pattern $mFebruary :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bFebruary :: MonthOfYear
    February = 2

    pattern March :: MonthOfYear
    pattern $mMarch :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bMarch :: MonthOfYear
    March = 3

    pattern April :: MonthOfYear
    pattern $mApril :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bApril :: MonthOfYear
    April = 4

    pattern May :: MonthOfYear
    pattern $mMay :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bMay :: MonthOfYear
    May = 5

    pattern June :: MonthOfYear
    pattern $mJune :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bJune :: MonthOfYear
    June = 6

    pattern July :: MonthOfYear
    pattern $mJuly :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bJuly :: MonthOfYear
    July = 7

    pattern August :: MonthOfYear
    pattern $mAugust :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bAugust :: MonthOfYear
    August = 8

    pattern September :: MonthOfYear
    pattern $mSeptember :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSeptember :: MonthOfYear
    September = 9

    pattern October :: MonthOfYear
    pattern $mOctober :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bOctober :: MonthOfYear
    October = 10

    pattern November :: MonthOfYear
    pattern $mNovember :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNovember :: MonthOfYear
    November = 11

    -- | The twelve 'MonthOfYear' patterns form a @COMPLETE@ set.
    pattern December :: MonthOfYear
    pattern $mDecember :: forall {r}. MonthOfYear -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDecember :: MonthOfYear
    December = 12

    {-# COMPLETE January, February, March, April, May, June, July, August, September, October, November, December #-}

    -- | Day of month, in range 1 to 31.
    type DayOfMonth = Int

    -- | Day of quarter, in range 1 to 92.
    type DayOfQuarter = Int

    -- | Day of year, in range 1 (January 1st) to 366.
    -- December 31st is 365 in a common year, 366 in a leap year.
    type DayOfYear = Int

    -- | Week of year, by various reckonings, generally in range 0-53 depending on reckoning.
    type WeekOfYear = Int