chronos 1.0 → 1.0.1

raw patch · 3 files changed

+536/−334 lines, 3 filesdep +clockPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: clock

API changes (from Hackage documentation)

Files

• chronos.cabal +2/−1
• src/Chronos.hs +533/−74
• src/Chronos/Types.hs +1/−259

@@ -1,5 +1,5 @@ name: chronos-version: 1.0+version: 1.0.1 synopsis: A performant time library description:   Performance-oriented time library for haskell. The main differences@@ -55,6 +55,7 @@     , hashable >= 1.2 && < 1.3     , primitive >= 0.6 && < 0.7     , torsor >= 0.1 && < 0.2+    , clock >= 0.7 && < 0.8   default-language:    Haskell2010   c-sources:           src/cbits/hs-time.c 

@@ -1,6 +1,12 @@-{-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE BangPatterns #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UnboxedTuples #-}  {-# OPTIONS_GHC -Wall #-} @@ -12,6 +18,11 @@   , tomorrow   , yesterday   , epoch+    -- ** Duration+  , stopwatch+  , stopwatch_+  , stopwatchWith+  , stopwatchWith_     -- ** Construction   , datetimeFromYmdhms   , timeFromYmdhms@@ -24,6 +35,10 @@   , dayToTimeMidnight   , dayToDate   , dateToDay+  , dayToOrdinalDate+  , ordinalDateToDay+  , monthDateToDayOfYear+  , dayOfYearToMonthDay     -- ** Build Timespan   , second   , minute@@ -61,6 +76,10 @@   , thursday   , friday   , saturday+    -- ** Utility+  , daysInMonth+  , isLeapYear+  , observedOffsets     -- * Textual Conversion     -- ** Date     -- *** Text@@ -128,14 +147,48 @@   , builder_YmdIMS_p_z   , builder_DmyIMS_p_z   , builderW3Cz+  , builderOffset+  , parserOffset     -- *** UTF-8 ByteString   , builderUtf8_YmdHMSz   , parserUtf8_YmdHMSz   , builderUtf8_YmdIMS_p_z   , builderUtf8W3Cz+  , builderOffsetUtf8+  , parserOffsetUtf8+    -- ** Timespan+    -- *** Text+  , encodeTimespan +  , builderTimespan +    -- *** UTF-8 ByteString+  , encodeTimespanUtf8+  , builderTimespanUtf8+    -- * Types+  , Day(..)+  , DayOfWeek(..)+  , DayOfMonth(..)+  , DayOfYear(..)+  , Month(..)+  , Year(..)+  , Offset(..)+  , Time(..)+  , DayOfWeekMatch(..)+  , MonthMatch(..)+  , UnboxedMonthMatch(..)+  , Timespan(..)+  , SubsecondPrecision(..)+  , Date(..)+  , OrdinalDate(..)+  , MonthDate(..)+  , Datetime(..)+  , OffsetDatetime(..)+  , TimeOfDay(..)+  , DatetimeFormat(..)+  , OffsetFormat(..)+  , DatetimeLocale(..)+  , MeridiemLocale(..)   ) where -import Chronos.Types import Data.Text (Text) import Data.Vector (Vector) import Data.Monoid@@ -149,6 +202,14 @@ import Torsor (add,difference,scale,plus) import Chronos.Internal.CTimespec (getPosixNanoseconds) import Data.Word (Word64)+import Torsor+import GHC.Generics (Generic)+import Data.Aeson (FromJSON,ToJSON)+import Data.Primitive+import Foreign.Storable+import Data.Hashable (Hashable)+import Control.Exception (evaluate)+import qualified System.Clock as CLK import qualified Data.Text as Text import qualified Data.Text.Read as Text import qualified Data.Attoparsec.Text as AT@@ -161,6 +222,9 @@ import qualified Data.Text.Lazy as LT import qualified Data.ByteString.Lazy as LB import qualified Data.Vector.Unboxed as UVector+import qualified Data.Vector.Generic as GVector+import qualified Data.Vector.Primitive as PVector+import qualified Data.Vector.Generic.Mutable as MGVector  second :: Timespan second = Timespan 1000000000@@ -231,18 +295,55 @@ today :: IO Day today = fmap timeToDayTruncate now +-- | Gets the 'Day' of tomorrow. tomorrow :: IO Day tomorrow = fmap (add 1 . timeToDayTruncate) now +-- | Gets the 'Day' of yesterday. yesterday :: IO Day yesterday = fmap (add (-1) . timeToDayTruncate) now +-- | Get the current time from the system clock. now :: IO Time now = fmap Time getPosixNanoseconds +-- | The Unix epoch, that is 1970-01-01 00:00:00. epoch :: Time epoch = Time 0 +-- | Measures the time it takes to run an action and evaluate+--   its result to WHNF. This measurement uses a monotonic clock+--   instead of the standard system clock.+stopwatch :: IO a -> IO (Timespan, a)+stopwatch = stopwatchWith CLK.Monotonic++-- | Measures the time it takes to run an action. The result+--   is discarded. This measurement uses a monotonic clock+--   instead of the standard system clock.+stopwatch_ :: IO a -> IO Timespan+stopwatch_ = stopwatchWith_ CLK.Monotonic++-- | Variant of 'stopwatch' that accepts a clock type. Users+--   need to import @System.Clock@ from the @clock@ package+--   in order to provide the clock type.+stopwatchWith :: CLK.Clock -> IO a -> IO (Timespan, a)+stopwatchWith c action = do+  start <- CLK.getTime c+  a <- action >>= evaluate+  end <- CLK.getTime c+  return (timeSpecToTimespan (CLK.diffTimeSpec end start),a)++-- | Variant of 'stopwatch_' that accepts a clock type.+stopwatchWith_ :: CLK.Clock -> IO a -> IO Timespan+stopwatchWith_ c action = do+  start <- CLK.getTime c+  _ <- action+  end <- CLK.getTime c+  return (timeSpecToTimespan (CLK.diffTimeSpec end start))++timeSpecToTimespan :: CLK.TimeSpec -> Timespan+timeSpecToTimespan (CLK.TimeSpec s ns) = Timespan (s * 1000000000 + ns)+ data UtcTime = UtcTime   {-# UNPACK #-} !Day -- day   {-# UNPACK #-} !Int64 -- nanoseconds@@ -272,6 +373,50 @@ nanosecondsInMinute :: Int64 nanosecondsInMinute = 60000000000 +observedOffsets :: Vector Offset+observedOffsets = Vector.fromList $ map Offset+  [ -1200+  , -1100+  , -1000+  , -930+  , -900+  , -800+  , -700+  , -600+  , -500+  , -400+  , -330+  , -300+  , -230+  , -200+  , -100+  , 0+  , 100+  , 200+  , 300+  , 330+  , 400+  , 430+  , 500+  , 530+  , 545+  , 600+  , 630+  , 700+  , 800+  , 845+  , 900+  , 930+  , 1000+  , 1030+  , 1100+  , 1200+  , 1245+  , 1300+  , 1345+  , 1400+  ]+ -- | The first argument in the resulting tuple in a day --   adjustment. It should be either -1, 0, or 1, as no --   offset should ever exceed 24 hours.@@ -303,7 +448,7 @@ dayToDate theDay = Date year month dayOfMonth   where   OrdinalDate year yd = dayToOrdinalDate theDay-  MonthDate month dayOfMonth = dayOfYearToMonthAndDay (isLeapYear year) yd+  MonthDate month dayOfMonth = dayOfYearToMonthDay (isLeapYear year) yd  -- datetimeToOffsetDatetime :: Offset -> Datetime -> OffsetDatetime -- datetimeToOffsetDatetime offset@@ -341,7 +486,7 @@ monthDateToDayOfYear isLeap (MonthDate month@(Month m) (DayOfMonth dayOfMonth)) =   DayOfYear ((div (367 * (fromIntegral m + 1) - 362) 12) + k + day')   where-  day' = fromIntegral $ clip 1 (monthLength isLeap month) dayOfMonth+  day' = fromIntegral $ clip 1 (daysInMonth isLeap month) dayOfMonth   k = if month < Month 2 then 0 else if isLeap then -1 else -2  ordinalDateToDay :: OrdinalDate -> Day@@ -357,8 +502,8 @@ isLeapYear :: Year -> Bool isLeapYear (Year year) = (mod year 4 == 0) && ((mod year 400 == 0) || not (mod year 100 == 0)) -dayOfYearToMonthAndDay :: Bool -> DayOfYear -> MonthDate-dayOfYearToMonthAndDay isLeap dayOfYear =+dayOfYearToMonthDay :: Bool -> DayOfYear -> MonthDate+dayOfYearToMonthDay isLeap dayOfYear =   let (!upperBound,!monthTable,!dayTable) =         if isLeap           then (DayOfYear 366, leapYearDayOfYearMonthTable, leapYearDayOfYearDayOfMonthTable)@@ -413,8 +558,8 @@ internalMatchMonth :: MonthMatch a -> Month -> a internalMatchMonth (MonthMatch v) (Month ix) = Vector.unsafeIndex v (fromIntegral ix) -monthLength :: Bool -> Month -> Int-monthLength isLeap m = if isLeap+daysInMonth :: Bool -> Month -> Int+daysInMonth isLeap m = if isLeap   then internalMatchMonth leapYearMonthLength m   else internalMatchMonth normalYearMonthLength m @@ -737,6 +882,17 @@   (milli,milliRem) = quotRem nano 1000000   (micro,microRem) = quotRem nano 1000 ++encodeTimespan :: SubsecondPrecision -> Timespan -> Text+encodeTimespan sp =+  LT.toStrict . TB.toLazyText . builderTimespan sp++builderTimespan :: SubsecondPrecision -> Timespan -> TB.Builder+builderTimespan sp (Timespan ns) = +  TB.decimal sInt64 <> prettyNanosecondsBuilder sp nsRemainder+  where+  (!sInt64,!nsRemainder) = quotRem ns 1000000000+ internalBuilder_NS :: SubsecondPrecision -> Maybe Char -> Int -> Int64 -> TB.Builder internalBuilder_NS sp msep m ns = case msep of   Nothing -> indexTwoDigitTextBuilder m@@ -1013,13 +1169,23 @@     then mempty     else       let newSubsecondPart = quot nano (raiseTenTo (9 - d))-       in "."+       in BB.char7 '.'           <> BB.byteString (BC.replicate (d - countDigits newSubsecondPart) '0')           <> int64Builder newSubsecondPart   where   (milli,milliRem) = quotRem nano 1000000   (micro,microRem) = quotRem nano 1000 +encodeTimespanUtf8 :: SubsecondPrecision -> Timespan -> ByteString+encodeTimespanUtf8 sp =+  LB.toStrict . BB.toLazyByteString . builderTimespanUtf8 sp++builderTimespanUtf8 :: SubsecondPrecision -> Timespan -> BB.Builder+builderTimespanUtf8 sp (Timespan ns) = +  int64Builder sInt64 <> prettyNanosecondsBuilderUtf8 sp nsRemainder+  where+  (!sInt64,!nsRemainder) = quotRem ns 1000000000+ int64Builder :: Int64 -> BB.Builder int64Builder = BB.integerDec . fromIntegral @@ -1096,18 +1262,18 @@ builder_YmdHMSz :: OffsetFormat -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> TB.Builder builder_YmdHMSz offsetFormat sp datetimeFormat (OffsetDatetime datetime offset) =      builder_YmdHMS sp datetimeFormat datetime-  <> offsetBuilder offsetFormat offset+  <> builderOffset offsetFormat offset  parser_YmdHMSz :: OffsetFormat -> DatetimeFormat -> Parser OffsetDatetime parser_YmdHMSz offsetFormat datetimeFormat = OffsetDatetime   <$> parser_YmdHMS datetimeFormat-  <*> offsetParser offsetFormat+  <*> parserOffset offsetFormat  builder_YmdIMS_p_z :: OffsetFormat -> MeridiemLocale Text -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> TB.Builder builder_YmdIMS_p_z offsetFormat meridiemLocale sp datetimeFormat (OffsetDatetime datetime offset) =      builder_YmdIMS_p meridiemLocale sp datetimeFormat datetime   <> " "-  <> offsetBuilder offsetFormat offset+  <> builderOffset offsetFormat offset  encode_YmdHMSz :: OffsetFormat -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> Text encode_YmdHMSz offsetFormat sp datetimeFormat =@@ -1116,18 +1282,18 @@ builder_DmyHMSz :: OffsetFormat -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> TB.Builder builder_DmyHMSz offsetFormat sp datetimeFormat (OffsetDatetime datetime offset) =       builder_DmyHMS sp datetimeFormat datetime-  <> offsetBuilder offsetFormat offset+  <> builderOffset offsetFormat offset  parser_DmyHMSz :: OffsetFormat -> DatetimeFormat -> AT.Parser OffsetDatetime parser_DmyHMSz offsetFormat datetimeFormat = OffsetDatetime   <$> parser_DmyHMS datetimeFormat-  <*> offsetParser offsetFormat+  <*> parserOffset offsetFormat  builder_DmyIMS_p_z :: OffsetFormat -> MeridiemLocale Text -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> TB.Builder builder_DmyIMS_p_z offsetFormat meridiemLocale sp datetimeFormat (OffsetDatetime datetime offset) =        builder_DmyIMS_p meridiemLocale sp datetimeFormat datetime    <> " "-   <> offsetBuilder offsetFormat offset+   <> builderOffset offsetFormat offset  encode_DmyHMSz :: OffsetFormat -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> Text encode_DmyHMSz offsetFormat sp datetimeFormat =@@ -1139,19 +1305,19 @@   SubsecondPrecisionAuto   (DatetimeFormat (Just '-') (Just 'T') (Just ':')) -offsetBuilder :: OffsetFormat -> Offset -> TB.Builder-offsetBuilder x = case x of-  OffsetFormatColonOff -> buildOffset_z-  OffsetFormatColonOn -> buildOffset_z1-  OffsetFormatSecondsPrecision -> buildOffset_z2-  OffsetFormatColonAuto -> buildOffset_z3+builderOffset :: OffsetFormat -> Offset -> TB.Builder+builderOffset x = case x of+  OffsetFormatColonOff -> builderOffset_z+  OffsetFormatColonOn -> builderOffset_z1+  OffsetFormatSecondsPrecision -> builderOffset_z2+  OffsetFormatColonAuto -> builderOffset_z3 -offsetParser :: OffsetFormat -> Parser Offset-offsetParser x = case x of-  OffsetFormatColonOff -> parseOffset_z-  OffsetFormatColonOn -> parseOffset_z1-  OffsetFormatSecondsPrecision -> parseOffset_z2-  OffsetFormatColonAuto -> parseOffset_z3+parserOffset :: OffsetFormat -> Parser Offset+parserOffset x = case x of+  OffsetFormatColonOff -> parserOffset_z+  OffsetFormatColonOn -> parserOffset_z1+  OffsetFormatSecondsPrecision -> parserOffset_z2+  OffsetFormatColonAuto -> parserOffset_z3  -- | True means positive, false means negative parseSignedness :: Parser Bool@@ -1163,8 +1329,8 @@       then return True       else fail "while parsing offset, expected [+] or [-]" -parseOffset_z :: Parser Offset-parseOffset_z = do+parserOffset_z :: Parser Offset+parserOffset_z = do   pos <- parseSignedness   h <- parseFixedDigits 2   m <- parseFixedDigits 2@@ -1173,8 +1339,8 @@     then res     else negate res -parseOffset_z1 :: Parser Offset-parseOffset_z1 = do+parserOffset_z1 :: Parser Offset+parserOffset_z1 = do   pos <- parseSignedness   h <- parseFixedDigits 2   _ <- AT.char ':'@@ -1184,8 +1350,8 @@     then res     else negate res -parseOffset_z2 :: AT.Parser Offset-parseOffset_z2 = do+parserOffset_z2 :: AT.Parser Offset+parserOffset_z2 = do   pos <- parseSignedness   h <- parseFixedDigits 2   _ <- AT.char ':'@@ -1199,8 +1365,8 @@ -- | This is generous in what it accepts. If you give --   something like +04:00 as the offset, it will be --   allowed, even though it could be shorter.-parseOffset_z3 :: AT.Parser Offset-parseOffset_z3 = do+parserOffset_z3 :: AT.Parser Offset+parserOffset_z3 = do   pos <- parseSignedness   h <- parseFixedDigits 2   mc <- AT.peekChar@@ -1216,16 +1382,16 @@       then h * 60       else h * (-60) -buildOffset_z :: Offset -> TB.Builder-buildOffset_z (Offset i) =+builderOffset_z :: Offset -> TB.Builder+builderOffset_z (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in prefix       <> indexTwoDigitTextBuilder a       <> indexTwoDigitTextBuilder b -buildOffset_z1 :: Offset -> TB.Builder-buildOffset_z1 (Offset i) =+builderOffset_z1 :: Offset -> TB.Builder+builderOffset_z1 (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in prefix@@ -1233,8 +1399,8 @@       <> ":"       <> indexTwoDigitTextBuilder b -buildOffset_z2 :: Offset -> TB.Builder-buildOffset_z2 (Offset i) =+builderOffset_z2 :: Offset -> TB.Builder+builderOffset_z2 (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in prefix@@ -1243,8 +1409,8 @@       <> indexTwoDigitTextBuilder b       <> ":00" -buildOffset_z3 :: Offset -> TB.Builder-buildOffset_z3 (Offset i) =+builderOffset_z3 :: Offset -> TB.Builder+builderOffset_z3 (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in if b == 0@@ -1258,18 +1424,18 @@ builderUtf8_YmdHMSz :: OffsetFormat -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> BB.Builder builderUtf8_YmdHMSz offsetFormat sp datetimeFormat (OffsetDatetime datetime offset) =      builderUtf8_YmdHMS sp datetimeFormat datetime-  <> offsetBuilderUtf8 offsetFormat offset+  <> builderOffsetUtf8 offsetFormat offset  parserUtf8_YmdHMSz :: OffsetFormat -> DatetimeFormat -> AB.Parser OffsetDatetime parserUtf8_YmdHMSz offsetFormat datetimeFormat = OffsetDatetime   <$> parserUtf8_YmdHMS datetimeFormat-  <*> offsetParserUtf8 offsetFormat+  <*> parserOffsetUtf8 offsetFormat  builderUtf8_YmdIMS_p_z :: OffsetFormat -> MeridiemLocale ByteString -> SubsecondPrecision -> DatetimeFormat -> OffsetDatetime -> BB.Builder builderUtf8_YmdIMS_p_z offsetFormat meridiemLocale sp datetimeFormat (OffsetDatetime datetime offset) =      builderUtf8_YmdIMS_p meridiemLocale sp datetimeFormat datetime   <> " "-  <> offsetBuilderUtf8 offsetFormat offset+  <> builderOffsetUtf8 offsetFormat offset  builderUtf8W3Cz :: OffsetDatetime -> BB.Builder builderUtf8W3Cz = builderUtf8_YmdHMSz@@ -1277,19 +1443,19 @@   SubsecondPrecisionAuto   (DatetimeFormat (Just '-') (Just 'T') (Just ':')) -offsetBuilderUtf8 :: OffsetFormat -> Offset -> BB.Builder-offsetBuilderUtf8 x = case x of-  OffsetFormatColonOff -> buildOffsetUtf8_z-  OffsetFormatColonOn -> buildOffsetUtf8_z1-  OffsetFormatSecondsPrecision -> buildOffsetUtf8_z2-  OffsetFormatColonAuto -> buildOffsetUtf8_z3+builderOffsetUtf8 :: OffsetFormat -> Offset -> BB.Builder+builderOffsetUtf8 x = case x of+  OffsetFormatColonOff -> builderOffsetUtf8_z+  OffsetFormatColonOn -> builderOffsetUtf8_z1+  OffsetFormatSecondsPrecision -> builderOffsetUtf8_z2+  OffsetFormatColonAuto -> builderOffsetUtf8_z3 -offsetParserUtf8 :: OffsetFormat -> AB.Parser Offset-offsetParserUtf8 x = case x of-  OffsetFormatColonOff -> parseOffsetUtf8_z-  OffsetFormatColonOn -> parseOffsetUtf8_z1-  OffsetFormatSecondsPrecision -> parseOffsetUtf8_z2-  OffsetFormatColonAuto -> parseOffsetUtf8_z3+parserOffsetUtf8 :: OffsetFormat -> AB.Parser Offset+parserOffsetUtf8 x = case x of+  OffsetFormatColonOff -> parserOffsetUtf8_z+  OffsetFormatColonOn -> parserOffsetUtf8_z1+  OffsetFormatSecondsPrecision -> parserOffsetUtf8_z2+  OffsetFormatColonAuto -> parserOffsetUtf8_z3  -- | True means positive, false means negative parseSignednessUtf8 :: AB.Parser Bool@@ -1301,8 +1467,8 @@       then return True       else fail "while parsing offset, expected [+] or [-]" -parseOffsetUtf8_z :: AB.Parser Offset-parseOffsetUtf8_z = do+parserOffsetUtf8_z :: AB.Parser Offset+parserOffsetUtf8_z = do   pos <- parseSignednessUtf8   h <- parseFixedDigitsIntBS 2   m <- parseFixedDigitsIntBS 2@@ -1311,8 +1477,8 @@     then res     else negate res -parseOffsetUtf8_z1 :: AB.Parser Offset-parseOffsetUtf8_z1 = do+parserOffsetUtf8_z1 :: AB.Parser Offset+parserOffsetUtf8_z1 = do   pos <- parseSignednessUtf8   h <- parseFixedDigitsIntBS 2   _ <- AB.char ':'@@ -1322,8 +1488,8 @@     then res     else negate res -parseOffsetUtf8_z2 :: AB.Parser Offset-parseOffsetUtf8_z2 = do+parserOffsetUtf8_z2 :: AB.Parser Offset+parserOffsetUtf8_z2 = do   pos <- parseSignednessUtf8   h <- parseFixedDigitsIntBS 2   _ <- AB.char ':'@@ -1337,8 +1503,8 @@ -- | This is generous in what it accepts. If you give --   something like +04:00 as the offset, it will be --   allowed, even though it could be shorter.-parseOffsetUtf8_z3 :: AB.Parser Offset-parseOffsetUtf8_z3 = do+parserOffsetUtf8_z3 :: AB.Parser Offset+parserOffsetUtf8_z3 = do   pos <- parseSignednessUtf8   h <- parseFixedDigitsIntBS 2   mc <- AB.peekChar@@ -1354,16 +1520,16 @@       then h * 60       else h * (-60) -buildOffsetUtf8_z :: Offset -> BB.Builder-buildOffsetUtf8_z (Offset i) =+builderOffsetUtf8_z :: Offset -> BB.Builder+builderOffsetUtf8_z (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in prefix       <> indexTwoDigitByteStringBuilder a       <> indexTwoDigitByteStringBuilder b -buildOffsetUtf8_z1 :: Offset -> BB.Builder-buildOffsetUtf8_z1 (Offset i) =+builderOffsetUtf8_z1 :: Offset -> BB.Builder+builderOffsetUtf8_z1 (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in prefix@@ -1371,8 +1537,8 @@       <> ":"       <> indexTwoDigitByteStringBuilder b -buildOffsetUtf8_z2 :: Offset -> BB.Builder-buildOffsetUtf8_z2 (Offset i) =+builderOffsetUtf8_z2 :: Offset -> BB.Builder+builderOffsetUtf8_z2 (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in prefix@@ -1381,8 +1547,8 @@       <> indexTwoDigitByteStringBuilder b       <> ":00" -buildOffsetUtf8_z3 :: Offset -> BB.Builder-buildOffsetUtf8_z3 (Offset i) =+builderOffsetUtf8_z3 :: Offset -> BB.Builder+builderOffsetUtf8_z3 (Offset i) =   let (!a,!b) = divMod (abs i) 60       !prefix = if signum i == (-1) then "-" else "+"    in if b == 0@@ -1557,4 +1723,297 @@  zeroPadDayOfMonthBS :: DayOfMonth -> BB.Builder zeroPadDayOfMonthBS (DayOfMonth d) = indexTwoDigitByteStringBuilder d++-- | A day represented as the modified Julian date, the number of days+--   since midnight on November 17, 1858.+newtype Day = Day { getDay :: Int }+  deriving (Show,Read,Eq,Ord,Hashable,Enum,ToJSON,FromJSON,Storable,Prim)++instance Torsor Day Int where+  add i (Day d) = Day (d + i)+  difference (Day a) (Day b) = a - b++-- | The day of the week.+newtype DayOfWeek = DayOfWeek { getDayOfWeek :: Int }+  deriving (Show,Read,Eq,Ord,Hashable)++-- | The day of the month.+newtype DayOfMonth = DayOfMonth { getDayOfMonth :: Int }+  deriving (Show,Read,Eq,Ord,Prim,Enum)++-- | The day of the year.+newtype DayOfYear = DayOfYear { getDayOfYear :: Int }+  deriving (Show,Read,Eq,Ord,Prim)++-- | The month of the year.+newtype Month = Month { getMonth :: Int }+  deriving (Show,Read,Eq,Ord,Prim)++instance Bounded Month where+  minBound = Month 0+  maxBound = Month 11++-- | The number of years elapsed since the beginning+--   of the Common Era.+newtype Year = Year { getYear :: Int }+  deriving (Show,Read,Eq,Ord)++newtype Offset = Offset { getOffset :: Int }+  deriving (Show,Read,Eq,Ord,Enum)++-- | POSIX time with nanosecond resolution.+newtype Time = Time { getTime :: Int64 }+  deriving (FromJSON,ToJSON,Hashable,Eq,Ord,Show,Read,Storable,Prim)++newtype DayOfWeekMatch a = DayOfWeekMatch { getDayOfWeekMatch :: Vector a }++newtype MonthMatch a = MonthMatch { getMonthMatch :: Vector a }++newtype UnboxedMonthMatch a = UnboxedMonthMatch { getUnboxedMonthMatch :: UVector.Vector a }++-- | A timespan. This is represented internally as a number+--   of nanoseconds.+newtype Timespan = Timespan { getTimespan :: Int64 }+  deriving (Show,Read,Eq,Ord,ToJSON,FromJSON,Additive)++instance Monoid Timespan where+  mempty = Timespan 0+  mappend (Timespan a) (Timespan b) = Timespan (a + b)++instance Torsor Time Timespan where+  add (Timespan ts) (Time t) = Time (t + ts)+  difference (Time t) (Time s) = Timespan (t - s)++instance Scaling Timespan Int64 where+  scale i (Timespan ts) = Timespan (i * ts)++instance Torsor Offset Int where+  add i (Offset x) = Offset (x + i)+  difference (Offset x) (Offset y) = x - y++-- | The precision used when encoding seconds to a human-readable format.+data SubsecondPrecision+  = SubsecondPrecisionAuto -- ^ Rounds to second, millisecond, microsecond, or nanosecond+  | SubsecondPrecisionFixed {-# UNPACK #-} !Int -- ^ Specify number of places after decimal++-- | A date as represented by the Gregorian calendar.+data Date = Date+  { dateYear  :: {-# UNPACK #-} !Year+  , dateMonth :: {-# UNPACK #-} !Month+  , dateDay   :: {-# UNPACK #-} !DayOfMonth+  } deriving (Show,Read,Eq,Ord)++-- | The year and number of days elapsed since the beginning it began.+data OrdinalDate = OrdinalDate+  { ordinalDateYear :: {-# UNPACK #-} !Year+  , ordinalDateDayOfYear :: {-# UNPACK #-} !DayOfYear+  } deriving (Show,Read,Eq,Ord)++-- | A month and the day of the month. This does not actually represent+--   a specific date, since this recurs every year.+data MonthDate = MonthDate+  { monthDateMonth :: {-# UNPACK #-} !Month+  , monthDateDay :: {-# UNPACK #-} !DayOfMonth+  } deriving (Show,Read,Eq,Ord)++-- | A date as represented by the Gregorian calendar+--   and a time of day.+data Datetime = Datetime+  { datetimeDate :: {-# UNPACK #-} !Date+  , datetimeTime :: {-# UNPACK #-} !TimeOfDay+  } deriving (Show,Read,Eq,Ord)++data OffsetDatetime = OffsetDatetime+  { offsetDatetimeDatetime :: {-# UNPACK #-} !Datetime+  , offsetDatetimeOffset :: {-# UNPACK #-} !Offset+  } deriving (Show,Read,Eq,Ord)++-- | A time of day with nanosecond resolution.+data TimeOfDay = TimeOfDay+  { timeOfDayHour :: {-# UNPACK #-} !Int+  , timeOfDayMinute :: {-# UNPACK #-} !Int+  , timeOfDayNanoseconds :: {-# UNPACK #-} !Int64+  } deriving (Show,Read,Eq,Ord)++data DatetimeFormat = DatetimeFormat+  { datetimeFormatDateSeparator :: !(Maybe Char)+    -- ^ Separator in the date+  , datetimeFormatSeparator :: !(Maybe Char)+    -- ^ Separator between date and time+  , datetimeFormatTimeSeparator :: !(Maybe Char)+    -- ^ Separator in the time+  } deriving (Show,Read,Eq,Ord)++-- | Formatting settings for a timezone offset.+data OffsetFormat+  = OffsetFormatColonOff -- ^ @%z@ (e.g., -0400)+  | OffsetFormatColonOn -- ^ @%:z@ (e.g., -04:00)+  | OffsetFormatSecondsPrecision -- ^ @%::z@ (e.g., -04:00:00)+  | OffsetFormatColonAuto -- ^ @%:::z@ (e.g., -04, +05:30)+  deriving (Show,Read,Eq,Ord,Enum,Bounded,Generic)++-- | Locale-specific formatting for weekdays and months. The+--   type variable will likely be instantiated to @Text@+--   or @ByteString@.+data DatetimeLocale a = DatetimeLocale+  { datetimeLocaleDaysOfWeekFull :: !(DayOfWeekMatch a)+    -- ^ full weekdays starting with Sunday, 7 elements+  , datetimeLocaleDaysOfWeekAbbreviated :: !(DayOfWeekMatch a)+    -- ^ abbreviated weekdays starting with Sunday, 7 elements+  , datetimeLocaleMonthsFull :: !(MonthMatch a)+    -- ^ full months starting with January, 12 elements+  , datetimeLocaleMonthsAbbreviated :: !(MonthMatch a)+    -- ^ abbreviated months starting with January, 12 elements+  }++-- | Locale-specific formatting for AM and PM.+data MeridiemLocale a = MeridiemLocale+  { meridiemLocaleAm :: !a+  , meridiemLocalePm :: !a+  } deriving (Read,Show,Eq,Ord)++newtype instance UVector.MVector s Month = MV_Month (PVector.MVector s Month)+newtype instance UVector.Vector Month = V_Month (PVector.Vector Month)++instance UVector.Unbox Month++instance MGVector.MVector UVector.MVector Month where+  {-# INLINE basicLength #-}+  {-# INLINE basicUnsafeSlice #-}+  {-# INLINE basicOverlaps #-}+  {-# INLINE basicUnsafeNew #-}+  {-# INLINE basicInitialize #-}+  {-# INLINE basicUnsafeReplicate #-}+  {-# INLINE basicUnsafeRead #-}+  {-# INLINE basicUnsafeWrite #-}+  {-# INLINE basicClear #-}+  {-# INLINE basicSet #-}+  {-# INLINE basicUnsafeCopy #-}+  {-# INLINE basicUnsafeGrow #-}+  basicLength (MV_Month v) = MGVector.basicLength v+  basicUnsafeSlice i n (MV_Month v) = MV_Month $ MGVector.basicUnsafeSlice i n v+  basicOverlaps (MV_Month v1) (MV_Month v2) = MGVector.basicOverlaps v1 v2+  basicUnsafeNew n = MV_Month `liftM` MGVector.basicUnsafeNew n+  basicInitialize (MV_Month v) = MGVector.basicInitialize v+  basicUnsafeReplicate n x = MV_Month `liftM` MGVector.basicUnsafeReplicate n x+  basicUnsafeRead (MV_Month v) i = MGVector.basicUnsafeRead v i+  basicUnsafeWrite (MV_Month v) i x = MGVector.basicUnsafeWrite v i x+  basicClear (MV_Month v) = MGVector.basicClear v+  basicSet (MV_Month v) x = MGVector.basicSet v x+  basicUnsafeCopy (MV_Month v1) (MV_Month v2) = MGVector.basicUnsafeCopy v1 v2+  basicUnsafeMove (MV_Month v1) (MV_Month v2) = MGVector.basicUnsafeMove v1 v2+  basicUnsafeGrow (MV_Month v) n = MV_Month `liftM` MGVector.basicUnsafeGrow v n++instance GVector.Vector UVector.Vector Month where+  {-# INLINE basicUnsafeFreeze #-}+  {-# INLINE basicUnsafeThaw #-}+  {-# INLINE basicLength #-}+  {-# INLINE basicUnsafeSlice #-}+  {-# INLINE basicUnsafeIndexM #-}+  {-# INLINE elemseq #-}+  basicUnsafeFreeze (MV_Month v) = V_Month `liftM` GVector.basicUnsafeFreeze v+  basicUnsafeThaw (V_Month v) = MV_Month `liftM` GVector.basicUnsafeThaw v+  basicLength (V_Month v) = GVector.basicLength v+  basicUnsafeSlice i n (V_Month v) = V_Month $ GVector.basicUnsafeSlice i n v+  basicUnsafeIndexM (V_Month v) i = GVector.basicUnsafeIndexM v i+  basicUnsafeCopy (MV_Month mv) (V_Month v) = GVector.basicUnsafeCopy mv v+  elemseq _ = seq++newtype instance UVector.MVector s DayOfMonth = MV_DayOfMonth (PVector.MVector s DayOfMonth)+newtype instance UVector.Vector DayOfMonth = V_DayOfMonth (PVector.Vector DayOfMonth)++instance UVector.Unbox DayOfMonth++instance MGVector.MVector UVector.MVector DayOfMonth where+  {-# INLINE basicLength #-}+  {-# INLINE basicUnsafeSlice #-}+  {-# INLINE basicOverlaps #-}+  {-# INLINE basicUnsafeNew #-}+  {-# INLINE basicInitialize #-}+  {-# INLINE basicUnsafeReplicate #-}+  {-# INLINE basicUnsafeRead #-}+  {-# INLINE basicUnsafeWrite #-}+  {-# INLINE basicClear #-}+  {-# INLINE basicSet #-}+  {-# INLINE basicUnsafeCopy #-}+  {-# INLINE basicUnsafeGrow #-}+  basicLength (MV_DayOfMonth v) = MGVector.basicLength v+  basicUnsafeSlice i n (MV_DayOfMonth v) = MV_DayOfMonth $ MGVector.basicUnsafeSlice i n v+  basicOverlaps (MV_DayOfMonth v1) (MV_DayOfMonth v2) = MGVector.basicOverlaps v1 v2+  basicUnsafeNew n = MV_DayOfMonth `liftM` MGVector.basicUnsafeNew n+  basicInitialize (MV_DayOfMonth v) = MGVector.basicInitialize v+  basicUnsafeReplicate n x = MV_DayOfMonth `liftM` MGVector.basicUnsafeReplicate n x+  basicUnsafeRead (MV_DayOfMonth v) i = MGVector.basicUnsafeRead v i+  basicUnsafeWrite (MV_DayOfMonth v) i x = MGVector.basicUnsafeWrite v i x+  basicClear (MV_DayOfMonth v) = MGVector.basicClear v+  basicSet (MV_DayOfMonth v) x = MGVector.basicSet v x+  basicUnsafeCopy (MV_DayOfMonth v1) (MV_DayOfMonth v2) = MGVector.basicUnsafeCopy v1 v2+  basicUnsafeMove (MV_DayOfMonth v1) (MV_DayOfMonth v2) = MGVector.basicUnsafeMove v1 v2+  basicUnsafeGrow (MV_DayOfMonth v) n = MV_DayOfMonth `liftM` MGVector.basicUnsafeGrow v n++instance GVector.Vector UVector.Vector DayOfMonth where+  {-# INLINE basicUnsafeFreeze #-}+  {-# INLINE basicUnsafeThaw #-}+  {-# INLINE basicLength #-}+  {-# INLINE basicUnsafeSlice #-}+  {-# INLINE basicUnsafeIndexM #-}+  {-# INLINE elemseq #-}+  basicUnsafeFreeze (MV_DayOfMonth v) = V_DayOfMonth `liftM` GVector.basicUnsafeFreeze v+  basicUnsafeThaw (V_DayOfMonth v) = MV_DayOfMonth `liftM` GVector.basicUnsafeThaw v+  basicLength (V_DayOfMonth v) = GVector.basicLength v+  basicUnsafeSlice i n (V_DayOfMonth v) = V_DayOfMonth $ GVector.basicUnsafeSlice i n v+  basicUnsafeIndexM (V_DayOfMonth v) i = GVector.basicUnsafeIndexM v i+  basicUnsafeCopy (MV_DayOfMonth mv) (V_DayOfMonth v) = GVector.basicUnsafeCopy mv v+  elemseq _ = seq++------------------------+-- The Torsor and Enum instances for Date and OrdinalDate+-- are both bad. This only causes problems for dates+-- at least a million years in the future. Some of this+-- badness is caused by pragmatism, and some of it is caused by+-- my own laziness.+--+-- The badness that comes from pragmatism:+--   - Int technically is not a good delta for Date. Date+--     has too many inhabitants. If we subtract the lowest+--     Date from the highest Date, we get something too+--     big to fit in a machine integer.+--   - There is no good way to write fromEnum or toEnum for+--     Date. Again, Date has more inhabitants than Int, so+--     it simply cannot be done.+-- The badness that comes from laziness:+--   - Technically, we should still be able to add deltas to+--     Dates that do not fit in machine integers. We should+--     also be able to correctly subtract Dates to cannot+--     fit in machine integers.+--   - For similar reasons, the Enum functions succ, pred,+--     enumFromThen, enumFromThenTo, etc. could all have+--     better definitions than the default ones currently+--     used.+-- If, for some reason, anyone ever wants to fix the badness+-- that comes from laziness, all+-- you really have to do is define a version of dateToDay,+-- dayToDate, ordinalDateToDay, and dayToOrdinalDate+-- that uses something bigger instead of Day. Maybe something like+-- (Int,Word) or (Int,Word,Word). I'm not exactly sure how+-- big it would need to be to work correctly. Then you could+-- handle deltas of two very far off days correctly, provided+-- that the two days weren't also super far from each other.+--+------------------------+instance Torsor Date Int where+  add i d = dayToDate (add i (dateToDay d))+  difference a b = difference (dateToDay a) (dateToDay b)++instance Torsor OrdinalDate Int where+  add i d = dayToOrdinalDate (add i (ordinalDateToDay d))+  difference a b = difference (ordinalDateToDay a) (ordinalDateToDay b)++instance Enum Date where+  fromEnum d = fromEnum (dateToDay d)+  toEnum i = dayToDate (toEnum i)++instance Enum OrdinalDate where+  fromEnum d = fromEnum (ordinalDateToDay d)+  toEnum i = dayToOrdinalDate (toEnum i) 

@@ -1,10 +1,3 @@-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE UnboxedTuples #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE MagicHash #-}- {-# OPTIONS_GHC -Wall -Werror #-}  {- | Data types for representing different date and time-related@@ -62,255 +55,4 @@   , MeridiemLocale(..)   ) where -import Torsor-import Data.Int-import Data.Vector (Vector)-import Data.Aeson (FromJSON,ToJSON)-import Data.Hashable (Hashable)-import Data.Primitive-import Foreign.Storable-import Control.Monad-import GHC.Generics (Generic)-import Data.Monoid (Monoid(..))-import qualified Data.Vector.Generic as GVector-import qualified Data.Vector.Unboxed as UVector-import qualified Data.Vector.Primitive as PVector-import qualified Data.Vector.Generic.Mutable as MGVector---- | A day represented as the modified Julian date, the number of days---   since midnight on November 17, 1858.-newtype Day = Day { getDay :: Int }-  deriving (Show,Read,Eq,Ord,Hashable,Enum,ToJSON,FromJSON,Storable,Prim)--instance Torsor Day Int where-  add i (Day d) = Day (d + i)-  difference (Day a) (Day b) = a - b---- | The day of the week.-newtype DayOfWeek = DayOfWeek { getDayOfWeek :: Int }-  deriving (Show,Read,Eq,Ord,Hashable)---- | The day of the month.-newtype DayOfMonth = DayOfMonth { getDayOfMonth :: Int }-  deriving (Show,Read,Eq,Ord,Prim,Enum)---- | The day of the year.-newtype DayOfYear = DayOfYear { getDayOfYear :: Int }-  deriving (Show,Read,Eq,Ord,Prim)---- | The month of the year.-newtype Month = Month { getMonth :: Int }-  deriving (Show,Read,Eq,Ord,Prim)--instance Bounded Month where-  minBound = Month 0-  maxBound = Month 11---- | The number of years elapsed since the beginning---   of the Common Era.-newtype Year = Year { getYear :: Int }-  deriving (Show,Read,Eq,Ord)--newtype Offset = Offset { getOffset :: Int }-  deriving (Show,Read,Eq,Ord)---- | POSIX time with nanosecond resolution.-newtype Time = Time { getTime :: Int64 }-  deriving (FromJSON,ToJSON,Hashable,Eq,Ord,Show,Read,Storable,Prim)--newtype DayOfWeekMatch a = DayOfWeekMatch { getDayOfWeekMatch :: Vector a }--newtype MonthMatch a = MonthMatch { getMonthMatch :: Vector a }--newtype UnboxedMonthMatch a = UnboxedMonthMatch { getUnboxedMonthMatch :: UVector.Vector a }---- | A timespan. This is represented internally as a number---   of nanoseconds.-newtype Timespan = Timespan { getTimespan :: Int64 }-  deriving (Show,Read,Eq,Ord,ToJSON,FromJSON,Additive)--instance Monoid Timespan where-  mempty = Timespan 0-  mappend (Timespan a) (Timespan b) = Timespan (a + b)--instance Torsor Time Timespan where-  add (Timespan ts) (Time t) = Time (t + ts)-  difference (Time t) (Time s) = Timespan (t - s)--instance Scaling Timespan Int64 where-  scale i (Timespan ts) = Timespan (i * ts)---- | The precision used when encoding seconds to a human-readable format.-data SubsecondPrecision-  = SubsecondPrecisionAuto -- ^ Rounds to second, millisecond, microsecond, or nanosecond-  | SubsecondPrecisionFixed {-# UNPACK #-} !Int -- ^ Specify number of places after decimal---- | A date as represented by the Gregorian calendar.-data Date = Date-  { dateYear  :: {-# UNPACK #-} !Year-  , dateMonth :: {-# UNPACK #-} !Month-  , dateDay   :: {-# UNPACK #-} !DayOfMonth-  } deriving (Show,Read,Eq,Ord)---- | The year and number of days elapsed since the beginning it began.-data OrdinalDate = OrdinalDate-  { ordinalDateYear :: {-# UNPACK #-} !Year-  , ordinalDateDayOfYear :: {-# UNPACK #-} !DayOfYear-  } deriving (Show,Read,Eq,Ord)---- | A month and the day of the month. This does not actually represent---   a specific date, since this recurs every year.-data MonthDate = MonthDate-  { monthDateMonth :: {-# UNPACK #-} !Month-  , monthDateDay :: {-# UNPACK #-} !DayOfMonth-  } deriving (Show,Read,Eq,Ord)---- | A date as represented by the Gregorian calendar---   and a time of day.-data Datetime = Datetime-  { datetimeDate :: {-# UNPACK #-} !Date-  , datetimeTime :: {-# UNPACK #-} !TimeOfDay-  } deriving (Show,Read,Eq,Ord)--data OffsetDatetime = OffsetDatetime-  { offsetDatetimeDatetime :: {-# UNPACK #-} !Datetime-  , offsetDatetimeOffset :: {-# UNPACK #-} !Offset-  } deriving (Show,Read,Eq,Ord)---- | A time of day with nanosecond resolution.-data TimeOfDay = TimeOfDay-  { timeOfDayHour :: {-# UNPACK #-} !Int-  , timeOfDayMinute :: {-# UNPACK #-} !Int-  , timeOfDayNanoseconds :: {-# UNPACK #-} !Int64-  } deriving (Show,Read,Eq,Ord)--data DatetimeFormat = DatetimeFormat-  { datetimeFormatDateSeparator :: !(Maybe Char)-    -- ^ Separator in the date-  , datetimeFormatSeparator :: !(Maybe Char)-    -- ^ Separator between date and time-  , datetimeFormatTimeSeparator :: !(Maybe Char)-    -- ^ Separator in the time-  } deriving (Show,Read,Eq,Ord)---- | Formatting settings for a timezone offset.-data OffsetFormat-  = OffsetFormatColonOff -- ^ @%z@ (e.g., -0400)-  | OffsetFormatColonOn -- ^ @%:z@ (e.g., -04:00)-  | OffsetFormatSecondsPrecision -- ^ @%::z@ (e.g., -04:00:00)-  | OffsetFormatColonAuto -- ^ @%:::z@ (e.g., -04, +05:30)-  deriving (Show,Read,Eq,Ord,Enum,Bounded,Generic)---- | Locale-specific formatting for weekdays and months. The---   type variable will likely be instantiated to @Text@---   or @ByteString@.-data DatetimeLocale a = DatetimeLocale-  { datetimeLocaleDaysOfWeekFull :: !(DayOfWeekMatch a)-    -- ^ full weekdays starting with Sunday, 7 elements-  , datetimeLocaleDaysOfWeekAbbreviated :: !(DayOfWeekMatch a)-    -- ^ abbreviated weekdays starting with Sunday, 7 elements-  , datetimeLocaleMonthsFull :: !(MonthMatch a)-    -- ^ full months starting with January, 12 elements-  , datetimeLocaleMonthsAbbreviated :: !(MonthMatch a)-    -- ^ abbreviated months starting with January, 12 elements-  }---- | Locale-specific formatting for AM and PM.-data MeridiemLocale a = MeridiemLocale-  { meridiemLocaleAm :: !a-  , meridiemLocalePm :: !a-  } deriving (Read,Show,Eq,Ord)--newtype instance UVector.MVector s Month = MV_Month (PVector.MVector s Month)-newtype instance UVector.Vector Month = V_Month (PVector.Vector Month)--instance UVector.Unbox Month--instance MGVector.MVector UVector.MVector Month where-  {-# INLINE basicLength #-}-  {-# INLINE basicUnsafeSlice #-}-  {-# INLINE basicOverlaps #-}-  {-# INLINE basicUnsafeNew #-}-  {-# INLINE basicInitialize #-}-  {-# INLINE basicUnsafeReplicate #-}-  {-# INLINE basicUnsafeRead #-}-  {-# INLINE basicUnsafeWrite #-}-  {-# INLINE basicClear #-}-  {-# INLINE basicSet #-}-  {-# INLINE basicUnsafeCopy #-}-  {-# INLINE basicUnsafeGrow #-}-  basicLength (MV_Month v) = MGVector.basicLength v-  basicUnsafeSlice i n (MV_Month v) = MV_Month $ MGVector.basicUnsafeSlice i n v-  basicOverlaps (MV_Month v1) (MV_Month v2) = MGVector.basicOverlaps v1 v2-  basicUnsafeNew n = MV_Month `liftM` MGVector.basicUnsafeNew n-  basicInitialize (MV_Month v) = MGVector.basicInitialize v-  basicUnsafeReplicate n x = MV_Month `liftM` MGVector.basicUnsafeReplicate n x-  basicUnsafeRead (MV_Month v) i = MGVector.basicUnsafeRead v i-  basicUnsafeWrite (MV_Month v) i x = MGVector.basicUnsafeWrite v i x-  basicClear (MV_Month v) = MGVector.basicClear v-  basicSet (MV_Month v) x = MGVector.basicSet v x-  basicUnsafeCopy (MV_Month v1) (MV_Month v2) = MGVector.basicUnsafeCopy v1 v2-  basicUnsafeMove (MV_Month v1) (MV_Month v2) = MGVector.basicUnsafeMove v1 v2-  basicUnsafeGrow (MV_Month v) n = MV_Month `liftM` MGVector.basicUnsafeGrow v n--instance GVector.Vector UVector.Vector Month where-  {-# INLINE basicUnsafeFreeze #-}-  {-# INLINE basicUnsafeThaw #-}-  {-# INLINE basicLength #-}-  {-# INLINE basicUnsafeSlice #-}-  {-# INLINE basicUnsafeIndexM #-}-  {-# INLINE elemseq #-}-  basicUnsafeFreeze (MV_Month v) = V_Month `liftM` GVector.basicUnsafeFreeze v-  basicUnsafeThaw (V_Month v) = MV_Month `liftM` GVector.basicUnsafeThaw v-  basicLength (V_Month v) = GVector.basicLength v-  basicUnsafeSlice i n (V_Month v) = V_Month $ GVector.basicUnsafeSlice i n v-  basicUnsafeIndexM (V_Month v) i = GVector.basicUnsafeIndexM v i-  basicUnsafeCopy (MV_Month mv) (V_Month v) = GVector.basicUnsafeCopy mv v-  elemseq _ = seq--newtype instance UVector.MVector s DayOfMonth = MV_DayOfMonth (PVector.MVector s DayOfMonth)-newtype instance UVector.Vector DayOfMonth = V_DayOfMonth (PVector.Vector DayOfMonth)--instance UVector.Unbox DayOfMonth--instance MGVector.MVector UVector.MVector DayOfMonth where-  {-# INLINE basicLength #-}-  {-# INLINE basicUnsafeSlice #-}-  {-# INLINE basicOverlaps #-}-  {-# INLINE basicUnsafeNew #-}-  {-# INLINE basicInitialize #-}-  {-# INLINE basicUnsafeReplicate #-}-  {-# INLINE basicUnsafeRead #-}-  {-# INLINE basicUnsafeWrite #-}-  {-# INLINE basicClear #-}-  {-# INLINE basicSet #-}-  {-# INLINE basicUnsafeCopy #-}-  {-# INLINE basicUnsafeGrow #-}-  basicLength (MV_DayOfMonth v) = MGVector.basicLength v-  basicUnsafeSlice i n (MV_DayOfMonth v) = MV_DayOfMonth $ MGVector.basicUnsafeSlice i n v-  basicOverlaps (MV_DayOfMonth v1) (MV_DayOfMonth v2) = MGVector.basicOverlaps v1 v2-  basicUnsafeNew n = MV_DayOfMonth `liftM` MGVector.basicUnsafeNew n-  basicInitialize (MV_DayOfMonth v) = MGVector.basicInitialize v-  basicUnsafeReplicate n x = MV_DayOfMonth `liftM` MGVector.basicUnsafeReplicate n x-  basicUnsafeRead (MV_DayOfMonth v) i = MGVector.basicUnsafeRead v i-  basicUnsafeWrite (MV_DayOfMonth v) i x = MGVector.basicUnsafeWrite v i x-  basicClear (MV_DayOfMonth v) = MGVector.basicClear v-  basicSet (MV_DayOfMonth v) x = MGVector.basicSet v x-  basicUnsafeCopy (MV_DayOfMonth v1) (MV_DayOfMonth v2) = MGVector.basicUnsafeCopy v1 v2-  basicUnsafeMove (MV_DayOfMonth v1) (MV_DayOfMonth v2) = MGVector.basicUnsafeMove v1 v2-  basicUnsafeGrow (MV_DayOfMonth v) n = MV_DayOfMonth `liftM` MGVector.basicUnsafeGrow v n--instance GVector.Vector UVector.Vector DayOfMonth where-  {-# INLINE basicUnsafeFreeze #-}-  {-# INLINE basicUnsafeThaw #-}-  {-# INLINE basicLength #-}-  {-# INLINE basicUnsafeSlice #-}-  {-# INLINE basicUnsafeIndexM #-}-  {-# INLINE elemseq #-}-  basicUnsafeFreeze (MV_DayOfMonth v) = V_DayOfMonth `liftM` GVector.basicUnsafeFreeze v-  basicUnsafeThaw (V_DayOfMonth v) = MV_DayOfMonth `liftM` GVector.basicUnsafeThaw v-  basicLength (V_DayOfMonth v) = GVector.basicLength v-  basicUnsafeSlice i n (V_DayOfMonth v) = V_DayOfMonth $ GVector.basicUnsafeSlice i n v-  basicUnsafeIndexM (V_DayOfMonth v) i = GVector.basicUnsafeIndexM v i-  basicUnsafeCopy (MV_DayOfMonth mv) (V_DayOfMonth v) = GVector.basicUnsafeCopy mv v-  elemseq _ = seq+import Chronos