format everything with hindent
authorAshley Yakeley <ashley@semantic.org>
Tue, 21 May 2019 05:27:20 +0000 (22:27 -0700)
committerAshley Yakeley <ashley@semantic.org>
Tue, 21 May 2019 05:27:20 +0000 (22:27 -0700)
81 files changed:
.hindent.ignore [new file with mode: 0644]
.vscode/.gitignore [new file with mode: 0644]
Setup.hs
benchmark/Main.hs
hindent-all [new file with mode: 0755]
lib/Data/Format.hs
lib/Data/Time.hs
lib/Data/Time/Calendar.hs
lib/Data/Time/Calendar/CalendarDiffDays.hs
lib/Data/Time/Calendar/Days.hs
lib/Data/Time/Calendar/Easter.hs
lib/Data/Time/Calendar/Gregorian.hs
lib/Data/Time/Calendar/Julian.hs
lib/Data/Time/Calendar/JulianYearDay.hs
lib/Data/Time/Calendar/MonthDay.hs
lib/Data/Time/Calendar/OrdinalDate.hs
lib/Data/Time/Calendar/Private.hs
lib/Data/Time/Calendar/WeekDate.hs
lib/Data/Time/Clock.hs
lib/Data/Time/Clock/Internal/AbsoluteTime.hs
lib/Data/Time/Clock/Internal/CTimespec.hsc
lib/Data/Time/Clock/Internal/CTimeval.hs
lib/Data/Time/Clock/Internal/DiffTime.hs
lib/Data/Time/Clock/Internal/NominalDiffTime.hs
lib/Data/Time/Clock/Internal/POSIXTime.hs
lib/Data/Time/Clock/Internal/SystemTime.hs
lib/Data/Time/Clock/Internal/UTCTime.hs
lib/Data/Time/Clock/Internal/UniversalTime.hs
lib/Data/Time/Clock/POSIX.hs
lib/Data/Time/Clock/System.hs
lib/Data/Time/Clock/TAI.hs
lib/Data/Time/Format.hs
lib/Data/Time/Format/Format/Class.hs
lib/Data/Time/Format/Format/Instances.hs
lib/Data/Time/Format/ISO8601.hs
lib/Data/Time/Format/Internal.hs
lib/Data/Time/Format/Locale.hs
lib/Data/Time/Format/Parse.hs
lib/Data/Time/Format/Parse/Class.hs
lib/Data/Time/Format/Parse/Instances.hs
lib/Data/Time/LocalTime.hs
lib/Data/Time/LocalTime/Internal/CalendarDiffTime.hs
lib/Data/Time/LocalTime/Internal/LocalTime.hs
lib/Data/Time/LocalTime/Internal/TimeOfDay.hs
lib/Data/Time/LocalTime/Internal/TimeZone.hs
lib/Data/Time/LocalTime/Internal/ZonedTime.hs
stack.yaml
test/RealToFracBenchmark.hs
test/ShowDST.hs
test/ShowDefaultTZAbbreviations.hs
test/main/Main.hs
test/main/Test/Arbitrary.hs
test/main/Test/Calendar/AddDays.hs
test/main/Test/Calendar/AddDaysRef.hs
test/main/Test/Calendar/Calendars.hs
test/main/Test/Calendar/CalendarsRef.hs
test/main/Test/Calendar/ClipDates.hs
test/main/Test/Calendar/ClipDatesRef.hs
test/main/Test/Calendar/ConvertBack.hs
test/main/Test/Calendar/Duration.hs
test/main/Test/Calendar/Easter.hs
test/main/Test/Calendar/EasterRef.hs
test/main/Test/Calendar/LongWeekYears.hs
test/main/Test/Calendar/LongWeekYearsRef.hs
test/main/Test/Calendar/MonthDay.hs
test/main/Test/Calendar/MonthDayRef.hs
test/main/Test/Calendar/Valid.hs
test/main/Test/Clock/Conversion.hs
test/main/Test/Clock/Resolution.hs
test/main/Test/Clock/TAI.hs
test/main/Test/Format/Format.hs
test/main/Test/Format/ISO8601.hs
test/main/Test/Format/ParseTime.hs
test/main/Test/LocalTime/CalendarDiffTime.hs
test/main/Test/LocalTime/Time.hs
test/main/Test/LocalTime/TimeRef.hs
test/main/Test/TestUtil.hs
test/unix/Main.hs
test/unix/Test/Format/Format.hs
test/unix/Test/LocalTime/TimeZone.hs
test/unix/Test/TestUtil.hs

diff --git a/.hindent.ignore b/.hindent.ignore
new file mode 100644 (file)
index 0000000..4467119
--- /dev/null
@@ -0,0 +1,2 @@
+./lib/Data/Time/Calendar/CalendarDiffDays.hs
+./lib/Data/Time/LocalTime/Internal/CalendarDiffTime.hs
diff --git a/.vscode/.gitignore b/.vscode/.gitignore
new file mode 100644 (file)
index 0000000..78b073f
--- /dev/null
@@ -0,0 +1 @@
+ipch
index 54f57d6..ca7d91c 100644 (file)
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,4 +1,6 @@
-module Main (main) where
+module Main
+    ( main
+    ) where
 
 import Distribution.Simple
 
index 4807034..5b6b012 100644 (file)
@@ -1,12 +1,13 @@
 {-# LANGUAGE PackageImports #-}
+
 module Main where
 
-import  Criterion.Main
-import  Data.Time
-import  Data.Time.Clock.POSIX
-import  Data.Time.Clock.System
+import Criterion.Main
+import Data.Time
+import Data.Time.Clock.POSIX
+import Data.Time.Clock.System
 
-import qualified "time" Data.Time             as O
+import qualified "time" Data.Time as O
 import qualified "time" Data.Time.Clock.POSIX as O
 
 main :: IO ()
@@ -17,38 +18,20 @@ main = do
     O.getPOSIXTime >>= print . O.posixSecondsToUTCTime
     getZonedTime >>= print
     O.getZonedTime >>= print
-
     _tz <- getCurrentTimeZone
     ct <- getCurrentTime
     _otz <- O.getCurrentTimeZone
     oct <- O.getCurrentTime
-
-    defaultMain [
-        bgroup "getCurrentTime" [
-            bench "old" $ nfIO O.getCurrentTime,
-            bench "new" $ nfIO getCurrentTime
-            ],
-        bgroup "getPOSIXTime" [
-            bench "old" $ nfIO O.getPOSIXTime,
-            bench "new" $ nfIO getPOSIXTime
-            ],
-        bgroup "getSystemTime" [
-            bench "new" $ nfIO getSystemTime
-            ],
-        bgroup "getTimeZone" [
-            bench "old" $ nfIO $ O.getTimeZone oct,
-            bench "new" $ nfIO $ getTimeZone ct
-            ],
-        bgroup "getCurrentTimeZone" [
-            bench "old" $ nfIO O.getCurrentTimeZone,
-            bench "new" $ nfIO getCurrentTimeZone
-            ],
-        bgroup "getZonedTime" [
-            bench "old" $ nfIO O.getZonedTime,
-            bench "new" $ nfIO getZonedTime
-            ],
-        bgroup "formatTime" [
-            bench "old" $ nf (O.formatTime O.defaultTimeLocale "%a, %_d %b %Y %H:%M:%S %Z") oct,
-            bench "new" $ nf (formatTime defaultTimeLocale "%a, %_d %b %Y %H:%M:%S %Z") ct
-            ]
+    defaultMain
+        [ bgroup "getCurrentTime" [bench "old" $ nfIO O.getCurrentTime, bench "new" $ nfIO getCurrentTime]
+        , bgroup "getPOSIXTime" [bench "old" $ nfIO O.getPOSIXTime, bench "new" $ nfIO getPOSIXTime]
+        , bgroup "getSystemTime" [bench "new" $ nfIO getSystemTime]
+        , bgroup "getTimeZone" [bench "old" $ nfIO $ O.getTimeZone oct, bench "new" $ nfIO $ getTimeZone ct]
+        , bgroup "getCurrentTimeZone" [bench "old" $ nfIO O.getCurrentTimeZone, bench "new" $ nfIO getCurrentTimeZone]
+        , bgroup "getZonedTime" [bench "old" $ nfIO O.getZonedTime, bench "new" $ nfIO getZonedTime]
+        , bgroup
+              "formatTime"
+              [ bench "old" $ nf (O.formatTime O.defaultTimeLocale "%a, %_d %b %Y %H:%M:%S %Z") oct
+              , bench "new" $ nf (formatTime defaultTimeLocale "%a, %_d %b %Y %H:%M:%S %Z") ct
+              ]
         ]
diff --git a/hindent-all b/hindent-all
new file mode 100755 (executable)
index 0000000..18e6d9e
--- /dev/null
@@ -0,0 +1,3 @@
+#!/bin/bash -e
+stack install --no-test hindent
+for f in `find -name '*.hs' -not -path '*.stack-work/*' | grep -xvf .hindent.ignore`; do `stack path --local-bin`/hindent $f || exit; done
index 17fe319..15681a8 100644 (file)
@@ -22,56 +22,40 @@ module Data.Format
     , decimalFormat
     ) where
 
-#if MIN_VERSION_base(4,9,0)
 import Control.Monad.Fail
-import Prelude hiding (fail)
-#endif
-#if MIN_VERSION_base(4,8,0)
-import Data.Void
-#endif
 import Data.Char
+import Data.Void
+import Prelude hiding (fail)
 import Text.ParserCombinators.ReadP
 
-
-#if MIN_VERSION_base(4,8,0)
-#else
-data Void
-absurd :: Void -> a
-absurd v = seq v $ error "absurd"
-#endif
-
 class IsoVariant f where
     isoMap :: (a -> b) -> (b -> a) -> f a -> f b
 
-enumMap :: (IsoVariant f,Enum a) => f Int -> f a
+enumMap :: (IsoVariant f, Enum a) => f Int -> f a
 enumMap = isoMap toEnum fromEnum
 
 infixr 3 <**>, **>, <**
+
 class IsoVariant f => Productish f where
     pUnit :: f ()
-    (<**>) :: f a -> f b -> f (a,b)
-    (**>) ::  f () -> f a -> f a
-    fu **> fa = isoMap (\((),a) -> a) (\a -> ((),a)) $ fu <**> fa
-    (<**) ::  f a -> f () -> f a
-    fa <** fu = isoMap (\(a,()) -> a) (\a -> (a,())) $ fa <**> fu
+    (<**>) :: f a -> f b -> f (a, b)
+    (**>) :: f () -> f a -> f a
+    fu **> fa = isoMap (\((), a) -> a) (\a -> ((), a)) $ fu <**> fa
+    (<**) :: f a -> f () -> f a
+    fa <** fu = isoMap (\(a, ()) -> a) (\a -> (a, ())) $ fa <**> fu
 
 infixr 2 <++>
+
 class IsoVariant f => Summish f where
     pVoid :: f Void
     (<++>) :: f a -> f b -> f (Either a b)
 
-
-parseReader :: (
-#if MIN_VERSION_base(4,9,0)
-    MonadFail m
-#else
-    Monad m
-#endif
-    ) => ReadP t -> String -> m t
-parseReader readp s = case [ t | (t,"") <- readP_to_S readp s] of
-    [t] -> return t
-    []  -> fail $ "no parse of " ++ show s
-    _   -> fail $ "multiple parses of " ++ show s
+parseReader :: (MonadFail m) => ReadP t -> String -> m t
+parseReader readp s =
+    case [t | (t, "") <- readP_to_S readp s] of
+        [t] -> return t
+        [] -> fail $ "no parse of " ++ show s
+        _ -> fail $ "multiple parses of " ++ show s
 
 -- | A text format for a type
 data Format t = MkFormat
@@ -83,36 +67,41 @@ data Format t = MkFormat
 
 -- | Show a value in the format, or error if unrepresentable
 formatShow :: Format t -> t -> String
-formatShow fmt t = case formatShowM fmt t of
-    Just str -> str
-    Nothing -> error "formatShow: bad value"
+formatShow fmt t =
+    case formatShowM fmt t of
+        Just str -> str
+        Nothing -> error "formatShow: bad value"
 
 -- | Parse a value in the format
-formatParseM :: (
-#if MIN_VERSION_base(4,9,0)
-    MonadFail m
-#else
-    Monad m
-#endif
-    ) => Format t -> String -> m t
+formatParseM :: (MonadFail m) => Format t -> String -> m t
 formatParseM format = parseReader $ formatReadP format
 
 instance IsoVariant Format where
     isoMap ab ba (MkFormat sa ra) = MkFormat (\b -> sa $ ba b) (fmap ab ra)
 
 mapMFormat :: (a -> Maybe b) -> (b -> Maybe a) -> Format a -> Format b
-mapMFormat amb bma (MkFormat sa ra) = MkFormat (\b -> bma b >>= sa) $ do
-    a <- ra
-    case amb a of
-        Just b -> return b
-        Nothing -> pfail
+mapMFormat amb bma (MkFormat sa ra) =
+    MkFormat (\b -> bma b >>= sa) $ do
+        a <- ra
+        case amb a of
+            Just b -> return b
+            Nothing -> pfail
 
 filterFormat :: (a -> Bool) -> Format a -> Format a
-filterFormat test = mapMFormat (\a -> if test a then Just a else Nothing) (\a -> if test a then Just a else Nothing)
+filterFormat test =
+    mapMFormat
+        (\a ->
+             if test a
+                 then Just a
+                 else Nothing)
+        (\a ->
+             if test a
+                 then Just a
+                 else Nothing)
 
 -- | Limits are inclusive
-clipFormat :: Ord a => (a,a) -> Format a -> Format a
-clipFormat (lo,hi) = filterFormat (\a -> a >= lo && a <= hi)
+clipFormat :: Ord a => (a, a) -> Format a -> Format a
+clipFormat (lo, hi) = filterFormat (\a -> a >= lo && a <= hi)
 
 instance Productish Format where
     pUnit = MkFormat {formatShowM = \_ -> Just "", formatReadP = return ()}
@@ -157,45 +146,36 @@ instance Summish Format where
 literalFormat :: String -> Format ()
 literalFormat s = MkFormat {formatShowM = \_ -> Just s, formatReadP = string s >> return ()}
 
-specialCaseShowFormat :: Eq a => (a,String) -> Format a -> Format a
-specialCaseShowFormat (val,str) (MkFormat s r) = let
-    s' t | t == val = Just str
+specialCaseShowFormat :: Eq a => (a, String) -> Format a -> Format a
+specialCaseShowFormat (val, str) (MkFormat s r) = let
+    s' t
+        | t == val = Just str
     s' t = s t
     in MkFormat s' r
 
-specialCaseFormat :: Eq a => (a,String) -> Format a -> Format a
-specialCaseFormat (val,str) (MkFormat s r) = let
-    s' t | t == val = Just str
+specialCaseFormat :: Eq a => (a, String) -> Format a -> Format a
+specialCaseFormat (val, str) (MkFormat s r) = let
+    s' t
+        | t == val = Just str
     s' t = s t
     r' = (string str >> return val) +++ r
     in MkFormat s' r'
 
 optionalFormat :: Eq a => a -> Format a -> Format a
-optionalFormat val = specialCaseFormat (val,"")
+optionalFormat val = specialCaseFormat (val, "")
 
-casesFormat :: Eq a => [(a,String)] -> Format a
+casesFormat :: Eq a => [(a, String)] -> Format a
 casesFormat pairs = let
     s t = lookup t pairs
     r [] = pfail
-    r ((v,str):pp) = (string str >> return v) <++ r pp
+    r ((v, str):pp) = (string str >> return v) <++ r pp
     in MkFormat s $ r pairs
 
-optionalSignFormat :: (Eq t,Num t) => Format t
-optionalSignFormat = casesFormat
-    [
-        (1,""),
-        (1,"+"),
-        (0,""),
-        (-1,"-")
-    ]
-
-mandatorySignFormat :: (Eq t,Num t) => Format t
-mandatorySignFormat = casesFormat
-    [
-        (1,"+"),
-        (0,"+"),
-        (-1,"-")
-    ]
+optionalSignFormat :: (Eq t, Num t) => Format t
+optionalSignFormat = casesFormat [(1, ""), (1, "+"), (0, ""), (-1, "-")]
+
+mandatorySignFormat :: (Eq t, Num t) => Format t
+mandatorySignFormat = casesFormat [(1, "+"), (0, "+"), (-1, "-")]
 
 data SignOption
     = NoSign
@@ -231,7 +211,8 @@ zeroPad (Just i) s = replicate (i - length s) '0' ++ s
 trimTrailing :: String -> String
 trimTrailing "" = ""
 trimTrailing "." = ""
-trimTrailing s | last s == '0' = trimTrailing $ init s
+trimTrailing s
+    | last s == '0' = trimTrailing $ init s
 trimTrailing s = s
 
 showNumber :: Show t => SignOption -> Maybe Int -> t -> Maybe String
@@ -245,12 +226,13 @@ showNumber signOpt mdigitcount t = let
                    NoSign -> Nothing
                    _ -> Just $ '-' : showIt str
            str ->
-               Just $ case signOpt of
+               Just $
+               case signOpt of
                    PosNegSign -> '+' : showIt str
                    _ -> showIt str
 
-integerFormat :: (Show t,Read t,Num t) => SignOption -> Maybe Int -> Format t
+integerFormat :: (Show t, Read t, Num t) => SignOption -> Maybe Int -> Format t
 integerFormat signOpt mdigitcount = MkFormat (showNumber signOpt mdigitcount) (readNumber signOpt mdigitcount False)
 
-decimalFormat :: (Show t,Read t,Num t) => SignOption -> Maybe Int -> Format t
+decimalFormat :: (Show t, Read t, Num t) => SignOption -> Maybe Int -> Format t
 decimalFormat signOpt mdigitcount = MkFormat (showNumber signOpt mdigitcount) (readNumber signOpt mdigitcount True)
index 607ad28..75cf094 100644 (file)
@@ -29,14 +29,13 @@ These are less commonly needed:
 * 'UniversalTime' for time based on Earth rotation
 -}
 module Data.Time
-(
-    module Data.Time.Calendar,
-    module Data.Time.Clock,
-    module Data.Time.LocalTime,
-    module Data.Time.Format
-) where
+    ( module Data.Time.Calendar
+    , module Data.Time.Clock
+    , module Data.Time.LocalTime
+    , module Data.Time.Format
+    ) where
 
 import Data.Time.Calendar
 import Data.Time.Clock
-import Data.Time.LocalTime
 import Data.Time.Format
+import Data.Time.LocalTime
index fc5ace4..bcfdd31 100644 (file)
@@ -1,13 +1,12 @@
 module Data.Time.Calendar
-(
-    module Data.Time.Calendar.Days,
-    module Data.Time.Calendar.CalendarDiffDays,
-    module Data.Time.Calendar.Gregorian,
-    module Data.Time.Calendar.Week
-) where
+    ( module Data.Time.Calendar.Days
+    , module Data.Time.Calendar.CalendarDiffDays
+    , module Data.Time.Calendar.Gregorian
+    , module Data.Time.Calendar.Week
+    ) where
 
-import Data.Time.Calendar.Days
 import Data.Time.Calendar.CalendarDiffDays
+import Data.Time.Calendar.Days
 import Data.Time.Calendar.Gregorian
 import Data.Time.Calendar.Week
-import Data.Time.Format()
+import Data.Time.Format ()
index d5c69b8..68f338a 100644 (file)
@@ -4,11 +4,8 @@ module Data.Time.Calendar.CalendarDiffDays
         module Data.Time.Calendar.CalendarDiffDays
     ) where
 
-#if MIN_VERSION_base(4,8,0)
+#if MIN_VERSION_base(4,11,0)
 #else
-import Data.Monoid
-#endif
-#if MIN_VERSION_base(4,9,0) && !MIN_VERSION_base(4,11,0)
 import Data.Semigroup hiding (option)
 #endif
 import Data.Typeable
@@ -28,20 +25,14 @@ data CalendarDiffDays = CalendarDiffDays
 #endif
     )
 
-#if MIN_VERSION_base(4,9,0)
 -- | Additive
 instance Semigroup CalendarDiffDays where
     CalendarDiffDays m1 d1 <> CalendarDiffDays m2 d2 = CalendarDiffDays (m1 + m2) (d1 + d2)
-#endif
 
 -- | Additive
 instance Monoid CalendarDiffDays where
     mempty = CalendarDiffDays 0 0
-#if MIN_VERSION_base(4,9,0)
     mappend = (<>)
-#else
-    mappend (CalendarDiffDays m1 d1) (CalendarDiffDays m2 d2) = CalendarDiffDays (m1 + m2) (d1 + d2)
-#endif
 
 instance Show CalendarDiffDays where
     show (CalendarDiffDays m d) = "P" ++ show m ++ "M" ++ show d ++ "D"
index 450ef07..a1aebf2 100644 (file)
@@ -1,17 +1,22 @@
 {-# OPTIONS -fno-warn-unused-imports #-}
+
 module Data.Time.Calendar.Days
-(
+    (
     -- * Days
-    Day(..),addDays,diffDays
-) where
+      Day(..)
+    , addDays
+    , diffDays
+    ) where
 
 import Control.DeepSeq
+import Data.Data
 import Data.Ix
 import Data.Typeable
-import Data.Data
 
 -- | The Modified Julian Day is a standard count of days, with zero being the day 1858-11-17.
-newtype Day = ModifiedJulianDay {toModifiedJulianDay :: Integer} deriving (Eq,Ord,Data, Typeable)
+newtype Day = ModifiedJulianDay
+    { toModifiedJulianDay :: Integer
+    } deriving (Eq, Ord, Data, Typeable)
 
 instance NFData Day where
     rnf (ModifiedJulianDay a) = rnf a
@@ -25,14 +30,15 @@ instance Enum Day where
     enumFrom (ModifiedJulianDay a) = fmap ModifiedJulianDay (enumFrom a)
     enumFromThen (ModifiedJulianDay a) (ModifiedJulianDay b) = fmap ModifiedJulianDay (enumFromThen a b)
     enumFromTo (ModifiedJulianDay a) (ModifiedJulianDay b) = fmap ModifiedJulianDay (enumFromTo a b)
-    enumFromThenTo (ModifiedJulianDay a) (ModifiedJulianDay b) (ModifiedJulianDay c) = fmap ModifiedJulianDay (enumFromThenTo a b c)
+    enumFromThenTo (ModifiedJulianDay a) (ModifiedJulianDay b) (ModifiedJulianDay c) =
+        fmap ModifiedJulianDay (enumFromThenTo a b c)
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
 instance Ix Day where
-    range (ModifiedJulianDay a,ModifiedJulianDay b) = fmap ModifiedJulianDay (range (a,b))
-    index (ModifiedJulianDay a,ModifiedJulianDay b) (ModifiedJulianDay c) = index (a,b) c
-    inRange (ModifiedJulianDay a,ModifiedJulianDay b) (ModifiedJulianDay c) = inRange (a,b) c
-    rangeSize (ModifiedJulianDay a,ModifiedJulianDay b) = rangeSize (a,b)
+    range (ModifiedJulianDay a, ModifiedJulianDay b) = fmap ModifiedJulianDay (range (a, b))
+    index (ModifiedJulianDay a, ModifiedJulianDay b) (ModifiedJulianDay c) = index (a, b) c
+    inRange (ModifiedJulianDay a, ModifiedJulianDay b) (ModifiedJulianDay c) = inRange (a, b) c
+    rangeSize (ModifiedJulianDay a, ModifiedJulianDay b) = rangeSize (a, b)
 
 addDays :: Integer -> Day -> Day
 addDays n (ModifiedJulianDay a) = ModifiedJulianDay (a + n)
index ddc029c..f6ce579 100644 (file)
@@ -1,12 +1,12 @@
 module Data.Time.Calendar.Easter
-    (
-    sundayAfter,
-    orthodoxPaschalMoon,orthodoxEaster,
-    gregorianPaschalMoon,gregorianEaster
+    ( sundayAfter
+    , orthodoxPaschalMoon
+    , orthodoxEaster
+    , gregorianPaschalMoon
+    , gregorianEaster
     ) where
 
 -- formulae from Reingold & Dershowitz, _Calendrical Calculations_, ch. 8.
-
 import Data.Time.Calendar
 import Data.Time.Calendar.Julian
 
@@ -16,9 +16,13 @@ sundayAfter day = addDays (7 - (mod (toModifiedJulianDay day + 3) 7)) day
 
 -- | Given a year, find the Paschal full moon according to Orthodox Christian tradition
 orthodoxPaschalMoon :: Integer -> Day
-orthodoxPaschalMoon year  = addDays (- shiftedEpact) (fromJulian jyear 4 19) where
+orthodoxPaschalMoon year = addDays (-shiftedEpact) (fromJulian jyear 4 19)
+  where
     shiftedEpact = mod (14 + 11 * (mod year 19)) 30
-    jyear = if year > 0 then year else year - 1
+    jyear =
+        if year > 0
+            then year
+            else year - 1
 
 -- | Given a year, find Easter according to Orthodox Christian tradition
 orthodoxEaster :: Integer -> Day
@@ -26,10 +30,14 @@ orthodoxEaster = sundayAfter . orthodoxPaschalMoon
 
 -- | Given a year, find the Paschal full moon according to the Gregorian method
 gregorianPaschalMoon :: Integer -> Day
-gregorianPaschalMoon year  = addDays (- adjustedEpact) (fromGregorian year 4 19) where
+gregorianPaschalMoon year = addDays (-adjustedEpact) (fromGregorian year 4 19)
+  where
     century = (div year 100) + 1
     shiftedEpact = mod (14 + 11 * (mod year 19) - (div (3 * century) 4) + (div (5 + 8 * century) 25)) 30
-    adjustedEpact = if shiftedEpact == 0 || ((shiftedEpact == 1) && (mod year 19 < 10)) then shiftedEpact + 1 else shiftedEpact
+    adjustedEpact =
+        if shiftedEpact == 0 || ((shiftedEpact == 1) && (mod year 19 < 10))
+            then shiftedEpact + 1
+            else shiftedEpact
 
 -- | Given a year, find Easter according to the Gregorian method
 gregorianEaster :: Integer -> Day
index 022435d..198a950 100644 (file)
@@ -1,31 +1,39 @@
 {-# OPTIONS -fno-warn-orphans #-}
+
 module Data.Time.Calendar.Gregorian
-(
+    (
     -- * Gregorian calendar
-    toGregorian,fromGregorian,fromGregorianValid,showGregorian,gregorianMonthLength,
-
+      toGregorian
+    , fromGregorian
+    , fromGregorianValid
+    , showGregorian
+    , gregorianMonthLength
     -- calendrical arithmetic
     -- e.g. "one month after March 31st"
-    addGregorianMonthsClip,addGregorianMonthsRollOver,
-    addGregorianYearsClip,addGregorianYearsRollOver,
-    addGregorianDurationClip,addGregorianDurationRollOver,
-    diffGregorianDurationClip,diffGregorianDurationRollOver,
-
+    , addGregorianMonthsClip
+    , addGregorianMonthsRollOver
+    , addGregorianYearsClip
+    , addGregorianYearsRollOver
+    , addGregorianDurationClip
+    , addGregorianDurationRollOver
+    , diffGregorianDurationClip
+    , diffGregorianDurationRollOver
     -- re-exported from OrdinalDate
-    isLeapYear
-) where
+    isLeapYear
+    ) where
 
+import Data.Time.Calendar.CalendarDiffDays
+import Data.Time.Calendar.Days
 import Data.Time.Calendar.MonthDay
 import Data.Time.Calendar.OrdinalDate
-import Data.Time.Calendar.Days
-import Data.Time.Calendar.CalendarDiffDays
 import Data.Time.Calendar.Private
 
 -- | Convert to proleptic Gregorian calendar. First element of result is year, second month number (1-12), third day (1-31).
-toGregorian :: Day -> (Integer,Int,Int)
-toGregorian date = (year,month,day) where
-    (year,yd) = toOrdinalDate date
-    (month,day) = dayOfYearToMonthAndDay (isLeapYear year) yd
+toGregorian :: Day -> (Integer, Int, Int)
+toGregorian date = (year, month, day)
+  where
+    (year, yd) = toOrdinalDate date
+    (month, day) = dayOfYearToMonthAndDay (isLeapYear year) yd
 
 -- | Convert from proleptic Gregorian calendar. First argument is year, second month number (1-12), third day (1-31).
 -- Invalid values will be clipped to the correct range, month first, then day.
@@ -41,32 +49,36 @@ fromGregorianValid year month day = do
 
 -- | Show in ISO 8601 format (yyyy-mm-dd)
 showGregorian :: Day -> String
-showGregorian date = (show4 y) ++ "-" ++ (show2 m) ++ "-" ++ (show2 d) where
-    (y,m,d) = toGregorian date
+showGregorian date = (show4 y) ++ "-" ++ (show2 m) ++ "-" ++ (show2 d)
+  where
+    (y, m, d) = toGregorian date
 
 -- | The number of days in a given month according to the proleptic Gregorian calendar. First argument is year, second is month.
 gregorianMonthLength :: Integer -> Int -> Int
 gregorianMonthLength year = monthLength (isLeapYear year)
 
-rolloverMonths :: (Integer,Integer) -> (Integer,Int)
-rolloverMonths (y,m) = (y + (div (m - 1) 12),fromIntegral (mod (m - 1) 12) + 1)
+rolloverMonths :: (Integer, Integer) -> (Integer, Int)
+rolloverMonths (y, m) = (y + (div (m - 1) 12), fromIntegral (mod (m - 1) 12) + 1)
 
-addGregorianMonths :: Integer -> Day -> (Integer,Int,Int)
-addGregorianMonths n day = (y',m',d) where
-    (y,m,d) = toGregorian day
-    (y',m') = rolloverMonths (y,fromIntegral m + n)
+addGregorianMonths :: Integer -> Day -> (Integer, Int, Int)
+addGregorianMonths n day = (y', m', d)
+  where
+    (y, m, d) = toGregorian day
+    (y', m') = rolloverMonths (y, fromIntegral m + n)
 
 -- | Add months, with days past the last day of the month clipped to the last day.
 -- For instance, 2005-01-30 + 1 month = 2005-02-28.
 addGregorianMonthsClip :: Integer -> Day -> Day
-addGregorianMonthsClip n day = fromGregorian y m d where
-    (y,m,d) = addGregorianMonths n day
+addGregorianMonthsClip n day = fromGregorian y m d
+  where
+    (y, m, d) = addGregorianMonths n day
 
 -- | Add months, with days past the last day of the month rolling over to the next month.
 -- For instance, 2005-01-30 + 1 month = 2005-03-02.
 addGregorianMonthsRollOver :: Integer -> Day -> Day
-addGregorianMonthsRollOver n day = addDays (fromIntegral d - 1) (fromGregorian y m 1) where
-    (y,m,d) = addGregorianMonths n day
+addGregorianMonthsRollOver n day = addDays (fromIntegral d - 1) (fromGregorian y m 1)
+  where
+    (y, m, d) = addGregorianMonths n day
 
 -- | Add years, matching month and day, with Feb 29th clipped to Feb 28th if necessary.
 -- For instance, 2004-02-29 + 2 years = 2006-02-28.
@@ -89,15 +101,19 @@ addGregorianDurationRollOver (CalendarDiffDays m d) day = addDays d $ addGregori
 -- | Calendrical difference, with as many whole months as possible
 diffGregorianDurationClip :: Day -> Day -> CalendarDiffDays
 diffGregorianDurationClip day2 day1 = let
-    (y1,m1,d1) = toGregorian day1
-    (y2,m2,d2) = toGregorian day2
+    (y1, m1, d1) = toGregorian day1
+    (y2, m2, d2) = toGregorian day2
     ym1 = y1 * 12 + toInteger m1
     ym2 = y2 * 12 + toInteger m2
     ymdiff = ym2 - ym1
     ymAllowed =
-        if day2 >= day1 then
-        if d2 >= d1 then ymdiff else ymdiff - 1
-        else if d2 <= d1 then ymdiff else ymdiff + 1
+        if day2 >= day1
+            then if d2 >= d1
+                     then ymdiff
+                     else ymdiff - 1
+            else if d2 <= d1
+                     then ymdiff
+                     else ymdiff + 1
     dayAllowed = addGregorianDurationClip (CalendarDiffDays ymAllowed 0) day1
     in CalendarDiffDays ymAllowed $ diffDays day2 dayAllowed
 
@@ -105,15 +121,19 @@ diffGregorianDurationClip day2 day1 = let
 -- Same as 'diffGregorianDurationClip' for positive durations.
 diffGregorianDurationRollOver :: Day -> Day -> CalendarDiffDays
 diffGregorianDurationRollOver day2 day1 = let
-    (y1,m1,d1) = toGregorian day1
-    (y2,m2,d2) = toGregorian day2
+    (y1, m1, d1) = toGregorian day1
+    (y2, m2, d2) = toGregorian day2
     ym1 = y1 * 12 + toInteger m1
     ym2 = y2 * 12 + toInteger m2
     ymdiff = ym2 - ym1
     ymAllowed =
-        if day2 >= day1 then
-        if d2 >= d1 then ymdiff else ymdiff - 1
-        else if d2 <= d1 then ymdiff else ymdiff + 1
+        if day2 >= day1
+            then if d2 >= d1
+                     then ymdiff
+                     else ymdiff - 1
+            else if d2 <= d1
+                     then ymdiff
+                     else ymdiff + 1
     dayAllowed = addGregorianDurationRollOver (CalendarDiffDays ymAllowed 0) day1
     in CalendarDiffDays ymAllowed $ diffDays day2 dayAllowed
 
index 6fd343b..dd1273a 100644 (file)
@@ -1,28 +1,34 @@
 module Data.Time.Calendar.Julian
-(
-    module Data.Time.Calendar.JulianYearDay,
-
-    toJulian,fromJulian,fromJulianValid,showJulian,julianMonthLength,
-
+    ( module Data.Time.Calendar.JulianYearDay
+    , toJulian
+    , fromJulian
+    , fromJulianValid
+    , showJulian
+    , julianMonthLength
     -- calendrical arithmetic
     -- e.g. "one month after March 31st"
-    addJulianMonthsClip,addJulianMonthsRollOver,
-    addJulianYearsClip,addJulianYearsRollOver,
-    addJulianDurationClip,addJulianDurationRollOver,
-    diffJulianDurationClip,diffJulianDurationRollOver,
-) where
+    , addJulianMonthsClip
+    , addJulianMonthsRollOver
+    , addJulianYearsClip
+    , addJulianYearsRollOver
+    , addJulianDurationClip
+    , addJulianDurationRollOver
+    , diffJulianDurationClip
+    , diffJulianDurationRollOver
+    ) where
 
-import Data.Time.Calendar.MonthDay
-import Data.Time.Calendar.JulianYearDay
-import Data.Time.Calendar.Days
 import Data.Time.Calendar.CalendarDiffDays
+import Data.Time.Calendar.Days
+import Data.Time.Calendar.JulianYearDay
+import Data.Time.Calendar.MonthDay
 import Data.Time.Calendar.Private
 
 -- | Convert to proleptic Julian calendar. First element of result is year, second month number (1-12), third day (1-31).
-toJulian :: Day -> (Integer,Int,Int)
-toJulian date = (year,month,day) where
-    (year,yd) = toJulianYearAndDay date
-    (month,day) = dayOfYearToMonthAndDay (isJulianLeapYear year) yd
+toJulian :: Day -> (Integer, Int, Int)
+toJulian date = (year, month, day)
+  where
+    (year, yd) = toJulianYearAndDay date
+    (month, day) = dayOfYearToMonthAndDay (isJulianLeapYear year) yd
 
 -- | Convert from proleptic Julian calendar. First argument is year, second month number (1-12), third day (1-31).
 -- Invalid values will be clipped to the correct range, month first, then day.
@@ -38,32 +44,36 @@ fromJulianValid year month day = do
 
 -- | Show in ISO 8601 format (yyyy-mm-dd)
 showJulian :: Day -> String
-showJulian date = (show4 y) ++ "-" ++ (show2 m) ++ "-" ++ (show2 d) where
-    (y,m,d) = toJulian date
+showJulian date = (show4 y) ++ "-" ++ (show2 m) ++ "-" ++ (show2 d)
+  where
+    (y, m, d) = toJulian date
 
 -- | The number of days in a given month according to the proleptic Julian calendar. First argument is year, second is month.
 julianMonthLength :: Integer -> Int -> Int
 julianMonthLength year = monthLength (isJulianLeapYear year)
 
-rolloverMonths :: (Integer,Integer) -> (Integer,Int)
-rolloverMonths (y,m) = (y + (div (m - 1) 12),fromIntegral (mod (m - 1) 12) + 1)
+rolloverMonths :: (Integer, Integer) -> (Integer, Int)
+rolloverMonths (y, m) = (y + (div (m - 1) 12), fromIntegral (mod (m - 1) 12) + 1)
 
-addJulianMonths :: Integer -> Day -> (Integer,Int,Int)
-addJulianMonths n day = (y',m',d) where
-    (y,m,d) = toJulian day
-    (y',m') = rolloverMonths (y,fromIntegral m + n)
+addJulianMonths :: Integer -> Day -> (Integer, Int, Int)
+addJulianMonths n day = (y', m', d)
+  where
+    (y, m, d) = toJulian day
+    (y', m') = rolloverMonths (y, fromIntegral m + n)
 
 -- | Add months, with days past the last day of the month clipped to the last day.
 -- For instance, 2005-01-30 + 1 month = 2005-02-28.
 addJulianMonthsClip :: Integer -> Day -> Day
-addJulianMonthsClip n day = fromJulian y m d where
-    (y,m,d) = addJulianMonths n day
+addJulianMonthsClip n day = fromJulian y m d
+  where
+    (y, m, d) = addJulianMonths n day
 
 -- | Add months, with days past the last day of the month rolling over to the next month.
 -- For instance, 2005-01-30 + 1 month = 2005-03-02.
 addJulianMonthsRollOver :: Integer -> Day -> Day
-addJulianMonthsRollOver n day = addDays (fromIntegral d - 1) (fromJulian y m 1) where
-    (y,m,d) = addJulianMonths n day
+addJulianMonthsRollOver n day = addDays (fromIntegral d - 1) (fromJulian y m 1)
+  where
+    (y, m, d) = addJulianMonths n day
 
 -- | Add years, matching month and day, with Feb 29th clipped to Feb 28th if necessary.
 -- For instance, 2004-02-29 + 2 years = 2006-02-28.
@@ -86,15 +96,19 @@ addJulianDurationRollOver (CalendarDiffDays m d) day = addDays d $ addJulianMont
 -- | Calendrical difference, with as many whole months as possible
 diffJulianDurationClip :: Day -> Day -> CalendarDiffDays
 diffJulianDurationClip day2 day1 = let
-    (y1,m1,d1) = toJulian day1
-    (y2,m2,d2) = toJulian day2
+    (y1, m1, d1) = toJulian day1
+    (y2, m2, d2) = toJulian day2
     ym1 = y1 * 12 + toInteger m1
     ym2 = y2 * 12 + toInteger m2
     ymdiff = ym2 - ym1
     ymAllowed =
-        if day2 >= day1 then
-        if d2 >= d1 then ymdiff else ymdiff - 1
-        else if d2 <= d1 then ymdiff else ymdiff + 1
+        if day2 >= day1
+            then if d2 >= d1
+                     then ymdiff
+                     else ymdiff - 1
+            else if d2 <= d1
+                     then ymdiff
+                     else ymdiff + 1
     dayAllowed = addJulianDurationClip (CalendarDiffDays ymAllowed 0) day1
     in CalendarDiffDays ymAllowed $ diffDays day2 dayAllowed
 
@@ -102,14 +116,18 @@ diffJulianDurationClip day2 day1 = let
 -- Same as 'diffJulianDurationClip' for positive durations.
 diffJulianDurationRollOver :: Day -> Day -> CalendarDiffDays
 diffJulianDurationRollOver day2 day1 = let
-    (y1,m1,d1) = toJulian day1
-    (y2,m2,d2) = toJulian day2
+    (y1, m1, d1) = toJulian day1
+    (y2, m2, d2) = toJulian day2
     ym1 = y1 * 12 + toInteger m1
     ym2 = y2 * 12 + toInteger m2
     ymdiff = ym2 - ym1
     ymAllowed =
-        if day2 >= day1 then
-        if d2 >= d1 then ymdiff else ymdiff - 1
-        else if d2 <= d1 then ymdiff else ymdiff + 1
+        if day2 >= day1
+            then if d2 >= d1
+                     then ymdiff
+                     else ymdiff - 1
+            else if d2 <= d1
+                     then ymdiff
+                     else ymdiff + 1
     dayAllowed = addJulianDurationRollOver (CalendarDiffDays ymAllowed 0) day1
     in CalendarDiffDays ymAllowed $ diffDays day2 dayAllowed
index 0b36ecb..a49a03d 100644 (file)
@@ -1,7 +1,7 @@
 module Data.Time.Calendar.JulianYearDay
     (
     -- * Year and day format
-    module Data.Time.Calendar.JulianYearDay
+      module Data.Time.Calendar.JulianYearDay
     ) where
 
 import Data.Time.Calendar.Days
@@ -9,8 +9,9 @@ import Data.Time.Calendar.Private
 
 -- | Convert to proleptic Julian year and day format. First element of result is year (proleptic Julian calendar),
 -- second is the day of the year, with 1 for Jan 1, and 365 (or 366 in leap years) for Dec 31.
-toJulianYearAndDay :: Day -> (Integer,Int)
-toJulianYearAndDay (ModifiedJulianDay mjd) = (year,yd) where
+toJulianYearAndDay :: Day -> (Integer, Int)
+toJulianYearAndDay (ModifiedJulianDay mjd) = (year, yd)
+  where
     a = mjd + 678577
     quad = div a 1461
     d = mod a 1461
@@ -21,15 +22,32 @@ toJulianYearAndDay (ModifiedJulianDay mjd) = (year,yd) where
 -- | Convert from proleptic Julian year and day format.
 -- Invalid day numbers will be clipped to the correct range (1 to 365 or 366).
 fromJulianYearAndDay :: Integer -> Int -> Day
-fromJulianYearAndDay year day = ModifiedJulianDay mjd where
+fromJulianYearAndDay year day = ModifiedJulianDay mjd
+  where
     y = year - 1
-    mjd = (fromIntegral (clip 1 (if isJulianLeapYear year then 366 else 365) day)) + (365 * y) + (div y 4) - 678578
+    mjd =
+        (fromIntegral
+             (clip
+                  1
+                  (if isJulianLeapYear year
+                       then 366
+                       else 365)
+                  day)) +
+        (365 * y) +
+        (div y 4) -
+        678578
 
 -- | Convert from proleptic Julian year and day format.
 -- Invalid day numbers will return Nothing
 fromJulianYearAndDayValid :: Integer -> Int -> Maybe Day
 fromJulianYearAndDayValid year day = do
-    day' <- clipValid 1 (if isJulianLeapYear year then 366 else 365) day
+    day' <-
+        clipValid
+            1
+            (if isJulianLeapYear year
+                 then 366
+                 else 365)
+            day
     let
         y = year - 1
         mjd = (fromIntegral day') + (365 * y) + (div y 4) - 678578
@@ -37,8 +55,9 @@ fromJulianYearAndDayValid year day = do
 
 -- | Show in proleptic Julian year and day format (yyyy-ddd)
 showJulianYearAndDay :: Day -> String
-showJulianYearAndDay date = (show4 y) ++ "-" ++ (show3 d) where
-    (y,d) = toJulianYearAndDay date
+showJulianYearAndDay date = (show4 y) ++ "-" ++ (show3 d)
+  where
+    (y, d) = toJulianYearAndDay date
 
 -- | Is this year a leap year according to the proleptic Julian calendar?
 isJulianLeapYear :: Integer -> Bool
index 99b0801..0acc3f4 100644 (file)
@@ -1,6 +1,8 @@
 module Data.Time.Calendar.MonthDay
-    (
-    monthAndDayToDayOfYear,monthAndDayToDayOfYearValid,dayOfYearToMonthAndDay,monthLength
+    ( monthAndDayToDayOfYear
+    , monthAndDayToDayOfYearValid
+    , dayOfYearToMonthAndDay
+    , monthLength
     ) where
 
 import Data.Time.Calendar.Private
@@ -8,11 +10,17 @@ import Data.Time.Calendar.Private
 -- | Convert month and day in the Gregorian or Julian calendars to day of year.
 -- First arg is leap year flag.
 monthAndDayToDayOfYear :: Bool -> Int -> Int -> Int
-monthAndDayToDayOfYear isLeap month day = (div (367 * month'' - 362) 12) + k + day' where
+monthAndDayToDayOfYear isLeap month day = (div (367 * month'' - 362) 12) + k + day'
+  where
     month' = clip 1 12 month
     day' = fromIntegral (clip 1 (monthLength' isLeap month') day)
     month'' = fromIntegral month'
-    k = if month' <= 2 then 0 else if isLeap then -1 else -2
+    k =
+        if month' <= 2
+            then 0
+            else if isLeap
+                     then -1
+                     else -2
 
 -- | Convert month and day in the Gregorian or Julian calendars to day of year.
 -- First arg is leap year flag.
@@ -23,17 +31,31 @@ monthAndDayToDayOfYearValid isLeap month day = do
     let
         day'' = fromIntegral day'
         month'' = fromIntegral month'
-        k = if month' <= 2 then 0 else if isLeap then -1 else -2
+        k =
+            if month' <= 2
+                then 0
+                else if isLeap
+                         then -1
+                         else -2
     return ((div (367 * month'' - 362) 12) + k + day'')
 
 -- | Convert day of year in the Gregorian or Julian calendars to month and day.
 -- First arg is leap year flag.
-dayOfYearToMonthAndDay :: Bool -> Int -> (Int,Int)
-dayOfYearToMonthAndDay isLeap yd = findMonthDay (monthLengths isLeap) (clip 1 (if isLeap then 366 else 365) yd)
+dayOfYearToMonthAndDay :: Bool -> Int -> (Int, Int)
+dayOfYearToMonthAndDay isLeap yd =
+    findMonthDay
+        (monthLengths isLeap)
+        (clip
+             1
+             (if isLeap
+                  then 366
+                  else 365)
+             yd)
 
-findMonthDay :: [Int] -> Int -> (Int,Int)
-findMonthDay (n:ns) yd | yd > n = (\(m,d) -> (m + 1,d)) (findMonthDay ns (yd - n))
-findMonthDay _ yd = (1,yd)
+findMonthDay :: [Int] -> Int -> (Int, Int)
+findMonthDay (n:ns) yd
+    | yd > n = (\(m, d) -> (m + 1, d)) (findMonthDay ns (yd - n))
+findMonthDay _ yd = (1, yd)
 
 -- | The length of a given month in the Gregorian or Julian calendars.
 -- First arg is leap year flag.
@@ -45,5 +67,19 @@ monthLength' isLeap month' = (monthLengths isLeap) !! (month' - 1)
 
 monthLengths :: Bool -> [Int]
 monthLengths isleap =
-    [31,if isleap then 29 else 28,31,30,31,30,31,31,30,31,30,31]
+    [ 31
+    , if isleap
+          then 29
+          else 28
+    , 31
+    , 30
+    , 31
+    , 30
+    , 31
+    , 31
+    , 30
+    , 31
+    , 30
+    , 31
+    ]
     --J        F                   M  A  M  J  J  A  S  O  N  D
index 59a8edf..9817d58 100644 (file)
@@ -6,8 +6,9 @@ import Data.Time.Calendar.Private
 
 -- | Convert to ISO 8601 Ordinal Date format. First element of result is year (proleptic Gregoran calendar),
 -- second is the day of the year, with 1 for Jan 1, and 365 (or 366 in leap years) for Dec 31.
-toOrdinalDate :: Day -> (Integer,Int)
-toOrdinalDate (ModifiedJulianDay mjd) = (year,yd) where
+toOrdinalDate :: Day -> (Integer, Int)
+toOrdinalDate (ModifiedJulianDay mjd) = (year, yd)
+  where
     a = mjd + 678575
     quadcent = div a 146097
     b = mod a 146097
@@ -22,15 +23,34 @@ toOrdinalDate (ModifiedJulianDay mjd) = (year,yd) where
 -- | Convert from ISO 8601 Ordinal Date format.
 -- Invalid day numbers will be clipped to the correct range (1 to 365 or 366).
 fromOrdinalDate :: Integer -> Int -> Day
-fromOrdinalDate year day = ModifiedJulianDay mjd where
+fromOrdinalDate year day = ModifiedJulianDay mjd
+  where
     y = year - 1
-    mjd = (fromIntegral (clip 1 (if isLeapYear year then 366 else 365) day)) + (365 * y) + (div y 4) - (div y 100) + (div y 400) - 678576
+    mjd =
+        (fromIntegral
+             (clip
+                  1
+                  (if isLeapYear year
+                       then 366
+                       else 365)
+                  day)) +
+        (365 * y) +
+        (div y 4) -
+        (div y 100) +
+        (div y 400) -
+        678576
 
 -- | Convert from ISO 8601 Ordinal Date format.
 -- Invalid day numbers return 'Nothing'
 fromOrdinalDateValid :: Integer -> Int -> Maybe Day
 fromOrdinalDateValid year day = do
-    day' <- clipValid 1 (if isLeapYear year then 366 else 365) day
+    day' <-
+        clipValid
+            1
+            (if isLeapYear year
+                 then 366
+                 else 365)
+            day
     let
         y = year - 1
         mjd = (fromIntegral day') + (365 * y) + (div y 4) - (div y 100) + (div y 400) - 678576
@@ -38,8 +58,9 @@ fromOrdinalDateValid year day = do
 
 -- | Show in ISO 8601 Ordinal Date format (yyyy-ddd)
 showOrdinalDate :: Day -> String
-showOrdinalDate date = (show4 y) ++ "-" ++ (show3 d) where
-    (y,d) = toOrdinalDate date
+showOrdinalDate date = (show4 y) ++ "-" ++ (show3 d)
+  where
+    (y, d) = toOrdinalDate date
 
 -- | Is this year a leap year according to the proleptic Gregorian calendar?
 isLeapYear :: Integer -> Bool
@@ -48,8 +69,9 @@ isLeapYear year = (mod year 4 == 0) && ((mod year 400 == 0) || not (mod year 100
 -- | Get the number of the Monday-starting week in the year and the day of the week.
 -- The first Monday is the first day of week 1, any earlier days in the year are week 0 (as @%W@ in 'Data.Time.Format.formatTime').
 -- Monday is 1, Sunday is 7 (as @%u@ in 'Data.Time.Format.formatTime').
-mondayStartWeek :: Day -> (Int,Int)
-mondayStartWeek date = (fromInteger ((div d 7) - (div k 7)),fromInteger (mod d 7) + 1) where
+mondayStartWeek :: Day -> (Int, Int)
+mondayStartWeek date = (fromInteger ((div d 7) - (div k 7)), fromInteger (mod d 7) + 1)
+  where
     yd = snd (toOrdinalDate date)
     d = (toModifiedJulianDay date) + 2
     k = d - (toInteger yd)
@@ -57,8 +79,9 @@ mondayStartWeek date = (fromInteger ((div d 7) - (div k 7)),fromInteger (mod d 7
 -- | Get the number of the Sunday-starting week in the year and the day of the week.
 -- The first Sunday is the first day of week 1, any earlier days in the year are week 0 (as @%U@ in 'Data.Time.Format.formatTime').
 -- Sunday is 0, Saturday is 6 (as @%w@ in 'Data.Time.Format.formatTime').
-sundayStartWeek :: Day -> (Int,Int)
-sundayStartWeek date =(fromInteger ((div d 7) - (div k 7)),fromInteger (mod d 7)) where
+sundayStartWeek :: Day -> (Int, Int)
+sundayStartWeek date = (fromInteger ((div d 7) - (div k 7)), fromInteger (mod d 7))
+  where
     yd = snd (toOrdinalDate date)
     d = (toModifiedJulianDay date) + 3
     k = d - (toInteger yd)
@@ -67,104 +90,100 @@ sundayStartWeek date =(fromInteger ((div d 7) - (div k 7)),fromInteger (mod d 7)
 -- the number of the Monday-starting week, and the day of the week.
 -- The first Monday is the first day of week 1, any earlier days in the year
 -- are week 0 (as @%W@ in 'Data.Time.Format.formatTime').
-fromMondayStartWeek :: Integer -- ^ Year.
-                    -> Int     -- ^ Monday-starting week number (as @%W@ in 'Data.Time.Format.formatTime').
-                    -> Int     -- ^ Day of week.
+fromMondayStartWeek ::
+       Integer -- ^ Year.
+    -> Int -- ^ Monday-starting week number (as @%W@ in 'Data.Time.Format.formatTime').
+    -> Int -- ^ Day of week.
                                -- Monday is 1, Sunday is 7 (as @%u@ in 'Data.Time.Format.formatTime').
-                    -> Day
+    -> Day
 fromMondayStartWeek year w d = let
     -- first day of the year
     firstDay = fromOrdinalDate year 1
-
     -- 0-based year day of first monday of the year
     zbFirstMonday = (5 - toModifiedJulianDay firstDay) `mod` 7
-
     -- 0-based week of year
     zbWeek = w - 1
-
     -- 0-based day of week
     zbDay = d - 1
-
     -- 0-based day in year
     zbYearDay = zbFirstMonday + 7 * toInteger zbWeek + toInteger zbDay
-
     in addDays zbYearDay firstDay
 
-fromMondayStartWeekValid :: Integer -- ^ Year.
-                    -> Int     -- ^ Monday-starting week number (as @%W@ in 'Data.Time.Format.formatTime').
-                    -> Int     -- ^ Day of week.
+fromMondayStartWeekValid ::
+       Integer -- ^ Year.
+    -> Int -- ^ Monday-starting week number (as @%W@ in 'Data.Time.Format.formatTime').
+    -> Int -- ^ Day of week.
                                -- Monday is 1, Sunday is 7 (as @%u@ in 'Data.Time.Format.formatTime').
-                    -> Maybe Day
+    -> Maybe Day
 fromMondayStartWeekValid year w d = do
     d' <- clipValid 1 7 d
     let
         -- first day of the year
         firstDay = fromOrdinalDate year 1
-
         -- 0-based week of year
         zbFirstMonday = (5 - toModifiedJulianDay firstDay) `mod` 7
-
         -- 0-based week number
         zbWeek = w - 1
-
         -- 0-based day of week
         zbDay = d' - 1
-
         -- 0-based day in year
         zbYearDay = zbFirstMonday + 7 * toInteger zbWeek + toInteger zbDay
-
-    zbYearDay' <- clipValid 0 (if isLeapYear year then 365 else 364) zbYearDay
+    zbYearDay' <-
+        clipValid
+            0
+            (if isLeapYear year
+                 then 365
+                 else 364)
+            zbYearDay
     return $ addDays zbYearDay' firstDay
 
 -- | The inverse of 'sundayStartWeek'. Get a 'Day' given the year and
 -- the number of the day of a Sunday-starting week.
 -- The first Sunday is the first day of week 1, any earlier days in the
 -- year are week 0 (as @%U@ in 'Data.Time.Format.formatTime').
-fromSundayStartWeek :: Integer -- ^ Year.
-                    -> Int     -- ^ Sunday-starting week number (as @%U@ in 'Data.Time.Format.formatTime').
-                    -> Int     -- ^ Day of week
+fromSundayStartWeek ::
+       Integer -- ^ Year.
+    -> Int -- ^ Sunday-starting week number (as @%U@ in 'Data.Time.Format.formatTime').
+    -> Int -- ^ Day of week
                                -- Sunday is 0, Saturday is 6 (as @%w@ in 'Data.Time.Format.formatTime').
-                    -> Day
+    -> Day
 fromSundayStartWeek year w d = let
     -- first day of the year
     firstDay = fromOrdinalDate year 1
-
     -- 0-based year day of first monday of the year
     zbFirstSunday = (4 - toModifiedJulianDay firstDay) `mod` 7
-
     -- 0-based week of year
     zbWeek = w - 1
-
     -- 0-based day of week
     zbDay = d
-
     -- 0-based day in year
     zbYearDay = zbFirstSunday + 7 * toInteger zbWeek + toInteger zbDay
-
     in addDays zbYearDay firstDay
 
-fromSundayStartWeekValid :: Integer -- ^ Year.
-                    -> Int     -- ^ Sunday-starting week number (as @%U@ in 'Data.Time.Format.formatTime').
-                    -> Int     -- ^ Day of week.
+fromSundayStartWeekValid ::
+       Integer -- ^ Year.
+    -> Int -- ^ Sunday-starting week number (as @%U@ in 'Data.Time.Format.formatTime').
+    -> Int -- ^ Day of week.
                                -- Sunday is 0, Saturday is 6 (as @%w@ in 'Data.Time.Format.formatTime').
-                    -> Maybe Day
-fromSundayStartWeekValid year w d =  do
+    -> Maybe Day
+fromSundayStartWeekValid year w d = do
     d' <- clipValid 0 6 d
     let
         -- first day of the year
         firstDay = fromOrdinalDate year 1
-
         -- 0-based week of year
         zbFirstSunday = (4 - toModifiedJulianDay firstDay) `mod` 7
-
         -- 0-based week number
         zbWeek = w - 1
-
         -- 0-based day of week
         zbDay = d'
-
         -- 0-based day in year
         zbYearDay = zbFirstSunday + 7 * toInteger zbWeek + toInteger zbDay
-
-    zbYearDay' <- clipValid 0 (if isLeapYear year then 365 else 364) zbYearDay
+    zbYearDay' <-
+        clipValid
+            0
+            (if isLeapYear year
+                 then 365
+                 else 364)
+            zbYearDay
     return $ addDays zbYearDay' firstDay
index 9f192f9..367e759 100644 (file)
@@ -2,28 +2,35 @@ module Data.Time.Calendar.Private where
 
 import Data.Fixed
 
-data PadOption = Pad Int Char | NoPad
+data PadOption
+    = Pad Int
+          Char
+    | NoPad
 
 showPadded :: PadOption -> String -> String
 showPadded NoPad s = s
 showPadded (Pad i c) s = replicate (i - length s) c ++ s
 
-class (Num t,Ord t,Show t) => ShowPadded t where
+class (Num t, Ord t, Show t) => ShowPadded t where
     showPaddedNum :: PadOption -> t -> String
 
 instance ShowPadded Integer where
     showPaddedNum NoPad i = show i
-    showPaddedNum pad i | i < 0 = '-':(showPaddedNum pad (negate i))
+    showPaddedNum pad i
+        | i < 0 = '-' : (showPaddedNum pad (negate i))
     showPaddedNum pad i = showPadded pad $ show i
 
 instance ShowPadded Int where
     showPaddedNum NoPad i = show i
-    showPaddedNum _pad i | i == minBound = show i
-    showPaddedNum pad i | i < 0 = '-':(showPaddedNum pad (negate i))
+    showPaddedNum _pad i
+        | i == minBound = show i
+    showPaddedNum pad i
+        | i < 0 = '-' : (showPaddedNum pad (negate i))
     showPaddedNum pad i = showPadded pad $ show i
 
 show2Fixed :: Pico -> String
-show2Fixed x | x < 10 = '0':(showFixed True x)
+show2Fixed x
+    | x < 10 = '0' : (showFixed True x)
 show2Fixed x = showFixed True x
 
 show2 :: (ShowPadded t) => t -> String
@@ -42,23 +49,28 @@ div100 :: (Integral i) => i -> i
 div100 x = div x 100
 
 clip :: (Ord t) => t -> t -> t -> t
-clip a _ x | x < a = a
-clip _ b x | x > b = b
+clip a _ x
+    | x < a = a
+clip _ b x
+    | x > b = b
 clip _ _ x = x
 
 clipValid :: (Ord t) => t -> t -> t -> Maybe t
-clipValid a _ x | x < a = Nothing
-clipValid _ b x | x > b = Nothing
+clipValid a _ x
+    | x < a = Nothing
+clipValid _ b x
+    | x > b = Nothing
 clipValid _ _ x = Just x
 
-quotBy :: (Real a,Integral b) => a -> a -> b
+quotBy :: (Real a, Integral b) => a -> a -> b
 quotBy d n = truncate ((toRational n) / (toRational d))
 
 remBy :: Real a => a -> a -> a
-remBy d n = n - (fromInteger f) * d where
+remBy d n = n - (fromInteger f) * d
+  where
     f = quotBy d n
 
-quotRemBy :: (Real a,Integral b) => a -> a -> (b,a)
+quotRemBy :: (Real a, Integral b) => a -> a -> (b, a)
 quotRemBy d n = let
     f = quotBy d n
-    in (f,n - (fromIntegral f) * d)
+    in (f, n - (fromIntegral f) * d)
index 09154c7..c12f261 100644 (file)
@@ -1,35 +1,52 @@
 -- | ISO 8601 Week Date format
 module Data.Time.Calendar.WeekDate where
 
-import Data.Time.Calendar.OrdinalDate
 import Data.Time.Calendar.Days
+import Data.Time.Calendar.OrdinalDate
 import Data.Time.Calendar.Private
 
 -- | Convert to ISO 8601 Week Date format. First element of result is year, second week number (1-53), third day of week (1 for Monday to 7 for Sunday).
 -- Note that \"Week\" years are not quite the same as Gregorian years, as the first day of the year is always a Monday.
 -- The first week of a year is the first week to contain at least four days in the corresponding Gregorian year.
-toWeekDate :: Day -> (Integer,Int,Int)
-toWeekDate date@(ModifiedJulianDay mjd) = (y1,fromInteger (w1 + 1),fromInteger d_mod_7 + 1) where
+toWeekDate :: Day -> (Integer, Int, Int)
+toWeekDate date@(ModifiedJulianDay mjd) = (y1, fromInteger (w1 + 1), fromInteger d_mod_7 + 1)
+  where
     (d_div_7, d_mod_7) = d `divMod` 7
-    (y0,yd) = toOrdinalDate date
+    (y0, yd) = toOrdinalDate date
     d = mjd + 2
     foo :: Integer -> Integer
     foo y = bar (toModifiedJulianDay (fromOrdinalDate y 6))
     bar k = d_div_7 - k `div` 7
-    (y1,w1) = case bar (d - toInteger yd + 4) of
-                -1 -> (y0 - 1, foo (y0 - 1))
-                52 -> if foo (y0 + 1) == 0
-                      then (y0 + 1, 0)
-                      else (y0, 52)
-                w0  -> (y0, w0)
+    (y1, w1) =
+        case bar (d - toInteger yd + 4) of
+            -1 -> (y0 - 1, foo (y0 - 1))
+            52 ->
+                if foo (y0 + 1) == 0
+                    then (y0 + 1, 0)
+                    else (y0, 52)
+            w0 -> (y0, w0)
 
 -- | Convert from ISO 8601 Week Date format. First argument is year, second week number (1-52 or 53), third day of week (1 for Monday to 7 for Sunday).
 -- Invalid week and day values will be clipped to the correct range.
 fromWeekDate :: Integer -> Int -> Int -> Day
-fromWeekDate y w d = ModifiedJulianDay (k - (mod k 7) + (toInteger (((clip 1 (if longYear then 53 else 52) w) * 7) + (clip 1 7 d))) - 10) where
-        k = toModifiedJulianDay (fromOrdinalDate y 6)
-        longYear = case toWeekDate (fromOrdinalDate y 365) of
-            (_,53,_) -> True
+fromWeekDate y w d =
+    ModifiedJulianDay
+        (k - (mod k 7) +
+         (toInteger
+              (((clip
+                     1
+                     (if longYear
+                          then 53
+                          else 52)
+                     w) *
+                7) +
+               (clip 1 7 d))) -
+         10)
+  where
+    k = toModifiedJulianDay (fromOrdinalDate y 6)
+    longYear =
+        case toWeekDate (fromOrdinalDate y 365) of
+            (_, 53, _) -> True
             _ -> False
 
 -- | Convert from ISO 8601 Week Date format. First argument is year, second week number (1-52 or 53), third day of week (1 for Monday to 7 for Sunday).
@@ -38,15 +55,22 @@ fromWeekDateValid :: Integer -> Int -> Int -> Maybe Day
 fromWeekDateValid y w d = do
     d' <- clipValid 1 7 d
     let
-        longYear = case toWeekDate (fromOrdinalDate y 365) of
-            (_,53,_) -> True
-            _ -> False
-    w' <- clipValid 1 (if longYear then 53 else 52) w
-    let
-        k = toModifiedJulianDay (fromOrdinalDate y 6)
+        longYear =
+            case toWeekDate (fromOrdinalDate y 365) of
+                (_, 53, _) -> True
+                _ -> False
+    w' <-
+        clipValid
+            1
+            (if longYear
+                 then 53
+                 else 52)
+            w
+    let k = toModifiedJulianDay (fromOrdinalDate y 6)
     return (ModifiedJulianDay (k - (mod k 7) + (toInteger ((w' * 7) + d')) - 10))
 
 -- | Show in ISO 8601 Week Date format as yyyy-Www-d (e.g. \"2006-W46-3\").
 showWeekDate :: Day -> String
-showWeekDate date = (show4 y) ++ "-W" ++ (show2 w) ++ "-" ++ (show d) where
-    (y,w,d) = toWeekDate date
+showWeekDate date = (show4 y) ++ "-W" ++ (show2 w) ++ "-" ++ (show d)
+  where
+    (y, w, d) = toWeekDate date
index af771f7..1131695 100644 (file)
@@ -1,21 +1,20 @@
 -- | Types and functions for UTC and UT1
 module Data.Time.Clock
-(
-    module Data.Time.Clock.Internal.UniversalTime,
-    module Data.Time.Clock.Internal.DiffTime,
-    module Data.Time.Clock.Internal.UTCTime,
-    module Data.Time.Clock.Internal.NominalDiffTime,
-    module Data.Time.Clock.Internal.UTCDiff,
-    getCurrentTime,
-    getTime_resolution
-) where
+    ( module Data.Time.Clock.Internal.UniversalTime
+    , module Data.Time.Clock.Internal.DiffTime
+    , module Data.Time.Clock.Internal.UTCTime
+    , module Data.Time.Clock.Internal.NominalDiffTime
+    , module Data.Time.Clock.Internal.UTCDiff
+    , getCurrentTime
+    , getTime_resolution
+    ) where
 
-import Data.Time.Clock.Internal.UniversalTime
 import Data.Time.Clock.Internal.DiffTime
+import Data.Time.Clock.Internal.NominalDiffTime
 import Data.Time.Clock.Internal.SystemTime
 import Data.Time.Clock.Internal.UTCDiff
-import Data.Time.Clock.Internal.NominalDiffTime
 import Data.Time.Clock.Internal.UTCTime
+import Data.Time.Clock.Internal.UniversalTime
 import Data.Time.Clock.POSIX
-import Data.Time.Format.Parse()
-import Data.Time.LocalTime()
+import Data.Time.Format.Parse ()
+import Data.Time.LocalTime ()
index 42af672..f6df44a 100644 (file)
@@ -1,20 +1,23 @@
 -- | TAI and leap-second maps for converting to UTC: most people won't need this module.
 module Data.Time.Clock.Internal.AbsoluteTime
-(
+    (
     -- TAI arithmetic
-    AbsoluteTime,taiEpoch,addAbsoluteTime,diffAbsoluteTime,
-    taiNominalDayStart,
-) where
+      AbsoluteTime
+    , taiEpoch
+    , addAbsoluteTime
+    , diffAbsoluteTime
+    , taiNominalDayStart
+    ) where
 
-import Data.Typeable
-import Data.Data
 import Control.DeepSeq
+import Data.Data
 import Data.Time.Calendar.Days
 import Data.Time.Clock.Internal.DiffTime
 
-
 -- | AbsoluteTime is TAI, time as measured by a clock.
-newtype AbsoluteTime = MkAbsoluteTime DiffTime deriving (Eq,Ord,Data,Typeable)
+newtype AbsoluteTime =
+    MkAbsoluteTime DiffTime
+    deriving (Eq, Ord, Data, Typeable)
 
 instance NFData AbsoluteTime where
     rnf (MkAbsoluteTime a) = rnf a
index 38197a4..380de2d 100644 (file)
@@ -4,11 +4,7 @@ module Data.Time.Clock.Internal.CTimespec where
 
 #if !defined(mingw32_HOST_OS) && HAVE_CLOCK_GETTIME
 
-#if __GLASGOW_HASKELL__ >= 709
 import Foreign
-#else
-import Foreign.Safe
-#endif
 import Foreign.C
 import System.IO.Unsafe
 
index 8e496b1..58e500b 100644 (file)
@@ -1,22 +1,18 @@
 module Data.Time.Clock.Internal.CTimeval where
-
 #ifndef mingw32_HOST_OS
 -- All Unix-specific, this
-
-#if __GLASGOW_HASKELL__ >= 709
 import Foreign
-#else
-import Foreign.Safe
-#endif
 import Foreign.C
 
-data CTimeval = MkCTimeval CLong CLong
+data CTimeval =
+    MkCTimeval CLong
+               CLong
 
 instance Storable CTimeval where
     sizeOf _ = (sizeOf (undefined :: CLong)) * 2
     alignment _ = alignment (undefined :: CLong)
     peek p = do
-        s   <- peekElemOff (castPtr p) 0
+        s <- peekElemOff (castPtr p) 0
         mus <- peekElemOff (castPtr p) 1
         return (MkCTimeval s mus)
     poke p (MkCTimeval s mus) = do
@@ -27,9 +23,10 @@ foreign import ccall unsafe "time.h gettimeofday" gettimeofday :: Ptr CTimeval -
 
 -- | Get the current POSIX time from the system clock.
 getCTimeval :: IO CTimeval
-getCTimeval = with (MkCTimeval 0 0) (\ptval -> do
-    throwErrnoIfMinus1_ "gettimeofday" $ gettimeofday ptval nullPtr
-    peek ptval
-    )
-
+getCTimeval =
+    with
+        (MkCTimeval 0 0)
+        (\ptval -> do
+             throwErrnoIfMinus1_ "gettimeofday" $ gettimeofday ptval nullPtr
+             peek ptval)
 #endif
index 51a84ab..5e17beb 100644 (file)
@@ -1,29 +1,32 @@
 {-# LANGUAGE Trustworthy #-}
 {-# OPTIONS -fno-warn-unused-imports #-}
+
 module Data.Time.Clock.Internal.DiffTime
     (
     -- * Absolute intervals
-    DiffTime,
-    secondsToDiffTime,
-    picosecondsToDiffTime,
-    diffTimeToPicoseconds,
+      DiffTime
+    , secondsToDiffTime
+    , picosecondsToDiffTime
+    , diffTimeToPicoseconds
     ) where
 
-import Data.Typeable
+import Control.DeepSeq
 import Data.Data
-import Data.Ratio ((%))
 import Data.Fixed
-import Control.DeepSeq
-
+import Data.Ratio ((%))
+import Data.Typeable
 
 -- | This is a length of time, as measured by a clock.
 -- Conversion functions will treat it as seconds.
 -- It has a precision of 10^-12 s.
-newtype DiffTime = MkDiffTime Pico deriving (Eq,Ord,Data, Typeable)
+newtype DiffTime =
+    MkDiffTime Pico
+    deriving (Eq, Ord, Data, Typeable)
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
-instance NFData DiffTime where -- FIXME: Data.Fixed had no NFData instances yet at time of writing
-        rnf dt = seq dt ()
+instance NFData DiffTime -- FIXME: Data.Fixed had no NFData instances yet at time of writing
+                                                                                             where
+    rnf dt = seq dt ()
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
 instance Enum DiffTime where
@@ -61,7 +64,9 @@ instance Fractional DiffTime where
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
 instance RealFrac DiffTime where
-    properFraction (MkDiffTime a) = let (b',a') = properFraction a in (b',MkDiffTime a')
+    properFraction (MkDiffTime a) = let
+        (b', a') = properFraction a
+        in (b', MkDiffTime a')
     truncate (MkDiffTime a) = truncate a
     round (MkDiffTime a) = round a
     ceiling (MkDiffTime a) = ceiling a
@@ -80,6 +85,6 @@ diffTimeToPicoseconds :: DiffTime -> Integer
 diffTimeToPicoseconds (MkDiffTime (MkFixed x)) = x
 
 {-# RULES
-"realToFrac/DiffTime->Pico"              realToFrac = \ (MkDiffTime ps) -> ps
-"realToFrac/Pico->DiffTime"              realToFrac = MkDiffTime
 #-}
+"realToFrac/DiffTime->Pico" realToFrac = \ (MkDiffTime ps) -> ps
+"realToFrac/Pico->DiffTime" realToFrac = MkDiffTime
+ #-}
index 70c3721..b5266f2 100644 (file)
@@ -1,19 +1,18 @@
 {-# OPTIONS -fno-warn-unused-imports #-}
 {-# LANGUAGE Trustworthy #-}
+
 module Data.Time.Clock.Internal.NominalDiffTime
-    (
-    NominalDiffTime,
-    secondsToNominalDiffTime,
-    nominalDiffTimeToSeconds,
-    nominalDay,
+    ( NominalDiffTime
+    , secondsToNominalDiffTime
+    , nominalDiffTimeToSeconds
+    , nominalDay
     ) where
 
-import Data.Typeable
+import Control.DeepSeq
 import Data.Data
 import Data.Fixed
 import Data.Time.Calendar.Days
-import Control.DeepSeq
-
+import Data.Typeable
 
 -- | This is a length of time, as measured by UTC.
 -- It has a precision of 10^-12 s.
@@ -24,7 +23,9 @@ import Control.DeepSeq
 -- 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 (Eq,Ord,Data,Typeable)
+newtype NominalDiffTime =
+    MkNominalDiffTime Pico
+    deriving (Eq, Ord, Data, Typeable)
 
 -- | Create a 'NominalDiffTime' from a number of seconds.
 --
@@ -39,7 +40,8 @@ nominalDiffTimeToSeconds :: NominalDiffTime -> Pico
 nominalDiffTimeToSeconds (MkNominalDiffTime t) = t
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
-instance NFData NominalDiffTime where -- FIXME: Data.Fixed had no NFData instances yet at time of writing
+instance NFData NominalDiffTime -- FIXME: Data.Fixed had no NFData instances yet at time of writing
+                                                                                                    where
     rnf ndt = seq ndt ()
 
 instance Enum NominalDiffTime where
@@ -50,7 +52,8 @@ instance Enum NominalDiffTime where
     enumFrom (MkNominalDiffTime a) = fmap MkNominalDiffTime (enumFrom a)
     enumFromThen (MkNominalDiffTime a) (MkNominalDiffTime b) = fmap MkNominalDiffTime (enumFromThen a b)
     enumFromTo (MkNominalDiffTime a) (MkNominalDiffTime b) = fmap MkNominalDiffTime (enumFromTo a b)
-    enumFromThenTo (MkNominalDiffTime a) (MkNominalDiffTime b) (MkNominalDiffTime c) = fmap MkNominalDiffTime (enumFromThenTo a b c)
+    enumFromThenTo (MkNominalDiffTime a) (MkNominalDiffTime b) (MkNominalDiffTime c) =
+        fmap MkNominalDiffTime (enumFromThenTo a b c)
 
 instance Show NominalDiffTime where
     show (MkNominalDiffTime t) = (showFixed True t) ++ "s"
@@ -77,20 +80,23 @@ instance Fractional NominalDiffTime where
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
 instance RealFrac NominalDiffTime where
-    properFraction (MkNominalDiffTime a) = (i,MkNominalDiffTime f) where
-        (i,f) = properFraction a
+    properFraction (MkNominalDiffTime a) = (i, MkNominalDiffTime f)
+      where
+        (i, f) = properFraction a
     truncate (MkNominalDiffTime a) = truncate a
     round (MkNominalDiffTime a) = round a
     ceiling (MkNominalDiffTime a) = ceiling a
     floor (MkNominalDiffTime a) = floor 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
-  #-}
+"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
index dfaaaaa..88696f3 100644 (file)
@@ -2,7 +2,6 @@ module Data.Time.Clock.Internal.POSIXTime where
 
 import Data.Time.Clock.Internal.NominalDiffTime
 
-
 -- | 86400 nominal seconds in every day
 posixDayLength :: NominalDiffTime
 posixDayLength = nominalDay
index b87d302..42fd608 100644 (file)
@@ -1,41 +1,36 @@
-#if __GLASGOW_HASKELL__ >= 710
 {-# OPTIONS -fno-warn-trustworthy-safe #-}
-#endif
 {-# LANGUAGE Trustworthy #-}
+
 module Data.Time.Clock.Internal.SystemTime
-    (
-    SystemTime(..),
-    getSystemTime,
-    getTime_resolution,
-    getTAISystemTime,
+    ( SystemTime(..)
+    , getSystemTime
+    , getTime_resolution
+    , getTAISystemTime
     ) where
 
-import Data.Int (Int64)
-import Data.Word
 import Control.DeepSeq
+import Data.Int (Int64)
 import Data.Time.Clock.Internal.DiffTime
-
+import Data.Word
 #include "HsTimeConfig.h"
 
 #ifdef mingw32_HOST_OS
 import qualified System.Win32.Time as Win32
 #elif defined(HAVE_CLOCK_GETTIME)
 import Data.Time.Clock.Internal.CTimespec
-import Foreign.C.Types (CTime(..), CLong(..))
+import Foreign.C.Types (CLong(..), CTime(..))
 #else
 import Data.Time.Clock.Internal.CTimeval
 import Foreign.C.Types (CLong(..))
 #endif
-
 --------------------------------------------------------------------------------
-
 -- | 'SystemTime' is time returned by system clock functions.
 -- Its semantics depends on the clock function, but the epoch is typically the beginning of 1970.
 -- Note that 'systemNanoseconds' of 1E9 to 2E9-1 can be used to represent leap seconds.
 data SystemTime = MkSystemTime
-    { systemSeconds ::     {-# UNPACK #-} !Int64
-    , systemNanoseconds :: {-# UNPACK #-} !Word32
-    } deriving (Eq,Ord,Show)
+    { systemSeconds :: {-# UNPACK #-}!Int64
+    , systemNanoseconds :: {-# UNPACK #-}!Word32
+    } deriving (Eq, Ord, Show)
 
 instance NFData SystemTime where
     rnf a = a `seq` ()
@@ -43,20 +38,16 @@ instance NFData SystemTime where
 -- | Get the system time, epoch start of 1970 UTC, leap-seconds ignored.
 -- 'getSystemTime' is typically much faster than 'getCurrentTime'.
 getSystemTime :: IO SystemTime
-
 -- | The resolution of 'getSystemTime', 'getCurrentTime', 'getPOSIXTime'
 getTime_resolution :: DiffTime
-
 -- | If supported, get TAI time, epoch start of 1970 TAI, with resolution.
 -- This is supported only on UNIX systems, and only those with CLOCK_TAI available at run-time.
-getTAISystemTime :: Maybe (DiffTime,IO SystemTime)
-
+getTAISystemTime :: Maybe (DiffTime, IO SystemTime)
 #ifdef mingw32_HOST_OS
 -- On Windows, the equlvalent of POSIX time is "file time", defined as
 -- the number of 100-nanosecond intervals that have elapsed since
 -- 12:00 A.M. January 1, 1601 (UTC).  We can convert this into a POSIX
 -- time by adjusting the offset to be relative to the POSIX epoch.
-
 getSystemTime = do
     Win32.FILETIME ft <- Win32.getSystemTimeAsFileTime
     let (s, us) = (ft - win32_epoch_adjust) `divMod` 10000000
@@ -64,12 +55,12 @@ getSystemTime = do
   where
     win32_epoch_adjust :: Word64
     win32_epoch_adjust = 116444736000000000
+
 getTime_resolution = 100E-9 -- 100ns
-getTAISystemTime = Nothing
 
+getTAISystemTime = Nothing
 #elif defined(HAVE_CLOCK_GETTIME)
 -- Use hi-res clock_gettime
-
 timespecToSystemTime :: CTimespec -> SystemTime
 timespecToSystemTime (MkCTimespec (CTime s) (CLong ns)) = (MkSystemTime (fromIntegral s) (fromIntegral ns))
 
@@ -80,15 +71,18 @@ clockGetSystemTime :: ClockID -> IO SystemTime
 clockGetSystemTime clock = fmap timespecToSystemTime $ clockGetTime clock
 
 getSystemTime = clockGetSystemTime clock_REALTIME
+
 getTime_resolution = timespecToDiffTime realtimeRes
-getTAISystemTime = fmap (\resolution -> (timespecToDiffTime resolution,clockGetSystemTime clock_TAI)) $ clockResolution clock_TAI
 
+getTAISystemTime =
+    fmap (\resolution -> (timespecToDiffTime resolution, clockGetSystemTime clock_TAI)) $ clockResolution clock_TAI
 #else
 -- Use gettimeofday
 getSystemTime = do
     MkCTimeval (CLong s) (CLong us) <- getCTimeval
     return (MkSystemTime (fromIntegral s) (fromIntegral us * 1000))
+
 getTime_resolution = 1E-6 -- microsecond
-getTAISystemTime = Nothing
 
+getTAISystemTime = Nothing
 #endif
index 0001e5f..d2518a1 100644 (file)
@@ -1,5 +1,5 @@
 module Data.Time.Clock.Internal.UTCTime
-(
+    (
     -- * UTC
     -- | UTC is time as measured by a clock, corrected to keep pace with the earth by adding or removing
     -- occasional seconds, known as \"leap seconds\".
@@ -9,25 +9,21 @@ module Data.Time.Clock.Internal.UTCTime
     --
     -- If you don't care about leap seconds, use 'UTCTime' and 'NominalDiffTime' for your clock calculations,
     -- and you'll be fine.
-    UTCTime(..),
-) where
+      UTCTime(..)
+    ) where
 
-import Data.Typeable
-import Data.Data
 import Control.DeepSeq
+import Data.Data
 import Data.Time.Calendar.Days
 import Data.Time.Clock.Internal.DiffTime
 
-
 -- | This is the simplest representation of UTC.
 -- It consists of the day number, and a time offset from midnight.
 -- Note that if a day has a leap second added to it, it will have 86401 seconds.
-data UTCTime = UTCTime {
-    -- | the day
-    utctDay :: Day,
-    -- | the time from midnight, 0 <= t < 86401s (because of leap-seconds)
-    utctDayTime :: DiffTime
-} deriving (Data, Typeable)
+data UTCTime = UTCTime
+    { utctDay :: Day -- ^ the day
+    , utctDayTime :: DiffTime -- ^ the time from midnight, 0 <= t < 86401s (because of leap-seconds)
+    } deriving (Data, Typeable)
 
 instance NFData UTCTime where
     rnf (UTCTime d t) = rnf d `seq` rnf t `seq` ()
@@ -36,6 +32,7 @@ instance Eq UTCTime where
     (UTCTime da ta) == (UTCTime db tb) = (da == db) && (ta == tb)
 
 instance Ord UTCTime where
-    compare (UTCTime da ta) (UTCTime db tb) = case (compare da db) of
-        EQ -> compare ta tb
-        cmp -> cmp
+    compare (UTCTime da ta) (UTCTime db tb) =
+        case (compare da db) of
+            EQ -> compare ta tb
+            cmp -> cmp
index 7a28e39..0649e00 100644 (file)
@@ -2,17 +2,17 @@ module Data.Time.Clock.Internal.UniversalTime
     (
     -- * Universal Time
     -- | Time as measured by the Earth.
-    UniversalTime(..),
+      UniversalTime(..)
     ) where
 
-import Data.Typeable
-import Data.Data
 import Control.DeepSeq
-
+import Data.Data
 
 -- | The Modified Julian Date is the day with the fraction of the day, measured from UT midnight.
 -- It's used to represent UT1, which is time as measured by the earth's rotation, adjusted for various wobbles.
-newtype UniversalTime = ModJulianDate {getModJulianDate :: Rational} deriving (Eq,Ord,Data, Typeable)
+newtype UniversalTime = ModJulianDate
+    { getModJulianDate :: Rational
+    } deriving (Eq, Ord, Data, Typeable)
 
 -- necessary because H98 doesn't have "cunning newtype" derivation
 instance NFData UniversalTime where
index edd2024..9ebe8cd 100644 (file)
 -- >     u <- getCurrentTime
 -- >     print $ nanosSinceEpoch u
 module Data.Time.Clock.POSIX
-(
-    posixDayLength,POSIXTime,posixSecondsToUTCTime,utcTimeToPOSIXSeconds,getPOSIXTime,getCurrentTime,
-    systemToPOSIXTime,
-) where
+    ( posixDayLength
+    , POSIXTime
+    , posixSecondsToUTCTime
+    , utcTimeToPOSIXSeconds
+    , getPOSIXTime
+    , getCurrentTime
+    , systemToPOSIXTime
+    ) where
 
+import Data.Fixed
+import Data.Time.Calendar.Days
 import Data.Time.Clock.Internal.POSIXTime
 import Data.Time.Clock.Internal.UTCTime
 import Data.Time.Clock.System
-import Data.Time.Calendar.Days
-import Data.Fixed
 
 posixSecondsToUTCTime :: POSIXTime -> UTCTime
 posixSecondsToUTCTime i = let
-    (d,t) = divMod' i posixDayLength
- in UTCTime (addDays d systemEpochDay) (realToFrac t)
+    (d, t) = divMod' i posixDayLength
   in UTCTime (addDays d systemEpochDay) (realToFrac t)
 
 utcTimeToPOSIXSeconds :: UTCTime -> POSIXTime
 utcTimeToPOSIXSeconds (UTCTime d t) =
- (fromInteger (diffDays d systemEpochDay) * posixDayLength) + min posixDayLength (realToFrac t)
   (fromInteger (diffDays d systemEpochDay) * posixDayLength) + min posixDayLength (realToFrac t)
 
 systemToPOSIXTime :: SystemTime -> POSIXTime
 systemToPOSIXTime (MkSystemTime s ns) = (fromIntegral s) + (fromIntegral ns) * 1E-9
index f9aca19..52c3bf2 100644 (file)
@@ -1,27 +1,26 @@
 -- | Fast access to the system clock.
 module Data.Time.Clock.System
-(
-    systemEpochDay,
-    SystemTime(..),
-    truncateSystemTimeLeapSecond,
-    getSystemTime,
-    systemToUTCTime,
-    utcToSystemTime,
-    systemToTAITime,
-) where
+    ( systemEpochDay
+    , SystemTime(..)
+    , truncateSystemTimeLeapSecond
+    , getSystemTime
+    , systemToUTCTime
+    , utcToSystemTime
+    , systemToTAITime
+    ) where
 
+import Data.Int (Int64)
+import Data.Time.Calendar.Days
 import Data.Time.Clock.Internal.AbsoluteTime
 import Data.Time.Clock.Internal.DiffTime
 import Data.Time.Clock.Internal.SystemTime
 import Data.Time.Clock.Internal.UTCTime
-import Data.Time.Calendar.Days
-import Data.Int (Int64)
-
 
 -- | Map leap-second values to the start of the following second.
 -- The resulting 'systemNanoseconds' will always be in the range 0 to 1E9-1.
 truncateSystemTimeLeapSecond :: SystemTime -> SystemTime
-truncateSystemTimeLeapSecond (MkSystemTime seconds nanoseconds) | nanoseconds >= 1000000000 = MkSystemTime (succ seconds) 0
+truncateSystemTimeLeapSecond (MkSystemTime seconds nanoseconds)
+    | nanoseconds >= 1000000000 = MkSystemTime (succ seconds) 0
 truncateSystemTimeLeapSecond t = t
 
 -- | Convert 'SystemTime' to 'UTCTime', matching zero 'SystemTime' to midnight of 'systemEpochDay' UTC.
@@ -30,16 +29,12 @@ systemToUTCTime (MkSystemTime seconds nanoseconds) = let
     days :: Int64
     timeSeconds :: Int64
     (days, timeSeconds) = seconds `divMod` 86400
-
     day :: Day
     day = addDays (fromIntegral days) systemEpochDay
-
     timeNanoseconds :: Int64
     timeNanoseconds = timeSeconds * 1000000000 + (fromIntegral nanoseconds)
-
     timePicoseconds :: Int64
     timePicoseconds = timeNanoseconds * 1000
-
     time :: DiffTime
     time = picosecondsToDiffTime $ fromIntegral timePicoseconds
     in UTCTime day time
@@ -49,20 +44,18 @@ utcToSystemTime :: UTCTime -> SystemTime
 utcToSystemTime (UTCTime day time) = let
     days :: Int64
     days = fromIntegral $ diffDays day systemEpochDay
-
     timePicoseconds :: Int64
     timePicoseconds = fromIntegral $ diffTimeToPicoseconds time
-
     timeNanoseconds :: Int64
     timeNanoseconds = timePicoseconds `div` 1000
-
     timeSeconds :: Int64
     nanoseconds :: Int64
-    (timeSeconds,nanoseconds) = if timeNanoseconds >= 86400000000000 then (86399,timeNanoseconds - 86399000000000) else timeNanoseconds `divMod` 1000000000
-
+    (timeSeconds, nanoseconds) =
+        if timeNanoseconds >= 86400000000000
+            then (86399, timeNanoseconds - 86399000000000)
+            else timeNanoseconds `divMod` 1000000000
     seconds :: Int64
     seconds = days * 86400 + timeSeconds
-
     in MkSystemTime seconds $ fromIntegral nanoseconds
 
 systemEpochAbsolute :: AbsoluteTime
index 641b58f..a6ea392 100644 (file)
@@ -1,27 +1,27 @@
 {-# OPTIONS -fno-warn-orphans #-}
+
 -- | TAI and leap-second maps for converting to UTC: most people won't need this module.
 module Data.Time.Clock.TAI
-(
+    (
     -- TAI arithmetic
-    module Data.Time.Clock.Internal.AbsoluteTime,
-
+      module Data.Time.Clock.Internal.AbsoluteTime
     -- leap-second map type
-    LeapSecondMap,
-
+    , LeapSecondMap
     -- conversion between UTC and TAI with map
-    utcDayLength,utcToTAITime,taiToUTCTime,
-
-    taiClock,
-) where
+    , utcDayLength
+    , utcToTAITime
+    , taiToUTCTime
+    , taiClock
+    ) where
 
-import Data.Time.Clock.Internal.AbsoluteTime
-import Data.Time.LocalTime
+import Data.Fixed
+import Data.Maybe
 import Data.Time.Calendar.Days
+import Data.Time.Clock
+import Data.Time.Clock.Internal.AbsoluteTime
 import Data.Time.Clock.Internal.SystemTime
 import Data.Time.Clock.System
-import Data.Time.Clock
-import Data.Maybe
-import Data.Fixed
+import Data.Time.LocalTime
 
 instance Show AbsoluteTime where
     show t = show (utcToLocalTime utc (fromJust (taiToUTCTime (const (Just 0)) t))) ++ " TAI" -- ugly, but standard apparently
@@ -55,9 +55,11 @@ taiToUTCTime lsmap abstime = let
         let
             dtime = diffAbsoluteTime abstime dayt
             day' = addDays (div' dtime len) day
-        if day == day' then return (UTCTime day dtime) else stable day'
+        if day == day'
+            then return (UTCTime day dtime)
+            else stable day'
     in stable $ ModifiedJulianDay $ div' (diffAbsoluteTime abstime taiEpoch) 86400
 
 -- | TAI clock, if it exists. Note that it is unlikely to be set correctly, without due care and attention.
-taiClock :: Maybe (DiffTime,IO AbsoluteTime)
+taiClock :: Maybe (DiffTime, IO AbsoluteTime)
 taiClock = fmap (fmap (fmap systemToTAITime)) getTAISystemTime
index 749223d..000c130 100644 (file)
@@ -1,9 +1,11 @@
 module Data.Time.Format
     (
     -- * UNIX-style formatting
-    FormatTime(),formatTime,
-    module Data.Time.Format.Parse
+      FormatTime()
+    , formatTime
+    , module Data.Time.Format.Parse
     ) where
+
 import Data.Time.Format.Format.Class
-import Data.Time.Format.Format.Instances()
+import Data.Time.Format.Format.Instances ()
 import Data.Time.Format.Parse
index 96567e9..21637d3 100644 (file)
@@ -1,59 +1,75 @@
 module Data.Time.Format.Format.Class
     (
         -- * Formatting
-        formatTime,
-        FormatNumericPadding,
-        FormatOptions(..),
-        FormatTime(..),
-        ShowPadded,PadOption,
-        formatGeneral,formatString,formatNumber,formatNumberStd,
-        showPaddedFixed,showPaddedFixedFraction,
-        quotBy,remBy,
-    )
-    where
+      formatTime
+    , FormatNumericPadding
+    , FormatOptions(..)
+    , FormatTime(..)
+    , ShowPadded
+    , PadOption
+    , formatGeneral
+    , formatString
+    , formatNumber
+    , formatNumberStd
+    , showPaddedFixed
+    , showPaddedFixedFraction
+    , quotBy
+    , remBy
+    ) where
 
 import Data.Char
-import Data.Maybe
 import Data.Fixed
+import Data.Maybe
 import Data.Time.Calendar.Private
 import Data.Time.Format.Locale
 
 type FormatNumericPadding = Maybe Char
 
-data FormatOptions = MkFormatOptions {
-    foLocale :: TimeLocale,
-    foPadding :: Maybe FormatNumericPadding,
-    foWidth :: Maybe Int
-}
+data FormatOptions = MkFormatOptions
+    { foLocale :: TimeLocale
+    , foPadding :: Maybe FormatNumericPadding
+    foWidth :: Maybe Int
+    }
 
 -- <http://www.opengroup.org/onlinepubs/007908799/xsh/strftime.html>
 class FormatTime t where
     -- | @since 1.9.1
     formatCharacter :: Bool -> Char -> Maybe (FormatOptions -> t -> String)
 
-
 -- the weird UNIX logic is here
 getPadOption :: Bool -> Bool -> Int -> Char -> Maybe FormatNumericPadding -> Maybe Int -> PadOption
 getPadOption trunc fdef idef cdef mnpad mi = let
-    c = case mnpad of
-        Just (Just c') -> c'
-        Just Nothing -> ' '
-        _ -> cdef
-    i = case mi of
-        Just i' -> case mnpad of
-            Just Nothing -> i'
-            _ -> if trunc then i' else max i' idef
-        Nothing -> idef
-    f = case mi of
-        Just _ -> True
-        Nothing -> case mnpad of
-            Nothing -> fdef
-            Just Nothing -> False
-            Just (Just _) -> True
-    in if f then Pad i c else NoPad
+    c =
+        case mnpad of
+            Just (Just c') -> c'
+            Just Nothing -> ' '
+            _ -> cdef
+    i =
+        case mi of
+            Just i' ->
+                case mnpad of
+                    Just Nothing -> i'
+                    _ ->
+                        if trunc
+                            then i'
+                            else max i' idef
+            Nothing -> idef
+    f =
+        case mi of
+            Just _ -> True
+            Nothing ->
+                case mnpad of
+                    Nothing -> fdef
+                    Just Nothing -> False
+                    Just (Just _) -> True
+    in if f
+           then Pad i c
+           else NoPad
 
-formatGeneral :: Bool -> Bool -> Int -> Char -> (TimeLocale -> PadOption -> t -> String) -> (FormatOptions -> t -> String)
-formatGeneral trunc fdef idef cdef ff fo = ff (foLocale fo) $ getPadOption trunc fdef idef cdef (foPadding fo) (foWidth fo)
+formatGeneral ::
+       Bool -> Bool -> Int -> Char -> (TimeLocale -> PadOption -> t -> String) -> (FormatOptions -> t -> String)
+formatGeneral trunc fdef idef cdef ff fo =
+    ff (foLocale fo) $ getPadOption trunc fdef idef cdef (foPadding fo) (foWidth fo)
 
 formatString :: (TimeLocale -> t -> String) -> (FormatOptions -> t -> String)
 formatString ff = formatGeneral False False 1 ' ' $ \locale pado -> showPadded pado . ff locale
@@ -65,23 +81,27 @@ formatNumberStd :: Int -> (t -> Integer) -> (FormatOptions -> t -> String)
 formatNumberStd n = formatNumber False n '0'
 
 showPaddedFixed :: HasResolution a => PadOption -> PadOption -> Fixed a -> String
-showPaddedFixed padn padf x | x < 0 = '-' : showPaddedFixed padn padf (negate x)
+showPaddedFixed padn padf x
+    | x < 0 = '-' : showPaddedFixed padn padf (negate x)
 showPaddedFixed padn padf x = let
     ns = showPaddedNum padn $ (floor x :: Integer)
     fs = showPaddedFixedFraction padf x
-    ds = if null fs then "" else "."
+    ds =
+        if null fs
+            then ""
+            else "."
     in ns ++ ds ++ fs
 
 showPaddedFixedFraction :: HasResolution a => PadOption -> Fixed a -> String
 showPaddedFixedFraction pado x = let
-    digits = dropWhile (=='.') $ dropWhile (/='.') $ showFixed True x
+    digits = dropWhile (== '.') $ dropWhile (/= '.') $ showFixed True x
     n = length digits
     in case pado of
-        NoPad -> digits
-        Pad i c -> if i < n
-            then take i digits
-            else digits ++ replicate (i - n) c
-
+           NoPad -> digits
+           Pad i c ->
+               if i < n
+                   then take i digits
+                   else digits ++ replicate (i - n) c
 
 -- | Substitute various time-related information for each %-code in the string, as per 'formatCharacter'.
 --
@@ -304,10 +324,11 @@ showPaddedFixedFraction pado x = let
 -- [@%0ES@] seconds of minute as two digits, with decimal point and \<width\> (default 12) decimal places.
 formatTime :: (FormatTime t) => TimeLocale -> String -> t -> String
 formatTime _ [] _ = ""
-formatTime locale ('%':cs) t = case formatTime1 locale cs t of
-    Just result -> result
-    Nothing -> '%':(formatTime locale cs t)
-formatTime locale (c:cs) t = c:(formatTime locale cs t)
+formatTime locale ('%':cs) t =
+    case formatTime1 locale cs t of
+        Just result -> result
+        Nothing -> '%' : (formatTime locale cs t)
+formatTime locale (c:cs) t = c : (formatTime locale cs t)
 
 formatTime1 :: (FormatTime t) => TimeLocale -> String -> t -> Maybe String
 formatTime1 locale ('_':cs) t = formatTime2 locale id (Just (Just ' ')) cs t
@@ -318,22 +339,34 @@ formatTime1 locale ('#':cs) t = formatTime2 locale (fmap toLower) Nothing cs t
 formatTime1 locale cs t = formatTime2 locale id Nothing cs t
 
 getDigit :: Char -> Maybe Int
-getDigit c | c < '0' = Nothing
-getDigit c | c > '9' = Nothing
+getDigit c
+    | c < '0' = Nothing
+getDigit c
+    | c > '9' = Nothing
 getDigit c = Just $ (ord c) - (ord '0')
 
-pullNumber :: Maybe Int -> String -> (Maybe Int,String)
-pullNumber mx [] = (mx,[])
-pullNumber mx s@(c:cs) = case getDigit c of
-    Just i -> pullNumber (Just $ (fromMaybe 0 mx)*10+i) cs
-    Nothing -> (mx,s)
+pullNumber :: Maybe Int -> String -> (Maybe Int, String)
+pullNumber mx [] = (mx, [])
+pullNumber mx s@(c:cs) =
+    case getDigit c of
+        Just i -> pullNumber (Just $ (fromMaybe 0 mx) * 10 + i) cs
+        Nothing -> (mx, s)
 
-formatTime2 :: (FormatTime t) => TimeLocale -> (String -> String) -> Maybe FormatNumericPadding -> String -> t -> Maybe String
+formatTime2 ::
+       (FormatTime t) => TimeLocale -> (String -> String) -> Maybe FormatNumericPadding -> String -> t -> Maybe String
 formatTime2 locale recase mpad cs t = let
-    (mwidth,rest) = pullNumber Nothing cs
+    (mwidth, rest) = pullNumber Nothing cs
     in formatTime3 locale recase mpad mwidth rest t
 
-formatTime3 :: (FormatTime t) => TimeLocale -> (String -> String) -> Maybe FormatNumericPadding -> Maybe Int -> String -> t -> Maybe String
+formatTime3 ::
+       (FormatTime t)
+    => TimeLocale
+    -> (String -> String)
+    -> Maybe FormatNumericPadding
+    -> Maybe Int
+    -> String
+    -> t
+    -> Maybe String
 formatTime3 locale recase mpad mwidth ('E':cs) = formatTime4 True recase (MkFormatOptions locale mpad mwidth) cs
 formatTime3 locale recase mpad mwidth cs = formatTime4 False recase (MkFormatOptions locale mpad mwidth) cs
 
@@ -345,6 +378,7 @@ formatChar :: (FormatTime t) => Bool -> Char -> FormatOptions -> t -> String
 formatChar _ '%' = formatString $ \_ _ -> "%"
 formatChar _ 't' = formatString $ \_ _ -> "\t"
 formatChar _ 'n' = formatString $ \_ _ -> "\n"
-formatChar alt c = case formatCharacter alt c of
-    Just f -> f
-    _ -> \_ _ -> ""
+formatChar alt c =
+    case formatCharacter alt c of
+        Just f -> f
+        _ -> \_ _ -> ""
index 2106437..c051440 100644 (file)
@@ -1,41 +1,47 @@
 {-# OPTIONS -fno-warn-orphans #-}
-module Data.Time.Format.Format.Instances () where
+
+module Data.Time.Format.Format.Instances
+    (
+    ) where
 
 import Data.Char
 import Data.Fixed
-import Data.Time.Clock.Internal.DiffTime
-import Data.Time.Clock.Internal.NominalDiffTime
-import Data.Time.Clock.Internal.UniversalTime
-import Data.Time.Clock.Internal.UTCTime
-import Data.Time.Clock.POSIX
-import Data.Time.Calendar.Days
 import Data.Time.Calendar.CalendarDiffDays
+import Data.Time.Calendar.Days
 import Data.Time.Calendar.Gregorian
-import Data.Time.Calendar.Week
-import Data.Time.Calendar.WeekDate
 import Data.Time.Calendar.OrdinalDate
 import Data.Time.Calendar.Private
+import Data.Time.Calendar.Week
+import Data.Time.Calendar.WeekDate
+import Data.Time.Clock.Internal.DiffTime
+import Data.Time.Clock.Internal.NominalDiffTime
+import Data.Time.Clock.Internal.UTCTime
+import Data.Time.Clock.Internal.UniversalTime
+import Data.Time.Clock.POSIX
+import Data.Time.Format.Format.Class
+import Data.Time.Format.Locale
 import Data.Time.LocalTime.Internal.CalendarDiffTime
-import Data.Time.LocalTime.Internal.TimeZone
-import Data.Time.LocalTime.Internal.TimeOfDay
 import Data.Time.LocalTime.Internal.LocalTime
+import Data.Time.LocalTime.Internal.TimeOfDay
+import Data.Time.LocalTime.Internal.TimeZone
 import Data.Time.LocalTime.Internal.ZonedTime
-import Data.Time.Format.Locale
-import Data.Time.Format.Format.Class
-
 
 instance FormatTime LocalTime where
     formatCharacter _ 'c' = Just $ \fo -> formatTime (foLocale fo) $ dateTimeFmt $ foLocale fo
-    formatCharacter alt c = case formatCharacter alt c of
-        Just f -> Just $ \fo dt -> f fo (localDay dt)
-        Nothing -> case formatCharacter alt c of
-            Just f -> Just $ \fo dt -> f fo (localTimeOfDay dt)
-            Nothing -> Nothing
+    formatCharacter alt c =
+        case formatCharacter alt c of
+            Just f -> Just $ \fo dt -> f fo (localDay dt)
+            Nothing ->
+                case formatCharacter alt c of
+                    Just f -> Just $ \fo dt -> f fo (localTimeOfDay dt)
+                    Nothing -> Nothing
 
 todAMPM :: TimeLocale -> TimeOfDay -> String
 todAMPM locale day = let
-    (am,pm) = amPm locale
-    in if (todHour day) < 12 then am else pm
+    (am, pm) = amPm locale
+    in if (todHour day) < 12
+           then am
+           else pm
 
 tod12Hour :: TimeOfDay -> Int
 tod12Hour day = (mod (todHour day - 1) 12) + 1
@@ -50,85 +56,93 @@ instance FormatTime TimeOfDay where
     formatCharacter _ 'P' = Just $ formatString $ \locale -> map toLower . todAMPM locale
     formatCharacter _ 'p' = Just $ formatString $ \locale -> todAMPM locale
     -- Hour
-    formatCharacter _ 'H' = Just $ formatNumber True  2 '0' todHour
-    formatCharacter _ 'I' = Just $ formatNumber True  2 '0' tod12Hour
-    formatCharacter _ 'k' = Just $ formatNumber True  2 ' ' todHour
-    formatCharacter _ 'l' = Just $ formatNumber True  2 ' ' tod12Hour
+    formatCharacter _ 'H' = Just $ formatNumber True 2 '0' todHour
+    formatCharacter _ 'I' = Just $ formatNumber True 2 '0' tod12Hour
+    formatCharacter _ 'k' = Just $ formatNumber True 2 ' ' todHour
+    formatCharacter _ 'l' = Just $ formatNumber True 2 ' ' tod12Hour
     -- Minute
-    formatCharacter _ 'M' = Just $ formatNumber True  2 '0' todMin
+    formatCharacter _ 'M' = Just $ formatNumber True 2 '0' todMin
     -- Second
-    formatCharacter _ 'S' = Just $ formatNumber True  2 '0' $ (floor . todSec :: TimeOfDay -> Int)
+    formatCharacter _ 'S' = Just $ formatNumber True 2 '0' $ (floor . todSec :: TimeOfDay -> Int)
     formatCharacter _ 'q' = Just $ formatGeneral True True 12 '0' $ \_ pado -> showPaddedFixedFraction pado . todSec
-    formatCharacter _ 'Q' = Just $ formatGeneral True False 12 '0' $ \_ pado -> dotNonEmpty . showPaddedFixedFraction pado . todSec where
+    formatCharacter _ 'Q' =
+        Just $ formatGeneral True False 12 '0' $ \_ pado -> dotNonEmpty . showPaddedFixedFraction pado . todSec
+      where
         dotNonEmpty "" = ""
-        dotNonEmpty s = '.':s
-
+        dotNonEmpty s = '.' : s
     -- Default
-    formatCharacter _ _   = Nothing
+    formatCharacter _ _ = Nothing
 
 instance FormatTime ZonedTime where
     formatCharacter _ 'c' = Just $ formatString $ \locale -> formatTime locale (dateTimeFmt locale)
-    formatCharacter _ 's' = Just $ formatNumber True  1 '0' $ (floor . utcTimeToPOSIXSeconds . zonedTimeToUTC :: ZonedTime -> Integer)
-    formatCharacter alt c = case formatCharacter alt c of
-        Just f -> Just $ \fo dt -> f fo (zonedTimeToLocalTime dt)
-        Nothing -> case formatCharacter alt c of
-            Just f -> Just $ \fo dt -> f fo (zonedTimeZone dt)
-            Nothing -> Nothing
+    formatCharacter _ 's' =
+        Just $ formatNumber True 1 '0' $ (floor . utcTimeToPOSIXSeconds . zonedTimeToUTC :: ZonedTime -> Integer)
+    formatCharacter alt c =
+        case formatCharacter alt c of
+            Just f -> Just $ \fo dt -> f fo (zonedTimeToLocalTime dt)
+            Nothing ->
+                case formatCharacter alt c of
+                    Just f -> Just $ \fo dt -> f fo (zonedTimeZone dt)
+                    Nothing -> Nothing
 
 instance FormatTime TimeZone where
     formatCharacter False 'z' = Just $ formatGeneral False True 4 '0' $ \_ -> timeZoneOffsetString'' False
     formatCharacter True 'z' = Just $ formatGeneral False True 5 '0' $ \_ -> timeZoneOffsetString'' True
-    formatCharacter alt 'Z' = Just $ \fo z -> let
-        n = timeZoneName z
-        idef = if alt then 5 else 4
-        in if null n then formatGeneral False True idef '0' (\_ -> timeZoneOffsetString'' alt) fo z else formatString (\_ -> timeZoneName) fo z
+    formatCharacter alt 'Z' =
+        Just $ \fo z -> let
+            n = timeZoneName z
+            idef =
+                if alt
+                    then 5
+                    else 4
+            in if null n
+                   then formatGeneral False True idef '0' (\_ -> timeZoneOffsetString'' alt) fo z
+                   else formatString (\_ -> timeZoneName) fo z
     formatCharacter _ _ = Nothing
 
 instance FormatTime DayOfWeek where
-    formatCharacter _ 'u' = Just $ formatNumber True  1 '0' $ fromEnum
-    formatCharacter _ 'w' = Just $ formatNumber True  1 '0' $ \wd -> (mod (fromEnum wd) 7)
+    formatCharacter _ 'u' = Just $ formatNumber True 1 '0' $ fromEnum
+    formatCharacter _ 'w' = Just $ formatNumber True 1 '0' $ \wd -> (mod (fromEnum wd) 7)
     formatCharacter _ 'a' = Just $ formatString $ \locale wd -> snd $ (wDays locale) !! (mod (fromEnum wd) 7)
     formatCharacter _ 'A' = Just $ formatString $ \locale wd -> fst $ (wDays locale) !! (mod (fromEnum wd) 7)
-    formatCharacter _ _   = Nothing
+    formatCharacter _ _ = Nothing
 
 instance FormatTime Day where
     -- Aggregate
     formatCharacter _ 'D' = Just $ formatString $ \locale -> formatTime locale "%m/%d/%y"
     formatCharacter _ 'F' = Just $ formatString $ \locale -> formatTime locale "%Y-%m-%d"
     formatCharacter _ 'x' = Just $ formatString $ \locale -> formatTime locale (dateFmt locale)
-
     -- Year Count
-    formatCharacter _ 'Y' = Just $ formatNumber False 4 '0' $          fst . toOrdinalDate
-    formatCharacter _ 'y' = Just $ formatNumber True  2 '0' $ mod100 . fst . toOrdinalDate
+    formatCharacter _ 'Y' = Just $ formatNumber False 4 '0' $ fst . toOrdinalDate
+    formatCharacter _ 'y' = Just $ formatNumber True 2 '0' $ mod100 . fst . toOrdinalDate
     formatCharacter _ 'C' = Just $ formatNumber False 2 '0' $ div100 . fst . toOrdinalDate
     -- Month of Year
-    formatCharacter _ 'B' = Just $ formatString $ \locale -> fst . (\(_,m,_) -> (months locale) !! (m - 1)) . toGregorian
-    formatCharacter _ 'b' = Just $ formatString $ \locale -> snd . (\(_,m,_) -> (months locale) !! (m - 1)) . toGregorian
-    formatCharacter _ 'h' = Just $ formatString $ \locale -> snd . (\(_,m,_) -> (months locale) !! (m - 1)) . toGregorian
-    formatCharacter _ 'm' = Just $ formatNumber True  2 '0' $ (\(_,m,_) -> m) . toGregorian
+    formatCharacter _ 'B' =
+        Just $ formatString $ \locale -> fst . (\(_, m, _) -> (months locale) !! (m - 1)) . toGregorian
+    formatCharacter _ 'b' =
+        Just $ formatString $ \locale -> snd . (\(_, m, _) -> (months locale) !! (m - 1)) . toGregorian
+    formatCharacter _ 'h' =
+        Just $ formatString $ \locale -> snd . (\(_, m, _) -> (months locale) !! (m - 1)) . toGregorian
+    formatCharacter _ 'm' = Just $ formatNumber True 2 '0' $ (\(_, m, _) -> m) . toGregorian
     -- Day of Month
-    formatCharacter _ 'd' = Just $ formatNumber True  2 '0' $ (\(_,_,d) -> d) . toGregorian
-    formatCharacter _ 'e' = Just $ formatNumber True  2 ' ' $ (\(_,_,d) -> d) . toGregorian
+    formatCharacter _ 'd' = Just $ formatNumber True 2 '0' $ (\(_, _, d) -> d) . toGregorian
+    formatCharacter _ 'e' = Just $ formatNumber True 2 ' ' $ (\(_, _, d) -> d) . toGregorian
     -- Day of Year
-    formatCharacter _ 'j' = Just $ formatNumber True  3 '0' $ snd . toOrdinalDate
-
+    formatCharacter _ 'j' = Just $ formatNumber True 3 '0' $ snd . toOrdinalDate
     -- ISO 8601 Week Date
-    formatCharacter _ 'G' = Just $ formatNumber False 4 '0' $ (\(y,_,_) -> y) . toWeekDate
-    formatCharacter _ 'g' = Just $ formatNumber True  2 '0' $ mod100 . (\(y,_,_) -> y) . toWeekDate
-    formatCharacter _ 'f' = Just $ formatNumber False 2 '0' $ div100 . (\(y,_,_) -> y) . toWeekDate
-
-    formatCharacter _ 'V' = Just $ formatNumber True  2 '0' $ (\(_,w,_) -> w) . toWeekDate
-    formatCharacter _ 'u' = Just $ formatNumber True  1 '0' $ (\(_,_,d) -> d) . toWeekDate
-
+    formatCharacter _ 'G' = Just $ formatNumber False 4 '0' $ (\(y, _, _) -> y) . toWeekDate
+    formatCharacter _ 'g' = Just $ formatNumber True 2 '0' $ mod100 . (\(y, _, _) -> y) . toWeekDate
+    formatCharacter _ 'f' = Just $ formatNumber False 2 '0' $ div100 . (\(y, _, _) -> y) . toWeekDate
+    formatCharacter _ 'V' = Just $ formatNumber True 2 '0' $ (\(_, w, _) -> w) . toWeekDate
+    formatCharacter _ 'u' = Just $ formatNumber True 1 '0' $ (\(_, _, d) -> d) . toWeekDate
     -- Day of week
     formatCharacter _ 'a' = Just $ formatString $ \locale -> snd . ((wDays locale) !!) . snd . sundayStartWeek
     formatCharacter _ 'A' = Just $ formatString $ \locale -> fst . ((wDays locale) !!) . snd . sundayStartWeek
-    formatCharacter _ 'U' = Just $ formatNumber True  2 '0' $ fst . sundayStartWeek
-    formatCharacter _ 'w' = Just $ formatNumber True  1 '0' $ snd . sundayStartWeek
-    formatCharacter _ 'W' = Just $ formatNumber True  2 '0' $ fst . mondayStartWeek
-
+    formatCharacter _ 'U' = Just $ formatNumber True 2 '0' $ fst . sundayStartWeek
+    formatCharacter _ 'w' = Just $ formatNumber True 1 '0' $ snd . sundayStartWeek
+    formatCharacter _ 'W' = Just $ formatNumber True 2 '0' $ fst . mondayStartWeek
     -- Default
-    formatCharacter _ _   = Nothing
+    formatCharacter _ _ = Nothing
 
 instance FormatTime UTCTime where
     formatCharacter alt c = fmap (\f fo t -> f fo (utcToZonedTime utc t)) (formatCharacter alt c)
@@ -145,14 +159,18 @@ instance FormatTime NominalDiffTime where
     formatCharacter _ 'm' = Just $ formatNumberStd 1 $ quotBy 60
     formatCharacter _ 'M' = Just $ formatNumberStd 2 $ remBy 60 . quotBy 60
     formatCharacter False 's' = Just $ formatNumberStd 1 $ quotBy 1
-    formatCharacter True 's' = Just $ formatGeneral False False 12 '0' $ \_ padf t -> showPaddedFixed NoPad padf (realToFrac t :: Pico)
+    formatCharacter True 's' =
+        Just $ formatGeneral False False 12 '0' $ \_ padf t -> showPaddedFixed NoPad padf (realToFrac t :: Pico)
     formatCharacter False 'S' = Just $ formatNumberStd 2 $ remBy 60 . quotBy 1
-    formatCharacter True 'S' = Just $ formatGeneral False False 12 '0' $ \_ padf t -> let
-        padn = case padf of
-            NoPad -> NoPad
-            Pad _ c -> Pad 2 c
-        in showPaddedFixed padn padf (realToFrac $ remBy 60 t :: Pico)
-    formatCharacter _ _   = Nothing
+    formatCharacter True 'S' =
+        Just $
+        formatGeneral False False 12 '0' $ \_ padf t -> let
+            padn =
+                case padf of
+                    NoPad -> NoPad
+                    Pad _ c -> Pad 2 c
+            in showPaddedFixed padn padf (realToFrac $ remBy 60 t :: Pico)
+    formatCharacter _ _ = Nothing
 
 instance FormatTime DiffTime where
     formatCharacter _ 'w' = Just $ formatNumberStd 1 $ quotBy $ 7 * 86400
@@ -163,14 +181,18 @@ instance FormatTime DiffTime where
     formatCharacter _ 'm' = Just $ formatNumberStd 1 $ quotBy 60
     formatCharacter _ 'M' = Just $ formatNumberStd 2 $ remBy 60 . quotBy 60
     formatCharacter False 's' = Just $ formatNumberStd 1 $ quotBy 1
-    formatCharacter True 's' = Just $ formatGeneral False False 12 '0' $ \_ padf t -> showPaddedFixed NoPad padf (realToFrac t :: Pico)
+    formatCharacter True 's' =
+        Just $ formatGeneral False False 12 '0' $ \_ padf t -> showPaddedFixed NoPad padf (realToFrac t :: Pico)
     formatCharacter False 'S' = Just $ formatNumberStd 2 $ remBy 60 . quotBy 1
-    formatCharacter True 'S' = Just $ formatGeneral False False 12 '0' $ \_ padf t -> let
-        padn = case padf of
-            NoPad -> NoPad
-            Pad _ c -> Pad 2 c
-        in showPaddedFixed padn padf (realToFrac $ remBy 60 t :: Pico)
-    formatCharacter _ _   = Nothing
+    formatCharacter True 'S' =
+        Just $
+        formatGeneral False False 12 '0' $ \_ padf t -> let
+            padn =
+                case padf of
+                    NoPad -> NoPad
+                    Pad _ c -> Pad 2 c
+            in showPaddedFixed padn padf (realToFrac $ remBy 60 t :: Pico)
+    formatCharacter _ _ = Nothing
 
 instance FormatTime CalendarDiffDays where
     formatCharacter _ 'y' = Just $ formatNumberStd 1 $ quotBy 12 . cdMonths
@@ -179,7 +201,7 @@ instance FormatTime CalendarDiffDays where
     formatCharacter _ 'w' = Just $ formatNumberStd 1 $ quotBy 7 . cdDays
     formatCharacter _ 'd' = Just $ formatNumberStd 1 $ cdDays
     formatCharacter _ 'D' = Just $ formatNumberStd 1 $ remBy 7 . cdDays
-    formatCharacter _ _   = Nothing
+    formatCharacter _ _ = Nothing
 
 instance FormatTime CalendarDiffTime where
     formatCharacter _ 'y' = Just $ formatNumberStd 1 $ quotBy 12 . ctMonths
index 204216b..7840eff 100644 (file)
 module Data.Time.Format.ISO8601
     (
         -- * Format
-        Format,
-        formatShowM,
-        formatShow,
-        formatReadP,
-        formatParseM,
+      Format
+    , formatShowM
+    , formatShow
+    , formatReadP
+    , formatParseM
         -- * Common formats
-        ISO8601(..),
-        iso8601Show,
-        iso8601ParseM,
+    , ISO8601(..)
+    , iso8601Show
+    , iso8601ParseM
         -- * All formats
-        FormatExtension(..),
-        formatReadPExtension,
-        parseFormatExtension,
-        calendarFormat,
-        yearMonthFormat,
-        yearFormat,
-        centuryFormat,
-        expandedCalendarFormat,
-        expandedYearMonthFormat,
-        expandedYearFormat,
-        expandedCenturyFormat,
-        ordinalDateFormat,
-        expandedOrdinalDateFormat,
-        weekDateFormat,
-        yearWeekFormat,
-        expandedWeekDateFormat,
-        expandedYearWeekFormat,
-        timeOfDayFormat,
-        hourMinuteFormat,
-        hourFormat,
-        withTimeDesignator,
-        withUTCDesignator,
-        timeOffsetFormat,
-        timeOfDayAndOffsetFormat,
-        localTimeFormat,
-        zonedTimeFormat,
-        utcTimeFormat,
-        dayAndTimeFormat,
-        timeAndOffsetFormat,
-        durationDaysFormat,
-        durationTimeFormat,
-        alternativeDurationDaysFormat,
-        alternativeDurationTimeFormat,
-        intervalFormat,
-        recurringIntervalFormat,
+    , FormatExtension(..)
+    , formatReadPExtension
+    , parseFormatExtension
+    , calendarFormat
+    , yearMonthFormat
+    , yearFormat
+    , centuryFormat
+    , expandedCalendarFormat
+    , expandedYearMonthFormat
+    , expandedYearFormat
+    , expandedCenturyFormat
+    , ordinalDateFormat
+    , expandedOrdinalDateFormat
+    , weekDateFormat
+    , yearWeekFormat
+    , expandedWeekDateFormat
+    , expandedYearWeekFormat
+    , timeOfDayFormat
+    , hourMinuteFormat
+    , hourFormat
+    , withTimeDesignator
+    , withUTCDesignator
+    , timeOffsetFormat
+    , timeOfDayAndOffsetFormat
+    , localTimeFormat
+    , zonedTimeFormat
+    , utcTimeFormat
+    , dayAndTimeFormat
+    , timeAndOffsetFormat
+    , durationDaysFormat
+    , durationTimeFormat
+    , alternativeDurationDaysFormat
+    , alternativeDurationTimeFormat
+    , intervalFormat
+    , recurringIntervalFormat
     ) where
 
-#if MIN_VERSION_base(4,9,0)
 import Control.Monad.Fail
-import Prelude hiding (fail)
-#endif
-#if MIN_VERSION_base(4,8,0)
-#else
-import Data.Monoid
-#endif
-import Data.Ratio
 import Data.Fixed
-import Text.ParserCombinators.ReadP
 import Data.Format
+import Data.Ratio
 import Data.Time
 import Data.Time.Calendar.OrdinalDate
-import Data.Time.Calendar.WeekDate
 import Data.Time.Calendar.Private
+import Data.Time.Calendar.WeekDate
+import Prelude hiding (fail)
+import Text.ParserCombinators.ReadP
 
-data FormatExtension =
+data FormatExtension
+    = 
     -- | ISO 8601:2004(E) sec. 2.3.4. Use hyphens and colons.
-    ExtendedFormat |
+      ExtendedFormat
     -- | ISO 8601:2004(E) sec. 2.3.3. Omit hyphens and colons. "The basic format should be avoided in plain text."
-    BasicFormat
+    BasicFormat
 
 -- | Read a value in either extended or basic format
 formatReadPExtension :: (FormatExtension -> Format t) -> ReadP t
 formatReadPExtension ff = formatReadP (ff ExtendedFormat) +++ formatReadP (ff BasicFormat)
 
 -- | Parse a value in either extended or basic format
-parseFormatExtension :: (
-#if MIN_VERSION_base(4,9,0)
-    MonadFail m
-#else
-    Monad m
-#endif
-    ) => (FormatExtension -> Format t) -> String -> m t
+parseFormatExtension :: (MonadFail m) => (FormatExtension -> Format t) -> String -> m t
 parseFormatExtension ff = parseReader $ formatReadPExtension ff
 
-sepFormat :: String -> Format a -> Format b -> Format (a,b)
+sepFormat :: String -> Format a -> Format b -> Format (a, b)
 sepFormat sep fa fb = (fa <** literalFormat sep) <**> fb
 
-dashFormat :: Format a -> Format b -> Format (a,b)
+dashFormat :: Format a -> Format b -> Format (a, b)
 dashFormat = sepFormat "-"
 
-colnFormat :: Format a -> Format b -> Format (a,b)
+colnFormat :: Format a -> Format b -> Format (a, b)
 colnFormat = sepFormat ":"
 
-extDashFormat :: FormatExtension -> Format a -> Format b -> Format (a,b)
+extDashFormat :: FormatExtension -> Format a -> Format b -> Format (a, b)
 extDashFormat ExtendedFormat = dashFormat
 extDashFormat BasicFormat = (<**>)
 
-extColonFormat :: FormatExtension -> Format a -> Format b -> Format (a,b)
+extColonFormat :: FormatExtension -> Format a -> Format b -> Format (a, b)
 extColonFormat ExtendedFormat = colnFormat
 extColonFormat BasicFormat = (<**>)
 
@@ -127,9 +116,12 @@ hourFormat' :: Format Int
 hourFormat' = integerFormat NoSign (Just 2)
 
 data E14
+
 instance HasResolution E14 where
     resolution _ = 100000000000000
+
 data E16
+
 instance HasResolution E16 where
     resolution _ = 10000000000000000
 
@@ -145,25 +137,26 @@ minuteDecimalFormat = decimalFormat NoSign (Just 2)
 secondFormat :: Format Pico
 secondFormat = decimalFormat NoSign (Just 2)
 
-mapGregorian :: Format (Integer,(Int,Int)) -> Format Day
-mapGregorian = mapMFormat (\(y,(m,d)) -> fromGregorianValid y m d) (\day -> (\(y,m,d) -> Just (y,(m,d))) $ toGregorian day)
+mapGregorian :: Format (Integer, (Int, Int)) -> Format Day
+mapGregorian =
+    mapMFormat (\(y, (m, d)) -> fromGregorianValid y m d) (\day -> (\(y, m, d) -> Just (y, (m, d))) $ toGregorian day)
 
-mapOrdinalDate :: Format (Integer,Int) -> Format Day
-mapOrdinalDate = mapMFormat (\(y,d) -> fromOrdinalDateValid y d) (Just . toOrdinalDate)
+mapOrdinalDate :: Format (Integer, Int) -> Format Day
+mapOrdinalDate = mapMFormat (\(y, d) -> fromOrdinalDateValid y d) (Just . toOrdinalDate)
 
-mapWeekDate :: Format (Integer,(Int,Int)) -> Format Day
-mapWeekDate = mapMFormat (\(y,(w,d)) -> fromWeekDateValid y w d) (\day -> (\(y,w,d) -> Just (y,(w,d))) $ toWeekDate day)
-
-mapTimeOfDay :: Format (Int,(Int,Pico)) -> Format TimeOfDay
-mapTimeOfDay = mapMFormat (\(h,(m,s)) -> makeTimeOfDayValid h m s) (\(TimeOfDay h m s) -> Just (h,(m,s)))
+mapWeekDate :: Format (Integer, (Int, Int)) -> Format Day
+mapWeekDate =
+    mapMFormat (\(y, (w, d)) -> fromWeekDateValid y w d) (\day -> (\(y, w, d) -> Just (y, (w, d))) $ toWeekDate day)
 
+mapTimeOfDay :: Format (Int, (Int, Pico)) -> Format TimeOfDay
+mapTimeOfDay = mapMFormat (\(h, (m, s)) -> makeTimeOfDayValid h m s) (\(TimeOfDay h m s) -> Just (h, (m, s)))
 
 -- | ISO 8601:2004(E) sec. 4.1.2.2
 calendarFormat :: FormatExtension -> Format Day
 calendarFormat fe = mapGregorian $ extDashFormat fe yearFormat $ extDashFormat fe monthFormat dayOfMonthFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.2.3(a)
-yearMonthFormat :: Format (Integer,Int)
+yearMonthFormat :: Format (Integer, Int)
 yearMonthFormat = yearFormat <**> literalFormat "-" **> monthFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.2.3(b)
@@ -176,10 +169,11 @@ centuryFormat = integerFormat NegSign (Just 2)
 
 -- | ISO 8601:2004(E) sec. 4.1.2.4(a)
 expandedCalendarFormat :: Int -> FormatExtension -> Format Day
-expandedCalendarFormat n fe = mapGregorian $ extDashFormat fe (expandedYearFormat n) $ extDashFormat fe monthFormat dayOfMonthFormat
+expandedCalendarFormat n fe =
+    mapGregorian $ extDashFormat fe (expandedYearFormat n) $ extDashFormat fe monthFormat dayOfMonthFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.2.4(b)
-expandedYearMonthFormat :: Int -> Format (Integer,Int)
+expandedYearMonthFormat :: Int -> Format (Integer, Int)
 expandedYearMonthFormat n = dashFormat (expandedYearFormat n) monthFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.2.4(c)
@@ -203,15 +197,16 @@ weekDateFormat :: FormatExtension -> Format Day
 weekDateFormat fe = mapWeekDate $ extDashFormat fe yearFormat $ extDashFormat fe weekOfYearFormat dayOfWeekFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.4.3
-yearWeekFormat :: FormatExtension -> Format  (Integer,Int)
+yearWeekFormat :: FormatExtension -> Format (Integer, Int)
 yearWeekFormat fe = extDashFormat fe yearFormat weekOfYearFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.4.2
 expandedWeekDateFormat :: Int -> FormatExtension -> Format Day
-expandedWeekDateFormat n fe = mapWeekDate $ extDashFormat fe (expandedYearFormat n) $ extDashFormat fe weekOfYearFormat dayOfWeekFormat
+expandedWeekDateFormat n fe =
+    mapWeekDate $ extDashFormat fe (expandedYearFormat n) $ extDashFormat fe weekOfYearFormat dayOfWeekFormat
 
 -- | ISO 8601:2004(E) sec. 4.1.4.3
-expandedYearWeekFormat :: Int -> FormatExtension -> Format (Integer,Int)
+expandedYearWeekFormat :: Int -> FormatExtension -> Format (Integer, Int)
 expandedYearWeekFormat n fe = extDashFormat fe (expandedYearFormat n) weekOfYearFormat
 
 -- | ISO 8601:2004(E) sec. 4.2.2.2, 4.2.2.4(a)
@@ -225,9 +220,10 @@ fromRationalRound r = fromRational $ round (r * 1000000000000) % 1000000000000
 -- | ISO 8601:2004(E) sec. 4.2.2.3(a), 4.2.2.4(b)
 hourMinuteFormat :: FormatExtension -> Format TimeOfDay
 hourMinuteFormat fe = let
-    toTOD (h,m) = case timeToDaysAndTimeOfDay $ fromRationalRound $ toRational $ (fromIntegral h) * 3600 + m * 60 of
-        (0,tod) -> Just tod
-        _ -> Nothing
+    toTOD (h, m) =
+        case timeToDaysAndTimeOfDay $ fromRationalRound $ toRational $ (fromIntegral h) * 3600 + m * 60 of
+            (0, tod) -> Just tod
+            _ -> Nothing
     fromTOD tod = let
         mm = (realToFrac $ daysAndTimeOfDayToTime 0 tod) / 60
         in Just $ quotRemBy 60 mm
@@ -236,9 +232,10 @@ hourMinuteFormat fe = let
 -- | ISO 8601:2004(E) sec. 4.2.2.3(b), 4.2.2.4(c)
 hourFormat :: Format TimeOfDay
 hourFormat = let
-    toTOD h = case timeToDaysAndTimeOfDay $ fromRationalRound $ toRational $ h * 3600 of
-        (0,tod) -> Just tod
-        _ -> Nothing
+    toTOD h =
+        case timeToDaysAndTimeOfDay $ fromRationalRound $ toRational $ h * 3600 of
+            (0, tod) -> Just tod
+            _ -> Nothing
     fromTOD tod = Just $ (realToFrac $ daysAndTimeOfDayToTime 0 tod) / 3600
     in mapMFormat toTOD fromTOD $ hourDecimalFormat
 
@@ -253,96 +250,108 @@ withUTCDesignator f = f <** literalFormat "Z"
 -- | ISO 8601:2004(E) sec. 4.2.5.1
 timeOffsetFormat :: FormatExtension -> Format TimeZone
 timeOffsetFormat fe = let
-    toTimeZone (sign,(h,m)) = minutesToTimeZone $ sign * (h * 60 + m)
+    toTimeZone (sign, (h, m)) = minutesToTimeZone $ sign * (h * 60 + m)
     fromTimeZone tz = let
         mm = timeZoneMinutes tz
         hm = quotRem (abs mm) 60
-        in (signum mm,hm)
+        in (signum mm, hm)
     in isoMap toTimeZone fromTimeZone $
-        mandatorySignFormat <**> extColonFormat fe (integerFormat NoSign (Just 2)) (integerFormat NoSign (Just 2))
+       mandatorySignFormat <**> extColonFormat fe (integerFormat NoSign (Just 2)) (integerFormat NoSign (Just 2))
 
 -- | ISO 8601:2004(E) sec. 4.2.5.2
-timeOfDayAndOffsetFormat :: FormatExtension -> Format (TimeOfDay,TimeZone)
+timeOfDayAndOffsetFormat :: FormatExtension -> Format (TimeOfDay, TimeZone)
 timeOfDayAndOffsetFormat fe = timeOfDayFormat fe <**> timeOffsetFormat fe
 
 -- | ISO 8601:2004(E) sec. 4.3.2
 localTimeFormat :: Format Day -> Format TimeOfDay -> Format LocalTime
-localTimeFormat fday ftod = isoMap (\(day,tod) -> LocalTime day tod) (\(LocalTime day tod) -> (day,tod)) $ fday <**> withTimeDesignator ftod
+localTimeFormat fday ftod =
+    isoMap (\(day, tod) -> LocalTime day tod) (\(LocalTime day tod) -> (day, tod)) $ fday <**> withTimeDesignator ftod
 
 -- | ISO 8601:2004(E) sec. 4.3.2
 zonedTimeFormat :: Format Day -> Format TimeOfDay -> FormatExtension -> Format ZonedTime
-zonedTimeFormat fday ftod fe = isoMap (\(lt,tz) -> ZonedTime lt tz) (\(ZonedTime lt tz) -> (lt,tz)) $ timeAndOffsetFormat (localTimeFormat fday ftod) fe
+zonedTimeFormat fday ftod fe =
+    isoMap (\(lt, tz) -> ZonedTime lt tz) (\(ZonedTime lt tz) -> (lt, tz)) $
+    timeAndOffsetFormat (localTimeFormat fday ftod) fe
 
 -- | ISO 8601:2004(E) sec. 4.3.2
 utcTimeFormat :: Format Day -> Format TimeOfDay -> Format UTCTime
-utcTimeFormat fday ftod = isoMap (localTimeToUTC utc) (utcToLocalTime utc) $ withUTCDesignator $ localTimeFormat fday ftod
+utcTimeFormat fday ftod =
+    isoMap (localTimeToUTC utc) (utcToLocalTime utc) $ withUTCDesignator $ localTimeFormat fday ftod
 
 -- | ISO 8601:2004(E) sec. 4.3.3
-dayAndTimeFormat :: Format Day -> Format time -> Format (Day,time)
+dayAndTimeFormat :: Format Day -> Format time -> Format (Day, time)
 dayAndTimeFormat fday ft = fday <**> withTimeDesignator ft
 
 -- | ISO 8601:2004(E) sec. 4.3.3
-timeAndOffsetFormat :: Format t -> FormatExtension -> Format (t,TimeZone)
+timeAndOffsetFormat :: Format t -> FormatExtension -> Format (t, TimeZone)
 timeAndOffsetFormat ft fe = ft <**> timeOffsetFormat fe
 
-intDesignator :: (Eq t,Show t,Read t,Num t) => Char -> Format t
+intDesignator :: (Eq t, Show t, Read t, Num t) => Char -> Format t
 intDesignator c = optionalFormat 0 $ integerFormat NoSign Nothing <** literalFormat [c]
 
-decDesignator :: (Eq t,Show t,Read t,Num t) => Char -> Format t
+decDesignator :: (Eq t, Show t, Read t, Num t) => Char -> Format t
 decDesignator c = optionalFormat 0 $ decimalFormat NoSign Nothing <** literalFormat [c]
 
 daysDesigs :: Format CalendarDiffDays
 daysDesigs = let
-    toCD (y,(m,(w,d))) = CalendarDiffDays (y * 12 + m) (w * 7 + d)
-    fromCD (CalendarDiffDays mm d) = (quot mm 12,(rem mm 12,(0,d)))
-    in isoMap toCD fromCD $
-        intDesignator 'Y' <**> intDesignator 'M' <**> intDesignator 'W' <**> intDesignator 'D'
+    toCD (y, (m, (w, d))) = CalendarDiffDays (y * 12 + m) (w * 7 + d)
+    fromCD (CalendarDiffDays mm d) = (quot mm 12, (rem mm 12, (0, d)))
+    in isoMap toCD fromCD $ intDesignator 'Y' <**> intDesignator 'M' <**> intDesignator 'W' <**> intDesignator 'D'
 
 -- | ISO 8601:2004(E) sec. 4.4.3.2
 durationDaysFormat :: Format CalendarDiffDays
-durationDaysFormat = (**>) (literalFormat "P") $ specialCaseShowFormat (mempty,"0D") $ daysDesigs
+durationDaysFormat = (**>) (literalFormat "P") $ specialCaseShowFormat (mempty, "0D") $ daysDesigs
 
 -- | ISO 8601:2004(E) sec. 4.4.3.2
 durationTimeFormat :: Format CalendarDiffTime
 durationTimeFormat = let
-    toCT (cd,(h,(m,s))) = mappend (calendarTimeDays cd) (calendarTimeTime $ daysAndTimeOfDayToTime 0 $ TimeOfDay h m s)
+    toCT (cd, (h, (m, s))) =
+        mappend (calendarTimeDays cd) (calendarTimeTime $ daysAndTimeOfDayToTime 0 $ TimeOfDay h m s)
     fromCT (CalendarDiffTime mm t) = let
-        (d,TimeOfDay h m s) = timeToDaysAndTimeOfDay t
-        in (CalendarDiffDays mm d,(h,(m,s)))
-    in (**>) (literalFormat "P") $ specialCaseShowFormat (mempty,"0D") $ isoMap toCT fromCT $
-        (<**>) daysDesigs $ optionalFormat (0,(0,0)) $ literalFormat "T" **> intDesignator 'H' <**> intDesignator 'M' <**> decDesignator 'S'
+        (d, TimeOfDay h m s) = timeToDaysAndTimeOfDay t
+        in (CalendarDiffDays mm d, (h, (m, s)))
+    in (**>) (literalFormat "P") $
+       specialCaseShowFormat (mempty, "0D") $
+       isoMap toCT fromCT $
+       (<**>) daysDesigs $
+       optionalFormat (0, (0, 0)) $
+       literalFormat "T" **> intDesignator 'H' <**> intDesignator 'M' <**> decDesignator 'S'
 
 -- | ISO 8601:2004(E) sec. 4.4.3.3
 alternativeDurationDaysFormat :: FormatExtension -> Format CalendarDiffDays
 alternativeDurationDaysFormat fe = let
-    toCD (y,(m,d)) = CalendarDiffDays (y * 12 + m) d
-    fromCD (CalendarDiffDays mm d) = (quot mm 12,(rem mm 12,d))
-    in isoMap toCD fromCD $ (**>) (literalFormat "P") $
-        extDashFormat fe (clipFormat (0,9999) $ integerFormat NegSign $ Just 4) $
-        extDashFormat fe (clipFormat (0,12) $ integerFormat NegSign $ Just 2) $
-        (clipFormat (0,30) $ integerFormat NegSign $ Just 2)
+    toCD (y, (m, d)) = CalendarDiffDays (y * 12 + m) d
+    fromCD (CalendarDiffDays mm d) = (quot mm 12, (rem mm 12, d))
+    in isoMap toCD fromCD $
+       (**>) (literalFormat "P") $
+       extDashFormat fe (clipFormat (0, 9999) $ integerFormat NegSign $ Just 4) $
+       extDashFormat fe (clipFormat (0, 12) $ integerFormat NegSign $ Just 2) $
+       (clipFormat (0, 30) $ integerFormat NegSign $ Just 2)
 
 -- | ISO 8601:2004(E) sec. 4.4.3.3
 alternativeDurationTimeFormat :: FormatExtension -> Format CalendarDiffTime
 alternativeDurationTimeFormat fe = let
-    toCT (cd,(h,(m,s))) = mappend (calendarTimeDays cd) (calendarTimeTime $ daysAndTimeOfDayToTime 0 $ TimeOfDay h m s)
+    toCT (cd, (h, (m, s))) =
+        mappend (calendarTimeDays cd) (calendarTimeTime $ daysAndTimeOfDayToTime 0 $ TimeOfDay h m s)
     fromCT (CalendarDiffTime mm t) = let
-        (d,TimeOfDay h m s) = timeToDaysAndTimeOfDay t
-        in (CalendarDiffDays mm d,(h,(m,s)))
+        (d, TimeOfDay h m s) = timeToDaysAndTimeOfDay t
+        in (CalendarDiffDays mm d, (h, (m, s)))
     in isoMap toCT fromCT $
-        (<**>) (alternativeDurationDaysFormat fe) $
-        withTimeDesignator $
-        extColonFormat fe (clipFormat (0,24) $ integerFormat NegSign (Just 2)) $
-        extColonFormat fe (clipFormat (0,60) $ integerFormat NegSign (Just 2)) $
-        (clipFormat (0,60) $ decimalFormat NegSign (Just 2))
+       (<**>) (alternativeDurationDaysFormat fe) $
+       withTimeDesignator $
+       extColonFormat fe (clipFormat (0, 24) $ integerFormat NegSign (Just 2)) $
+       extColonFormat fe (clipFormat (0, 60) $ integerFormat NegSign (Just 2)) $
+       (clipFormat (0, 60) $ decimalFormat NegSign (Just 2))
 
 -- | ISO 8601:2004(E) sec. 4.4.4.1
-intervalFormat :: Format a -> Format b -> Format (a,b)
+intervalFormat :: Format a -> Format b -> Format (a, b)
 intervalFormat = sepFormat "/"
 
 -- | ISO 8601:2004(E) sec. 4.5
-recurringIntervalFormat :: Format a -> Format b -> Format (Int,a,b)
-recurringIntervalFormat fa fb = isoMap (\(r,(a,b)) -> (r,a,b)) (\(r,a,b) -> (r,(a,b))) $ sepFormat "/" (literalFormat "R" **> integerFormat NoSign Nothing) $ intervalFormat fa fb
+recurringIntervalFormat :: Format a -> Format b -> Format (Int, a, b)
+recurringIntervalFormat fa fb =
+    isoMap (\(r, (a, b)) -> (r, a, b)) (\(r, a, b) -> (r, (a, b))) $
+    sepFormat "/" (literalFormat "R" **> integerFormat NoSign Nothing) $ intervalFormat fa fb
 
 class ISO8601 t where
     -- | The most commonly used ISO 8601 format for this type.
@@ -353,36 +362,37 @@ iso8601Show :: ISO8601 t => t -> String
 iso8601Show = formatShow iso8601Format
 
 -- | Parse the most commonly used ISO 8601 format.
-iso8601ParseM :: (
-#if MIN_VERSION_base(4,9,0)
-    MonadFail m
-#else
-    Monad m
-#endif
-    ,ISO8601 t) => String -> m t
+iso8601ParseM :: (MonadFail m, ISO8601 t) => String -> m t
 iso8601ParseM = formatParseM iso8601Format
 
 -- | @yyyy-mm-dd@ (ISO 8601:2004(E) sec. 4.1.2.2 extended format)
 instance ISO8601 Day where
     iso8601Format = calendarFormat ExtendedFormat
+
 -- | @hh:mm:ss[.sss]@ (ISO 8601:2004(E) sec. 4.2.2.2, 4.2.2.4(a) extended format)
 instance ISO8601 TimeOfDay where
     iso8601Format = timeOfDayFormat ExtendedFormat
+
 -- | @±hh:mm@ (ISO 8601:2004(E) sec. 4.2.5.1 extended format)
 instance ISO8601 TimeZone where
     iso8601Format = timeOffsetFormat ExtendedFormat
+
 -- | @yyyy-mm-ddThh:mm:ss[.sss]@ (ISO 8601:2004(E) sec. 4.3.2 extended format)
 instance ISO8601 LocalTime where
     iso8601Format = localTimeFormat iso8601Format iso8601Format
+
 -- | @yyyy-mm-ddThh:mm:ss[.sss]±hh:mm@ (ISO 8601:2004(E) sec. 4.3.2 extended format)
 instance ISO8601 ZonedTime where
     iso8601Format = zonedTimeFormat iso8601Format iso8601Format ExtendedFormat
+
 -- | @yyyy-mm-ddThh:mm:ss[.sss]Z@ (ISO 8601:2004(E) sec. 4.3.2 extended format)
 instance ISO8601 UTCTime where
     iso8601Format = utcTimeFormat iso8601Format iso8601Format
+
 -- | @PyYmMdD@ (ISO 8601:2004(E) sec. 4.4.3.2)
 instance ISO8601 CalendarDiffDays where
     iso8601Format = durationDaysFormat
+
 -- | @PyYmMdDThHmMs[.sss]S@ (ISO 8601:2004(E) sec. 4.4.3.2)
 instance ISO8601 CalendarDiffTime where
     iso8601Format = durationTimeFormat
index 79945c5..8585128 100644 (file)
@@ -2,7 +2,10 @@
 The contents of this module is liable to change, or disappear entirely.
 Please <https://github.com/haskell/time/issues/new let me know> if you depend on anything here.
 -}
-module Data.Time.Format.Internal (FormatTime(..),ParseTime(..)) where
+module Data.Time.Format.Internal
+    ( FormatTime(..)
+    , ParseTime(..)
+    ) where
 
 import Data.Time.Format.Format.Class
 import Data.Time.Format.Parse.Class
index d15ca1e..cffe074 100644 (file)
@@ -1,32 +1,25 @@
 -- Note: this file derives from old-locale:System.Locale.hs, which is copyright (c) The University of Glasgow 2001
-
-module Data.Time.Format.Locale (
-
-    TimeLocale(..)
-
+module Data.Time.Format.Locale
+    ( TimeLocale(..)
     , defaultTimeLocale
-
     , iso8601DateFormat
     , rfc822DateFormat
-    )
-where
+    ) where
 
 import Data.Time.LocalTime.Internal.TimeZone
 
-
-data TimeLocale = TimeLocale {
-        -- |full and abbreviated week days, starting with Sunday
-        wDays  :: [(String, String)],
-        -- |full and abbreviated months
-        months :: [(String, String)],
-        -- |AM\/PM symbols
-        amPm   :: (String, String),
-        -- |formatting strings
-        dateTimeFmt, dateFmt,
-        timeFmt, time12Fmt :: String,
-        -- |time zones known by name
-        knownTimeZones :: [TimeZone]
-        } deriving (Eq, Ord, Show)
+data TimeLocale = TimeLocale
+    { wDays :: [(String, String)]
+        -- ^ full and abbreviated week days, starting with Sunday
+    , months :: [(String, String)]
+        -- ^ full and abbreviated months
+    , amPm :: (String, String)
+        -- ^ AM\/PM symbols
+    , dateTimeFmt, dateFmt, timeFmt, time12Fmt :: String
+        -- ^ formatting strings
+    , knownTimeZones :: [TimeZone]
+        -- ^ time zones known by name
+    } deriving (Eq, Ord, Show)
 
 -- | Locale representing American usage.
 --
@@ -34,37 +27,48 @@ data TimeLocale = TimeLocale {
 -- \"UT\", \"GMT\", \"EST\", \"EDT\", \"CST\", \"CDT\", \"MST\", \"MDT\", \"PST\", \"PDT\".
 -- Note that the parsing functions will regardless parse \"UTC\", single-letter military time-zones, and +HHMM format.
 defaultTimeLocale :: TimeLocale
-defaultTimeLocale =  TimeLocale {
-        wDays  = [("Sunday",   "Sun"),  ("Monday",    "Mon"),
-                  ("Tuesday",  "Tue"),  ("Wednesday", "Wed"),
-                  ("Thursday", "Thu"),  ("Friday",    "Fri"),
-                  ("Saturday", "Sat")],
-
-        months = [("January",   "Jan"), ("February",  "Feb"),
-                  ("March",     "Mar"), ("April",     "Apr"),
-                  ("May",       "May"), ("June",      "Jun"),
-                  ("July",      "Jul"), ("August",    "Aug"),
-                  ("September", "Sep"), ("October",   "Oct"),
-                  ("November",  "Nov"), ("December",  "Dec")],
-
-        amPm = ("AM", "PM"),
-        dateTimeFmt = "%a %b %e %H:%M:%S %Z %Y",
-        dateFmt = "%m/%d/%y",
-        timeFmt = "%H:%M:%S",
-        time12Fmt = "%I:%M:%S %p",
-        knownTimeZones =
-            [
-            TimeZone 0 False "UT",
-            TimeZone 0 False "GMT",
-            TimeZone (-5 * 60) False "EST",
-            TimeZone (-4 * 60) True "EDT",
-            TimeZone (-6 * 60) False "CST",
-            TimeZone (-5 * 60) True "CDT",
-            TimeZone (-7 * 60) False "MST",
-            TimeZone (-6 * 60) True "MDT",
-            TimeZone (-8 * 60) False "PST",
-            TimeZone (-7 * 60) True "PDT"
-            ]
+defaultTimeLocale =
+    TimeLocale
+        { wDays =
+              [ ("Sunday", "Sun")
+              , ("Monday", "Mon")
+              , ("Tuesday", "Tue")
+              , ("Wednesday", "Wed")
+              , ("Thursday", "Thu")
+              , ("Friday", "Fri")
+              , ("Saturday", "Sat")
+              ]
+        , months =
+              [ ("January", "Jan")
+              , ("February", "Feb")
+              , ("March", "Mar")
+              , ("April", "Apr")
+              , ("May", "May")
+              , ("June", "Jun")
+              , ("July", "Jul")
+              , ("August", "Aug")
+              , ("September", "Sep")
+              , ("October", "Oct")
+              , ("November", "Nov")
+              , ("December", "Dec")
+              ]
+        , amPm = ("AM", "PM")
+        , dateTimeFmt = "%a %b %e %H:%M:%S %Z %Y"
+        , dateFmt = "%m/%d/%y"
+        , timeFmt = "%H:%M:%S"
+        , time12Fmt = "%I:%M:%S %p"
+        , knownTimeZones =
+              [ TimeZone 0 False "UT"
+              , TimeZone 0 False "GMT"
+              , TimeZone (-5 * 60) False "EST"
+              , TimeZone (-4 * 60) True "EDT"
+              , TimeZone (-6 * 60) False "CST"
+              , TimeZone (-5 * 60) True "CDT"
+              , TimeZone (-7 * 60) False "MST"
+              , TimeZone (-6 * 60) True "MDT"
+              , TimeZone (-8 * 60) False "PST"
+              , TimeZone (-7 * 60) True "PDT"
+              ]
         }
 
 {- | Construct format string according to <http://en.wikipedia.org/wiki/ISO_8601 ISO-8601>.
@@ -76,12 +80,12 @@ The @Maybe String@ argument allows to supply an optional time specification. E.g
 'iso8601DateFormat' (Just "%H:%M:%S")  == "%Y-%m-%dT%H:%M:%S"  -- i.e. @/YYYY-MM-DD/T/HH:MM:SS/@
 @
 -}
-
 iso8601DateFormat :: Maybe String -> String
 iso8601DateFormat mTimeFmt =
-    "%Y-%m-%d" ++ case mTimeFmt of
-             Nothing  -> ""
-             Just fmt -> 'T' : fmt
+    "%Y-%m-%d" ++
+    case mTimeFmt of
+        Nothing -> ""
+        Just fmt -> 'T' : fmt
 
 -- | Format string according to <http://tools.ietf.org/html/rfc822#section-5 RFC822>.
 rfc822DateFormat :: String
index 23cf27a..0302186 100644 (file)
@@ -1,31 +1,35 @@
 {-# OPTIONS -fno-warn-orphans #-}
+
 module Data.Time.Format.Parse
     (
     -- * UNIX-style parsing
-    parseTimeM, parseTimeOrError, readSTime, readPTime,
-    parseTime, readTime, readsTime,
-    ParseTime(),
+      parseTimeM
+    , parseTimeOrError
+    , readSTime
+    , readPTime
+    , parseTime
+    , readTime
+    , readsTime
+    , ParseTime()
     -- * Locale
-    module Data.Time.Format.Locale
+    module Data.Time.Format.Locale
     ) where
 
-import Data.Proxy
-#if MIN_VERSION_base(4,9,0)
 import Control.Monad.Fail
-import Prelude hiding (fail)
-#endif
 import Data.Char
-import Data.Time.Format.Locale
-import Text.ParserCombinators.ReadP hiding (char, string)
-import Data.Time.Clock.Internal.UniversalTime
-import Data.Time.Clock.Internal.UTCTime
+import Data.Proxy
 import Data.Time.Calendar.Days
-import Data.Time.LocalTime.Internal.TimeZone
-import Data.Time.LocalTime.Internal.TimeOfDay
+import Data.Time.Clock.Internal.UTCTime
+import Data.Time.Clock.Internal.UniversalTime
+import Data.Time.Format.Locale
+import Data.Time.Format.Parse.Class
+import Data.Time.Format.Parse.Instances ()
 import Data.Time.LocalTime.Internal.LocalTime
+import Data.Time.LocalTime.Internal.TimeOfDay
+import Data.Time.LocalTime.Internal.TimeZone
 import Data.Time.LocalTime.Internal.ZonedTime
-import Data.Time.Format.Parse.Class
-import Data.Time.Format.Parse.Instances()
+import Prelude hiding (fail)
+import Text.ParserCombinators.ReadP hiding (char, string)
 
 -- | Parses a time value given a format string.
 -- Supports the same %-codes as 'formatTime', including @%-@, @%_@ and @%0@ modifiers, however padding widths are not supported.
@@ -51,60 +55,61 @@ import Data.Time.Format.Parse.Instances()
 -- > Prelude Data.Time> parseTimeM True defaultTimeLocale "%Y-%-m-%-d" "2010-3-04" :: Maybe Day
 -- > Just 2010-03-04
 --
-parseTimeM :: (
-#if MIN_VERSION_base(4,9,0)
-    MonadFail m
-#else
-    Monad m
-#endif
-    ,ParseTime t) =>
-             Bool       -- ^ Accept leading and trailing whitespace?
-          -> TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string.
-          -> String     -- ^ Input string.
-          -> m t    -- ^ Return the time value, or fail if the input could
+parseTimeM ::
+       (MonadFail m, ParseTime t)
+    => Bool -- ^ Accept leading and trailing whitespace?
+    -> TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string.
+    -> String -- ^ Input string.
+    -> m t -- ^ Return the time value, or fail if the input could
                         -- not be parsed using the given format.
-parseTimeM acceptWS l fmt s = case parseTimeList acceptWS l fmt s of
-    [t] -> return t
-    []  -> fail $ "parseTimeM: no parse of " ++ show s
-    _   -> fail $ "parseTimeM: multiple parses of " ++ show s
+parseTimeM acceptWS l fmt s =
+    case parseTimeList acceptWS l fmt s of
+        [t] -> return t
+        [] -> fail $ "parseTimeM: no parse of " ++ show s
+        _ -> fail $ "parseTimeM: multiple parses of " ++ show s
 
 -- | Parse a time value given a format string. Fails if the input could
 -- not be parsed using the given format. See 'parseTimeM' for details.
-parseTimeOrError :: ParseTime t =>
-             Bool       -- ^ Accept leading and trailing whitespace?
-          -> TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string.
-          -> String     -- ^ Input string.
-          -> t          -- ^ The time value.
-parseTimeOrError acceptWS l fmt s = case parseTimeList acceptWS l fmt s of
-    [t] -> t
-    []  -> error $ "parseTimeOrError: no parse of " ++ show s
-    _   -> error $ "parseTimeOrError: multiple parses of " ++ show s
-
-parseTimeList :: ParseTime t =>
-             Bool       -- ^ Accept leading and trailing whitespace?
-          -> TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string
-          -> String     -- ^ Input string.
-          -> [t]
-parseTimeList False l fmt s = [t | (t,"") <- readSTime False l fmt s]
-parseTimeList True l fmt s = [t | (t,r) <- readSTime True l fmt s, all isSpace r]
+parseTimeOrError ::
+       ParseTime t
+    => Bool -- ^ Accept leading and trailing whitespace?
+    -> TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string.
+    -> String -- ^ Input string.
+    -> t -- ^ The time value.
+parseTimeOrError acceptWS l fmt s =
+    case parseTimeList acceptWS l fmt s of
+        [t] -> t
+        [] -> error $ "parseTimeOrError: no parse of " ++ show s
+        _ -> error $ "parseTimeOrError: multiple parses of " ++ show s
+
+parseTimeList ::
+       ParseTime t
+    => Bool -- ^ Accept leading and trailing whitespace?
+    -> TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string
+    -> String -- ^ Input string.
+    -> [t]
+parseTimeList False l fmt s = [t | (t, "") <- readSTime False l fmt s]
+parseTimeList True l fmt s = [t | (t, r) <- readSTime True l fmt s, all isSpace r]
 
 -- | Parse a time value given a format string.  See 'parseTimeM' for details.
-readSTime :: ParseTime t =>
-             Bool       -- ^ Accept leading whitespace?
-          -> TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string
-          -> ReadS t
+readSTime ::
+       ParseTime t
+    => Bool -- ^ Accept leading whitespace?
+    -> TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string
+    -> ReadS t
 readSTime acceptWS l f = readP_to_S (readPTime acceptWS l f)
 
 -- | Parse a time value given a format string.  See 'parseTimeM' for details.
-readPTime :: ParseTime t =>
-             Bool       -- ^ Accept leading whitespace?
-          -> TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string
-          -> ReadP t
+readPTime ::
+       ParseTime t
+    => Bool -- ^ Accept leading whitespace?
+    -> TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string
+    -> ReadP t
 readPTime False l f = readPOnlyTime l f
 readPTime True l f = (skipSpaces >> readPOnlyTime l f) <++ readPOnlyTime l f
 
@@ -116,38 +121,50 @@ readPOnlyTime' pt l f = do
         Nothing -> pfail
 
 -- | Parse a time value given a format string (without allowing leading whitespace).  See 'parseTimeM' for details.
-readPOnlyTime :: ParseTime t =>
-             TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string
-          -> ReadP t
+readPOnlyTime ::
+       ParseTime t
+    => TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string
+    -> ReadP t
 readPOnlyTime = readPOnlyTime' Proxy
 
-{-# DEPRECATED parseTime "use \"parseTimeM True\" instead" #-}
-parseTime :: ParseTime t =>
-             TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string.
-          -> String     -- ^ Input string.
-          -> Maybe t    -- ^ The time value, or 'Nothing' if the input could
+{-# DEPRECATED
+parseTime "use \"parseTimeM True\" instead"
+ #-}
+
+parseTime ::
+       ParseTime t
+    => TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string.
+    -> String -- ^ Input string.
+    -> Maybe t -- ^ The time value, or 'Nothing' if the input could
                         -- not be parsed using the given format.
 parseTime = parseTimeM True
 
-{-# DEPRECATED readTime "use \"parseTimeOrError True\" instead" #-}
-readTime :: ParseTime t =>
-            TimeLocale -- ^ Time locale.
-         -> String     -- ^ Format string.
-         -> String     -- ^ Input string.
-         -> t          -- ^ The time value.
+{-# DEPRECATED
+readTime "use \"parseTimeOrError True\" instead"
+ #-}
+
+readTime ::
+       ParseTime t
+    => TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string.
+    -> String -- ^ Input string.
+    -> t -- ^ The time value.
 readTime = parseTimeOrError True
 
-{-# DEPRECATED readsTime "use \"readSTime True\" instead" #-}
-readsTime :: ParseTime t =>
-             TimeLocale -- ^ Time locale.
-          -> String     -- ^ Format string
-          -> ReadS t
+{-# DEPRECATED
+readsTime "use \"readSTime True\" instead"
+ #-}
+
+readsTime ::
+       ParseTime t
+    => TimeLocale -- ^ Time locale.
+    -> String -- ^ Format string
+    -> ReadS t
 readsTime = readSTime True
 
 -- * Read instances for time package types
-
 instance Read Day where
     readsPrec _ = readParen False $ readSTime True defaultTimeLocale "%Y-%m-%d"
 
@@ -167,11 +184,10 @@ instance Read TimeZone where
 -- single-letter military time-zones,
 -- and these time-zones: \"UTC\", \"UT\", \"GMT\", \"EST\", \"EDT\", \"CST\", \"CDT\", \"MST\", \"MDT\", \"PST\", \"PDT\".
 instance Read ZonedTime where
-    readsPrec n = readParen False $ \s ->
-        [(ZonedTime t z, r2) | (t,r1) <- readsPrec n s, (z,r2) <- readsPrec n r1]
+    readsPrec n = readParen False $ \s -> [(ZonedTime t z, r2) | (t, r1) <- readsPrec n s, (z, r2) <- readsPrec n r1]
 
 instance Read UTCTime where
-    readsPrec n s = [ (zonedTimeToUTC t, r) | (t,r) <- readsPrec n s ]
+    readsPrec n s = [(zonedTimeToUTC t, r) | (t, r) <- readsPrec n s]
 
 instance Read UniversalTime where
-    readsPrec n s = [ (localTimeToUT1 0 t, r) | (t,r) <- readsPrec n s ]
+    readsPrec n s = [(localTimeToUT1 0 t, r) | (t, r) <- readsPrec n s]
index cfab53e..448cc8b 100644 (file)
@@ -1,22 +1,24 @@
 module Data.Time.Format.Parse.Class
     (
         -- * Parsing
-        ParseNumericPadding(..),
-        ParseTime(..),
-        parseSpecifiers,
-        timeSubstituteTimeSpecifier,
-        timeParseTimeSpecifier,
-        durationParseTimeSpecifier,
-    )
-    where
-
-import Control.Applicative hiding (optional,many)
+      ParseNumericPadding(..)
+    , ParseTime(..)
+    , parseSpecifiers
+    , timeSubstituteTimeSpecifier
+    , timeParseTimeSpecifier
+    , durationParseTimeSpecifier
+    ) where
+
+import Control.Applicative hiding (many, optional)
 import Data.Char
 import Data.Maybe
 import Data.Time.Format.Locale
 import Text.ParserCombinators.ReadP
 
-data ParseNumericPadding = NoPadding | SpacePadding | ZeroPadding
+data ParseNumericPadding
+    = NoPadding
+    | SpacePadding
+    | ZeroPadding
 
 -- | The class of types which can be parsed given a UNIX-style time format
 -- string.
@@ -35,10 +37,11 @@ class ParseTime t where
     -- In the absence of @%C@ or @%Y@, century is 1969 - 2068.
     --
     -- @since 1.9.1
-    buildTime :: TimeLocale -- ^ The time locale.
-              -> [(Char,String)] -- ^ Pairs of format characters and the
+    buildTime ::
+           TimeLocale -- ^ The time locale.
+        -> [(Char, String)] -- ^ Pairs of format characters and the
                                  -- corresponding part of the input.
-              -> Maybe t
+        -> Maybe t
 
 -- | Case-insensitive version of 'Text.ParserCombinators.ReadP.char'.
 charCI :: Char -> ReadP Char
@@ -49,47 +52,48 @@ stringCI :: String -> ReadP String
 stringCI this = do
     let
         scan [] _ = return this
-        scan (x:xs) (y:ys) | toUpper x == toUpper y = do
-            _ <- get
-            scan xs ys
+        scan (x:xs) (y:ys)
+            | toUpper x == toUpper y = do
+                _ <- get
+                scan xs ys
         scan _ _ = pfail
     s <- look
     scan this s
 
-parseSpecifiers :: ParseTime t => proxy t -> TimeLocale -> String -> ReadP [(Char,String)]
+parseSpecifiers :: ParseTime t => proxy t -> TimeLocale -> String -> ReadP [(Char, String)]
 parseSpecifiers pt locale = let
-    parse :: String -> ReadP [(Char,String)]
+    parse :: String -> ReadP [(Char, String)]
     parse [] = return []
     parse ('%':cs) = parse1 cs
-    parse (c:cs) | isSpace c = do
-        _ <- satisfy isSpace
-        case cs of
-            (c':_) | isSpace c' -> return ()
-            _ -> skipSpaces
-        parse cs
+    parse (c:cs)
+        | isSpace c = do
+            _ <- satisfy isSpace
+            case cs of
+                (c':_)
+                    | isSpace c' -> return ()
+                _ -> skipSpaces
+            parse cs
     parse (c:cs) = do
         _ <- charCI c
         parse cs
-
-    parse1 :: String -> ReadP [(Char,String)]
+    parse1 :: String -> ReadP [(Char, String)]
     parse1 ('-':cs) = parse2 (Just NoPadding) cs
     parse1 ('_':cs) = parse2 (Just SpacePadding) cs
     parse1 ('0':cs) = parse2 (Just ZeroPadding) cs
     parse1 cs = parse2 Nothing cs
-
-    parse2 :: Maybe ParseNumericPadding -> String -> ReadP [(Char,String)]
+    parse2 :: Maybe ParseNumericPadding -> String -> ReadP [(Char, String)]
     parse2 mpad ('E':cs) = parse3 mpad True cs
     parse2 mpad cs = parse3 mpad False cs
-
-    parse3 :: Maybe ParseNumericPadding -> Bool -> String -> ReadP [(Char,String)]
+    parse3 :: Maybe ParseNumericPadding -> Bool -> String -> ReadP [(Char, String)]
     parse3 _ _ ('%':cs) = do
         _ <- char '%'
         parse cs
-    parse3 _ _ (c:cs) | Just s <- substituteTimeSpecifier pt locale c = parse $ s ++ cs
+    parse3 _ _ (c:cs)
+        | Just s <- substituteTimeSpecifier pt locale c = parse $ s ++ cs
     parse3 mpad _alt (c:cs) = do
         str <- parseTimeSpecifier pt locale mpad c
         specs <- parse cs
-        return $ (c,str) : specs
+        return $ (c, str) : specs
     parse3 _ _ [] = return []
     in parse
 
@@ -109,10 +113,11 @@ parseSignedDecimal = do
     sign <- option "" $ char '-' >> return "-"
     skipSpaces
     digits <- many1 $ satisfy isDigit
-    decimaldigits <- option "" $ do
-        _ <- char '.'
-        dd <- many $ satisfy isDigit
-        return $ '.':dd
+    decimaldigits <-
+        option "" $ do
+            _ <- char '.'
+            dd <- many $ satisfy isDigit
+            return $ '.' : dd
     return $ sign ++ digits ++ decimaldigits
 
 timeParseTimeSpecifier :: TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String
@@ -124,75 +129,65 @@ timeParseTimeSpecifier l mpad c = let
         h <- parsePaddedDigits ZeroPadding 2
         optional (char ':')
         m <- parsePaddedDigits ZeroPadding 2
-        return (s:h++m)
+        return (s : h ++ m)
     in case c of
         -- century
-        'C' -> digits SpacePadding 2
-        'f' -> digits SpacePadding 2
-
+           'C' -> digits SpacePadding 2
+           'f' -> digits SpacePadding 2
         -- year
-        'Y' -> digits SpacePadding 4
-        'G' -> digits SpacePadding 4
-
+           'Y' -> digits SpacePadding 4
+           'G' -> digits SpacePadding 4
         -- year of century
-        'y' -> digits ZeroPadding 2
-        'g' -> digits ZeroPadding 2
-
+           'y' -> digits ZeroPadding 2
+           'g' -> digits ZeroPadding 2
         -- month of year
-        'B' -> oneOf (map fst (months l))
-        'b' -> oneOf (map snd (months l))
-        'm' -> digits ZeroPadding 2
-
+           'B' -> oneOf (map fst (months l))
+           'b' -> oneOf (map snd (months l))
+           'm' -> digits ZeroPadding 2
         -- day of month
-        'd' -> digits ZeroPadding 2
-        'e' -> digits SpacePadding 2
-
+           'd' -> digits ZeroPadding 2
+           'e' -> digits SpacePadding 2
         -- week of year
-        'V' -> digits ZeroPadding 2
-        'U' -> digits ZeroPadding 2
-        'W' -> digits ZeroPadding 2
-
+           'V' -> digits ZeroPadding 2
+           'U' -> digits ZeroPadding 2
+           'W' -> digits ZeroPadding 2
         -- day of week
-        'u' -> oneOf $ map (:[]) ['1'..'7']
-        'a' -> oneOf (map snd (wDays l))
-        'A' -> oneOf (map fst (wDays l))
-        'w' -> oneOf $ map (:[]) ['0'..'6']
-
+           'u' -> oneOf $ map (: []) ['1' .. '7']
+           'a' -> oneOf (map snd (wDays l))
+           'A' -> oneOf (map fst (wDays l))
+           'w' -> oneOf $ map (: []) ['0' .. '6']
         -- day of year
-        'j' -> digits ZeroPadding 3
-
+           'j' -> digits ZeroPadding 3
         -- dayhalf of day (i.e. AM or PM)
-        'P' -> oneOf (let (am,pm) = amPm l in [am, pm])
-        'p' -> oneOf (let (am,pm) = amPm l in [am, pm])
-
+           'P' ->
+               oneOf
+                   (let
+                        (am, pm) = amPm l
+                        in [am, pm])
+           'p' ->
+               oneOf
+                   (let
+                        (am, pm) = amPm l
+                        in [am, pm])
         -- hour of day (i.e. 24h)
-        'H' -> digits ZeroPadding 2
-        'k' -> digits SpacePadding 2
-
+           'H' -> digits ZeroPadding 2
+           'k' -> digits SpacePadding 2
         -- hour of dayhalf (i.e. 12h)
-        'I' -> digits ZeroPadding 2
-        'l' -> digits SpacePadding 2
-
+           'I' -> digits ZeroPadding 2
+           'l' -> digits SpacePadding 2
         -- minute of hour
-        'M' -> digits ZeroPadding 2
-
+           'M' -> digits ZeroPadding 2
         -- second of minute
-        'S' -> digits ZeroPadding 2
-
+           'S' -> digits ZeroPadding 2
         -- picosecond of second
-        'q' -> digits ZeroPadding 12
-        'Q' -> liftA2 (:) (char '.') (munch isDigit) <++ return ""
-
+           'q' -> digits ZeroPadding 12
+           'Q' -> liftA2 (:) (char '.') (munch isDigit) <++ return ""
         -- time zone
-        'z' -> numericTZ
-        'Z' -> munch1 isAlpha <++
-             numericTZ
-
+           'z' -> numericTZ
+           'Z' -> munch1 isAlpha <++ numericTZ
         -- seconds since epoch
-        's' -> (char '-' >> fmap ('-':) (munch1 isDigit))
-             <++ munch1 isDigit
-
-        _   -> fail $ "Unknown format character: " ++ show c
+           's' -> (char '-' >> fmap ('-' :) (munch1 isDigit)) <++ munch1 isDigit
+           _ -> fail $ "Unknown format character: " ++ show c
 
 timeSubstituteTimeSpecifier :: TimeLocale -> Char -> Maybe String
 timeSubstituteTimeSpecifier l 'c' = Just $ dateTimeFmt l
@@ -204,22 +199,22 @@ timeSubstituteTimeSpecifier _ 'D' = Just "%m/%d/%y"
 timeSubstituteTimeSpecifier _ 'F' = Just "%Y-%m-%d"
 timeSubstituteTimeSpecifier l 'x' = Just $ dateFmt l
 timeSubstituteTimeSpecifier _ 'h' = Just "%b"
-timeSubstituteTimeSpecifier _  _ = Nothing
+timeSubstituteTimeSpecifier _ _ = Nothing
 
 durationParseTimeSpecifier :: TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String
 durationParseTimeSpecifier _ mpad c = let
     padopt = parsePaddedSignedDigits $ fromMaybe NoPadding mpad
     in case c of
-        'y' -> padopt 1
-        'b' -> padopt 1
-        'B' -> padopt 2
-        'w' -> padopt 1
-        'd' -> padopt 1
-        'D' -> padopt 1
-        'h' -> padopt 1
-        'H' -> padopt 2
-        'm' -> padopt 1
-        'M' -> padopt 2
-        's' -> parseSignedDecimal
-        'S' -> parseSignedDecimal
-        _   -> fail $ "Unknown format character: " ++ show c
+           'y' -> padopt 1
+           'b' -> padopt 1
+           'B' -> padopt 2
+           'w' -> padopt 1
+           'd' -> padopt 1
+           'D' -> padopt 1
+           'h' -> padopt 1
+           'H' -> padopt 2
+           'm' -> padopt 1
+           'M' -> padopt 2
+           's' -> parseSignedDecimal
+           'S' -> parseSignedDecimal
+           _ -> fail $ "Unknown format character: " ++ show c
index 7234a17..bca59a3 100644 (file)
 {-# OPTIONS -fno-warn-orphans #-}
-module Data.Time.Format.Parse.Instances() where
 
-#if !MIN_VERSION_base(4,8,0)
-import Control.Applicative ((<$>),(<*>))
-#endif
+module Data.Time.Format.Parse.Instances
+    (
+    ) where
+
+import Control.Applicative ((<$>), (<*>))
 import Data.Char
 import Data.Fixed
 import Data.List
 import Data.Ratio
-import Data.Traversable
-import Text.Read(readMaybe)
-import Data.Time.Clock.Internal.DiffTime
-import Data.Time.Clock.Internal.NominalDiffTime
-import Data.Time.Clock.Internal.UniversalTime
-import Data.Time.Clock.POSIX
-import Data.Time.Clock.Internal.UTCTime
+import Data.Time.Calendar.CalendarDiffDays
 import Data.Time.Calendar.Days
 import Data.Time.Calendar.Gregorian
-import Data.Time.Calendar.CalendarDiffDays
 import Data.Time.Calendar.OrdinalDate
+import Data.Time.Calendar.Private (clipValid)
 import Data.Time.Calendar.WeekDate
-import Data.Time.Calendar.Private(clipValid)
+import Data.Time.Clock.Internal.DiffTime
+import Data.Time.Clock.Internal.NominalDiffTime
+import Data.Time.Clock.Internal.UTCTime
+import Data.Time.Clock.Internal.UniversalTime
+import Data.Time.Clock.POSIX
+import Data.Time.Format.Locale
+import Data.Time.Format.Parse.Class
 import Data.Time.LocalTime.Internal.CalendarDiffTime
-import Data.Time.LocalTime.Internal.TimeZone
-import Data.Time.LocalTime.Internal.TimeOfDay
 import Data.Time.LocalTime.Internal.LocalTime
+import Data.Time.LocalTime.Internal.TimeOfDay
+import Data.Time.LocalTime.Internal.TimeZone
 import Data.Time.LocalTime.Internal.ZonedTime
-import Data.Time.Format.Locale
-import Data.Time.Format.Parse.Class
-
-data DayComponent = Century Integer -- century of all years
-                  | CenturyYear Integer -- 0-99, last two digits of both real years and week years
-                  | YearMonth Int -- 1-12
-                  | MonthDay Int -- 1-31
-                  | YearDay Int -- 1-366
-                  | WeekDay Int -- 1-7 (mon-sun)
-                  | YearWeek WeekType Int -- 1-53 or 0-53
-
-data WeekType = ISOWeek | SundayWeek | MondayWeek
+import Data.Traversable
+import Text.Read (readMaybe)
+
+data DayComponent
+    = Century Integer -- century of all years
+    | CenturyYear Integer -- 0-99, last two digits of both real years and week years
+    | YearMonth Int -- 1-12
+    | MonthDay Int -- 1-31
+    | YearDay Int -- 1-366
+    | WeekDay Int -- 1-7 (mon-sun)
+    | YearWeek WeekType
+               Int -- 1-53 or 0-53
+
+data WeekType
+    = ISOWeek
+    | SundayWeek
+    | MondayWeek
 
 instance ParseTime Day where
     substituteTimeSpecifier _ = timeSubstituteTimeSpecifier
     parseTimeSpecifier _ = timeParseTimeSpecifier
     buildTime l = let
-
         -- 'Nothing' indicates a parse failure,
         -- while 'Just []' means no information
         f :: Char -> String -> Maybe [DayComponent]
         f c x = let
             ra :: (Read a) => Maybe a
             ra = readMaybe x
-
             zeroBasedListIndex :: [String] -> Maybe Int
             zeroBasedListIndex ss = elemIndex (map toUpper x) $ fmap (map toUpper) ss
-
             oneBasedListIndex :: [String] -> Maybe Int
             oneBasedListIndex ss = do
                 index <- zeroBasedListIndex ss
                 return $ 1 + index
-
             in case c of
             -- %C: century (all but the last two digits of the year), 00 - 99
-            'C' -> do
-                a <- ra
-                return [Century a]
+                   'C' -> do
+                       a <- ra
+                       return [Century a]
             -- %f century (all but the last two digits of the year), 00 - 99
-            'f' -> do
-                a <- ra
-                return [Century a]
+                   'f' -> do
+                       a <- ra
+                       return [Century a]
             -- %Y: year
-            'Y' -> do
-                a <- ra
-                return [Century (a `div` 100), CenturyYear (a `mod` 100)]
+                   'Y' -> do
+                       a <- ra
+                       return [Century (a `div` 100), CenturyYear (a `mod` 100)]
             -- %G: year for Week Date format
-            'G' -> do
-                a <- ra
-                return [Century (a `div` 100), CenturyYear (a `mod` 100)]
+                   'G' -> do
+                       a <- ra
+                       return [Century (a `div` 100), CenturyYear (a `mod` 100)]
             -- %y: last two digits of year, 00 - 99
-            'y' -> do
-                a <- ra
-                return [CenturyYear a]
+                   'y' -> do
+                       a <- ra
+                       return [CenturyYear a]
             -- %g: last two digits of year for Week Date format, 00 - 99
-            'g' -> do
-                a <- ra
-                return [CenturyYear a]
+                   'g' -> do
+                       a <- ra
+                       return [CenturyYear a]
             -- %B: month name, long form (fst from months locale), January - December
-            'B' -> do
-                a <- oneBasedListIndex $ fmap fst $ months l
-                return [YearMonth a]
+                   'B' -> do
+                       a <- oneBasedListIndex $ fmap fst $ months l
+                       return [YearMonth a]
             -- %b: month name, short form (snd from months locale), Jan - Dec
-            'b' -> do
-                a <- oneBasedListIndex $ fmap snd $ months l
-                return [YearMonth a]
+                   'b' -> do
+                       a <- oneBasedListIndex $ fmap snd $ months l
+                       return [YearMonth a]
             -- %m: month of year, leading 0 as needed, 01 - 12
-            'm' -> do
-                raw <- ra
-                a <- clipValid 1 12 raw
-                return [YearMonth a]
+                   'm' -> do
+                       raw <- ra
+                       a <- clipValid 1 12 raw
+                       return [YearMonth a]
             -- %d: day of month, leading 0 as needed, 01 - 31
-            'd' -> do
-                raw <- ra
-                a <- clipValid 1 31 raw
-                return [MonthDay a]
+                   'd' -> do
+                       raw <- ra
+                       a <- clipValid 1 31 raw
+                       return [MonthDay a]
             -- %e: day of month, leading space as needed, 1 - 31
-            'e' -> do
-                raw <- ra
-                a <- clipValid 1 31 raw
-                return [MonthDay a]
+                   'e' -> do
+                       raw <- ra
+                       a <- clipValid 1 31 raw
+                       return [MonthDay a]
             -- %V: week for Week Date format, 01 - 53
-            'V' -> do
-                raw <- ra
-                a <- clipValid 1 53 raw
-                return [YearWeek ISOWeek a]
+                   'V' -> do
+                       raw <- ra
+                       a <- clipValid 1 53 raw
+                       return [YearWeek ISOWeek a]
             -- %U: week number of year, where weeks start on Sunday (as sundayStartWeek), 00 - 53
-            'U' -> do
-                raw <- ra
-                a <- clipValid 0 53 raw
-                return [YearWeek SundayWeek a]
+                   'U' -> do
+                       raw <- ra
+                       a <- clipValid 0 53 raw
+                       return [YearWeek SundayWeek a]
             -- %W: week number of year, where weeks start on Monday (as mondayStartWeek), 00 - 53
-            'W' -> do
-                raw <- ra
-                a <- clipValid 0 53 raw
-                return [YearWeek MondayWeek a]
+                   'W' -> do
+                       raw <- ra
+                       a <- clipValid 0 53 raw
+                       return [YearWeek MondayWeek a]
             -- %u: day for Week Date format, 1 - 7
-            'u' -> do
-                raw <- ra
-                a <- clipValid 1 7 raw
-                return [WeekDay a]
+                   'u' -> do
+                       raw <- ra
+                       a <- clipValid 1 7 raw
+                       return [WeekDay a]
             -- %a: day of week, short form (snd from wDays locale), Sun - Sat
-            'a' -> do
-                a' <- zeroBasedListIndex $ fmap snd $ wDays l
-                let a = if a' == 0 then 7 else a'
-                return [WeekDay a]
+                   'a' -> do
+                       a' <- zeroBasedListIndex $ fmap snd $ wDays l
+                       let
+                           a =
+                               if a' == 0
+                                   then 7
+                                   else a'
+                       return [WeekDay a]
             -- %A: day of week, long form (fst from wDays locale), Sunday - Saturday
-            'A' -> do
-                a' <- zeroBasedListIndex $ fmap fst $ wDays l
-                let a = if a' == 0 then 7 else a'
-                return [WeekDay a]
+                   'A' -> do
+                       a' <- zeroBasedListIndex $ fmap fst $ wDays l
+                       let
+                           a =
+                               if a' == 0
+                                   then 7
+                                   else a'
+                       return [WeekDay a]
             -- %w: day of week number, 0 (= Sunday) - 6 (= Saturday)
-            'w' -> do
-                raw <- ra
-                a' <- clipValid 0 6 raw
-                let a = if a' == 0 then 7 else a'
-                return [WeekDay a]
+                   'w' -> do
+                       raw <- ra
+                       a' <- clipValid 0 6 raw
+                       let
+                           a =
+                               if a' == 0
+                                   then 7
+                                   else a'
+                       return [WeekDay a]
             -- %j: day of year for Ordinal Date format, 001 - 366
-            'j' -> do
-                raw <- ra
-                a <- clipValid 1 366 raw
-                return [YearDay a]
+                   'j' -> do
+                       raw <- ra
+                       a <- clipValid 1 366 raw
+                       return [YearDay a]
             -- unrecognised, pass on to other parsers
-            _   -> return []
-
+                   _ -> return []
         buildDay :: [DayComponent] -> Maybe Day
         buildDay cs = let
-            safeLast x xs = last (x:xs)
+            safeLast x xs = last (x : xs)
             y = let
                 d = safeLast 70 [x | CenturyYear x <- cs]
-                c = safeLast (if d >= 69 then 19 else 20) [x | Century x <- cs]
+                c =
+                    safeLast
+                        (if d >= 69
+                             then 19
+                             else 20)
+                        [x | Century x <- cs]
                 in 100 * c + d
             rest (YearMonth m:_) = let
                 d = safeLast 1 [x | MonthDay x <- cs]
@@ -165,17 +183,15 @@ instance ParseTime Day where
             rest (YearWeek wt w:_) = let
                 d = safeLast 4 [x | WeekDay x <- cs]
                 in case wt of
-                    ISOWeek    -> fromWeekDateValid y w d
-                    SundayWeek -> fromSundayStartWeekValid y w (d `mod` 7)
-                    MondayWeek -> fromMondayStartWeekValid y w d
-            rest (_:xs)        = rest xs
-            rest []            = rest [YearMonth 1]
-
+                       ISOWeek -> fromWeekDateValid y w d
+                       SundayWeek -> fromSundayStartWeekValid y w (d `mod` 7)
+                       MondayWeek -> fromMondayStartWeekValid y w d
+            rest (_:xs) = rest xs
+            rest [] = rest [YearMonth 1]
             in rest cs
-
         in \pairs -> do
-            components <- for pairs $ \(c,x) -> f c x
-            buildDay $ concat components
+               components <- for pairs $ \(c, x) -> f c x
+               buildDay $ concat components
 
 mfoldl :: (Monad m) => (a -> b -> m a) -> m a -> [b] -> m a
 mfoldl f = let
@@ -188,54 +204,60 @@ instance ParseTime TimeOfDay where
     substituteTimeSpecifier _ = timeSubstituteTimeSpecifier
     parseTimeSpecifier _ = timeParseTimeSpecifier
     buildTime l = let
-        f t@(TimeOfDay h m s) (c,x) = let
+        f t@(TimeOfDay h m s) (c, x) = let
             ra :: (Read a) => Maybe a
             ra = readMaybe x
-
             getAmPm = let
                 upx = map toUpper x
-                (amStr,pmStr) = amPm l
+                (amStr, pmStr) = amPm l
                 in if upx == amStr
-                    then Just $ TimeOfDay (h `mod` 12) m s
-                    else if upx == pmStr
-                    then Just $ TimeOfDay (if h < 12 then h + 12 else h) m s
-                    else Nothing
-
+                       then Just $ TimeOfDay (h `mod` 12) m s
+                       else if upx == pmStr
+                                then Just $
+                                     TimeOfDay
+                                         (if h < 12
+                                              then h + 12
+                                              else h)
+                                         m
+                                         s
+                                else Nothing
             in case c of
-                'P' -> getAmPm
-                'p' -> getAmPm
-                'H' -> do
-                    raw <- ra
-                    a <- clipValid 0 23 raw
-                    return $ TimeOfDay a m s
-                'I' -> do
-                    raw <- ra
-                    a <- clipValid 1 12 raw
-                    return $ TimeOfDay a m s
-                'k' -> do
-                    raw <- ra
-                    a <- clipValid 0 23 raw
-                    return $ TimeOfDay a m s
-                'l' -> do
-                    raw <- ra
-                    a <- clipValid 1 12 raw
-                    return $ TimeOfDay a m s
-                'M' -> do
-                    raw <- ra
-                    a <- clipValid 0 59 raw
-                    return $ TimeOfDay h a s
-                'S' -> do
-                    raw <- ra
-                    a <- clipValid 0 60 raw
-                    return $ TimeOfDay h m (fromInteger a)
-                'q' -> do
-                    a <- ra
-                    return $ TimeOfDay h m (mkPico (floor s) a)
-                'Q' -> if null x then Just t else do
-                    ps <- readMaybe $ take 12 $ rpad 12 '0' $ drop 1 x
-                    return $ TimeOfDay h m (mkPico (floor s) ps)
-                _   -> Just t
-
+                   'P' -> getAmPm
+                   'p' -> getAmPm
+                   'H' -> do
+                       raw <- ra
+                       a <- clipValid 0 23 raw
+                       return $ TimeOfDay a m s
+                   'I' -> do
+                       raw <- ra
+                       a <- clipValid 1 12 raw
+                       return $ TimeOfDay a m s
+                   'k' -> do
+                       raw <- ra
+                       a <- clipValid 0 23 raw
+                       return $ TimeOfDay a m s
+                   'l' -> do
+                       raw <- ra
+                       a <- clipValid 1 12 raw
+                       return $ TimeOfDay a m s
+                   'M' -> do
+                       raw <- ra
+                       a <- clipValid 0 59 raw
+                       return $ TimeOfDay h a s
+                   'S' -> do
+                       raw <- ra
+                       a <- clipValid 0 60 raw
+                       return $ TimeOfDay h m (fromInteger a)
+                   'q' -> do
+                       a <- ra
+                       return $ TimeOfDay h m (mkPico (floor s) a)
+                   'Q' ->
+                       if null x
+                           then Just t
+                           else do
+                               ps <- readMaybe $ take 12 $ rpad 12 '0' $ drop 1 x
+                               return $ TimeOfDay h m (mkPico (floor s) ps)
+                   _ -> Just t
         in mfoldl f (Just midnight)
 
 rpad :: Int -> a -> [a] -> [a]
@@ -253,11 +275,15 @@ enumDiff :: (Enum a) => a -> a -> Int
 enumDiff a b = (fromEnum a) - (fromEnum b)
 
 getMilZoneHours :: Char -> Maybe Int
-getMilZoneHours c | c < 'A' = Nothing
-getMilZoneHours c | c <= 'I' = Just $ 1 + enumDiff c 'A'
+getMilZoneHours c
+    | c < 'A' = Nothing
+getMilZoneHours c
+    | c <= 'I' = Just $ 1 + enumDiff c 'A'
 getMilZoneHours 'J' = Nothing
-getMilZoneHours c | c <= 'M' = Just $ 10 + enumDiff c 'K'
-getMilZoneHours c | c <= 'Y' = Just $ (enumDiff 'N' c) - 1
+getMilZoneHours c
+    | c <= 'M' = Just $ 10 + enumDiff c 'K'
+getMilZoneHours c
+    | c <= 'Y' = Just $ (enumDiff 'N' c) - 1
 getMilZoneHours 'Z' = Just 0
 getMilZoneHours _ = Nothing
 
@@ -265,8 +291,8 @@ getMilZone :: Char -> Maybe TimeZone
 getMilZone c = let
     yc = toUpper c
     in do
-        hours <- getMilZoneHours yc
-        return $ TimeZone (hours * 60) False [yc]
+           hours <- getMilZoneHours yc
+           return $ TimeZone (hours * 60) False [yc]
 
 getKnownTimeZone :: TimeLocale -> String -> Maybe TimeZone
 getKnownTimeZone locale x = find (\tz -> map toUpper x == timeZoneName tz) (knownTimeZones locale)
@@ -276,43 +302,44 @@ instance ParseTime TimeZone where
     parseTimeSpecifier _ = timeParseTimeSpecifier
     buildTime l = let
         f :: Char -> String -> TimeZone -> Maybe TimeZone
-        f 'z' str (TimeZone _ dst name) | Just offset <- readTzOffset str = Just $ TimeZone offset dst name
+        f 'z' str (TimeZone _ dst name)
+            | Just offset <- readTzOffset str = Just $ TimeZone offset dst name
         f 'z' _ _ = Nothing
-        f 'Z' str _ | Just offset <- readTzOffset str = Just $ TimeZone offset False ""
-        f 'Z' str _ | Just zone <- getKnownTimeZone l str = Just zone
+        f 'Z' str _
+            | Just offset <- readTzOffset str = Just $ TimeZone offset False ""
+        f 'Z' str _
+            | Just zone <- getKnownTimeZone l str = Just zone
         f 'Z' "UTC" _ = Just utc
-        f 'Z' [c] _ | Just zone <- getMilZone c = Just zone
+        f 'Z' [c] _
+            | Just zone <- getMilZone c = Just zone
         f 'Z' _ _ = Nothing
         f _ _ tz = Just tz
-        in foldl (\mt (c,s) -> mt >>= f c s) (Just $ minutesToTimeZone 0)
+        in foldl (\mt (c, s) -> mt >>= f c s) (Just $ minutesToTimeZone 0)
 
 readTzOffset :: String -> Maybe Int
 readTzOffset str = let
-
     getSign '+' = Just 1
     getSign '-' = Just (-1)
     getSign _ = Nothing
-
     calc s h1 h2 m1 m2 = do
         sign <- getSign s
-        h <- readMaybe [h1,h2]
-        m <- readMaybe [m1,m2]
+        h <- readMaybe [h1, h2]
+        m <- readMaybe [m1, m2]
         return $ sign * (60 * h + m)
-
     in case str of
-        (s:h1:h2:':':m1:m2:[]) -> calc s h1 h2 m1 m2
-        (s:h1:h2:m1:m2:[]) -> calc s h1 h2 m1 m2
-        _ -> Nothing
+           (s:h1:h2:':':m1:m2:[]) -> calc s h1 h2 m1 m2
+           (s:h1:h2:m1:m2:[]) -> calc s h1 h2 m1 m2
+           _ -> Nothing
 
 instance ParseTime ZonedTime where
     substituteTimeSpecifier _ = timeSubstituteTimeSpecifier
     parseTimeSpecifier _ = timeParseTimeSpecifier
     buildTime l xs = let
-        f (ZonedTime (LocalTime _ tod) z) ('s',x) = do
+        f (ZonedTime (LocalTime _ tod) z) ('s', x) = do
             a <- readMaybe x
             let
                 s = fromInteger a
-                (_,ps) = properFraction (todSec tod) :: (Integer,Pico)
+                (_, ps) = properFraction (todSec tod) :: (Integer, Pico)
                 s' = s + fromRational (toRational ps)
             return $ utcToZonedTime z (posixSecondsToUTCTime s')
         f t _ = Just t
@@ -328,39 +355,44 @@ instance ParseTime UniversalTime where
     parseTimeSpecifier _ = timeParseTimeSpecifier
     buildTime l xs = localTimeToUT1 0 <$> buildTime l xs
 
-buildTimeMonths :: [(Char,String)] -> Maybe Integer
+buildTimeMonths :: [(Char, String)] -> Maybe Integer
 buildTimeMonths xs = do
-    tt <- for xs $ \(c,s) -> case c of
-        'y' -> fmap ((*) 12) $ readMaybe s
-        'b' -> readMaybe s
-        'B' -> readMaybe s
-        _ -> return 0
+    tt <-
+        for xs $ \(c, s) ->
+            case c of
+                'y' -> fmap ((*) 12) $ readMaybe s
+                'b' -> readMaybe s
+                'B' -> readMaybe s
+                _ -> return 0
     return $ sum tt
 
-buildTimeDays :: [(Char,String)] -> Maybe Integer
+buildTimeDays :: [(Char, String)] -> Maybe Integer
 buildTimeDays xs = do
-    tt <- for xs $ \(c,s) -> case c of
-        'w' -> fmap ((*) 7) $ readMaybe s
-        'd' -> readMaybe s
-        'D' -> readMaybe s
-        _ -> return 0
+    tt <-
+        for xs $ \(c, s) ->
+            case c of
+                'w' -> fmap ((*) 7) $ readMaybe s
+                'd' -> readMaybe s
+                'D' -> readMaybe s
+                _ -> return 0
     return $ sum tt
 
-buildTimeSeconds :: [(Char,String)] -> Maybe Pico
+buildTimeSeconds :: [(Char, String)] -> Maybe Pico
 buildTimeSeconds xs = do
-    tt <- for xs $ \(c,s) -> let
-        readInt :: Integer -> Maybe Pico
-        readInt t = do
-            i <- readMaybe s
-            return $ fromInteger $ i * t
-        in case c of
-            'h' -> readInt 3600
-            'H' -> readInt 3600
-            'm' -> readInt 60
-            'M' -> readInt 60
-            's' -> readMaybe s
-            'S' -> readMaybe s
-            _ -> return 0
+    tt <-
+        for xs $ \(c, s) -> let
+            readInt :: Integer -> Maybe Pico
+            readInt t = do
+                i <- readMaybe s
+                return $ fromInteger $ i * t
+            in case c of
+                   'h' -> readInt 3600
+                   'H' -> readInt 3600
+                   'm' -> readInt 60
+                   'M' -> readInt 60
+                   's' -> readMaybe s
+                   'S' -> readMaybe s
+                   _ -> return 0
     return $ sum tt
 
 instance ParseTime NominalDiffTime where
index 8faf842..9b1feb9 100644 (file)
@@ -1,20 +1,24 @@
 module Data.Time.LocalTime
-(
+    (
     -- * Time zones
-    TimeZone(..),timeZoneOffsetString,timeZoneOffsetString',minutesToTimeZone,hoursToTimeZone,utc,
-
+      TimeZone(..)
+    , timeZoneOffsetString
+    , timeZoneOffsetString'
+    , minutesToTimeZone
+    , hoursToTimeZone
+    , utc
     -- getting the locale time zone
-    getTimeZone,getCurrentTimeZone,
-
-    module Data.Time.LocalTime.Internal.TimeOfDay,
-    module Data.Time.LocalTime.Internal.CalendarDiffTime,
-    module Data.Time.LocalTime.Internal.LocalTime,
-    module Data.Time.LocalTime.Internal.ZonedTime,
-) where
+    , getTimeZone
+    , getCurrentTimeZone
+    , module Data.Time.LocalTime.Internal.TimeOfDay
+    , module Data.Time.LocalTime.Internal.CalendarDiffTime
+    , module Data.Time.LocalTime.Internal.LocalTime
+    , module Data.Time.LocalTime.Internal.ZonedTime
+    ) where
 
-import Data.Time.Format()
-import Data.Time.LocalTime.Internal.TimeZone hiding (timeZoneOffsetString'')
-import Data.Time.LocalTime.Internal.TimeOfDay
+import Data.Time.Format ()
 import Data.Time.LocalTime.Internal.CalendarDiffTime
 import Data.Time.LocalTime.Internal.LocalTime
+import Data.Time.LocalTime.Internal.TimeOfDay
+import Data.Time.LocalTime.Internal.TimeZone hiding (timeZoneOffsetString'')
 import Data.Time.LocalTime.Internal.ZonedTime
index 7897e59..be43ea2 100644 (file)
@@ -3,11 +3,7 @@ module Data.Time.LocalTime.Internal.CalendarDiffTime
         -- * Calendar Duration
         module Data.Time.LocalTime.Internal.CalendarDiffTime
     ) where
-#if MIN_VERSION_base(4,8,0)
-#else
-import Data.Monoid
-#endif
-#if MIN_VERSION_base(4,9,0) && !MIN_VERSION_base(4,11,0)
+#if !MIN_VERSION_base(4,11,0)
 import Data.Semigroup hiding (option)
 #endif
 import Data.Fixed
@@ -30,19 +26,14 @@ data CalendarDiffTime = CalendarDiffTime
 #endif
     )
 
-#if MIN_VERSION_base(4,9,0)
 -- | Additive
 instance Semigroup CalendarDiffTime where
     CalendarDiffTime m1 d1 <> CalendarDiffTime m2 d2 = CalendarDiffTime (m1 + m2) (d1 + d2)
-#endif
+
 -- | Additive
 instance Monoid CalendarDiffTime where
     mempty = CalendarDiffTime 0 0
-#if MIN_VERSION_base(4,9,0)
     mappend = (<>)
-#else
-    mappend (CalendarDiffTime m1 d1) (CalendarDiffTime m2 d2) = CalendarDiffTime (m1 + m2) (d1 + d2)
-#endif
 
 instance Show CalendarDiffTime where
     show (CalendarDiffTime m t) = "P" ++ show m ++ "MT" ++ showFixed True (realToFrac t :: Pico) ++ "S"
index 647e459..358bab7 100644 (file)
@@ -1,38 +1,37 @@
 {-# OPTIONS -fno-warn-orphans #-}
+
 module Data.Time.LocalTime.Internal.LocalTime
-(
+    (
     -- * Local Time
-    LocalTime(..),
-
-    addLocalTime,diffLocalTime,
-
+      LocalTime(..)
+    , addLocalTime
+    , diffLocalTime
     -- converting UTC and UT1 times to LocalTime
-    utcToLocalTime,localTimeToUTC,ut1ToLocalTime,localTimeToUT1,
-) where
-
-
+    , utcToLocalTime
+    , localTimeToUTC
+    , ut1ToLocalTime
+    , localTimeToUT1
+    ) where
 
 import Control.DeepSeq
-import Data.Typeable
 import Data.Data
 import Data.Time.Calendar.Days
 import Data.Time.Calendar.Gregorian
 import Data.Time.Clock.Internal.NominalDiffTime
-import Data.Time.Clock.Internal.UniversalTime
 import Data.Time.Clock.Internal.UTCDiff
 import Data.Time.Clock.Internal.UTCTime
+import Data.Time.Clock.Internal.UniversalTime
 import Data.Time.LocalTime.Internal.TimeOfDay
 import Data.Time.LocalTime.Internal.TimeZone
 
-
 -- | A simple day and time aggregate, where the day is of the specified parameter,
 -- and the time is a TimeOfDay.
 -- Conversion of this (as local civil time) to UTC depends on the time zone.
 -- Conversion of this (as local mean time) to UT1 depends on the longitude.
-data LocalTime = LocalTime {
-    localDay    :: Day,
-    localTimeOfDay   :: TimeOfDay
-} deriving (Eq,Ord,Data, Typeable)
+data LocalTime = LocalTime
+    { localDay :: Day
+    , localTimeOfDay :: TimeOfDay
+    } deriving (Eq, Ord, Data, Typeable)
 
 instance NFData LocalTime where
     rnf (LocalTime d t) = rnf d `seq` rnf t `seq` ()
@@ -50,24 +49,29 @@ diffLocalTime a b = diffUTCTime (localTimeToUTC utc a) (localTimeToUTC utc b)
 
 -- | Get the local time of a UTC time in a time zone.
 utcToLocalTime :: TimeZone -> UTCTime -> LocalTime
-utcToLocalTime tz (UTCTime day dt) = LocalTime (addDays i day) tod where
-    (i,tod) = utcToLocalTimeOfDay tz (timeToTimeOfDay dt)
+utcToLocalTime tz (UTCTime day dt) = LocalTime (addDays i day) tod
+  where
+    (i, tod) = utcToLocalTimeOfDay tz (timeToTimeOfDay dt)
 
 -- | Get the UTC time of a local time in a time zone.
 localTimeToUTC :: TimeZone -> LocalTime -> UTCTime
-localTimeToUTC tz (LocalTime day tod) = UTCTime (addDays i day) (timeOfDayToTime todUTC) where
-    (i,todUTC) = localToUTCTimeOfDay tz tod
+localTimeToUTC tz (LocalTime day tod) = UTCTime (addDays i day) (timeOfDayToTime todUTC)
+  where
+    (i, todUTC) = localToUTCTimeOfDay tz tod
 
 -- | Get the local time of a UT1 time on a particular meridian (in degrees, positive is East).
 ut1ToLocalTime :: Rational -> UniversalTime -> LocalTime
-ut1ToLocalTime long (ModJulianDate date) = LocalTime (ModifiedJulianDay localMJD) (dayFractionToTimeOfDay localToDOffset) where
+ut1ToLocalTime long (ModJulianDate date) =
+    LocalTime (ModifiedJulianDay localMJD) (dayFractionToTimeOfDay localToDOffset)
+  where
     localTime = date + long / 360 :: Rational
     localMJD = floor localTime
     localToDOffset = localTime - (fromIntegral localMJD)
 
 -- | Get the UT1 time of a local time on a particular meridian (in degrees, positive is East).
 localTimeToUT1 :: Rational -> LocalTime -> UniversalTime
-localTimeToUT1 long (LocalTime (ModifiedJulianDay localMJD) tod) = ModJulianDate ((fromIntegral localMJD) + (timeOfDayToDayFraction tod) - (long / 360))
+localTimeToUT1 long (LocalTime (ModifiedJulianDay localMJD) tod) =
+    ModJulianDate ((fromIntegral localMJD) + (timeOfDayToDayFraction tod) - (long / 360))
 
 -- orphan instance
 instance Show UniversalTime where
index 1320f11..3cb4e0f 100644 (file)
@@ -1,34 +1,41 @@
 {-# OPTIONS -fno-warn-unused-imports #-}
+
 module Data.Time.LocalTime.Internal.TimeOfDay
-(
+    (
     -- * Time of day
-    TimeOfDay(..),midnight,midday,makeTimeOfDayValid,
-    timeToDaysAndTimeOfDay,daysAndTimeOfDayToTime,
-    utcToLocalTimeOfDay,localToUTCTimeOfDay,
-    timeToTimeOfDay,timeOfDayToTime,
-    dayFractionToTimeOfDay,timeOfDayToDayFraction
-) where
+      TimeOfDay(..)
+    , midnight
+    , midday
+    , makeTimeOfDayValid
+    , timeToDaysAndTimeOfDay
+    , daysAndTimeOfDayToTime
+    , utcToLocalTimeOfDay
+    , localToUTCTimeOfDay
+    , timeToTimeOfDay
+    , timeOfDayToTime
+    , dayFractionToTimeOfDay
+    , timeOfDayToDayFraction
+    ) where
 
 import Control.DeepSeq
-import Data.Typeable
-import Data.Fixed
 import Data.Data
+import Data.Fixed
+import Data.Time.Calendar.Private
 import Data.Time.Clock.Internal.DiffTime
 import Data.Time.Clock.Internal.NominalDiffTime
-import Data.Time.Calendar.Private
 import Data.Time.LocalTime.Internal.TimeZone
-
+import Data.Typeable
 
 -- | Time of day as represented in hour, minute and second (with picoseconds), typically used to express local time of day.
-data TimeOfDay = TimeOfDay {
-    -- | range 0 - 23
-    todHour    :: Int,
-    -- | range 0 - 59
-    todMin     :: Int,
-    -- | Note that 0 <= 'todSec' < 61, accomodating leap seconds.
+data TimeOfDay = TimeOfDay
+    { todHour :: Int
+    -- ^ range 0 - 23
+    , todMin :: Int
+    -- ^ range 0 - 59
+    , todSec :: Pico
+    -- ^ Note that 0 <= 'todSec' < 61, accomodating leap seconds.
     -- Any local minute may have a leap second, since leap seconds happen in all zones simultaneously
-    todSec     :: Pico
-} deriving (Eq,Ord,Data, Typeable)
+    } deriving (Eq, Ord, Data, Typeable)
 
 instance NFData TimeOfDay where
     rnf (TimeOfDay h m s) = rnf h `seq` rnf m `seq` s `seq` () -- FIXME: Data.Fixed had no NFData instances yet at time of writing
@@ -53,26 +60,28 @@ makeTimeOfDayValid h m s = do
 
 -- | Convert a period of time into a count of days and a time of day since midnight.
 -- The time of day will never have a leap second.
-timeToDaysAndTimeOfDay :: NominalDiffTime -> (Integer,TimeOfDay)
+timeToDaysAndTimeOfDay :: NominalDiffTime -> (Integer, TimeOfDay)
 timeToDaysAndTimeOfDay dt = let
     s = realToFrac dt
-    (m,ms) = divMod' s 60
-    (h,hm) = divMod' m 60
-    (d,dh) = divMod' h 24
-    in (d,TimeOfDay dh hm ms)
+    (m, ms) = divMod' s 60
+    (h, hm) = divMod' m 60
+    (d, dh) = divMod' h 24
+    in (d, TimeOfDay dh hm ms)
 
 -- | Convert a count of days and a time of day since midnight into a period of time.
 daysAndTimeOfDayToTime :: Integer -> TimeOfDay -> NominalDiffTime
-daysAndTimeOfDayToTime d (TimeOfDay dh hm ms) = (+) (realToFrac ms) $ (*) 60 $ (+) (realToFrac hm) $ (*) 60 $ (+) (realToFrac dh) $ (*) 24 $ realToFrac d
+daysAndTimeOfDayToTime d (TimeOfDay dh hm ms) =
+    (+) (realToFrac ms) $ (*) 60 $ (+) (realToFrac hm) $ (*) 60 $ (+) (realToFrac dh) $ (*) 24 $ realToFrac d
 
 -- | Convert a time of day in UTC to a time of day in some timezone, together with a day adjustment.
-utcToLocalTimeOfDay :: TimeZone -> TimeOfDay -> (Integer,TimeOfDay)
-utcToLocalTimeOfDay zone (TimeOfDay h m s) = (fromIntegral (div h' 24),TimeOfDay (mod h' 24) (mod m' 60) s) where
+utcToLocalTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
+utcToLocalTimeOfDay zone (TimeOfDay h m s) = (fromIntegral (div h' 24), TimeOfDay (mod h' 24) (mod m' 60) s)
+  where
     m' = m + timeZoneMinutes zone
     h' = h + (div m' 60)
 
 -- | Convert a time of day in some timezone to a time of day in UTC, together with a day adjustment.
-localToUTCTimeOfDay :: TimeZone -> TimeOfDay -> (Integer,TimeOfDay)
+localToUTCTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
 localToUTCTimeOfDay zone = utcToLocalTimeOfDay (minutesToTimeZone (negate (timeZoneMinutes zone)))
 
 posixDayLength :: DiffTime
@@ -81,8 +90,10 @@ posixDayLength = fromInteger 86400
 -- | Get the time of day given a time since midnight.
 -- Time more than 24h will be converted to leap-seconds.
 timeToTimeOfDay :: DiffTime -> TimeOfDay
-timeToTimeOfDay dt | dt >= posixDayLength = TimeOfDay 23 59 (60 + (realToFrac (dt - posixDayLength)))
-timeToTimeOfDay dt = TimeOfDay (fromInteger h) (fromInteger m) s where
+timeToTimeOfDay dt
+    | dt >= posixDayLength = TimeOfDay 23 59 (60 + (realToFrac (dt - posixDayLength)))
+timeToTimeOfDay dt = TimeOfDay (fromInteger h) (fromInteger m) s
+  where
     s' = realToFrac dt
     s = mod' s' 60
     m' = div' s' 60
index e525006..e34d1fe 100644 (file)
@@ -1,39 +1,41 @@
 {-# OPTIONS -fno-warn-unused-imports #-}
 {-# LANGUAGE ForeignFunctionInterface #-}
+
 module Data.Time.LocalTime.Internal.TimeZone
-(
+    (
     -- * Time zones
-    TimeZone(..),timeZoneOffsetString,timeZoneOffsetString',timeZoneOffsetString'',minutesToTimeZone,hoursToTimeZone,utc,
-
+      TimeZone(..)
+    , timeZoneOffsetString
+    , timeZoneOffsetString'
+    , timeZoneOffsetString''
+    , minutesToTimeZone
+    , hoursToTimeZone
+    , utc
     -- getting the locale time zone
-    getTimeZone,getCurrentTimeZone
-) where
+    , getTimeZone
+    , getCurrentTimeZone
+    ) where
 
+import Control.DeepSeq
+import Data.Data
 --import System.Time.Calendar.Format
 import Data.Time.Calendar.Private
-import Data.Time.Clock.System
-import Data.Time.Clock.POSIX
 import Data.Time.Clock.Internal.UTCTime
-
-#if __GLASGOW_HASKELL__ >= 709
+import Data.Time.Clock.POSIX
+import Data.Time.Clock.System
+import Data.Typeable
 import Foreign
-#else
-import Foreign.Safe
-#endif
 import Foreign.C
-import Control.DeepSeq
-import Data.Typeable
-import Data.Data
 
 -- | A TimeZone is a whole number of minutes offset from UTC, together with a name and a \"just for summer\" flag.
-data TimeZone = TimeZone {
-    -- | The number of minutes offset from UTC. Positive means local time will be later in the day than UTC.
-    timeZoneMinutes :: Int,
-    -- | Is this time zone just persisting for the summer?
-    timeZoneSummerOnly :: Bool,
-    -- | The name of the zone, typically a three- or four-letter acronym.
-    timeZoneName :: String
-} deriving (Eq,Ord,Data, Typeable)
+data TimeZone = TimeZone
+    { timeZoneMinutes :: Int
+    -- ^ The number of minutes offset from UTC. Positive means local time will be later in the day than UTC.
+    , timeZoneSummerOnly :: Bool
+    -- ^ Is this time zone just persisting for the summer?
+    , timeZoneName :: String
+    -- ^ The name of the zone, typically a three- or four-letter acronym.
+    } deriving (Eq, Ord, Data, Typeable)
 
 instance NFData TimeZone where
     rnf (TimeZone m so n) = rnf m `seq` rnf so `seq` rnf n `seq` ()
@@ -49,14 +51,16 @@ hoursToTimeZone i = minutesToTimeZone (60 * i)
 showT :: Bool -> PadOption -> Int -> String
 showT False opt t = showPaddedNum opt ((div t 60) * 100 + (mod t 60))
 showT True opt t = let
-    opt' = case opt of
-        NoPad -> NoPad
-        Pad i c -> Pad (max 0 $ i - 3) c
+    opt' =
+        case opt of
+            NoPad -> NoPad
+            Pad i c -> Pad (max 0 $ i - 3) c
     in showPaddedNum opt' (div t 60) ++ ":" ++ show2 (mod t 60)
 
 timeZoneOffsetString'' :: Bool -> PadOption -> TimeZone -> String
-timeZoneOffsetString'' colon opt (TimeZone t _ _) | t < 0 = '-':(showT colon opt (negate t))
-timeZoneOffsetString'' colon opt (TimeZone t _ _) = '+':(showT colon opt t)
+timeZoneOffsetString'' colon opt (TimeZone t _ _)
+    | t < 0 = '-' : (showT colon opt (negate t))
+timeZoneOffsetString'' colon opt (TimeZone t _ _) = '+' : (showT colon opt t)
 
 -- | Text representing the offset of this timezone, such as \"-0800\" or \"+0400\" (like @%z@ in formatTime), with arbitrary padding.
 timeZoneOffsetString' :: Maybe Char -> TimeZone -> String
@@ -77,26 +81,34 @@ utc :: TimeZone
 utc = TimeZone 0 False "UTC"
 
 {-# CFILES cbits/HsTime.c #-}
-foreign import ccall unsafe "HsTime.h get_current_timezone_seconds" get_current_timezone_seconds :: CTime -> Ptr CInt -> Ptr CString -> IO CLong
+foreign import ccall unsafe "HsTime.h get_current_timezone_seconds" get_current_timezone_seconds
+    :: CTime -> Ptr CInt -> Ptr CString -> IO CLong
 
 getTimeZoneCTime :: CTime -> IO TimeZone
-getTimeZoneCTime ctime = with 0 (\pdst -> with nullPtr (\pcname -> do
-    secs <- get_current_timezone_seconds ctime pdst pcname
-    case secs of
-        0x80000000 -> fail "localtime_r failed"
-        _ -> do
-            dst <- peek pdst
-            cname <- peek pcname
-            name <- peekCString cname
-            return (TimeZone (div (fromIntegral secs) 60) (dst == 1) name)
-    ))
+getTimeZoneCTime ctime =
+    with
+        0
+        (\pdst ->
+             with
+                 nullPtr
+                 (\pcname -> do
+                      secs <- get_current_timezone_seconds ctime pdst pcname
+                      case secs of
+                          0x80000000 -> fail "localtime_r failed"
+                          _ -> do
+                              dst <- peek pdst
+                              cname <- peek pcname
+                              name <- peekCString cname
+                              return (TimeZone (div (fromIntegral secs) 60) (dst == 1) name)))
 
 toCTime :: Int64 -> IO CTime
 toCTime t = let
     tt = fromIntegral t
     t' = fromIntegral tt
     -- there's no instance Bounded CTime, so this is the easiest way to check for overflow
-    in if t' == t then return $ CTime tt else fail "Data.Time.LocalTime.Internal.TimeZone.toCTime: Overflow"
+    in if t' == t
+           then return $ CTime tt
+           else fail "Data.Time.LocalTime.Internal.TimeZone.toCTime: Overflow"
 
 -- | Get the local time-zone for a given time (varying as per summertime adjustments).
 getTimeZoneSystem :: SystemTime -> IO TimeZone
index 6c57a53..671db30 100644 (file)
@@ -1,28 +1,29 @@
 {-# OPTIONS -fno-warn-orphans #-}
+
 module Data.Time.LocalTime.Internal.ZonedTime
-(
-    ZonedTime(..),utcToZonedTime,zonedTimeToUTC,getZonedTime,utcToLocalZonedTime
-) where
+    ( ZonedTime(..)
+    , utcToZonedTime
+    , zonedTimeToUTC
+    , getZonedTime
+    , utcToLocalZonedTime
+    ) where
 
 import Control.DeepSeq
-import Data.Typeable
 import Data.Data
 import Data.Time.Clock.Internal.UTCTime
 import Data.Time.Clock.POSIX
-import Data.Time.LocalTime.Internal.TimeZone
 import Data.Time.LocalTime.Internal.LocalTime
-
+import Data.Time.LocalTime.Internal.TimeZone
 
 -- | A local time together with a time zone.
 --
 -- There is no 'Eq' instance for @ZonedTime@.
 -- If you want to compare local times, use 'zonedTimeToLocalTime'.
 -- If you want to compare absolute times, use 'zonedTimeToUTC'.
-data ZonedTime = ZonedTime {
-    zonedTimeToLocalTime :: LocalTime,
-    zonedTimeZone :: TimeZone
-}
-    deriving (Data, Typeable)
+data ZonedTime = ZonedTime
+    { zonedTimeToLocalTime :: LocalTime
+    , zonedTimeZone :: TimeZone
+    } deriving (Data, Typeable)
 
 instance NFData ZonedTime where
     rnf (ZonedTime lt z) = rnf lt `seq` rnf z `seq` ()
index 73ecd4d..e09636b 100644 (file)
@@ -9,5 +9,11 @@ build:
     test-arguments:
         additional-args: [--hide-successes]
 
+extra-deps:
+- git: https://github.com/AshleyYakeley/haskell-src-exts.git
+  commit: 31e1466e35cee9a91fa6678d73c938f0f44759eb
+- git: https://github.com/AshleyYakeley/hindent.git
+  commit: ad88fc51f813a748d46c6bcd801047ec66b6b9c8
+
 ghc-options:
     "$locals": -Werror -Wincomplete-uni-patterns -Wincomplete-record-updates -Wredundant-constraints -Wcompat -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances
index be4eae2..6e8c52a 100644 (file)
@@ -1,22 +1,22 @@
 {- Contributed by Liyang HU <haskell.org@liyang.hu> -}
 module Main where
 
-import Prelude
 import Control.Applicative
-import Control.Monad
 import Control.DeepSeq
+import Control.Monad
 import Data.Time
 import Data.Time.Clock.POSIX
+import Prelude
 import System.Random
 
 main :: IO ()
 main = do
-    ts <- replicateM 100000 $ do
-        t <- posixSecondsToUTCTime . realToFrac <$>
-            ( (*) . fromInteger <$> randomRIO (-15*10^21, 15*10^21) <*>
-                randomIO :: IO Double ) :: IO UTCTime
-        rnf t `seq` return t
+    ts <-
+        replicateM 100000 $ do
+            t <-
+                posixSecondsToUTCTime . realToFrac <$>
+                ((*) . fromInteger <$> randomRIO (-15 * 10 ^ 21, 15 * 10 ^ 21) <*> randomIO :: IO Double) :: IO UTCTime
+            rnf t `seq` return t
     now <- getCurrentTime
     print . sum $ map (diffUTCTime now) ts
     print =<< flip diffUTCTime now <$> getCurrentTime
-
index 8b00014..7cabcfa 100644 (file)
@@ -3,31 +3,34 @@ module Main where
 import Data.Time
 
 monthBeginning :: TimeZone -> Integer -> Int -> UTCTime
-monthBeginning zone year month = localTimeToUTC zone
-    (LocalTime (fromGregorian year month 1) midnight)
+monthBeginning zone year month = localTimeToUTC zone (LocalTime (fromGregorian year month 1) midnight)
 
-findTransition :: UTCTime -> UTCTime -> IO [(UTCTime,TimeZone,TimeZone)]
+findTransition :: UTCTime -> UTCTime -> IO [(UTCTime, TimeZone, TimeZone)]
 findTransition a b = do
     za <- getTimeZone a
     zb <- getTimeZone b
-    if za == zb then return [] else do
-        let c = addUTCTime ((diffUTCTime b a) / 2) a
-        if a == c then return [(b,za,zb)] else do
-            tp <- findTransition a c
-            tq <- findTransition c b
-            return (tp ++ tq)
+    if za == zb
+        then return []
+        else do
+            let c = addUTCTime ((diffUTCTime b a) / 2) a
+            if a == c
+                then return [(b, za, zb)]
+                else do
+                    tp <- findTransition a c
+                    tq <- findTransition c b
+                    return (tp ++ tq)
 
 showZoneTime :: TimeZone -> UTCTime -> String
 showZoneTime zone time = show (utcToZonedTime zone time)
 
-showTransition :: (UTCTime,TimeZone,TimeZone) -> String
-showTransition (time,zone1,zone2) = (showZoneTime zone1 time) ++ " => " ++ (showZoneTime zone2 time)
+showTransition :: (UTCTime, TimeZone, TimeZone) -> String
+showTransition (time, zone1, zone2) = (showZoneTime zone1 time) ++ " => " ++ (showZoneTime zone2 time)
 
 main :: IO ()
 main = do
     now <- getCurrentTime
     zone <- getTimeZone now
-    let (year,_,_) = toGregorian (localDay (utcToLocalTime zone now))
+    let (year, _, _) = toGregorian (localDay (utcToLocalTime zone now))
     putStrLn ("DST adjustments for " ++ show year ++ ":")
     let t0 = monthBeginning zone year 1
     let t1 = monthBeginning zone year 4
index ce71402..c7c782e 100644 (file)
@@ -3,7 +3,11 @@ module Main where
 import Data.Time
 
 showTZ :: TimeZone -> String
-showTZ tz = (formatTime defaultTimeLocale "%Z %z" tz) ++ (if timeZoneSummerOnly tz then " DST" else "")
+showTZ tz =
+    (formatTime defaultTimeLocale "%Z %z" tz) ++
+    (if timeZoneSummerOnly tz
+         then " DST"
+         else "")
 
 main :: IO ()
 main = mapM_ (\tz -> putStrLn (showTZ tz)) (knownTimeZones defaultTimeLocale)
index 480e555..cd8c997 100644 (file)
@@ -1,6 +1,5 @@
 module Main where
 
-import Test.Tasty
 import Test.Calendar.AddDays
 import Test.Calendar.Calendars
 import Test.Calendar.ClipDates
@@ -15,43 +14,34 @@ import Test.Clock.Conversion
 import Test.Clock.Resolution
 import Test.Clock.TAI
 import Test.Format.Format
-import Test.Format.ParseTime
 import Test.Format.ISO8601
+import Test.Format.ParseTime
+import Test.LocalTime.CalendarDiffTime
 import Test.LocalTime.Time
 import Test.LocalTime.TimeOfDay
-import Test.LocalTime.CalendarDiffTime
-
+import Test.Tasty
 
 tests :: TestTree
-tests = testGroup "Time" [
-    testGroup "Calendar" [
-        addDaysTest,
-        testCalendars,
-        clipDates,
-        convertBack,
-        longWeekYears,
-        testMonthDay,
-        testEaster,
-        testValid,
-        testWeek,
-        testDuration
-        ],
-    testGroup "Clock" [
-        testClockConversion,
-        testResolutions,
-        testTAI
-        ],
-    testGroup "Format" [
-        testFormat,
-        testParseTime,
-        testISO8601
-        ],
-    testGroup "LocalTime" [
-        testTime,
-        testTimeOfDay,
-        testCalendarDiffTime
+tests =
+    testGroup
+        "Time"
+        [ testGroup
+              "Calendar"
+              [ addDaysTest
+              , testCalendars
+              , clipDates
+              , convertBack
+              , longWeekYears
+              , testMonthDay
+              , testEaster
+              , testValid
+              , testWeek
+              , testDuration
+              ]
+        , testGroup "Clock" [testClockConversion, testResolutions, testTAI]
+        , testGroup "Format" [testFormat, testParseTime, testISO8601]
+        , testGroup "LocalTime" [testTime, testTimeOfDay, testCalendarDiffTime]
         ]
-    ]
 
 main :: IO ()
 main = defaultMain tests
index 48fc1ac..d19902d 100644 (file)
@@ -9,7 +9,7 @@ import Data.Time.Clock.POSIX
 import Test.Tasty.QuickCheck hiding (reason)
 
 instance Arbitrary DayOfWeek where
-    arbitrary = fmap toEnum $ choose (1,7)
+    arbitrary = fmap toEnum $ choose (1, 7)
 
 instance Arbitrary Day where
     arbitrary = liftM ModifiedJulianDay $ choose (-313698, 2973483) -- 1000-01-1 to 9999-12-31
index 26ab307..d1dc184 100644 (file)
@@ -1,42 +1,43 @@
-module Test.Calendar.AddDays(addDaysTest) where
+module Test.Calendar.AddDays
+    ( addDaysTest
+    ) where
 
 import Data.Time.Calendar
+import Test.Calendar.AddDaysRef
 import Test.Tasty
 import Test.Tasty.HUnit
-import Test.Calendar.AddDaysRef
 
-days ::[Day]
+days :: [Day]
 days =
-    [
-    fromGregorian 2005 2 28,
-    fromGregorian 2004 2 29,
-    fromGregorian 2004 1 31,
-    fromGregorian 2004 12 31,
-    fromGregorian 2005 7 1,
-    fromGregorian 2005 4 21,
-    fromGregorian 2005 6 30
+    [ fromGregorian 2005 2 28
+    , fromGregorian 2004 2 29
+    , fromGregorian 2004 1 31
+    , fromGregorian 2004 12 31
+    , fromGregorian 2005 7 1
+    , fromGregorian 2005 4 21
+    , fromGregorian 2005 6 30
     ]
 
 increments :: [Integer]
-increments = [-10,-4,-1,0,1,7,83]
+increments = [-10, -4, -1, 0, 1, 7, 83]
 
-adders :: [(String,Integer -> Day -> Day)]
+adders :: [(String, Integer -> Day -> Day)]
 adders =
-    [
-    ("day",addDays),
-    ("month (clip)",addGregorianMonthsClip),
-    ("month (roll over)",addGregorianMonthsRollOver),
-    ("year (clip)",addGregorianYearsClip),
-    ("year (roll over)",addGregorianYearsRollOver)
+    [ ("day", addDays)
+    , ("month (clip)", addGregorianMonthsClip)
+    , ("month (roll over)", addGregorianMonthsRollOver)
+    , ("year (clip)", addGregorianYearsClip)
+    , ("year (roll over)", addGregorianYearsRollOver)
     ]
 
 resultDays :: [String]
 resultDays = do
-    (aname,adder) <- adders
+    (aname, adder) <- adders
     increment <- increments
     day <- days
-    return ((showGregorian day) ++ " + " ++ (show increment) ++ " * " ++ aname ++ " = " ++ showGregorian (adder increment day))
+    return
+        ((showGregorian day) ++
+         " + " ++ (show increment) ++ " * " ++ aname ++ " = " ++ showGregorian (adder increment day))
 
 addDaysTest :: TestTree
-addDaysTest = testCase "addDays" $
-    assertEqual "" addDaysRef $ unlines resultDays
+addDaysTest = testCase "addDays" $ assertEqual "" addDaysRef $ unlines resultDays
index f2e2d87..97588e9 100644 (file)
@@ -2,249 +2,250 @@ module Test.Calendar.AddDaysRef where
 
 addDaysRef :: String
 addDaysRef =
- unlines
-  [ "2005-02-28 + -10 * day = 2005-02-18"
-  , "2004-02-29 + -10 * day = 2004-02-19"
-  , "2004-01-31 + -10 * day = 2004-01-21"
-  , "2004-12-31 + -10 * day = 2004-12-21"
-  , "2005-07-01 + -10 * day = 2005-06-21"
-  , "2005-04-21 + -10 * day = 2005-04-11"
-  , "2005-06-30 + -10 * day = 2005-06-20"
-  , "2005-02-28 + -4 * day = 2005-02-24"
-  , "2004-02-29 + -4 * day = 2004-02-25"
-  , "2004-01-31 + -4 * day = 2004-01-27"
-  , "2004-12-31 + -4 * day = 2004-12-27"
-  , "2005-07-01 + -4 * day = 2005-06-27"
-  , "2005-04-21 + -4 * day = 2005-04-17"
-  , "2005-06-30 + -4 * day = 2005-06-26"
-  , "2005-02-28 + -1 * day = 2005-02-27"
-  , "2004-02-29 + -1 * day = 2004-02-28"
-  , "2004-01-31 + -1 * day = 2004-01-30"
-  , "2004-12-31 + -1 * day = 2004-12-30"
-  , "2005-07-01 + -1 * day = 2005-06-30"
-  , "2005-04-21 + -1 * day = 2005-04-20"
-  , "2005-06-30 + -1 * day = 2005-06-29"
-  , "2005-02-28 + 0 * day = 2005-02-28"
-  , "2004-02-29 + 0 * day = 2004-02-29"
-  , "2004-01-31 + 0 * day = 2004-01-31"
-  , "2004-12-31 + 0 * day = 2004-12-31"
-  , "2005-07-01 + 0 * day = 2005-07-01"
-  , "2005-04-21 + 0 * day = 2005-04-21"
-  , "2005-06-30 + 0 * day = 2005-06-30"
-  , "2005-02-28 + 1 * day = 2005-03-01"
-  , "2004-02-29 + 1 * day = 2004-03-01"
-  , "2004-01-31 + 1 * day = 2004-02-01"
-  , "2004-12-31 + 1 * day = 2005-01-01"
-  , "2005-07-01 + 1 * day = 2005-07-02"
-  , "2005-04-21 + 1 * day = 2005-04-22"
-  , "2005-06-30 + 1 * day = 2005-07-01"
-  , "2005-02-28 + 7 * day = 2005-03-07"
-  , "2004-02-29 + 7 * day = 2004-03-07"
-  , "2004-01-31 + 7 * day = 2004-02-07"
-  , "2004-12-31 + 7 * day = 2005-01-07"
-  , "2005-07-01 + 7 * day = 2005-07-08"
-  , "2005-04-21 + 7 * day = 2005-04-28"
-  , "2005-06-30 + 7 * day = 2005-07-07"
-  , "2005-02-28 + 83 * day = 2005-05-22"
-  , "2004-02-29 + 83 * day = 2004-05-22"
-  , "2004-01-31 + 83 * day = 2004-04-23"
-  , "2004-12-31 + 83 * day = 2005-03-24"
-  , "2005-07-01 + 83 * day = 2005-09-22"
-  , "2005-04-21 + 83 * day = 2005-07-13"
-  , "2005-06-30 + 83 * day = 2005-09-21"
-  , "2005-02-28 + -10 * month (clip) = 2004-04-28"
-  , "2004-02-29 + -10 * month (clip) = 2003-04-29"
-  , "2004-01-31 + -10 * month (clip) = 2003-03-31"
-  , "2004-12-31 + -10 * month (clip) = 2004-02-29"
-  , "2005-07-01 + -10 * month (clip) = 2004-09-01"
-  , "2005-04-21 + -10 * month (clip) = 2004-06-21"
-  , "2005-06-30 + -10 * month (clip) = 2004-08-30"
-  , "2005-02-28 + -4 * month (clip) = 2004-10-28"
-  , "2004-02-29 + -4 * month (clip) = 2003-10-29"
-  , "2004-01-31 + -4 * month (clip) = 2003-09-30"
-  , "2004-12-31 + -4 * month (clip) = 2004-08-31"
-  , "2005-07-01 + -4 * month (clip) = 2005-03-01"
-  , "2005-04-21 + -4 * month (clip) = 2004-12-21"
-  , "2005-06-30 + -4 * month (clip) = 2005-02-28"
-  , "2005-02-28 + -1 * month (clip) = 2005-01-28"
-  , "2004-02-29 + -1 * month (clip) = 2004-01-29"
-  , "2004-01-31 + -1 * month (clip) = 2003-12-31"
-  , "2004-12-31 + -1 * month (clip) = 2004-11-30"
-  , "2005-07-01 + -1 * month (clip) = 2005-06-01"
-  , "2005-04-21 + -1 * month (clip) = 2005-03-21"
-  , "2005-06-30 + -1 * month (clip) = 2005-05-30"
-  , "2005-02-28 + 0 * month (clip) = 2005-02-28"
-  , "2004-02-29 + 0 * month (clip) = 2004-02-29"
-  , "2004-01-31 + 0 * month (clip) = 2004-01-31"
-  , "2004-12-31 + 0 * month (clip) = 2004-12-31"
-  , "2005-07-01 + 0 * month (clip) = 2005-07-01"
-  , "2005-04-21 + 0 * month (clip) = 2005-04-21"
-  , "2005-06-30 + 0 * month (clip) = 2005-06-30"
-  , "2005-02-28 + 1 * month (clip) = 2005-03-28"
-  , "2004-02-29 + 1 * month (clip) = 2004-03-29"
-  , "2004-01-31 + 1 * month (clip) = 2004-02-29"
-  , "2004-12-31 + 1 * month (clip) = 2005-01-31"
-  , "2005-07-01 + 1 * month (clip) = 2005-08-01"
-  , "2005-04-21 + 1 * month (clip) = 2005-05-21"
-  , "2005-06-30 + 1 * month (clip) = 2005-07-30"
-  , "2005-02-28 + 7 * month (clip) = 2005-09-28"
-  , "2004-02-29 + 7 * month (clip) = 2004-09-29"
-  , "2004-01-31 + 7 * month (clip) = 2004-08-31"
-  , "2004-12-31 + 7 * month (clip) = 2005-07-31"
-  , "2005-07-01 + 7 * month (clip) = 2006-02-01"
-  , "2005-04-21 + 7 * month (clip) = 2005-11-21"
-  , "2005-06-30 + 7 * month (clip) = 2006-01-30"
-  , "2005-02-28 + 83 * month (clip) = 2012-01-28"
-  , "2004-02-29 + 83 * month (clip) = 2011-01-29"
-  , "2004-01-31 + 83 * month (clip) = 2010-12-31"
-  , "2004-12-31 + 83 * month (clip) = 2011-11-30"
-  , "2005-07-01 + 83 * month (clip) = 2012-06-01"
-  , "2005-04-21 + 83 * month (clip) = 2012-03-21"
-  , "2005-06-30 + 83 * month (clip) = 2012-05-30"
-  , "2005-02-28 + -10 * month (roll over) = 2004-04-28"
-  , "2004-02-29 + -10 * month (roll over) = 2003-04-29"
-  , "2004-01-31 + -10 * month (roll over) = 2003-03-31"
-  , "2004-12-31 + -10 * month (roll over) = 2004-03-02"
-  , "2005-07-01 + -10 * month (roll over) = 2004-09-01"
-  , "2005-04-21 + -10 * month (roll over) = 2004-06-21"
-  , "2005-06-30 + -10 * month (roll over) = 2004-08-30"
-  , "2005-02-28 + -4 * month (roll over) = 2004-10-28"
-  , "2004-02-29 + -4 * month (roll over) = 2003-10-29"
-  , "2004-01-31 + -4 * month (roll over) = 2003-10-01"
-  , "2004-12-31 + -4 * month (roll over) = 2004-08-31"
-  , "2005-07-01 + -4 * month (roll over) = 2005-03-01"
-  , "2005-04-21 + -4 * month (roll over) = 2004-12-21"
-  , "2005-06-30 + -4 * month (roll over) = 2005-03-02"
-  , "2005-02-28 + -1 * month (roll over) = 2005-01-28"
-  , "2004-02-29 + -1 * month (roll over) = 2004-01-29"
-  , "2004-01-31 + -1 * month (roll over) = 2003-12-31"
-  , "2004-12-31 + -1 * month (roll over) = 2004-12-01"
-  , "2005-07-01 + -1 * month (roll over) = 2005-06-01"
-  , "2005-04-21 + -1 * month (roll over) = 2005-03-21"
-  , "2005-06-30 + -1 * month (roll over) = 2005-05-30"
-  , "2005-02-28 + 0 * month (roll over) = 2005-02-28"
-  , "2004-02-29 + 0 * month (roll over) = 2004-02-29"
-  , "2004-01-31 + 0 * month (roll over) = 2004-01-31"
-  , "2004-12-31 + 0 * month (roll over) = 2004-12-31"
-  , "2005-07-01 + 0 * month (roll over) = 2005-07-01"
-  , "2005-04-21 + 0 * month (roll over) = 2005-04-21"
-  , "2005-06-30 + 0 * month (roll over) = 2005-06-30"
-  , "2005-02-28 + 1 * month (roll over) = 2005-03-28"
-  , "2004-02-29 + 1 * month (roll over) = 2004-03-29"
-  , "2004-01-31 + 1 * month (roll over) = 2004-03-02"
-  , "2004-12-31 + 1 * month (roll over) = 2005-01-31"
-  , "2005-07-01 + 1 * month (roll over) = 2005-08-01"
-  , "2005-04-21 + 1 * month (roll over) = 2005-05-21"
-  , "2005-06-30 + 1 * month (roll over) = 2005-07-30"
-  , "2005-02-28 + 7 * month (roll over) = 2005-09-28"
-  , "2004-02-29 + 7 * month (roll over) = 2004-09-29"
-  , "2004-01-31 + 7 * month (roll over) = 2004-08-31"
-  , "2004-12-31 + 7 * month (roll over) = 2005-07-31"
-  , "2005-07-01 + 7 * month (roll over) = 2006-02-01"
-  , "2005-04-21 + 7 * month (roll over) = 2005-11-21"
-  , "2005-06-30 + 7 * month (roll over) = 2006-01-30"
-  , "2005-02-28 + 83 * month (roll over) = 2012-01-28"
-  , "2004-02-29 + 83 * month (roll over) = 2011-01-29"
-  , "2004-01-31 + 83 * month (roll over) = 2010-12-31"
-  , "2004-12-31 + 83 * month (roll over) = 2011-12-01"
-  , "2005-07-01 + 83 * month (roll over) = 2012-06-01"
-  , "2005-04-21 + 83 * month (roll over) = 2012-03-21"
-  , "2005-06-30 + 83 * month (roll over) = 2012-05-30"
-  , "2005-02-28 + -10 * year (clip) = 1995-02-28"
-  , "2004-02-29 + -10 * year (clip) = 1994-02-28"
-  , "2004-01-31 + -10 * year (clip) = 1994-01-31"
-  , "2004-12-31 + -10 * year (clip) = 1994-12-31"
-  , "2005-07-01 + -10 * year (clip) = 1995-07-01"
-  , "2005-04-21 + -10 * year (clip) = 1995-04-21"
-  , "2005-06-30 + -10 * year (clip) = 1995-06-30"
-  , "2005-02-28 + -4 * year (clip) = 2001-02-28"
-  , "2004-02-29 + -4 * year (clip) = 2000-02-29"
-  , "2004-01-31 + -4 * year (clip) = 2000-01-31"
-  , "2004-12-31 + -4 * year (clip) = 2000-12-31"
-  , "2005-07-01 + -4 * year (clip) = 2001-07-01"
-  , "2005-04-21 + -4 * year (clip) = 2001-04-21"
-  , "2005-06-30 + -4 * year (clip) = 2001-06-30"
-  , "2005-02-28 + -1 * year (clip) = 2004-02-28"
-  , "2004-02-29 + -1 * year (clip) = 2003-02-28"
-  , "2004-01-31 + -1 * year (clip) = 2003-01-31"
-  , "2004-12-31 + -1 * year (clip) = 2003-12-31"
-  , "2005-07-01 + -1 * year (clip) = 2004-07-01"
-  , "2005-04-21 + -1 * year (clip) = 2004-04-21"
-  , "2005-06-30 + -1 * year (clip) = 2004-06-30"
-  , "2005-02-28 + 0 * year (clip) = 2005-02-28"
-  , "2004-02-29 + 0 * year (clip) = 2004-02-29"
-  , "2004-01-31 + 0 * year (clip) = 2004-01-31"
-  , "2004-12-31 + 0 * year (clip) = 2004-12-31"
-  , "2005-07-01 + 0 * year (clip) = 2005-07-01"
-  , "2005-04-21 + 0 * year (clip) = 2005-04-21"
-  , "2005-06-30 + 0 * year (clip) = 2005-06-30"
-  , "2005-02-28 + 1 * year (clip) = 2006-02-28"
-  , "2004-02-29 + 1 * year (clip) = 2005-02-28"
-  , "2004-01-31 + 1 * year (clip) = 2005-01-31"
-  , "2004-12-31 + 1 * year (clip) = 2005-12-31"
-  , "2005-07-01 + 1 * year (clip) = 2006-07-01"
-  , "2005-04-21 + 1 * year (clip) = 2006-04-21"
-  , "2005-06-30 + 1 * year (clip) = 2006-06-30"
-  , "2005-02-28 + 7 * year (clip) = 2012-02-28"
-  , "2004-02-29 + 7 * year (clip) = 2011-02-28"
-  , "2004-01-31 + 7 * year (clip) = 2011-01-31"
-  , "2004-12-31 + 7 * year (clip) = 2011-12-31"
-  , "2005-07-01 + 7 * year (clip) = 2012-07-01"
-  , "2005-04-21 + 7 * year (clip) = 2012-04-21"
-  , "2005-06-30 + 7 * year (clip) = 2012-06-30"
-  , "2005-02-28 + 83 * year (clip) = 2088-02-28"
-  , "2004-02-29 + 83 * year (clip) = 2087-02-28"
-  , "2004-01-31 + 83 * year (clip) = 2087-01-31"
-  , "2004-12-31 + 83 * year (clip) = 2087-12-31"
-  , "2005-07-01 + 83 * year (clip) = 2088-07-01"
-  , "2005-04-21 + 83 * year (clip) = 2088-04-21"
-  , "2005-06-30 + 83 * year (clip) = 2088-06-30"
-  , "2005-02-28 + -10 * year (roll over) = 1995-02-28"
-  , "2004-02-29 + -10 * year (roll over) = 1994-03-01"
-  , "2004-01-31 + -10 * year (roll over) = 1994-01-31"
-  , "2004-12-31 + -10 * year (roll over) = 1994-12-31"
-  , "2005-07-01 + -10 * year (roll over) = 1995-07-01"
-  , "2005-04-21 + -10 * year (roll over) = 1995-04-21"
-  , "2005-06-30 + -10 * year (roll over) = 1995-06-30"
-  , "2005-02-28 + -4 * year (roll over) = 2001-02-28"
-  , "2004-02-29 + -4 * year (roll over) = 2000-02-29"
-  , "2004-01-31 + -4 * year (roll over) = 2000-01-31"
-  , "2004-12-31 + -4 * year (roll over) = 2000-12-31"
-  , "2005-07-01 + -4 * year (roll over) = 2001-07-01"
-  , "2005-04-21 + -4 * year (roll over) = 2001-04-21"
-  , "2005-06-30 + -4 * year (roll over) = 2001-06-30"
-  , "2005-02-28 + -1 * year (roll over) = 2004-02-28"
-  , "2004-02-29 + -1 * year (roll over) = 2003-03-01"
-  , "2004-01-31 + -1 * year (roll over) = 2003-01-31"
-  , "2004-12-31 + -1 * year (roll over) = 2003-12-31"
-  , "2005-07-01 + -1 * year (roll over) = 2004-07-01"
-  , "2005-04-21 + -1 * year (roll over) = 2004-04-21"
-  , "2005-06-30 + -1 * year (roll over) = 2004-06-30"
-  , "2005-02-28 + 0 * year (roll over) = 2005-02-28"
-  , "2004-02-29 + 0 * year (roll over) = 2004-02-29"
-  , "2004-01-31 + 0 * year (roll over) = 2004-01-31"
-  , "2004-12-31 + 0 * year (roll over) = 2004-12-31"
-  , "2005-07-01 + 0 * year (roll over) = 2005-07-01"
-  , "2005-04-21 + 0 * year (roll over) = 2005-04-21"
-  , "2005-06-30 + 0 * year (roll over) = 2005-06-30"
-  , "2005-02-28 + 1 * year (roll over) = 2006-02-28"
-  , "2004-02-29 + 1 * year (roll over) = 2005-03-01"
-  , "2004-01-31 + 1 * year (roll over) = 2005-01-31"
-  , "2004-12-31 + 1 * year (roll over) = 2005-12-31"
-  , "2005-07-01 + 1 * year (roll over) = 2006-07-01"
-  , "2005-04-21 + 1 * year (roll over) = 2006-04-21"
-  , "2005-06-30 + 1 * year (roll over) = 2006-06-30"
-  , "2005-02-28 + 7 * year (roll over) = 2012-02-28"
-  , "2004-02-29 + 7 * year (roll over) = 2011-03-01"
-  , "2004-01-31 + 7 * year (roll over) = 2011-01-31"
-  , "2004-12-31 + 7 * year (roll over) = 2011-12-31"
-  , "2005-07-01 + 7 * year (roll over) = 2012-07-01"
-  , "2005-04-21 + 7 * year (roll over) = 2012-04-21"
-  , "2005-06-30 + 7 * year (roll over) = 2012-06-30"
-  , "2005-02-28 + 83 * year (roll over) = 2088-02-28"
-  , "2004-02-29 + 83 * year (roll over) = 2087-03-01"
-  , "2004-01-31 + 83 * year (roll over) = 2087-01-31"
-  , "2004-12-31 + 83 * year (roll over) = 2087-12-31"
-  , "2005-07-01 + 83 * year (roll over) = 2088-07-01"
-  , "2005-04-21 + 83 * year (roll over) = 2088-04-21"
-  , "2005-06-30 + 83 * year (roll over) = 2088-06-30" ]
+    unlines
+        [ "2005-02-28 + -10 * day = 2005-02-18"
+        , "2004-02-29 + -10 * day = 2004-02-19"
+        , "2004-01-31 + -10 * day = 2004-01-21"
+        , "2004-12-31 + -10 * day = 2004-12-21"
+        , "2005-07-01 + -10 * day = 2005-06-21"
+        , "2005-04-21 + -10 * day = 2005-04-11"
+        , "2005-06-30 + -10 * day = 2005-06-20"
+        , "2005-02-28 + -4 * day = 2005-02-24"
+        , "2004-02-29 + -4 * day = 2004-02-25"
+        , "2004-01-31 + -4 * day = 2004-01-27"
+        , "2004-12-31 + -4 * day = 2004-12-27"
+        , "2005-07-01 + -4 * day = 2005-06-27"
+        , "2005-04-21 + -4 * day = 2005-04-17"
+        , "2005-06-30 + -4 * day = 2005-06-26"
+        , "2005-02-28 + -1 * day = 2005-02-27"
+        , "2004-02-29 + -1 * day = 2004-02-28"
+        , "2004-01-31 + -1 * day = 2004-01-30"
+        , "2004-12-31 + -1 * day = 2004-12-30"
+        , "2005-07-01 + -1 * day = 2005-06-30"
+        , "2005-04-21 + -1 * day = 2005-04-20"
+        , "2005-06-30 + -1 * day = 2005-06-29"
+        , "2005-02-28 + 0 * day = 2005-02-28"
+        , "2004-02-29 + 0 * day = 2004-02-29"
+        , "2004-01-31 + 0 * day = 2004-01-31"
+        , "2004-12-31 + 0 * day = 2004-12-31"
+        , "2005-07-01 + 0 * day = 2005-07-01"
+        , "2005-04-21 + 0 * day = 2005-04-21"
+        , "2005-06-30 + 0 * day = 2005-06-30"
+        , "2005-02-28 + 1 * day = 2005-03-01"
+        , "2004-02-29 + 1 * day = 2004-03-01"
+        , "2004-01-31 + 1 * day = 2004-02-01"
+        , "2004-12-31 + 1 * day = 2005-01-01"
+        , "2005-07-01 + 1 * day = 2005-07-02"
+        , "2005-04-21 + 1 * day = 2005-04-22"
+        , "2005-06-30 + 1 * day = 2005-07-01"
+        , "2005-02-28 + 7 * day = 2005-03-07"
+        , "2004-02-29 + 7 * day = 2004-03-07"
+        , "2004-01-31 + 7 * day = 2004-02-07"
+        , "2004-12-31 + 7 * day = 2005-01-07"
+        , "2005-07-01 + 7 * day = 2005-07-08"
+        , "2005-04-21 + 7 * day = 2005-04-28"
+        , "2005-06-30 + 7 * day = 2005-07-07"
+        , "2005-02-28 + 83 * day = 2005-05-22"
+        , "2004-02-29 + 83 * day = 2004-05-22"
+        , "2004-01-31 + 83 * day = 2004-04-23"
+        , "2004-12-31 + 83 * day = 2005-03-24"
+        , "2005-07-01 + 83 * day = 2005-09-22"
+        , "2005-04-21 + 83 * day = 2005-07-13"
+        , "2005-06-30 + 83 * day = 2005-09-21"
+        , "2005-02-28 + -10 * month (clip) = 2004-04-28"
+        , "2004-02-29 + -10 * month (clip) = 2003-04-29"
+        , "2004-01-31 + -10 * month (clip) = 2003-03-31"
+        , "2004-12-31 + -10 * month (clip) = 2004-02-29"
+        , "2005-07-01 + -10 * month (clip) = 2004-09-01"
+        , "2005-04-21 + -10 * month (clip) = 2004-06-21"
+        , "2005-06-30 + -10 * month (clip) = 2004-08-30"
+        , "2005-02-28 + -4 * month (clip) = 2004-10-28"
+        , "2004-02-29 + -4 * month (clip) = 2003-10-29"
+        , "2004-01-31 + -4 * month (clip) = 2003-09-30"
+        , "2004-12-31 + -4 * month (clip) = 2004-08-31"
+        , "2005-07-01 + -4 * month (clip) = 2005-03-01"
+        , "2005-04-21 + -4 * month (clip) = 2004-12-21"
+        , "2005-06-30 + -4 * month (clip) = 2005-02-28"
+        , "2005-02-28 + -1 * month (clip) = 2005-01-28"
+        , "2004-02-29 + -1 * month (clip) = 2004-01-29"
+        , "2004-01-31 + -1 * month (clip) = 2003-12-31"
+        , "2004-12-31 + -1 * month (clip) = 2004-11-30"
+        , "2005-07-01 + -1 * month (clip) = 2005-06-01"
+        , "2005-04-21 + -1 * month (clip) = 2005-03-21"
+        , "2005-06-30 + -1 * month (clip) = 2005-05-30"
+        , "2005-02-28 + 0 * month (clip) = 2005-02-28"
+        , "2004-02-29 + 0 * month (clip) = 2004-02-29"
+        , "2004-01-31 + 0 * month (clip) = 2004-01-31"
+        , "2004-12-31 + 0 * month (clip) = 2004-12-31"
+        , "2005-07-01 + 0 * month (clip) = 2005-07-01"
+        , "2005-04-21 + 0 * month (clip) = 2005-04-21"
+        , "2005-06-30 + 0 * month (clip) = 2005-06-30"
+        , "2005-02-28 + 1 * month (clip) = 2005-03-28"
+        , "2004-02-29 + 1 * month (clip) = 2004-03-29"
+        , "2004-01-31 + 1 * month (clip) = 2004-02-29"
+        , "2004-12-31 + 1 * month (clip) = 2005-01-31"
+        , "2005-07-01 + 1 * month (clip) = 2005-08-01"
+        , "2005-04-21 + 1 * month (clip) = 2005-05-21"
+        , "2005-06-30 + 1 * month (clip) = 2005-07-30"
+        , "2005-02-28 + 7 * month (clip) = 2005-09-28"
+        , "2004-02-29 + 7 * month (clip) = 2004-09-29"
+        , "2004-01-31 + 7 * month (clip) = 2004-08-31"
+        , "2004-12-31 + 7 * month (clip) = 2005-07-31"
+        , "2005-07-01 + 7 * month (clip) = 2006-02-01"
+        , "2005-04-21 + 7 * month (clip) = 2005-11-21"
+        , "2005-06-30 + 7 * month (clip) = 2006-01-30"
+        , "2005-02-28 + 83 * month (clip) = 2012-01-28"
+        , "2004-02-29 + 83 * month (clip) = 2011-01-29"
+        , "2004-01-31 + 83 * month (clip) = 2010-12-31"
+        , "2004-12-31 + 83 * month (clip) = 2011-11-30"
+        , "2005-07-01 + 83 * month (clip) = 2012-06-01"
+        , "2005-04-21 + 83 * month (clip) = 2012-03-21"
+        , "2005-06-30 + 83 * month (clip) = 2012-05-30"
+        , "2005-02-28 + -10 * month (roll over) = 2004-04-28"
+        , "2004-02-29 + -10 * month (roll over) = 2003-04-29"
+        , "2004-01-31 + -10 * month (roll over) = 2003-03-31"
+        , "2004-12-31 + -10 * month (roll over) = 2004-03-02"
+        , "2005-07-01 + -10 * month (roll over) = 2004-09-01"
+        , "2005-04-21 + -10 * month (roll over) = 2004-06-21"
+        , "2005-06-30 + -10 * month (roll over) = 2004-08-30"
+        , "2005-02-28 + -4 * month (roll over) = 2004-10-28"
+        , "2004-02-29 + -4 * month (roll over) = 2003-10-29"
+        , "2004-01-31 + -4 * month (roll over) = 2003-10-01"
+        , "2004-12-31 + -4 * month (roll over) = 2004-08-31"
+        , "2005-07-01 + -4 * month (roll over) = 2005-03-01"
+        , "2005-04-21 + -4 * month (roll over) = 2004-12-21"
+        , "2005-06-30 + -4 * month (roll over) = 2005-03-02"
+        , "2005-02-28 + -1 * month (roll over) = 2005-01-28"
+        , "2004-02-29 + -1 * month (roll over) = 2004-01-29"
+        , "2004-01-31 + -1 * month (roll over) = 2003-12-31"
+        , "2004-12-31 + -1 * month (roll over) = 2004-12-01"
+        , "2005-07-01 + -1 * month (roll over) = 2005-06-01"
+        , "2005-04-21 + -1 * month (roll over) = 2005-03-21"
+        , "2005-06-30 + -1 * month (roll over) = 2005-05-30"
+        , "2005-02-28 + 0 * month (roll over) = 2005-02-28"
+        , "2004-02-29 + 0 * month (roll over) = 2004-02-29"
+        , "2004-01-31 + 0 * month (roll over) = 2004-01-31"
+        , "2004-12-31 + 0 * month (roll over) = 2004-12-31"
+        , "2005-07-01 + 0 * month (roll over) = 2005-07-01"
+        , "2005-04-21 + 0 * month (roll over) = 2005-04-21"
+        , "2005-06-30 + 0 * month (roll over) = 2005-06-30"
+        , "2005-02-28 + 1 * month (roll over) = 2005-03-28"
+        , "2004-02-29 + 1 * month (roll over) = 2004-03-29"
+        , "2004-01-31 + 1 * month (roll over) = 2004-03-02"
+        , "2004-12-31 + 1 * month (roll over) = 2005-01-31"
+        , "2005-07-01 + 1 * month (roll over) = 2005-08-01"
+        , "2005-04-21 + 1 * month (roll over) = 2005-05-21"
+        , "2005-06-30 + 1 * month (roll over) = 2005-07-30"
+        , "2005-02-28 + 7 * month (roll over) = 2005-09-28"
+        , "2004-02-29 + 7 * month (roll over) = 2004-09-29"
+        , "2004-01-31 + 7 * month (roll over) = 2004-08-31"
+        , "2004-12-31 + 7 * month (roll over) = 2005-07-31"
+        , "2005-07-01 + 7 * month (roll over) = 2006-02-01"
+        , "2005-04-21 + 7 * month (roll over) = 2005-11-21"
+        , "2005-06-30 + 7 * month (roll over) = 2006-01-30"
+        , "2005-02-28 + 83 * month (roll over) = 2012-01-28"
+        , "2004-02-29 + 83 * month (roll over) = 2011-01-29"
+        , "2004-01-31 + 83 * month (roll over) = 2010-12-31"
+        , "2004-12-31 + 83 * month (roll over) = 2011-12-01"
+        , "2005-07-01 + 83 * month (roll over) = 2012-06-01"
+        , "2005-04-21 + 83 * month (roll over) = 2012-03-21"
+        , "2005-06-30 + 83 * month (roll over) = 2012-05-30"
+        , "2005-02-28 + -10 * year (clip) = 1995-02-28"
+        , "2004-02-29 + -10 * year (clip) = 1994-02-28"
+        , "2004-01-31 + -10 * year (clip) = 1994-01-31"
+        , "2004-12-31 + -10 * year (clip) = 1994-12-31"
+        , "2005-07-01 + -10 * year (clip) = 1995-07-01"
+        , "2005-04-21 + -10 * year (clip) = 1995-04-21"
+        , "2005-06-30 + -10 * year (clip) = 1995-06-30"
+        , "2005-02-28 + -4 * year (clip) = 2001-02-28"
+        , "2004-02-29 + -4 * year (clip) = 2000-02-29"
+        , "2004-01-31 + -4 * year (clip) = 2000-01-31"
+        , "2004-12-31 + -4 * year (clip) = 2000-12-31"
+        , "2005-07-01 + -4 * year (clip) = 2001-07-01"
+        , "2005-04-21 + -4 * year (clip) = 2001-04-21"
+        , "2005-06-30 + -4 * year (clip) = 2001-06-30"
+        , "2005-02-28 + -1 * year (clip) = 2004-02-28"
+        , "2004-02-29 + -1 * year (clip) = 2003-02-28"
+        , "2004-01-31 + -1 * year (clip) = 2003-01-31"
+        , "2004-12-31 + -1 * year (clip) = 2003-12-31"
+        , "2005-07-01 + -1 * year (clip) = 2004-07-01"
+        , "2005-04-21 + -1 * year (clip) = 2004-04-21"
+        , "2005-06-30 + -1 * year (clip) = 2004-06-30"
+        , "2005-02-28 + 0 * year (clip) = 2005-02-28"
+        , "2004-02-29 + 0 * year (clip) = 2004-02-29"
+        , "2004-01-31 + 0 * year (clip) = 2004-01-31"
+        , "2004-12-31 + 0 * year (clip) = 2004-12-31"
+        , "2005-07-01 + 0 * year (clip) = 2005-07-01"
+        , "2005-04-21 + 0 * year (clip) = 2005-04-21"
+        , "2005-06-30 + 0 * year (clip) = 2005-06-30"
+        , "2005-02-28 + 1 * year (clip) = 2006-02-28"
+        , "2004-02-29 + 1 * year (clip) = 2005-02-28"
+        , "2004-01-31 + 1 * year (clip) = 2005-01-31"
+        , "2004-12-31 + 1 * year (clip) = 2005-12-31"
+        , "2005-07-01 + 1 * year (clip) = 2006-07-01"
+        , "2005-04-21 + 1 * year (clip) = 2006-04-21"
+        , "2005-06-30 + 1 * year (clip) = 2006-06-30"
+        , "2005-02-28 + 7 * year (clip) = 2012-02-28"
+        , "2004-02-29 + 7 * year (clip) = 2011-02-28"
+        , "2004-01-31 + 7 * year (clip) = 2011-01-31"
+        , "2004-12-31 + 7 * year (clip) = 2011-12-31"
+        , "2005-07-01 + 7 * year (clip) = 2012-07-01"
+        , "2005-04-21 + 7 * year (clip) = 2012-04-21"
+        , "2005-06-30 + 7 * year (clip) = 2012-06-30"
+        , "2005-02-28 + 83 * year (clip) = 2088-02-28"
+        , "2004-02-29 + 83 * year (clip) = 2087-02-28"
+        , "2004-01-31 + 83 * year (clip) = 2087-01-31"
+        , "2004-12-31 + 83 * year (clip) = 2087-12-31"
+        , "2005-07-01 + 83 * year (clip) = 2088-07-01"
+        , "2005-04-21 + 83 * year (clip) = 2088-04-21"
+        , "2005-06-30 + 83 * year (clip) = 2088-06-30"
+        , "2005-02-28 + -10 * year (roll over) = 1995-02-28"
+        , "2004-02-29 + -10 * year (roll over) = 1994-03-01"
+        , "2004-01-31 + -10 * year (roll over) = 1994-01-31"
+        , "2004-12-31 + -10 * year (roll over) = 1994-12-31"
+        , "2005-07-01 + -10 * year (roll over) = 1995-07-01"
+        , "2005-04-21 + -10 * year (roll over) = 1995-04-21"
+        , "2005-06-30 + -10 * year (roll over) = 1995-06-30"
+        , "2005-02-28 + -4 * year (roll over) = 2001-02-28"
+        , "2004-02-29 + -4 * year (roll over) = 2000-02-29"
+        , "2004-01-31 + -4 * year (roll over) = 2000-01-31"
+        , "2004-12-31 + -4 * year (roll over) = 2000-12-31"
+        , "2005-07-01 + -4 * year (roll over) = 2001-07-01"
+        , "2005-04-21 + -4 * year (roll over) = 2001-04-21"
+        , "2005-06-30 + -4 * year (roll over) = 2001-06-30"
+        , "2005-02-28 + -1 * year (roll over) = 2004-02-28"
+        , "2004-02-29 + -1 * year (roll over) = 2003-03-01"
+        , "2004-01-31 + -1 * year (roll over) = 2003-01-31"
+        , "2004-12-31 + -1 * year (roll over) = 2003-12-31"
+        , "2005-07-01 + -1 * year (roll over) = 2004-07-01"
+        , "2005-04-21 + -1 * year (roll over) = 2004-04-21"
+        , "2005-06-30 + -1 * year (roll over) = 2004-06-30"
+        , "2005-02-28 + 0 * year (roll over) = 2005-02-28"
+        , "2004-02-29 + 0 * year (roll over) = 2004-02-29"
+        , "2004-01-31 + 0 * year (roll over) = 2004-01-31"
+        , "2004-12-31 + 0 * year (roll over) = 2004-12-31"
+        , "2005-07-01 + 0 * year (roll over) = 2005-07-01"
+        , "2005-04-21 + 0 * year (roll over) = 2005-04-21"
+        , "2005-06-30 + 0 * year (roll over) = 2005-06-30"
+        , "2005-02-28 + 1 * year (roll over) = 2006-02-28"
+        , "2004-02-29 + 1 * year (roll over) = 2005-03-01"
+        , "2004-01-31 + 1 * year (roll over) = 2005-01-31"
+        , "2004-12-31 + 1 * year (roll over) = 2005-12-31"
+        , "2005-07-01 + 1 * year (roll over) = 2006-07-01"
+        , "2005-04-21 + 1 * year (roll over) = 2006-04-21"
+        , "2005-06-30 + 1 * year (roll over) = 2006-06-30"
+        , "2005-02-28 + 7 * year (roll over) = 2012-02-28"
+        , "2004-02-29 + 7 * year (roll over) = 2011-03-01"
+        , "2004-01-31 + 7 * year (roll over) = 2011-01-31"
+        , "2004-12-31 + 7 * year (roll over) = 2011-12-31"
+        , "2005-07-01 + 7 * year (roll over) = 2012-07-01"
+        , "2005-04-21 + 7 * year (roll over) = 2012-04-21"
+        , "2005-06-30 + 7 * year (roll over) = 2012-06-30"
+        , "2005-02-28 + 83 * year (roll over) = 2088-02-28"
+        , "2004-02-29 + 83 * year (roll over) = 2087-03-01"
+        , "2004-01-31 + 83 * year (roll over) = 2087-01-31"
+        , "2004-12-31 + 83 * year (roll over) = 2087-12-31"
+        , "2005-07-01 + 83 * year (roll over) = 2088-07-01"
+        , "2005-04-21 + 83 * year (roll over) = 2088-04-21"
+        , "2005-06-30 + 83 * year (roll over) = 2088-06-30"
+        ]
index 0854778..e8ae3d5 100644 (file)
@@ -1,31 +1,26 @@
-module Test.Calendar.Calendars(testCalendars) where
+module Test.Calendar.Calendars
+    ( testCalendars
+    ) where
 
+import Data.Time.Calendar
 import Data.Time.Calendar.Julian
 import Data.Time.Calendar.WeekDate
-import Data.Time.Calendar
+import Test.Calendar.CalendarsRef
 import Test.Tasty
 import Test.Tasty.HUnit
-import Test.Calendar.CalendarsRef
 
-showers :: [(String,Day -> String)]
-showers = [
-    ("MJD",show . toModifiedJulianDay),
-    ("Gregorian",showGregorian),
-    ("Julian",showJulian),
-    ("ISO 8601",showWeekDate)
+showers :: [(String, Day -> String)]
+showers =
+    [ ("MJD", show . toModifiedJulianDay)
+    , ("Gregorian", showGregorian)
+    , ("Julian", showJulian)
+    , ("ISO 8601", showWeekDate)
     ]
 
 days :: [Day]
-days = [
-    fromGregorian 0 12 31,
-    fromJulian 1752 9 2,
-    fromGregorian 1752 9 14,
-    fromGregorian 2005 1 23
-    ]
+days = [fromGregorian 0 12 31, fromJulian 1752 9 2, fromGregorian 1752 9 14, fromGregorian 2005 1 23]
 
 testCalendars :: TestTree
-testCalendars = testCase "testCalendars" $
-    assertEqual "" testCalendarsRef $ unlines $ map (\d -> showShowers d) days
+testCalendars = testCase "testCalendars" $ assertEqual "" testCalendarsRef $ unlines $ map (\d -> showShowers d) days
   where
-    showShowers day =
-        concatMap (\(nm,shower) -> unwords [" ==", nm, shower day]) showers
+    showShowers day = concatMap (\(nm, shower) -> unwords [" ==", nm, shower day]) showers
index d7b7fea..ae55b67 100644 (file)
@@ -2,8 +2,9 @@ module Test.Calendar.CalendarsRef where
 
 testCalendarsRef :: String
 testCalendarsRef =
- unlines
-  [ " == MJD -678576 == Gregorian 0000-12-31 == Julian 0001-01-02 == ISO 8601 0000-W52-7"
-  , " == MJD -38780 == Gregorian 1752-09-13 == Julian 1752-09-02 == ISO 8601 1752-W37-3"
-  , " == MJD -38779 == Gregorian 1752-09-14 == Julian 1752-09-03 == ISO 8601 1752-W37-4"
-  , " == MJD 53393 == Gregorian 2005-01-23 == Julian 2005-01-10 == ISO 8601 2005-W03-7" ]
+    unlines
+        [ " == MJD -678576 == Gregorian 0000-12-31 == Julian 0001-01-02 == ISO 8601 0000-W52-7"
+        , " == MJD -38780 == Gregorian 1752-09-13 == Julian 1752-09-02 == ISO 8601 1752-W37-3"
+        , " == MJD -38779 == Gregorian 1752-09-14 == Julian 1752-09-03 == ISO 8601 1752-W37-4"
+        , " == MJD 53393 == Gregorian 2005-01-23 == Julian 2005-01-10 == ISO 8601 2005-W03-7"
+        ]
index 246c437..1b32110 100644 (file)
@@ -1,45 +1,43 @@
-module Test.Calendar.ClipDates(clipDates) where
+module Test.Calendar.ClipDates
+    ( clipDates
+    ) where
 
+import Data.Time.Calendar
 import Data.Time.Calendar.OrdinalDate
 import Data.Time.Calendar.WeekDate
-import Data.Time.Calendar
+import Test.Calendar.ClipDatesRef
 import Test.Tasty
 import Test.Tasty.HUnit
-import Test.Calendar.ClipDatesRef
 
-yearAndDay :: (Integer,Int) -> String
-yearAndDay (y,d) = (show y) ++ "-" ++ (show d) ++ " = " ++ (showOrdinalDate (fromOrdinalDate y d))
+yearAndDay :: (Integer, Int) -> String
+yearAndDay (y, d) = (show y) ++ "-" ++ (show d) ++ " = " ++ (showOrdinalDate (fromOrdinalDate y d))
 
-gregorian :: (Integer,Int,Int) -> String
-gregorian (y,m,d) = (show y) ++ "-" ++ (show m) ++ "-" ++ (show d) ++ " = " ++ (showGregorian (fromGregorian y m d))
+gregorian :: (Integer, Int, Int) -> String
+gregorian (y, m, d) = (show y) ++ "-" ++ (show m) ++ "-" ++ (show d) ++ " = " ++ (showGregorian (fromGregorian y m d))
 
-iSOWeekDay :: (Integer,Int,Int) -> String
-iSOWeekDay (y,w,d) = (show y) ++ "-W" ++ (show w) ++ "-" ++ (show d) ++ " = " ++ (showWeekDate (fromWeekDate y w d))
+iSOWeekDay :: (Integer, Int, Int) -> String
+iSOWeekDay (y, w, d) = (show y) ++ "-W" ++ (show w) ++ "-" ++ (show d) ++ " = " ++ (showWeekDate (fromWeekDate y w d))
 
 --
-
 tupleUp2 :: [a] -> [b] -> [(a, b)]
-tupleUp2 l1 l2 = concatMap (\e -> map (e,) l2) l1
+tupleUp2 l1 l2 = concatMap (\e -> map (e, ) l2) l1
 
 tupleUp3 :: [a] -> [b] -> [c] -> [(a, b, c)]
-tupleUp3 l1 l2 l3
-  = let ts = tupleUp2 l2 l3
+tupleUp3 l1 l2 l3 = let
+    ts = tupleUp2 l2 l3
     in concatMap (\e -> map (\(f, g) -> (e, f, g)) ts) l1
 
 --
-
 clipDates :: TestTree
-clipDates = testCase "clipDates" $
-    let
-        yad  = unlines $ map yearAndDay $
-            tupleUp2 [1968,1969,1971] [-4,0,1,200,364,365,366,367,700]
-
-
-        greg = unlines $ map gregorian $
-            tupleUp3 [1968,1969,1971] [-20,-1,0,1,2,12,13,17] [-7,-1,0,1,2,27,28,29,30,31,32,40]
-
-        iso  = unlines $ map iSOWeekDay $
-            tupleUp3 [1968,1969,2004] [-20,-1,0,1,20,51,52,53,54] [-2,-1,0,1,4,6,7,8,9]
-
-    in assertEqual "" clipDatesRef $
-        concat [ "YearAndDay\n", yad, "Gregorian\n", greg, "ISOWeekDay\n", iso ]
+clipDates =
+    testCase "clipDates" $ let
+        yad = unlines $ map yearAndDay $ tupleUp2 [1968, 1969, 1971] [-4, 0, 1, 200, 364, 365, 366, 367, 700]
+        greg =
+            unlines $
+            map gregorian $
+            tupleUp3 [1968, 1969, 1971] [-20, -1, 0, 1, 2, 12, 13, 17] [-7, -1, 0, 1, 2, 27, 28, 29, 30, 31, 32, 40]
+        iso =
+            unlines $
+            map iSOWeekDay $
+            tupleUp3 [1968, 1969, 2004] [-20, -1, 0, 1, 20, 51, 52, 53, 54] [-2, -1, 0, 1, 4, 6, 7, 8, 9]
+        in assertEqual "" clipDatesRef $ concat ["YearAndDay\n", yad, "Gregorian\n", greg, "ISOWeekDay\n", iso]
index 3079d83..63f8ef7 100644 (file)
@@ -2,565 +2,566 @@ module Test.Calendar.ClipDatesRef where
 
 clipDatesRef :: String
 clipDatesRef =
- unlines
-  [ "YearAndDay"
-  , "1968--4 = 1968-001"
-  , "1968-0 = 1968-001"
-  , "1968-1 = 1968-001"
-  , "1968-200 = 1968-200"
-  , "1968-364 = 1968-364"
-  , "1968-365 = 1968-365"
-  , "1968-366 = 1968-366"
-  , "1968-367 = 1968-366"
-  , "1968-700 = 1968-366"
-  , "1969--4 = 1969-001"
-  , "1969-0 = 1969-001"
-  , "1969-1 = 1969-001"
-  , "1969-200 = 1969-200"
-  , "1969-364 = 1969-364"
-  , "1969-365 = 1969-365"
-  , "1969-366 = 1969-365"
-  , "1969-367 = 1969-365"
-  , "1969-700 = 1969-365"
-  , "1971--4 = 1971-001"
-  , "1971-0 = 1971-001"
-  , "1971-1 = 1971-001"
-  , "1971-200 = 1971-200"
-  , "1971-364 = 1971-364"
-  , "1971-365 = 1971-365"
-  , "1971-366 = 1971-365"
-  , "1971-367 = 1971-365"
-  , "1971-700 = 1971-365"
-  , "Gregorian"
-  , "1968--20--7 = 1968-01-01"
-  , "1968--20--1 = 1968-01-01"
-  , "1968--20-0 = 1968-01-01"
-  , "1968--20-1 = 1968-01-01"
-  , "1968--20-2 = 1968-01-02"
-  , "1968--20-27 = 1968-01-27"
-  , "1968--20-28 = 1968-01-28"
-  , "1968--20-29 = 1968-01-29"
-  , "1968--20-30 = 1968-01-30"
-  , "1968--20-31 = 1968-01-31"
-  , "1968--20-32 = 1968-01-31"
-  , "1968--20-40 = 1968-01-31"
-  , "1968--1--7 = 1968-01-01"
-  , "1968--1--1 = 1968-01-01"
-  , "1968--1-0 = 1968-01-01"
-  , "1968--1-1 = 1968-01-01"
-  , "1968--1-2 = 1968-01-02"
-  , "1968--1-27 = 1968-01-27"
-  , "1968--1-28 = 1968-01-28"
-  , "1968--1-29 = 1968-01-29"
-  , "1968--1-30 = 1968-01-30"
-  , "1968--1-31 = 1968-01-31"
-  , "1968--1-32 = 1968-01-31"
-  , "1968--1-40 = 1968-01-31"
-  , "1968-0--7 = 1968-01-01"
-  , "1968-0--1 = 1968-01-01"
-  , "1968-0-0 = 1968-01-01"
-  , "1968-0-1 = 1968-01-01"
-  , "1968-0-2 = 1968-01-02"
-  , "1968-0-27 = 1968-01-27"
-  , "1968-0-28 = 1968-01-28"
-  , "1968-0-29 = 1968-01-29"
-  , "1968-0-30 = 1968-01-30"
-  , "1968-0-31 = 1968-01-31"
-  , "1968-0-32 = 1968-01-31"
-  , "1968-0-40 = 1968-01-31"
-  , "1968-1--7 = 1968-01-01"
-  , "1968-1--1 = 1968-01-01"
-  , "1968-1-0 = 1968-01-01"
-  , "1968-1-1 = 1968-01-01"
-  , "1968-1-2 = 1968-01-02"
-  , "1968-1-27 = 1968-01-27"
-  , "1968-1-28 = 1968-01-28"
-  , "1968-1-29 = 1968-01-29"
-  , "1968-1-30 = 1968-01-30"
-  , "1968-1-31 = 1968-01-31"
-  , "1968-1-32 = 1968-01-31"
-  , "1968-1-40 = 1968-01-31"
-  , "1968-2--7 = 1968-02-01"
-  , "1968-2--1 = 1968-02-01"
-  , "1968-2-0 = 1968-02-01"
-  , "1968-2-1 = 1968-02-01"
-  , "1968-2-2 = 1968-02-02"
-  , "1968-2-27 = 1968-02-27"
-  , "1968-2-28 = 1968-02-28"
-  , "1968-2-29 = 1968-02-29"
-  , "1968-2-30 = 1968-02-29"
-  , "1968-2-31 = 1968-02-29"
-  , "1968-2-32 = 1968-02-29"
-  , "1968-2-40 = 1968-02-29"
-  , "1968-12--7 = 1968-12-01"
-  , "1968-12--1 = 1968-12-01"
-  , "1968-12-0 = 1968-12-01"
-  , "1968-12-1 = 1968-12-01"
-  , "1968-12-2 = 1968-12-02"
-  , "1968-12-27 = 1968-12-27"
-  , "1968-12-28 = 1968-12-28"
-  , "1968-12-29 = 1968-12-29"
-  , "1968-12-30 = 1968-12-30"
-  , "1968-12-31 = 1968-12-31"
-  , "1968-12-32 = 1968-12-31"
-  , "1968-12-40 = 1968-12-31"
-  , "1968-13--7 = 1968-12-01"
-  , "1968-13--1 = 1968-12-01"
-  , "1968-13-0 = 1968-12-01"
-  , "1968-13-1 = 1968-12-01"
-  , "1968-13-2 = 1968-12-02"
-  , "1968-13-27 = 1968-12-27"
-  , "1968-13-28 = 1968-12-28"
-  , "1968-13-29 = 1968-12-29"
-  , "1968-13-30 = 1968-12-30"
-  , "1968-13-31 = 1968-12-31"
-  , "1968-13-32 = 1968-12-31"
-  , "1968-13-40 = 1968-12-31"
-  , "1968-17--7 = 1968-12-01"
-  , "1968-17--1 = 1968-12-01"
-  , "1968-17-0 = 1968-12-01"
-  , "1968-17-1 = 1968-12-01"
-  , "1968-17-2 = 1968-12-02"
-  , "1968-17-27 = 1968-12-27"
-  , "1968-17-28 = 1968-12-28"
-  , "1968-17-29 = 1968-12-29"
-  , "1968-17-30 = 1968-12-30"
-  , "1968-17-31 = 1968-12-31"
-  , "1968-17-32 = 1968-12-31"
-  , "1968-17-40 = 1968-12-31"
-  , "1969--20--7 = 1969-01-01"
-  , "1969--20--1 = 1969-01-01"
-  , "1969--20-0 = 1969-01-01"
-  , "1969--20-1 = 1969-01-01"
-  , "1969--20-2 = 1969-01-02"
-  , "1969--20-27 = 1969-01-27"
-  , "1969--20-28 = 1969-01-28"
-  , "1969--20-29 = 1969-01-29"
-  , "1969--20-30 = 1969-01-30"
-  , "1969--20-31 = 1969-01-31"
-  , "1969--20-32 = 1969-01-31"
-  , "1969--20-40 = 1969-01-31"
-  , "1969--1--7 = 1969-01-01"
-  , "1969--1--1 = 1969-01-01"
-  , "1969--1-0 = 1969-01-01"
-  , "1969--1-1 = 1969-01-01"
-  , "1969--1-2 = 1969-01-02"
-  , "1969--1-27 = 1969-01-27"
-  , "1969--1-28 = 1969-01-28"
-  , "1969--1-29 = 1969-01-29"
-  , "1969--1-30 = 1969-01-30"
-  , "1969--1-31 = 1969-01-31"
-  , "1969--1-32 = 1969-01-31"
-  , "1969--1-40 = 1969-01-31"
-  , "1969-0--7 = 1969-01-01"
-  , "1969-0--1 = 1969-01-01"
-  , "1969-0-0 = 1969-01-01"
-  , "1969-0-1 = 1969-01-01"
-  , "1969-0-2 = 1969-01-02"
-  , "1969-0-27 = 1969-01-27"
-  , "1969-0-28 = 1969-01-28"
-  , "1969-0-29 = 1969-01-29"
-  , "1969-0-30 = 1969-01-30"
-  , "1969-0-31 = 1969-01-31"
-  , "1969-0-32 = 1969-01-31"
-  , "1969-0-40 = 1969-01-31"
-  , "1969-1--7 = 1969-01-01"
-  , "1969-1--1 = 1969-01-01"
-  , "1969-1-0 = 1969-01-01"
-  , "1969-1-1 = 1969-01-01"
-  , "1969-1-2 = 1969-01-02"
-  , "1969-1-27 = 1969-01-27"
-  , "1969-1-28 = 1969-01-28"
-  , "1969-1-29 = 1969-01-29"
-  , "1969-1-30 = 1969-01-30"
-  , "1969-1-31 = 1969-01-31"
-  , "1969-1-32 = 1969-01-31"
-  , "1969-1-40 = 1969-01-31"
-  , "1969-2--7 = 1969-02-01"
-  , "1969-2--1 = 1969-02-01"
-  , "1969-2-0 = 1969-02-01"
-  , "1969-2-1 = 1969-02-01"
-  , "1969-2-2 = 1969-02-02"
-  , "1969-2-27 = 1969-02-27"
-  , "1969-2-28 = 1969-02-28"
-  , "1969-2-29 = 1969-02-28"
-  , "1969-2-30 = 1969-02-28"
-  , "1969-2-31 = 1969-02-28"
-  , "1969-2-32 = 1969-02-28"
-  , "1969-2-40 = 1969-02-28"
-  , "1969-12--7 = 1969-12-01"
-  , "1969-12--1 = 1969-12-01"
-  , "1969-12-0 = 1969-12-01"
-  , "1969-12-1 = 1969-12-01"
-  , "1969-12-2 = 1969-12-02"
-  , "1969-12-27 = 1969-12-27"
-  , "1969-12-28 = 1969-12-28"
-  , "1969-12-29 = 1969-12-29"
-  , "1969-12-30 = 1969-12-30"
-  , "1969-12-31 = 1969-12-31"
-  , "1969-12-32 = 1969-12-31"
-  , "1969-12-40 = 1969-12-31"
-  , "1969-13--7 = 1969-12-01"
-  , "1969-13--1 = 1969-12-01"
-  , "1969-13-0 = 1969-12-01"
-  , "1969-13-1 = 1969-12-01"
-  , "1969-13-2 = 1969-12-02"
-  , "1969-13-27 = 1969-12-27"
-  , "1969-13-28 = 1969-12-28"
-  , "1969-13-29 = 1969-12-29"
-  , "1969-13-30 = 1969-12-30"
-  , "1969-13-31 = 1969-12-31"
-  , "1969-13-32 = 1969-12-31"
-  , "1969-13-40 = 1969-12-31"
-  , "1969-17--7 = 1969-12-01"
-  , "1969-17--1 = 1969-12-01"
-  , "1969-17-0 = 1969-12-01"
-  , "1969-17-1 = 1969-12-01"
-  , "1969-17-2 = 1969-12-02"
-  , "1969-17-27 = 1969-12-27"
-  , "1969-17-28 = 1969-12-28"
-  , "1969-17-29 = 1969-12-29"
-  , "1969-17-30 = 1969-12-30"
-  , "1969-17-31 = 1969-12-31"
-  , "1969-17-32 = 1969-12-31"
-  , "1969-17-40 = 1969-12-31"
-  , "1971--20--7 = 1971-01-01"
-  , "1971--20--1 = 1971-01-01"
-  , "1971--20-0 = 1971-01-01"
-  , "1971--20-1 = 1971-01-01"
-  , "1971--20-2 = 1971-01-02"
-  , "1971--20-27 = 1971-01-27"
-  , "1971--20-28 = 1971-01-28"
-  , "1971--20-29 = 1971-01-29"
-  , "1971--20-30 = 1971-01-30"
-  , "1971--20-31 = 1971-01-31"
-  , "1971--20-32 = 1971-01-31"
-  , "1971--20-40 = 1971-01-31"
-  , "1971--1--7 = 1971-01-01"
-  , "1971--1--1 = 1971-01-01"
-  , "1971--1-0 = 1971-01-01"
-  , "1971--1-1 = 1971-01-01"
-  , "1971--1-2 = 1971-01-02"
-  , "1971--1-27 = 1971-01-27"
-  , "1971--1-28 = 1971-01-28"
-  , "1971--1-29 = 1971-01-29"
-  , "1971--1-30 = 1971-01-30"
-  , "1971--1-31 = 1971-01-31"
-  , "1971--1-32 = 1971-01-31"
-  , "1971--1-40 = 1971-01-31"
-  , "1971-0--7 = 1971-01-01"
-  , "1971-0--1 = 1971-01-01"
-  , "1971-0-0 = 1971-01-01"
-  , "1971-0-1 = 1971-01-01"
-  , "1971-0-2 = 1971-01-02"
-  , "1971-0-27 = 1971-01-27"
-  , "1971-0-28 = 1971-01-28"
-  , "1971-0-29 = 1971-01-29"
-  , "1971-0-30 = 1971-01-30"
-  , "1971-0-31 = 1971-01-31"
-  , "1971-0-32 = 1971-01-31"
-  , "1971-0-40 = 1971-01-31"
-  , "1971-1--7 = 1971-01-01"
-  , "1971-1--1 = 1971-01-01"
-  , "1971-1-0 = 1971-01-01"
-  , "1971-1-1 = 1971-01-01"
-  , "1971-1-2 = 1971-01-02"
-  , "1971-1-27 = 1971-01-27"
-  , "1971-1-28 = 1971-01-28"
-  , "1971-1-29 = 1971-01-29"
-  , "1971-1-30 = 1971-01-30"
-  , "1971-1-31 = 1971-01-31"
-  , "1971-1-32 = 1971-01-31"
-  , "1971-1-40 = 1971-01-31"
-  , "1971-2--7 = 1971-02-01"
-  , "1971-2--1 = 1971-02-01"
-  , "1971-2-0 = 1971-02-01"
-  , "1971-2-1 = 1971-02-01"
-  , "1971-2-2 = 1971-02-02"
-  , "1971-2-27 = 1971-02-27"
-  , "1971-2-28 = 1971-02-28"
-  , "1971-2-29 = 1971-02-28"
-  , "1971-2-30 = 1971-02-28"
-  , "1971-2-31 = 1971-02-28"
-  , "1971-2-32 = 1971-02-28"
-  , "1971-2-40 = 1971-02-28"
-  , "1971-12--7 = 1971-12-01"
-  , "1971-12--1 = 1971-12-01"
-  , "1971-12-0 = 1971-12-01"
-  , "1971-12-1 = 1971-12-01"
-  , "1971-12-2 = 1971-12-02"
-  , "1971-12-27 = 1971-12-27"
-  , "1971-12-28 = 1971-12-28"
-  , "1971-12-29 = 1971-12-29"
-  , "1971-12-30 = 1971-12-30"
-  , "1971-12-31 = 1971-12-31"
-  , "1971-12-32 = 1971-12-31"
-  , "1971-12-40 = 1971-12-31"
-  , "1971-13--7 = 1971-12-01"
-  , "1971-13--1 = 1971-12-01"
-  , "1971-13-0 = 1971-12-01"
-  , "1971-13-1 = 1971-12-01"
-  , "1971-13-2 = 1971-12-02"
-  , "1971-13-27 = 1971-12-27"
-  , "1971-13-28 = 1971-12-28"
-  , "1971-13-29 = 1971-12-29"
-  , "1971-13-30 = 1971-12-30"
-  , "1971-13-31 = 1971-12-31"
-  , "1971-13-32 = 1971-12-31"
-  , "1971-13-40 = 1971-12-31"
-  , "1971-17--7 = 1971-12-01"
-  , "1971-17--1 = 1971-12-01"
-  , "1971-17-0 = 1971-12-01"
-  , "1971-17-1 = 1971-12-01"
-  , "1971-17-2 = 1971-12-02"
-  , "1971-17-27 = 1971-12-27"
-  , "1971-17-28 = 1971-12-28"
-  , "1971-17-29 = 1971-12-29"
-  , "1971-17-30 = 1971-12-30"
-  , "1971-17-31 = 1971-12-31"
-  , "1971-17-32 = 1971-12-31"
-  , "1971-17-40 = 1971-12-31"
-  , "ISOWeekDay"
-  , "1968-W-20--2 = 1968-W01-1"
-  , "1968-W-20--1 = 1968-W01-1"
-  , "1968-W-20-0 = 1968-W01-1"
-  , "1968-W-20-1 = 1968-W01-1"
-  , "1968-W-20-4 = 1968-W01-4"
-  , "1968-W-20-6 = 1968-W01-6"
-  , "1968-W-20-7 = 1968-W01-7"
-  , "1968-W-20-8 = 1968-W01-7"
-  , "1968-W-20-9 = 1968-W01-7"
-  , "1968-W-1--2 = 1968-W01-1"
-  , "1968-W-1--1 = 1968-W01-1"
-  , "1968-W-1-0 = 1968-W01-1"
-  , "1968-W-1-1 = 1968-W01-1"
-  , "1968-W-1-4 = 1968-W01-4"
-  , "1968-W-1-6 = 1968-W01-6"
-  , "1968-W-1-7 = 1968-W01-7"
-  , "1968-W-1-8 = 1968-W01-7"
-  , "1968-W-1-9 = 1968-W01-7"
-  , "1968-W0--2 = 1968-W01-1"
-  , "1968-W0--1 = 1968-W01-1"
-  , "1968-W0-0 = 1968-W01-1"
-  , "1968-W0-1 = 1968-W01-1"
-  , "1968-W0-4 = 1968-W01-4"
-  , "1968-W0-6 = 1968-W01-6"
-  , "1968-W0-7 = 1968-W01-7"
-  , "1968-W0-8 = 1968-W01-7"
-  , "1968-W0-9 = 1968-W01-7"
-  , "1968-W1--2 = 1968-W01-1"
-  , "1968-W1--1 = 1968-W01-1"
-  , "1968-W1-0 = 1968-W01-1"
-  , "1968-W1-1 = 1968-W01-1"
-  , "1968-W1-4 = 1968-W01-4"
-  , "1968-W1-6 = 1968-W01-6"
-  , "1968-W1-7 = 1968-W01-7"
-  , "1968-W1-8 = 1968-W01-7"
-  , "1968-W1-9 = 1968-W01-7"
-  , "1968-W20--2 = 1968-W20-1"
-  , "1968-W20--1 = 1968-W20-1"
-  , "1968-W20-0 = 1968-W20-1"
-  , "1968-W20-1 = 1968-W20-1"
-  , "1968-W20-4 = 1968-W20-4"
-  , "1968-W20-6 = 1968-W20-6"
-  , "1968-W20-7 = 1968-W20-7"
-  , "1968-W20-8 = 1968-W20-7"
-  , "1968-W20-9 = 1968-W20-7"
-  , "1968-W51--2 = 1968-W51-1"
-  , "1968-W51--1 = 1968-W51-1"
-  , "1968-W51-0 = 1968-W51-1"
-  , "1968-W51-1 = 1968-W51-1"
-  , "1968-W51-4 = 1968-W51-4"
-  , "1968-W51-6 = 1968-W51-6"
-  , "1968-W51-7 = 1968-W51-7"
-  , "1968-W51-8 = 1968-W51-7"
-  , "1968-W51-9 = 1968-W51-7"
-  , "1968-W52--2 = 1968-W52-1"
-  , "1968-W52--1 = 1968-W52-1"
-  , "1968-W52-0 = 1968-W52-1"
-  , "1968-W52-1 = 1968-W52-1"
-  , "1968-W52-4 = 1968-W52-4"
-  , "1968-W52-6 = 1968-W52-6"
-  , "1968-W52-7 = 1968-W52-7"
-  , "1968-W52-8 = 1968-W52-7"
-  , "1968-W52-9 = 1968-W52-7"
-  , "1968-W53--2 = 1968-W52-1"
-  , "1968-W53--1 = 1968-W52-1"
-  , "1968-W53-0 = 1968-W52-1"
-  , "1968-W53-1 = 1968-W52-1"
-  , "1968-W53-4 = 1968-W52-4"
-  , "1968-W53-6 = 1968-W52-6"
-  , "1968-W53-7 = 1968-W52-7"
-  , "1968-W53-8 = 1968-W52-7"
-  , "1968-W53-9 = 1968-W52-7"
-  , "1968-W54--2 = 1968-W52-1"
-  , "1968-W54--1 = 1968-W52-1"
-  , "1968-W54-0 = 1968-W52-1"
-  , "1968-W54-1 = 1968-W52-1"
-  , "1968-W54-4 = 1968-W52-4"
-  , "1968-W54-6 = 1968-W52-6"
-  , "1968-W54-7 = 1968-W52-7"
-  , "1968-W54-8 = 1968-W52-7"
-  , "1968-W54-9 = 1968-W52-7"
-  , "1969-W-20--2 = 1969-W01-1"
-  , "1969-W-20--1 = 1969-W01-1"
-  , "1969-W-20-0 = 1969-W01-1"
-  , "1969-W-20-1 = 1969-W01-1"
-  , "1969-W-20-4 = 1969-W01-4"
-  , "1969-W-20-6 = 1969-W01-6"
-  , "1969-W-20-7 = 1969-W01-7"
-  , "1969-W-20-8 = 1969-W01-7"
-  , "1969-W-20-9 = 1969-W01-7"
-  , "1969-W-1--2 = 1969-W01-1"
-  , "1969-W-1--1 = 1969-W01-1"
-  , "1969-W-1-0 = 1969-W01-1"
-  , "1969-W-1-1 = 1969-W01-1"
-  , "1969-W-1-4 = 1969-W01-4"
-  , "1969-W-1-6 = 1969-W01-6"
-  , "1969-W-1-7 = 1969-W01-7"
-  , "1969-W-1-8 = 1969-W01-7"
-  , "1969-W-1-9 = 1969-W01-7"
-  , "1969-W0--2 = 1969-W01-1"
-  , "1969-W0--1 = 1969-W01-1"
-  , "1969-W0-0 = 1969-W01-1"
-  , "1969-W0-1 = 1969-W01-1"
-  , "1969-W0-4 = 1969-W01-4"
-  , "1969-W0-6 = 1969-W01-6"
-  , "1969-W0-7 = 1969-W01-7"
-  , "1969-W0-8 = 1969-W01-7"
-  , "1969-W0-9 = 1969-W01-7"
-  , "1969-W1--2 = 1969-W01-1"
-  , "1969-W1--1 = 1969-W01-1"
-  , "1969-W1-0 = 1969-W01-1"
-  , "1969-W1-1 = 1969-W01-1"
-  , "1969-W1-4 = 1969-W01-4"
-  , "1969-W1-6 = 1969-W01-6"
-  , "1969-W1-7 = 1969-W01-7"
-  , "1969-W1-8 = 1969-W01-7"
-  , "1969-W1-9 = 1969-W01-7"
-  , "1969-W20--2 = 1969-W20-1"
-  , "1969-W20--1 = 1969-W20-1"
-  , "1969-W20-0 = 1969-W20-1"
-  , "1969-W20-1 = 1969-W20-1"
-  , "1969-W20-4 = 1969-W20-4"
-  , "1969-W20-6 = 1969-W20-6"
-  , "1969-W20-7 = 1969-W20-7"
-  , "1969-W20-8 = 1969-W20-7"
-  , "1969-W20-9 = 1969-W20-7"
-  , "1969-W51--2 = 1969-W51-1"
-  , "1969-W51--1 = 1969-W51-1"
-  , "1969-W51-0 = 1969-W51-1"
-  , "1969-W51-1 = 1969-W51-1"
-  , "1969-W51-4 = 1969-W51-4"
-  , "1969-W51-6 = 1969-W51-6"
-  , "1969-W51-7 = 1969-W51-7"
-  , "1969-W51-8 = 1969-W51-7"
-  , "1969-W51-9 = 1969-W51-7"
-  , "1969-W52--2 = 1969-W52-1"
-  , "1969-W52--1 = 1969-W52-1"
-  , "1969-W52-0 = 1969-W52-1"
-  , "1969-W52-1 = 1969-W52-1"
-  , "1969-W52-4 = 1969-W52-4"
-  , "1969-W52-6 = 1969-W52-6"
-  , "1969-W52-7 = 1969-W52-7"
-  , "1969-W52-8 = 1969-W52-7"
-  , "1969-W52-9 = 1969-W52-7"
-  , "1969-W53--2 = 1969-W52-1"
-  , "1969-W53--1 = 1969-W52-1"
-  , "1969-W53-0 = 1969-W52-1"
-  , "1969-W53-1 = 1969-W52-1"
-  , "1969-W53-4 = 1969-W52-4"
-  , "1969-W53-6 = 1969-W52-6"
-  , "1969-W53-7 = 1969-W52-7"
-  , "1969-W53-8 = 1969-W52-7"
-  , "1969-W53-9 = 1969-W52-7"
-  , "1969-W54--2 = 1969-W52-1"
-  , "1969-W54--1 = 1969-W52-1"
-  , "1969-W54-0 = 1969-W52-1"
-  , "1969-W54-1 = 1969-W52-1"
-  , "1969-W54-4 = 1969-W52-4"
-  , "1969-W54-6 = 1969-W52-6"
-  , "1969-W54-7 = 1969-W52-7"
-  , "1969-W54-8 = 1969-W52-7"
-  , "1969-W54-9 = 1969-W52-7"
-  , "2004-W-20--2 = 2004-W01-1"
-  , "2004-W-20--1 = 2004-W01-1"
-  , "2004-W-20-0 = 2004-W01-1"
-  , "2004-W-20-1 = 2004-W01-1"
-  , "2004-W-20-4 = 2004-W01-4"
-  , "2004-W-20-6 = 2004-W01-6"
-  , "2004-W-20-7 = 2004-W01-7"
-  , "2004-W-20-8 = 2004-W01-7"
-  , "2004-W-20-9 = 2004-W01-7"
-  , "2004-W-1--2 = 2004-W01-1"
-  , "2004-W-1--1 = 2004-W01-1"
-  , "2004-W-1-0 = 2004-W01-1"
-  , "2004-W-1-1 = 2004-W01-1"
-  , "2004-W-1-4 = 2004-W01-4"
-  , "2004-W-1-6 = 2004-W01-6"
-  , "2004-W-1-7 = 2004-W01-7"
-  , "2004-W-1-8 = 2004-W01-7"
-  , "2004-W-1-9 = 2004-W01-7"
-  , "2004-W0--2 = 2004-W01-1"
-  , "2004-W0--1 = 2004-W01-1"
-  , "2004-W0-0 = 2004-W01-1"
-  , "2004-W0-1 = 2004-W01-1"
-  , "2004-W0-4 = 2004-W01-4"
-  , "2004-W0-6 = 2004-W01-6"
-  , "2004-W0-7 = 2004-W01-7"
-  , "2004-W0-8 = 2004-W01-7"
-  , "2004-W0-9 = 2004-W01-7"
-  , "2004-W1--2 = 2004-W01-1"
-  , "2004-W1--1 = 2004-W01-1"
-  , "2004-W1-0 = 2004-W01-1"
-  , "2004-W1-1 = 2004-W01-1"
-  , "2004-W1-4 = 2004-W01-4"
-  , "2004-W1-6 = 2004-W01-6"
-  , "2004-W1-7 = 2004-W01-7"
-  , "2004-W1-8 = 2004-W01-7"
-  , "2004-W1-9 = 2004-W01-7"
-  , "2004-W20--2 = 2004-W20-1"
-  , "2004-W20--1 = 2004-W20-1"
-  , "2004-W20-0 = 2004-W20-1"
-  , "2004-W20-1 = 2004-W20-1"
-  , "2004-W20-4 = 2004-W20-4"
-  , "2004-W20-6 = 2004-W20-6"
-  , "2004-W20-7 = 2004-W20-7"
-  , "2004-W20-8 = 2004-W20-7"
-  , "2004-W20-9 = 2004-W20-7"
-  , "2004-W51--2 = 2004-W51-1"
-  , "2004-W51--1 = 2004-W51-1"
-  , "2004-W51-0 = 2004-W51-1"
-  , "2004-W51-1 = 2004-W51-1"
-  , "2004-W51-4 = 2004-W51-4"
-  , "2004-W51-6 = 2004-W51-6"
-  , "2004-W51-7 = 2004-W51-7"
-  , "2004-W51-8 = 2004-W51-7"
-  , "2004-W51-9 = 2004-W51-7"
-  , "2004-W52--2 = 2004-W52-1"
-  , "2004-W52--1 = 2004-W52-1"
-  , "2004-W52-0 = 2004-W52-1"
-  , "2004-W52-1 = 2004-W52-1"
-  , "2004-W52-4 = 2004-W52-4"
-  , "2004-W52-6 = 2004-W52-6"
-  , "2004-W52-7 = 2004-W52-7"
-  , "2004-W52-8 = 2004-W52-7"
-  , "2004-W52-9 = 2004-W52-7"
-  , "2004-W53--2 = 2004-W53-1"
-  , "2004-W53--1 = 2004-W53-1"
-  , "2004-W53-0 = 2004-W53-1"
-  , "2004-W53-1 = 2004-W53-1"
-  , "2004-W53-4 = 2004-W53-4"
-  , "2004-W53-6 = 2004-W53-6"
-  , "2004-W53-7 = 2004-W53-7"
-  , "2004-W53-8 = 2004-W53-7"
-  , "2004-W53-9 = 2004-W53-7"
-  , "2004-W54--2 = 2004-W53-1"
-  , "2004-W54--1 = 2004-W53-1"
-  , "2004-W54-0 = 2004-W53-1"
-  , "2004-W54-1 = 2004-W53-1"
-  , "2004-W54-4 = 2004-W53-4"
-  , "2004-W54-6 = 2004-W53-6"
-  , "2004-W54-7 = 2004-W53-7"
-  , "2004-W54-8 = 2004-W53-7"
-  , "2004-W54-9 = 2004-W53-7" ]
+    unlines
+        [ "YearAndDay"
+        , "1968--4 = 1968-001"
+        , "1968-0 = 1968-001"
+        , "1968-1 = 1968-001"
+        , "1968-200 = 1968-200"
+        , "1968-364 = 1968-364"
+        , "1968-365 = 1968-365"
+        , "1968-366 = 1968-366"
+        , "1968-367 = 1968-366"
+        , "1968-700 = 1968-366"
+        , "1969--4 = 1969-001"
+        , "1969-0 = 1969-001"
+        , "1969-1 = 1969-001"
+        , "1969-200 = 1969-200"
+        , "1969-364 = 1969-364"
+        , "1969-365 = 1969-365"
+        , "1969-366 = 1969-365"
+        , "1969-367 = 1969-365"
+        , "1969-700 = 1969-365"
+        , "1971--4 = 1971-001"
+        , "1971-0 = 1971-001"
+        , "1971-1 = 1971-001"
+        , "1971-200 = 1971-200"
+        , "1971-364 = 1971-364"
+        , "1971-365 = 1971-365"
+        , "1971-366 = 1971-365"
+        , "1971-367 = 1971-365"
+        , "1971-700 = 1971-365"
+        , "Gregorian"
+        , "1968--20--7 = 1968-01-01"
+        , "1968--20--1 = 1968-01-01"
+        , "1968--20-0 = 1968-01-01"
+        , "1968--20-1 = 1968-01-01"
+        , "1968--20-2 = 1968-01-02"
+        , "1968--20-27 = 1968-01-27"
+        , "1968--20-28 = 1968-01-28"
+        , "1968--20-29 = 1968-01-29"
+        , "1968--20-30 = 1968-01-30"
+        , "1968--20-31 = 1968-01-31"
+        , "1968--20-32 = 1968-01-31"
+        , "1968--20-40 = 1968-01-31"
+        , "1968--1--7 = 1968-01-01"
+        , "1968--1--1 = 1968-01-01"
+        , "1968--1-0 = 1968-01-01"
+        , "1968--1-1 = 1968-01-01"
+        , "1968--1-2 = 1968-01-02"
+        , "1968--1-27 = 1968-01-27"
+        , "1968--1-28 = 1968-01-28"
+        , "1968--1-29 = 1968-01-29"
+        , "1968--1-30 = 1968-01-30"
+        , "1968--1-31 = 1968-01-31"
+        , "1968--1-32 = 1968-01-31"
+        , "1968--1-40 = 1968-01-31"
+        , "1968-0--7 = 1968-01-01"
+        , "1968-0--1 = 1968-01-01"
+        , "1968-0-0 = 1968-01-01"
+        , "1968-0-1 = 1968-01-01"
+        , "1968-0-2 = 1968-01-02"
+        , "1968-0-27 = 1968-01-27"
+        , "1968-0-28 = 1968-01-28"
+        , "1968-0-29 = 1968-01-29"
+        , "1968-0-30 = 1968-01-30"
+        , "1968-0-31 = 1968-01-31"
+        , "1968-0-32 = 1968-01-31"
+        , "1968-0-40 = 1968-01-31"
+        , "1968-1--7 = 1968-01-01"
+        , "1968-1--1 = 1968-01-01"
+        , "1968-1-0 = 1968-01-01"
+        , "1968-1-1 = 1968-01-01"
+        , "1968-1-2 = 1968-01-02"
+        , "1968-1-27 = 1968-01-27"
+        , "1968-1-28 = 1968-01-28"
+        , "1968-1-29 = 1968-01-29"
+        , "1968-1-30 = 1968-01-30"
+        , "1968-1-31 = 1968-01-31"
+        , "1968-1-32 = 1968-01-31"
+        , "1968-1-40 = 1968-01-31"
+        , "1968-2--7 = 1968-02-01"
+        , "1968-2--1 = 1968-02-01"
+        , "1968-2-0 = 1968-02-01"
+        , "1968-2-1 = 1968-02-01"
+        , "1968-2-2 = 1968-02-02"
+        , "1968-2-27 = 1968-02-27"
+        , "1968-2-28 = 1968-02-28"
+        , "1968-2-29 = 1968-02-29"
+        , "1968-2-30 = 1968-02-29"
+        , "1968-2-31 = 1968-02-29"
+        , "1968-2-32 = 1968-02-29"
+        , "1968-2-40 = 1968-02-29"
+        , "1968-12--7 = 1968-12-01"
+        , "1968-12--1 = 1968-12-01"
+        , "1968-12-0 = 1968-12-01"
+        , "1968-12-1 = 1968-12-01"
+        , "1968-12-2 = 1968-12-02"
+        , "1968-12-27 = 1968-12-27"
+        , "1968-12-28 = 1968-12-28"
+        , "1968-12-29 = 1968-12-29"
+        , "1968-12-30 = 1968-12-30"
+        , "1968-12-31 = 1968-12-31"
+        , "1968-12-32 = 1968-12-31"
+        , "1968-12-40 = 1968-12-31"
+        , "1968-13--7 = 1968-12-01"
+        , "1968-13--1 = 1968-12-01"
+        , "1968-13-0 = 1968-12-01"
+        , "1968-13-1 = 1968-12-01"
+        , "1968-13-2 = 1968-12-02"
+        , "1968-13-27 = 1968-12-27"
+        , "1968-13-28 = 1968-12-28"
+        , "1968-13-29 = 1968-12-29"
+        , "1968-13-30 = 1968-12-30"
+        , "1968-13-31 = 1968-12-31"
+        , "1968-13-32 = 1968-12-31"
+        , "1968-13-40 = 1968-12-31"
+        , "1968-17--7 = 1968-12-01"
+        , "1968-17--1 = 1968-12-01"
+        , "1968-17-0 = 1968-12-01"
+        , "1968-17-1 = 1968-12-01"
+        , "1968-17-2 = 1968-12-02"
+        , "1968-17-27 = 1968-12-27"
+        , "1968-17-28 = 1968-12-28"
+        , "1968-17-29 = 1968-12-29"
+        , "1968-17-30 = 1968-12-30"
+        , "1968-17-31 = 1968-12-31"
+        , "1968-17-32 = 1968-12-31"
+        , "1968-17-40 = 1968-12-31"
+        , "1969--20--7 = 1969-01-01"
+        , "1969--20--1 = 1969-01-01"
+        , "1969--20-0 = 1969-01-01"
+        , "1969--20-1 = 1969-01-01"
+        , "1969--20-2 = 1969-01-02"
+        , "1969--20-27 = 1969-01-27"
+        , "1969--20-28 = 1969-01-28"
+        , "1969--20-29 = 1969-01-29"
+        , "1969--20-30 = 1969-01-30"
+        , "1969--20-31 = 1969-01-31"
+        , "1969--20-32 = 1969-01-31"
+        , "1969--20-40 = 1969-01-31"
+        , "1969--1--7 = 1969-01-01"
+        , "1969--1--1 = 1969-01-01"
+        , "1969--1-0 = 1969-01-01"
+        , "1969--1-1 = 1969-01-01"
+        , "1969--1-2 = 1969-01-02"
+        , "1969--1-27 = 1969-01-27"
+        , "1969--1-28 = 1969-01-28"
+        , "1969--1-29 = 1969-01-29"
+        , "1969--1-30 = 1969-01-30"
+        , "1969--1-31 = 1969-01-31"
+        , "1969--1-32 = 1969-01-31"
+        , "1969--1-40 = 1969-01-31"
+        , "1969-0--7 = 1969-01-01"
+        , "1969-0--1 = 1969-01-01"
+        , "1969-0-0 = 1969-01-01"
+        , "1969-0-1 = 1969-01-01"
+        , "1969-0-2 = 1969-01-02"
+        , "1969-0-27 = 1969-01-27"
+        , "1969-0-28 = 1969-01-28"
+        , "1969-0-29 = 1969-01-29"
+        , "1969-0-30 = 1969-01-30"
+        , "1969-0-31 = 1969-01-31"
+        , "1969-0-32 = 1969-01-31"
+        , "1969-0-40 = 1969-01-31"
+        , "1969-1--7 = 1969-01-01"
+        , "1969-1--1 = 1969-01-01"
+        , "1969-1-0 = 1969-01-01"
+        , "1969-1-1 = 1969-01-01"
+        , "1969-1-2 = 1969-01-02"
+        , "1969-1-27 = 1969-01-27"
+        , "1969-1-28 = 1969-01-28"
+        , "1969-1-29 = 1969-01-29"
+        , "1969-1-30 = 1969-01-30"
+        , "1969-1-31 = 1969-01-31"
+        , "1969-1-32 = 1969-01-31"
+        , "1969-1-40 = 1969-01-31"
+        , "1969-2--7 = 1969-02-01"
+        , "1969-2--1 = 1969-02-01"
+        , "1969-2-0 = 1969-02-01"
+        , "1969-2-1 = 1969-02-01"
+        , "1969-2-2 = 1969-02-02"
+        , "1969-2-27 = 1969-02-27"
+        , "1969-2-28 = 1969-02-28"
+        , "1969-2-29 = 1969-02-28"
+        , "1969-2-30 = 1969-02-28"
+        , "1969-2-31 = 1969-02-28"
+        , "1969-2-32 = 1969-02-28"
+        , "1969-2-40 = 1969-02-28"
+        , "1969-12--7 = 1969-12-01"
+        , "1969-12--1 = 1969-12-01"
+        , "1969-12-0 = 1969-12-01"
+        , "1969-12-1 = 1969-12-01"
+        , "1969-12-2 = 1969-12-02"
+        , "1969-12-27 = 1969-12-27"
+        , "1969-12-28 = 1969-12-28"
+        , "1969-12-29 = 1969-12-29"
+        , "1969-12-30 = 1969-12-30"
+        , "1969-12-31 = 1969-12-31"
+        , "1969-12-32 = 1969-12-31"
+        , "1969-12-40 = 1969-12-31"
+        , "1969-13--7 = 1969-12-01"
+        , "1969-13--1 = 1969-12-01"
+        , "1969-13-0 = 1969-12-01"
+        , "1969-13-1 = 1969-12-01"
+        , "1969-13-2 = 1969-12-02"
+        , "1969-13-27 = 1969-12-27"
+        , "1969-13-28 = 1969-12-28"
+        , "1969-13-29 = 1969-12-29"
+        , "1969-13-30 = 1969-12-30"
+        , "1969-13-31 = 1969-12-31"
+        , "1969-13-32 = 1969-12-31"
+        , "1969-13-40 = 1969-12-31"
+        , "1969-17--7 = 1969-12-01"
+        , "1969-17--1 = 1969-12-01"
+        , "1969-17-0 = 1969-12-01"
+        , "1969-17-1 = 1969-12-01"
+        , "1969-17-2 = 1969-12-02"
+        , "1969-17-27 = 1969-12-27"
+        , "1969-17-28 = 1969-12-28"
+        , "1969-17-29 = 1969-12-29"
+        , "1969-17-30 = 1969-12-30"
+        , "1969-17-31 = 1969-12-31"
+        , "1969-17-32 = 1969-12-31"
+        , "1969-17-40 = 1969-12-31"
+        , "1971--20--7 = 1971-01-01"
+        , "1971--20--1 = 1971-01-01"
+        , "1971--20-0 = 1971-01-01"
+        , "1971--20-1 = 1971-01-01"
+        , "1971--20-2 = 1971-01-02"
+        , "1971--20-27 = 1971-01-27"
+        , "1971--20-28 = 1971-01-28"
+        , "1971--20-29 = 1971-01-29"
+        , "1971--20-30 = 1971-01-30"
+        , "1971--20-31 = 1971-01-31"
+        , "1971--20-32 = 1971-01-31"
+        , "1971--20-40 = 1971-01-31"
+        , "1971--1--7 = 1971-01-01"
+        , "1971--1--1 = 1971-01-01"
+        , "1971--1-0 = 1971-01-01"
+        , "1971--1-1 = 1971-01-01"
+        , "1971--1-2 = 1971-01-02"
+        , "1971--1-27 = 1971-01-27"
+        , "1971--1-28 = 1971-01-28"
+        , "1971--1-29 = 1971-01-29"
+        , "1971--1-30 = 1971-01-30"
+        , "1971--1-31 = 1971-01-31"
+        , "1971--1-32 = 1971-01-31"
+        , "1971--1-40 = 1971-01-31"
+        , "1971-0--7 = 1971-01-01"
+        , "1971-0--1 = 1971-01-01"
+        , "1971-0-0 = 1971-01-01"
+        , "1971-0-1 = 1971-01-01"
+        , "1971-0-2 = 1971-01-02"
+        , "1971-0-27 = 1971-01-27"
+        , "1971-0-28 = 1971-01-28"
+        , "1971-0-29 = 1971-01-29"
+        , "1971-0-30 = 1971-01-30"
+        , "1971-0-31 = 1971-01-31"
+        , "1971-0-32 = 1971-01-31"
+        , "1971-0-40 = 1971-01-31"
+        , "1971-1--7 = 1971-01-01"
+        , "1971-1--1 = 1971-01-01"
+        , "1971-1-0 = 1971-01-01"
+        , "1971-1-1 = 1971-01-01"
+        , "1971-1-2 = 1971-01-02"
+        , "1971-1-27 = 1971-01-27"
+        , "1971-1-28 = 1971-01-28"
+        , "1971-1-29 = 1971-01-29"
+        , "1971-1-30 = 1971-01-30"
+        , "1971-1-31 = 1971-01-31"
+        , "1971-1-32 = 1971-01-31"
+        , "1971-1-40 = 1971-01-31"
+        , "1971-2--7 = 1971-02-01"
+        , "1971-2--1 = 1971-02-01"
+        , "1971-2-0 = 1971-02-01"
+        , "1971-2-1 = 1971-02-01"
+        , "1971-2-2 = 1971-02-02"
+        , "1971-2-27 = 1971-02-27"
+        , "1971-2-28 = 1971-02-28"
+        , "1971-2-29 = 1971-02-28"
+        , "1971-2-30 = 1971-02-28"
+        , "1971-2-31 = 1971-02-28"
+        , "1971-2-32 = 1971-02-28"
+        , "1971-2-40 = 1971-02-28"
+        , "1971-12--7 = 1971-12-01"
+        , "1971-12--1 = 1971-12-01"
+        , "1971-12-0 = 1971-12-01"
+        , "1971-12-1 = 1971-12-01"
+        , "1971-12-2 = 1971-12-02"
+        , "1971-12-27 = 1971-12-27"
+        , "1971-12-28 = 1971-12-28"
+        , "1971-12-29 = 1971-12-29"
+        , "1971-12-30 = 1971-12-30"
+        , "1971-12-31 = 1971-12-31"
+        , "1971-12-32 = 1971-12-31"
+        , "1971-12-40 = 1971-12-31"
+        , "1971-13--7 = 1971-12-01"
+        , "1971-13--1 = 1971-12-01"
+        , "1971-13-0 = 1971-12-01"
+        , "1971-13-1 = 1971-12-01"
+        , "1971-13-2 = 1971-12-02"
+        , "1971-13-27 = 1971-12-27"
+        , "1971-13-28 = 1971-12-28"
+        , "1971-13-29 = 1971-12-29"
+        , "1971-13-30 = 1971-12-30"
+        , "1971-13-31 = 1971-12-31"
+        , "1971-13-32 = 1971-12-31"
+        , "1971-13-40 = 1971-12-31"
+        , "1971-17--7 = 1971-12-01"
+        , "1971-17--1 = 1971-12-01"
+        , "1971-17-0 = 1971-12-01"
+        , "1971-17-1 = 1971-12-01"
+        , "1971-17-2 = 1971-12-02"
+        , "1971-17-27 = 1971-12-27"
+        , "1971-17-28 = 1971-12-28"
+        , "1971-17-29 = 1971-12-29"
+        , "1971-17-30 = 1971-12-30"
+        , "1971-17-31 = 1971-12-31"
+        , "1971-17-32 = 1971-12-31"
+        , "1971-17-40 = 1971-12-31"
+        , "ISOWeekDay"
+        , "1968-W-20--2 = 1968-W01-1"
+        , "1968-W-20--1 = 1968-W01-1"
+        , "1968-W-20-0 = 1968-W01-1"
+        , "1968-W-20-1 = 1968-W01-1"
+        , "1968-W-20-4 = 1968-W01-4"
+        , "1968-W-20-6 = 1968-W01-6"
+        , "1968-W-20-7 = 1968-W01-7"
+        , "1968-W-20-8 = 1968-W01-7"
+        , "1968-W-20-9 = 1968-W01-7"
+        , "1968-W-1--2 = 1968-W01-1"
+        , "1968-W-1--1 = 1968-W01-1"
+        , "1968-W-1-0 = 1968-W01-1"
+        , "1968-W-1-1 = 1968-W01-1"
+        , "1968-W-1-4 = 1968-W01-4"
+        , "1968-W-1-6 = 1968-W01-6"
+        , "1968-W-1-7 = 1968-W01-7"
+        , "1968-W-1-8 = 1968-W01-7"
+        , "1968-W-1-9 = 1968-W01-7"
+        , "1968-W0--2 = 1968-W01-1"
+        , "1968-W0--1 = 1968-W01-1"
+        , "1968-W0-0 = 1968-W01-1"
+        , "1968-W0-1 = 1968-W01-1"
+        , "1968-W0-4 = 1968-W01-4"
+        , "1968-W0-6 = 1968-W01-6"
+        , "1968-W0-7 = 1968-W01-7"
+        , "1968-W0-8 = 1968-W01-7"
+        , "1968-W0-9 = 1968-W01-7"
+        , "1968-W1--2 = 1968-W01-1"
+        , "1968-W1--1 = 1968-W01-1"
+        , "1968-W1-0 = 1968-W01-1"
+        , "1968-W1-1 = 1968-W01-1"
+        , "1968-W1-4 = 1968-W01-4"
+        , "1968-W1-6 = 1968-W01-6"
+        , "1968-W1-7 = 1968-W01-7"
+        , "1968-W1-8 = 1968-W01-7"
+        , "1968-W1-9 = 1968-W01-7"
+        , "1968-W20--2 = 1968-W20-1"
+        , "1968-W20--1 = 1968-W20-1"
+        , "1968-W20-0 = 1968-W20-1"
+        , "1968-W20-1 = 1968-W20-1"
+        , "1968-W20-4 = 1968-W20-4"
+        , "1968-W20-6 = 1968-W20-6"
+        , "1968-W20-7 = 1968-W20-7"
+        , "1968-W20-8 = 1968-W20-7"
+        , "1968-W20-9 = 1968-W20-7"
+        , "1968-W51--2 = 1968-W51-1"
+        , "1968-W51--1 = 1968-W51-1"
+        , "1968-W51-0 = 1968-W51-1"
+        , "1968-W51-1 = 1968-W51-1"
+        , "1968-W51-4 = 1968-W51-4"
+        , "1968-W51-6 = 1968-W51-6"
+        , "1968-W51-7 = 1968-W51-7"
+        , "1968-W51-8 = 1968-W51-7"
+        , "1968-W51-9 = 1968-W51-7"
+        , "1968-W52--2 = 1968-W52-1"
+        , "1968-W52--1 = 1968-W52-1"
+        , "1968-W52-0 = 1968-W52-1"
+        , "1968-W52-1 = 1968-W52-1"
+        , "1968-W52-4 = 1968-W52-4"
+        , "1968-W52-6 = 1968-W52-6"
+        , "1968-W52-7 = 1968-W52-7"
+        , "1968-W52-8 = 1968-W52-7"
+        , "1968-W52-9 = 1968-W52-7"
+        , "1968-W53--2 = 1968-W52-1"
+        , "1968-W53--1 = 1968-W52-1"
+        , "1968-W53-0 = 1968-W52-1"
+        , "1968-W53-1 = 1968-W52-1"
+        , "1968-W53-4 = 1968-W52-4"
+        , "1968-W53-6 = 1968-W52-6"
+        , "1968-W53-7 = 1968-W52-7"
+        , "1968-W53-8 = 1968-W52-7"
+        , "1968-W53-9 = 1968-W52-7"
+        , "1968-W54--2 = 1968-W52-1"
+        , "1968-W54--1 = 1968-W52-1"
+        , "1968-W54-0 = 1968-W52-1"
+        , "1968-W54-1 = 1968-W52-1"
+        , "1968-W54-4 = 1968-W52-4"
+        , "1968-W54-6 = 1968-W52-6"
+        , "1968-W54-7 = 1968-W52-7"
+        , "1968-W54-8 = 1968-W52-7"
+        , "1968-W54-9 = 1968-W52-7"
+        , "1969-W-20--2 = 1969-W01-1"
+        , "1969-W-20--1 = 1969-W01-1"
+        , "1969-W-20-0 = 1969-W01-1"
+        , "1969-W-20-1 = 1969-W01-1"
+        , "1969-W-20-4 = 1969-W01-4"
+        , "1969-W-20-6 = 1969-W01-6"
+        , "1969-W-20-7 = 1969-W01-7"
+        , "1969-W-20-8 = 1969-W01-7"
+        , "1969-W-20-9 = 1969-W01-7"
+        , "1969-W-1--2 = 1969-W01-1"
+        , "1969-W-1--1 = 1969-W01-1"
+        , "1969-W-1-0 = 1969-W01-1"
+        , "1969-W-1-1 = 1969-W01-1"
+        , "1969-W-1-4 = 1969-W01-4"
+        , "1969-W-1-6 = 1969-W01-6"
+        , "1969-W-1-7 = 1969-W01-7"
+        , "1969-W-1-8 = 1969-W01-7"
+        , "1969-W-1-9 = 1969-W01-7"
+        , "1969-W0--2 = 1969-W01-1"
+        , "1969-W0--1 = 1969-W01-1"
+        , "1969-W0-0 = 1969-W01-1"
+        , "1969-W0-1 = 1969-W01-1"
+        , "1969-W0-4 = 1969-W01-4"
+        , "1969-W0-6 = 1969-W01-6"
+        , "1969-W0-7 = 1969-W01-7"
+        , "1969-W0-8 = 1969-W01-7"
+        , "1969-W0-9 = 1969-W01-7"
+        , "1969-W1--2 = 1969-W01-1"
+        , "1969-W1--1 = 1969-W01-1"
+        , "1969-W1-0 = 1969-W01-1"
+        , "1969-W1-1 = 1969-W01-1"
+        , "1969-W1-4 = 1969-W01-4"
+        , "1969-W1-6 = 1969-W01-6"
+        , "1969-W1-7 = 1969-W01-7"
+        , "1969-W1-8 = 1969-W01-7"
+        , "1969-W1-9 = 1969-W01-7"
+        , "1969-W20--2 = 1969-W20-1"
+        , "1969-W20--1 = 1969-W20-1"
+        , "1969-W20-0 = 1969-W20-1"
+        , "1969-W20-1 = 1969-W20-1"
+        , "1969-W20-4 = 1969-W20-4"
+        , "1969-W20-6 = 1969-W20-6"
+        , "1969-W20-7 = 1969-W20-7"
+        , "1969-W20-8 = 1969-W20-7"
+        , "1969-W20-9 = 1969-W20-7"
+        , "1969-W51--2 = 1969-W51-1"
+        , "1969-W51--1 = 1969-W51-1"
+        , "1969-W51-0 = 1969-W51-1"
+        , "1969-W51-1 = 1969-W51-1"
+        , "1969-W51-4 = 1969-W51-4"
+        , "1969-W51-6 = 1969-W51-6"
+        , "1969-W51-7 = 1969-W51-7"
+        , "1969-W51-8 = 1969-W51-7"
+        , "1969-W51-9 = 1969-W51-7"
+        , "1969-W52--2 = 1969-W52-1"
+        , "1969-W52--1 = 1969-W52-1"
+        , "1969-W52-0 = 1969-W52-1"
+        , "1969-W52-1 = 1969-W52-1"
+        , "1969-W52-4 = 1969-W52-4"
+        , "1969-W52-6 = 1969-W52-6"
+        , "1969-W52-7 = 1969-W52-7"
+        , "1969-W52-8 = 1969-W52-7"
+        , "1969-W52-9 = 1969-W52-7"
+        , "1969-W53--2 = 1969-W52-1"
+        , "1969-W53--1 = 1969-W52-1"
+        , "1969-W53-0 = 1969-W52-1"
+        , "1969-W53-1 = 1969-W52-1"
+        , "1969-W53-4 = 1969-W52-4"
+        , "1969-W53-6 = 1969-W52-6"
+        , "1969-W53-7 = 1969-W52-7"
+        , "1969-W53-8 = 1969-W52-7"
+        , "1969-W53-9 = 1969-W52-7"
+        , "1969-W54--2 = 1969-W52-1"
+        , "1969-W54--1 = 1969-W52-1"
+        , "1969-W54-0 = 1969-W52-1"
+        , "1969-W54-1 = 1969-W52-1"
+        , "1969-W54-4 = 1969-W52-4"
+        , "1969-W54-6 = 1969-W52-6"
+        , "1969-W54-7 = 1969-W52-7"
+        , "1969-W54-8 = 1969-W52-7"
+        , "1969-W54-9 = 1969-W52-7"
+        , "2004-W-20--2 = 2004-W01-1"
+        , "2004-W-20--1 = 2004-W01-1"
+        , "2004-W-20-0 = 2004-W01-1"
+        , "2004-W-20-1 = 2004-W01-1"
+        , "2004-W-20-4 = 2004-W01-4"
+        , "2004-W-20-6 = 2004-W01-6"
+        , "2004-W-20-7 = 2004-W01-7"
+        , "2004-W-20-8 = 2004-W01-7"
+        , "2004-W-20-9 = 2004-W01-7"
+        , "2004-W-1--2 = 2004-W01-1"
+        , "2004-W-1--1 = 2004-W01-1"
+        , "2004-W-1-0 = 2004-W01-1"
+        , "2004-W-1-1 = 2004-W01-1"
+        , "2004-W-1-4 = 2004-W01-4"
+        , "2004-W-1-6 = 2004-W01-6"
+        , "2004-W-1-7 = 2004-W01-7"
+        , "2004-W-1-8 = 2004-W01-7"
+        , "2004-W-1-9 = 2004-W01-7"
+        , "2004-W0--2 = 2004-W01-1"
+        , "2004-W0--1 = 2004-W01-1"
+        , "2004-W0-0 = 2004-W01-1"
+        , "2004-W0-1 = 2004-W01-1"
+        , "2004-W0-4 = 2004-W01-4"
+        , "2004-W0-6 = 2004-W01-6"
+        , "2004-W0-7 = 2004-W01-7"
+        , "2004-W0-8 = 2004-W01-7"
+        , "2004-W0-9 = 2004-W01-7"
+        , "2004-W1--2 = 2004-W01-1"
+        , "2004-W1--1 = 2004-W01-1"
+        , "2004-W1-0 = 2004-W01-1"
+        , "2004-W1-1 = 2004-W01-1"
+        , "2004-W1-4 = 2004-W01-4"
+        , "2004-W1-6 = 2004-W01-6"
+        , "2004-W1-7 = 2004-W01-7"
+        , "2004-W1-8 = 2004-W01-7"
+        , "2004-W1-9 = 2004-W01-7"
+        , "2004-W20--2 = 2004-W20-1"
+        , "2004-W20--1 = 2004-W20-1"
+        , "2004-W20-0 = 2004-W20-1"
+        , "2004-W20-1 = 2004-W20-1"
+        , "2004-W20-4 = 2004-W20-4"
+        , "2004-W20-6 = 2004-W20-6"
+        , "2004-W20-7 = 2004-W20-7"
+        , "2004-W20-8 = 2004-W20-7"
+        , "2004-W20-9 = 2004-W20-7"
+        , "2004-W51--2 = 2004-W51-1"
+        , "2004-W51--1 = 2004-W51-1"
+        , "2004-W51-0 = 2004-W51-1"
+        , "2004-W51-1 = 2004-W51-1"
+        , "2004-W51-4 = 2004-W51-4"
+        , "2004-W51-6 = 2004-W51-6"
+        , "2004-W51-7 = 2004-W51-7"
+        , "2004-W51-8 = 2004-W51-7"
+        , "2004-W51-9 = 2004-W51-7"
+        , "2004-W52--2 = 2004-W52-1"
+        , "2004-W52--1 = 2004-W52-1"
+        , "2004-W52-0 = 2004-W52-1"
+        , "2004-W52-1 = 2004-W52-1"
+        , "2004-W52-4 = 2004-W52-4"
+        , "2004-W52-6 = 2004-W52-6"
+        , "2004-W52-7 = 2004-W52-7"
+        , "2004-W52-8 = 2004-W52-7"
+        , "2004-W52-9 = 2004-W52-7"
+        , "2004-W53--2 = 2004-W53-1"
+        , "2004-W53--1 = 2004-W53-1"
+        , "2004-W53-0 = 2004-W53-1"
+        , "2004-W53-1 = 2004-W53-1"
+        , "2004-W53-4 = 2004-W53-4"
+        , "2004-W53-6 = 2004-W53-6"
+        , "2004-W53-7 = 2004-W53-7"
+        , "2004-W53-8 = 2004-W53-7"
+        , "2004-W53-9 = 2004-W53-7"
+        , "2004-W54--2 = 2004-W53-1"
+        , "2004-W54--1 = 2004-W53-1"
+        , "2004-W54-0 = 2004-W53-1"
+        , "2004-W54-1 = 2004-W53-1"
+        , "2004-W54-4 = 2004-W53-4"
+        , "2004-W54-6 = 2004-W53-6"
+        , "2004-W54-7 = 2004-W53-7"
+        , "2004-W54-8 = 2004-W53-7"
+        , "2004-W54-9 = 2004-W53-7"
+        ]
index fb84c84..75df48e 100644 (file)
@@ -1,41 +1,39 @@
-module Test.Calendar.ConvertBack(convertBack) where
+module Test.Calendar.ConvertBack
+    ( convertBack
+    ) where
 
-import Data.Time.Calendar.OrdinalDate
+import Data.Time.Calendar
 import Data.Time.Calendar.Julian
+import Data.Time.Calendar.OrdinalDate
 import Data.Time.Calendar.WeekDate
-import Data.Time.Calendar
 import Test.Tasty
 import Test.Tasty.HUnit
 
 checkDay :: (Show t) => (Day -> t) -> (t -> Day) -> (t -> Maybe Day) -> Day -> String
 checkDay encodeDay decodeDay decodeDayValid day = let
-    st    = encodeDay day
-    day'  = decodeDay st
+    st = encodeDay day
+    day' = decodeDay st
     mday' = decodeDayValid st
-
-    a = if day /= day'
-          then unwords [ show day, "-> "
-                           , show st,  "-> "
-                           , show day'
-                           , "(diff", show (diffDays day' day) ++ ")" ]
-          else ""
-
-    b = if Just day /= mday'
-          then unwords [show day, "->", show st, "->", show mday']
-          else ""
+    a =
+        if day /= day'
+            then unwords [show day, "-> ", show st, "-> ", show day', "(diff", show (diffDays day' day) ++ ")"]
+            else ""
+    b =
+        if Just day /= mday'
+            then unwords [show day, "->", show st, "->", show mday']
+            else ""
     in a ++ b
 
 checkers :: [Day -> String]
-checkers
-  = [ checkDay toOrdinalDate (\(y,d) -> fromOrdinalDate y d) (\(y,d) -> fromOrdinalDateValid y d)
-    , checkDay toWeekDate (\(y,w,d) -> fromWeekDate y w d) (\(y,w,d) -> fromWeekDateValid y w d)
-    , checkDay toGregorian (\(y,m,d) -> fromGregorian y m d) (\(y,m,d) -> fromGregorianValid y m d)
-    , checkDay toJulian (\(y,m,d) -> fromJulian y m d) (\(y,m,d) -> fromJulianValid y m d) ]
+checkers =
+    [ checkDay toOrdinalDate (\(y, d) -> fromOrdinalDate y d) (\(y, d) -> fromOrdinalDateValid y d)
+    , checkDay toWeekDate (\(y, w, d) -> fromWeekDate y w d) (\(y, w, d) -> fromWeekDateValid y w d)
+    , checkDay toGregorian (\(y, m, d) -> fromGregorian y m d) (\(y, m, d) -> fromGregorianValid y m d)
+    , checkDay toJulian (\(y, m, d) -> fromJulian y m d) (\(y, m, d) -> fromJulianValid y m d)
+    ]
 
 days :: [Day]
-days = [ModifiedJulianDay 50000 .. ModifiedJulianDay 50200] ++
-    (fmap (\year -> (fromGregorian year 1 4)) [1980..2000])
+days = [ModifiedJulianDay 50000 .. ModifiedJulianDay 50200] ++ (fmap (\year -> (fromGregorian year 1 4)) [1980 .. 2000])
 
 convertBack :: TestTree
-convertBack = testCase "convertBack" $
-    assertEqual "" "" $ concatMap (\ch -> concatMap ch days) checkers
+convertBack = testCase "convertBack" $ assertEqual "" "" $ concatMap (\ch -> concatMap ch days) checkers
index 8b8938d..6748b1c 100644 (file)
@@ -24,7 +24,7 @@ testAddDiff =
         ]
 
 testClip :: (Integer, Int, Int) -> (Integer, Int, Int) -> (Integer, Integer) -> TestTree
-testClip (y1,m1,d1) (y2,m2,d2) (em, ed) = let
+testClip (y1, m1, d1) (y2, m2, d2) (em, ed) = let
     day1 = fromGregorian y1 m1 d1
     day2 = fromGregorian y2 m2 d2
     expected = CalendarDiffDays em ed
index 1901835..1cc287a 100644 (file)
@@ -1,15 +1,16 @@
-module Test.Calendar.Easter(testEaster) where
+module Test.Calendar.Easter
+    ( testEaster
+    ) where
 
-import Data.Time.Calendar.Easter
 import Data.Time.Calendar
+import Data.Time.Calendar.Easter
 import Data.Time.Format
 
+import Test.Calendar.EasterRef
 import Test.Tasty
 import Test.Tasty.HUnit
-import Test.Calendar.EasterRef
 
 --
-
 days :: [Day]
 days = [ModifiedJulianDay 53000 .. ModifiedJulianDay 53014]
 
@@ -17,19 +18,21 @@ showWithWDay :: Day -> String
 showWithWDay = formatTime defaultTimeLocale "%F %A"
 
 testEaster :: TestTree
-testEaster = testCase "testEaster" $ let
-    ds = unlines $ map (\day ->
-                   unwords [ showWithWDay day, "->"
-                           , showWithWDay (sundayAfter day)]) days
-
-    f y = unwords [ show y ++ ", Gregorian: moon,"
-                          , show (gregorianPaschalMoon y) ++ ": Easter,"
-                          , showWithWDay (gregorianEaster y)]
-                  ++ "\n"
-
-    g y = unwords [ show y ++ ", Orthodox : moon,"
-                          , show (orthodoxPaschalMoon y) ++ ": Easter,"
-                          , showWithWDay (orthodoxEaster y)]
-                  ++ "\n"
-
-    in assertEqual "" testEasterRef $ ds ++ concatMap (\y -> f y ++ g y) [2000..2020]
+testEaster =
+    testCase "testEaster" $ let
+        ds = unlines $ map (\day -> unwords [showWithWDay day, "->", showWithWDay (sundayAfter day)]) days
+        f y =
+            unwords
+                [ show y ++ ", Gregorian: moon,"
+                , show (gregorianPaschalMoon y) ++ ": Easter,"
+                , showWithWDay (gregorianEaster y)
+                ] ++
+            "\n"
+        g y =
+            unwords
+                [ show y ++ ", Orthodox : moon,"
+                , show (orthodoxPaschalMoon y) ++ ": Easter,"
+                , showWithWDay (orthodoxEaster y)
+                ] ++
+            "\n"
+        in assertEqual "" testEasterRef $ ds ++ concatMap (\y -> f y ++ g y) [2000 .. 2020]
index 7ec6ab4..332581a 100644 (file)
@@ -2,61 +2,62 @@ module Test.Calendar.EasterRef where
 
 testEasterRef :: String
 testEasterRef =
- unlines
-  [ "2003-12-27 Saturday -> 2003-12-28 Sunday"
-  , "2003-12-28 Sunday -> 2004-01-04 Sunday"
-  , "2003-12-29 Monday -> 2004-01-04 Sunday"
-  , "2003-12-30 Tuesday -> 2004-01-04 Sunday"
-  , "2003-12-31 Wednesday -> 2004-01-04 Sunday"
-  , "2004-01-01 Thursday -> 2004-01-04 Sunday"
-  , "2004-01-02 Friday -> 2004-01-04 Sunday"
-  , "2004-01-03 Saturday -> 2004-01-04 Sunday"
-  , "2004-01-04 Sunday -> 2004-01-11 Sunday"
-  , "2004-01-05 Monday -> 2004-01-11 Sunday"
-  , "2004-01-06 Tuesday -> 2004-01-11 Sunday"
-  , "2004-01-07 Wednesday -> 2004-01-11 Sunday"
-  , "2004-01-08 Thursday -> 2004-01-11 Sunday"
-  , "2004-01-09 Friday -> 2004-01-11 Sunday"
-  , "2004-01-10 Saturday -> 2004-01-11 Sunday"
-  , "2000, Gregorian: moon, 2000-04-18: Easter, 2000-04-23 Sunday"
-  , "2000, Orthodox : moon, 2000-04-23: Easter, 2000-04-30 Sunday"
-  , "2001, Gregorian: moon, 2001-04-08: Easter, 2001-04-15 Sunday"
-  , "2001, Orthodox : moon, 2001-04-12: Easter, 2001-04-15 Sunday"
-  , "2002, Gregorian: moon, 2002-03-28: Easter, 2002-03-31 Sunday"
-  , "2002, Orthodox : moon, 2002-05-01: Easter, 2002-05-05 Sunday"
-  , "2003, Gregorian: moon, 2003-04-16: Easter, 2003-04-20 Sunday"
-  , "2003, Orthodox : moon, 2003-04-20: Easter, 2003-04-27 Sunday"
-  , "2004, Gregorian: moon, 2004-04-05: Easter, 2004-04-11 Sunday"
-  , "2004, Orthodox : moon, 2004-04-09: Easter, 2004-04-11 Sunday"
-  , "2005, Gregorian: moon, 2005-03-25: Easter, 2005-03-27 Sunday"
-  , "2005, Orthodox : moon, 2005-04-28: Easter, 2005-05-01 Sunday"
-  , "2006, Gregorian: moon, 2006-04-13: Easter, 2006-04-16 Sunday"
-  , "2006, Orthodox : moon, 2006-04-17: Easter, 2006-04-23 Sunday"
-  , "2007, Gregorian: moon, 2007-04-02: Easter, 2007-04-08 Sunday"
-  , "2007, Orthodox : moon, 2007-04-06: Easter, 2007-04-08 Sunday"
-  , "2008, Gregorian: moon, 2008-03-22: Easter, 2008-03-23 Sunday"
-  , "2008, Orthodox : moon, 2008-04-25: Easter, 2008-04-27 Sunday"
-  , "2009, Gregorian: moon, 2009-04-10: Easter, 2009-04-12 Sunday"
-  , "2009, Orthodox : moon, 2009-04-14: Easter, 2009-04-19 Sunday"
-  , "2010, Gregorian: moon, 2010-03-30: Easter, 2010-04-04 Sunday"
-  , "2010, Orthodox : moon, 2010-04-03: Easter, 2010-04-04 Sunday"
-  , "2011, Gregorian: moon, 2011-04-18: Easter, 2011-04-24 Sunday"
-  , "2011, Orthodox : moon, 2011-04-22: Easter, 2011-04-24 Sunday"
-  , "2012, Gregorian: moon, 2012-04-07: Easter, 2012-04-08 Sunday"
-  , "2012, Orthodox : moon, 2012-04-11: Easter, 2012-04-15 Sunday"
-  , "2013, Gregorian: moon, 2013-03-27: Easter, 2013-03-31 Sunday"
-  , "2013, Orthodox : moon, 2013-04-30: Easter, 2013-05-05 Sunday"
-  , "2014, Gregorian: moon, 2014-04-14: Easter, 2014-04-20 Sunday"
-  , "2014, Orthodox : moon, 2014-04-18: Easter, 2014-04-20 Sunday"
-  , "2015, Gregorian: moon, 2015-04-03: Easter, 2015-04-05 Sunday"
-  , "2015, Orthodox : moon, 2015-04-07: Easter, 2015-04-12 Sunday"
-  , "2016, Gregorian: moon, 2016-03-23: Easter, 2016-03-27 Sunday"
-  , "2016, Orthodox : moon, 2016-04-26: Easter, 2016-05-01 Sunday"
-  , "2017, Gregorian: moon, 2017-04-11: Easter, 2017-04-16 Sunday"
-  , "2017, Orthodox : moon, 2017-04-15: Easter, 2017-04-16 Sunday"
-  , "2018, Gregorian: moon, 2018-03-31: Easter, 2018-04-01 Sunday"
-  , "2018, Orthodox : moon, 2018-04-04: Easter, 2018-04-08 Sunday"
-  , "2019, Gregorian: moon, 2019-04-18: Easter, 2019-04-21 Sunday"
-  , "2019, Orthodox : moon, 2019-04-23: Easter, 2019-04-28 Sunday"
-  , "2020, Gregorian: moon, 2020-04-08: Easter, 2020-04-12 Sunday"
-  , "2020, Orthodox : moon, 2020-04-12: Easter, 2020-04-19 Sunday" ]
+    unlines
+        [ "2003-12-27 Saturday -> 2003-12-28 Sunday"
+        , "2003-12-28 Sunday -> 2004-01-04 Sunday"
+        , "2003-12-29 Monday -> 2004-01-04 Sunday"
+        , "2003-12-30 Tuesday -> 2004-01-04 Sunday"
+        , "2003-12-31 Wednesday -> 2004-01-04 Sunday"
+        , "2004-01-01 Thursday -> 2004-01-04 Sunday"
+        , "2004-01-02 Friday -> 2004-01-04 Sunday"
+        , "2004-01-03 Saturday -> 2004-01-04 Sunday"
+        , "2004-01-04 Sunday -> 2004-01-11 Sunday"
+        , "2004-01-05 Monday -> 2004-01-11 Sunday"
+        , "2004-01-06 Tuesday -> 2004-01-11 Sunday"
+        , "2004-01-07 Wednesday -> 2004-01-11 Sunday"
+        , "2004-01-08 Thursday -> 2004-01-11 Sunday"
+        , "2004-01-09 Friday -> 2004-01-11 Sunday"
+        , "2004-01-10 Saturday -> 2004-01-11 Sunday"
+        , "2000, Gregorian: moon, 2000-04-18: Easter, 2000-04-23 Sunday"
+        , "2000, Orthodox : moon, 2000-04-23: Easter, 2000-04-30 Sunday"
+        , "2001, Gregorian: moon, 2001-04-08: Easter, 2001-04-15 Sunday"
+        , "2001, Orthodox : moon, 2001-04-12: Easter, 2001-04-15 Sunday"
+        , "2002, Gregorian: moon, 2002-03-28: Easter, 2002-03-31 Sunday"
+        , "2002, Orthodox : moon, 2002-05-01: Easter, 2002-05-05 Sunday"
+        , "2003, Gregorian: moon, 2003-04-16: Easter, 2003-04-20 Sunday"
+        , "2003, Orthodox : moon, 2003-04-20: Easter, 2003-04-27 Sunday"
+        , "2004, Gregorian: moon, 2004-04-05: Easter, 2004-04-11 Sunday"
+        , "2004, Orthodox : moon, 2004-04-09: Easter, 2004-04-11 Sunday"
+        , "2005, Gregorian: moon, 2005-03-25: Easter, 2005-03-27 Sunday"
+        , "2005, Orthodox : moon, 2005-04-28: Easter, 2005-05-01 Sunday"
+        , "2006, Gregorian: moon, 2006-04-13: Easter, 2006-04-16 Sunday"
+        , "2006, Orthodox : moon, 2006-04-17: Easter, 2006-04-23 Sunday"
+        , "2007, Gregorian: moon, 2007-04-02: Easter, 2007-04-08 Sunday"
+        , "2007, Orthodox : moon, 2007-04-06: Easter, 2007-04-08 Sunday"
+        , "2008, Gregorian: moon, 2008-03-22: Easter, 2008-03-23 Sunday"
+        , "2008, Orthodox : moon, 2008-04-25: Easter, 2008-04-27 Sunday"
+        , "2009, Gregorian: moon, 2009-04-10: Easter, 2009-04-12 Sunday"
+        , "2009, Orthodox : moon, 2009-04-14: Easter, 2009-04-19 Sunday"
+        , "2010, Gregorian: moon, 2010-03-30: Easter, 2010-04-04 Sunday"
+        , "2010, Orthodox : moon, 2010-04-03: Easter, 2010-04-04 Sunday"
+        , "2011, Gregorian: moon, 2011-04-18: Easter, 2011-04-24 Sunday"
+        , "2011, Orthodox : moon, 2011-04-22: Easter, 2011-04-24 Sunday"
+        , "2012, Gregorian: moon, 2012-04-07: Easter, 2012-04-08 Sunday"
+        , "2012, Orthodox : moon, 2012-04-11: Easter, 2012-04-15 Sunday"
+        , "2013, Gregorian: moon, 2013-03-27: Easter, 2013-03-31 Sunday"
+        , "2013, Orthodox : moon, 2013-04-30: Easter, 2013-05-05 Sunday"
+        , "2014, Gregorian: moon, 2014-04-14: Easter, 2014-04-20 Sunday"
+        , "2014, Orthodox : moon, 2014-04-18: Easter, 2014-04-20 Sunday"
+        , "2015, Gregorian: moon, 2015-04-03: Easter, 2015-04-05 Sunday"
+        , "2015, Orthodox : moon, 2015-04-07: Easter, 2015-04-12 Sunday"
+        , "2016, Gregorian: moon, 2016-03-23: Easter, 2016-03-27 Sunday"
+        , "2016, Orthodox : moon, 2016-04-26: Easter, 2016-05-01 Sunday"
+        , "2017, Gregorian: moon, 2017-04-11: Easter, 2017-04-16 Sunday"
+        , "2017, Orthodox : moon, 2017-04-15: Easter, 2017-04-16 Sunday"
+        , "2018, Gregorian: moon, 2018-03-31: Easter, 2018-04-01 Sunday"
+        , "2018, Orthodox : moon, 2018-04-04: Easter, 2018-04-08 Sunday"
+        , "2019, Gregorian: moon, 2019-04-18: Easter, 2019-04-21 Sunday"
+        , "2019, Orthodox : moon, 2019-04-23: Easter, 2019-04-28 Sunday"
+        , "2020, Gregorian: moon, 2020-04-08: Easter, 2020-04-12 Sunday"
+        , "2020, Orthodox : moon, 2020-04-12: Easter, 2020-04-19 Sunday"
+        ]
index 1beeed5..fec011d 100644 (file)
@@ -1,21 +1,30 @@
-module Test.Calendar.LongWeekYears(longWeekYears) where
+module Test.Calendar.LongWeekYears
+    ( longWeekYears
+    ) where
 
-import Data.Time.Calendar.WeekDate
 import Data.Time.Calendar
+import Data.Time.Calendar.WeekDate
+import Test.Calendar.LongWeekYearsRef
 import Test.Tasty
 import Test.Tasty.HUnit
-import Test.Calendar.LongWeekYearsRef
 
 longYear :: Integer -> Bool
-longYear year = case toWeekDate (fromGregorian year 12 31) of
-    (_,53,_) -> True
-    _ -> False
+longYear year =
+    case toWeekDate (fromGregorian year 12 31) of
+        (_, 53, _) -> True
+        _ -> False
 
 showLongYear :: Integer -> String
-showLongYear year
-  = unwords [ show year ++ ":"
-            , (if isLeapYear year then "L" else " ") ++ (if longYear year then "*" else " ") ]
+showLongYear year =
+    unwords
+        [ show year ++ ":"
+        , (if isLeapYear year
+               then "L"
+               else " ") ++
+          (if longYear year
+               then "*"
+               else " ")
+        ]
 
 longWeekYears :: TestTree
-longWeekYears = testCase "longWeekYears" $
-    assertEqual "" longWeekYearsRef $ unlines $ map showLongYear [1901 .. 2050]
+longWeekYears = testCase "longWeekYears" $ assertEqual "" longWeekYearsRef $ unlines $ map showLongYear [1901 .. 2050]
index a0afd8c..84e52cb 100644 (file)
@@ -2,154 +2,155 @@ module Test.Calendar.LongWeekYearsRef where
 
 longWeekYearsRef :: String
 longWeekYearsRef =
- unlines
-  [ "1901:   "
-  , "1902:   "
-  , "1903:  *"
-  , "1904: L "
-  , "1905:   "
-  , "1906:   "
-  , "1907:   "
-  , "1908: L*"
-  , "1909:   "
-  , "1910:   "
-  , "1911:   "
-  , "1912: L "
-  , "1913:   "
-  , "1914:  *"
-  , "1915:   "
-  , "1916: L "
-  , "1917:   "
-  , "1918:   "
-  , "1919:   "
-  , "1920: L*"
-  , "1921:   "
-  , "1922:   "
-  , "1923:   "
-  , "1924: L "
-  , "1925:  *"
-  , "1926:   "
-  , "1927:   "
-  , "1928: L "
-  , "1929:   "
-  , "1930:   "
-  , "1931:  *"
-  , "1932: L "
-  , "1933:   "
-  , "1934:   "
-  , "1935:   "
-  , "1936: L*"
-  , "1937:   "
-  , "1938:   "
-  , "1939:   "
-  , "1940: L "
-  , "1941:   "
-  , "1942:  *"
-  , "1943:   "
-  , "1944: L "
-  , "1945:   "
-  , "1946:   "
-  , "1947:   "
-  , "1948: L*"
-  , "1949:   "
-  , "1950:   "
-  , "1951:   "
-  , "1952: L "
-  , "1953:  *"
-  , "1954:   "
-  , "1955:   "
-  , "1956: L "
-  , "1957:   "
-  , "1958:   "
-  , "1959:  *"
-  , "1960: L "
-  , "1961:   "
-  , "1962:   "
-  , "1963:   "
-  , "1964: L*"
-  , "1965:   "
-  , "1966:   "
-  , "1967:   "
-  , "1968: L "
-  , "1969:   "
-  , "1970:  *"
-  , "1971:   "
-  , "1972: L "
-  , "1973:   "
-  , "1974:   "
-  , "1975:   "
-  , "1976: L*"
-  , "1977:   "
-  , "1978:   "
-  , "1979:   "
-  , "1980: L "
-  , "1981:  *"
-  , "1982:   "
-  , "1983:   "
-  , "1984: L "
-  , "1985:   "
-  , "1986:   "
-  , "1987:  *"
-  , "1988: L "
-  , "1989:   "
-  , "1990:   "
-  , "1991:   "
-  , "1992: L*"
-  , "1993:   "
-  , "1994:   "
-  , "1995:   "
-  , "1996: L "
-  , "1997:   "
-  , "1998:  *"
-  , "1999:   "
-  , "2000: L "
-  , "2001:   "
-  , "2002:   "
-  , "2003:   "
-  , "2004: L*"
-  , "2005:   "
-  , "2006:   "
-  , "2007:   "
-  , "2008: L "
-  , "2009:  *"
-  , "2010:   "
-  , "2011:   "
-  , "2012: L "
-  , "2013:   "
-  , "2014:   "
-  , "2015:  *"
-  , "2016: L "
-  , "2017:   "
-  , "2018:   "
-  , "2019:   "
-  , "2020: L*"
-  , "2021:   "
-  , "2022:   "
-  , "2023:   "
-  , "2024: L "
-  , "2025:   "
-  , "2026:  *"
-  , "2027:   "
-  , "2028: L "
-  , "2029:   "
-  , "2030:   "
-  , "2031:   "
-  , "2032: L*"
-  , "2033:   "
-  , "2034:   "
-  , "2035:   "
-  , "2036: L "
-  , "2037:  *"
-  , "2038:   "
-  , "2039:   "
-  , "2040: L "
-  , "2041:   "
-  , "2042:   "
-  , "2043:  *"
-  , "2044: L "
-  , "2045:   "
-  , "2046:   "
-  , "2047:   "
-  , "2048: L*"
-  , "2049:   "
-  , "2050:   " ]
+    unlines
+        [ "1901:   "
+        , "1902:   "
+        , "1903:  *"
+        , "1904: L "
+        , "1905:   "
+        , "1906:   "
+        , "1907:   "
+        , "1908: L*"
+        , "1909:   "
+        , "1910:   "
+        , "1911:   "
+        , "1912: L "
+        , "1913:   "
+        , "1914:  *"
+        , "1915:   "
+        , "1916: L "
+        , "1917:   "
+        , "1918:   "
+        , "1919:   "
+        , "1920: L*"
+        , "1921:   "
+        , "1922:   "
+        , "1923:   "
+        , "1924: L "
+        , "1925:  *"
+        , "1926:   "
+        , "1927:   "
+        , "1928: L "
+        , "1929:   "
+        , "1930:   "
+        , "1931:  *"
+        , "1932: L "
+        , "1933:   "
+        , "1934:   "
+        , "1935:   "
+        , "1936: L*"
+        , "1937:   "
+        , "1938:   "
+        , "1939:   "
+        , "1940: L "
+        , "1941:   "
+        , "1942:  *"
+        , "1943:   "
+        , "1944: L "
+        , "1945:   "
+        , "1946:   "
+        , "1947:   "
+        , "1948: L*"
+        , "1949:   "
+        , "1950:   "
+        , "1951:   "
+        , "1952: L "
+        , "1953:  *"
+        , "1954:   "
+        , "1955:   "
+        , "1956: L "
+        , "1957:   "
+        , "1958:   "
+        , "1959:  *"
+        , "1960: L "
+        , "1961:   "
+        , "1962:   "
+        , "1963:   "
+        , "1964: L*"
+        , "1965:   "
+        , "1966:   "
+        , "1967:   "
+        , "1968: L "
+        , "1969:   "
+        , "1970:  *"
+        , "1971:   "
+        , "1972: L "
+        , "1973:   "
+        , "1974:   "
+        , "1975:   "
+        , "1976: L*"
+        , "1977:   "
+        , "1978:   "
+        , "1979:   "
+        , "1980: L "
+        , "1981:  *"
+        , "1982:   "
+        , "1983:   "
+        , "1984: L "
+        , "1985:   "
+        , "1986:   "
+        , "1987:  *"
+        , "1988: L "
+        , "1989:   "
+        , "1990:   "
+        , "1991:   "
+        , "1992: L*"
+        , "1993:   "
+        , "1994:   "
+        , "1995:   "
+        , "1996: L "
+        , "1997:   "
+        , "1998:  *"
+        , "1999:   "
+        , "2000: L "
+        , "2001:   "
+        , "2002:   "
+        , "2003:   "
+        , "2004: L*"
+        , "2005:   "
+        , "2006:   "
+        , "2007:   "
+        , "2008: L "
+        , "2009:  *"
+        , "2010:   "
+        , "2011:   "
+        , "2012: L "
+        , "2013:   "
+        , "2014:   "
+        , "2015:  *"
+        , "2016: L "
+        , "2017:   "
+        , "2018:   "
+        , "2019:   "
+        , "2020: L*"
+        , "2021:   "
+        , "2022:   "
+        , "2023:   "
+        , "2024: L "
+        , "2025:   "
+        , "2026:  *"
+        , "2027:   "
+        , "2028: L "
+        , "2029:   "
+        , "2030:   "
+        , "2031:   "
+        , "2032: L*"
+     &nb