-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A time library
--   
--   Time, clocks and calendars
@package time
@version 1.11.1.1


-- | ISO 8601 Ordinal Date format
module Data.Time.Calendar.OrdinalDate

-- | The Modified Julian Day is a standard count of days, with zero being
--   the day 1858-11-17.
data Day

-- | Year of Common Era.
type Year = Integer

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

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

-- | Bidirectional abstract constructor for ISO 8601 Ordinal Date format.
--   Invalid day numbers will be clipped to the correct range (1 to 365 or
--   366).
pattern YearDay :: Year -> DayOfYear -> Day

-- | The inverse of <a>mondayStartWeek</a>. Get a <a>Day</a> given the
--   year, 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 <tt>%W</tt> in <a>formatTime</a>).
fromMondayStartWeek :: Year -> WeekOfYear -> Int -> Day
fromMondayStartWeekValid :: Year -> WeekOfYear -> Int -> Maybe Day

-- | Convert from ISO 8601 Ordinal Date format. Invalid day numbers will be
--   clipped to the correct range (1 to 365 or 366).
fromOrdinalDate :: Year -> DayOfYear -> Day

-- | Convert from ISO 8601 Ordinal Date format. Invalid day numbers return
--   <a>Nothing</a>
fromOrdinalDateValid :: Year -> DayOfYear -> Maybe Day

-- | The inverse of <a>sundayStartWeek</a>. Get a <a>Day</a> 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 <tt>%U</tt> in <a>formatTime</a>).
fromSundayStartWeek :: Year -> WeekOfYear -> Int -> Day
fromSundayStartWeekValid :: Year -> WeekOfYear -> Int -> Maybe Day

-- | Is this year a leap year according to the proleptic Gregorian
--   calendar?
isLeapYear :: Year -> Bool

-- | 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 <tt>%W</tt> in <a>formatTime</a>).
--   Monday is 1, Sunday is 7 (as <tt>%u</tt> in <a>formatTime</a>).
mondayStartWeek :: Day -> (WeekOfYear, Int)

-- | Show in ISO 8601 Ordinal Date format (yyyy-ddd)
showOrdinalDate :: Day -> String

-- | 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 <tt>%U</tt> in <a>formatTime</a>).
--   Sunday is 0, Saturday is 6 (as <tt>%w</tt> in <a>formatTime</a>).
sundayStartWeek :: Day -> (WeekOfYear, Int)

-- | Convert to ISO 8601 Ordinal Date format.
toOrdinalDate :: Day -> (Year, DayOfYear)

module Data.Time.Calendar.MonthDay

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

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

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

-- | Convert month and day in the Gregorian or Julian calendars to day of
--   year. First arg is leap year flag.
monthAndDayToDayOfYear :: Bool -> MonthOfYear -> DayOfMonth -> DayOfYear

-- | Convert month and day in the Gregorian or Julian calendars to day of
--   year. First arg is leap year flag.
monthAndDayToDayOfYearValid :: Bool -> MonthOfYear -> DayOfMonth -> Maybe DayOfYear

-- | Convert day of year in the Gregorian or Julian calendars to month and
--   day. First arg is leap year flag.
dayOfYearToMonthAndDay :: Bool -> DayOfYear -> (MonthOfYear, DayOfMonth)

-- | The length of a given month in the Gregorian or Julian calendars.
--   First arg is leap year flag.
monthLength :: Bool -> MonthOfYear -> DayOfMonth

module Data.Time.Calendar.Julian

-- | Year of Common Era.
type Year = Integer

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

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

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

-- | Convert from proleptic Julian year and day format. Invalid day numbers
--   will be clipped to the correct range (1 to 365 or 366).
fromJulianYearAndDay :: Year -> DayOfYear -> Day

-- | Convert from proleptic Julian year and day format. Invalid day numbers
--   will return Nothing
fromJulianYearAndDayValid :: Year -> DayOfYear -> Maybe Day

-- | Is this year a leap year according to the proleptic Julian calendar?
isJulianLeapYear :: Year -> Bool

-- | Show in proleptic Julian year and day format (yyyy-ddd)
showJulianYearAndDay :: Day -> String

-- | Convert to proleptic Julian year and day format.
toJulianYearAndDay :: Day -> (Year, DayOfYear)

-- | Convert to proleptic Julian calendar.
toJulian :: Day -> (Year, MonthOfYear, DayOfMonth)

-- | Convert from proleptic Julian calendar. Invalid values will be clipped
--   to the correct range, month first, then day.
fromJulian :: Year -> MonthOfYear -> DayOfMonth -> Day

-- | Bidirectional abstract constructor for the proleptic Julian calendar.
--   Invalid values will be clipped to the correct range, month first, then
--   day.
pattern JulianYearMonthDay :: Year -> MonthOfYear -> DayOfMonth -> Day

-- | Convert from proleptic Julian calendar. Invalid values will return
--   Nothing.
fromJulianValid :: Year -> MonthOfYear -> DayOfMonth -> Maybe Day

-- | Show in ISO 8601 format (yyyy-mm-dd)
showJulian :: Day -> String

-- | The number of days in a given month according to the proleptic Julian
--   calendar.
julianMonthLength :: Year -> MonthOfYear -> DayOfMonth

-- | 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

-- | 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

-- | 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.
addJulianYearsClip :: Integer -> Day -> Day

-- | Add years, matching month and day, with Feb 29th rolled over to Mar
--   1st if necessary. For instance, 2004-02-29 + 2 years = 2006-03-01.
addJulianYearsRollOver :: Integer -> Day -> Day

-- | Add months (clipped to last day), then add days
addJulianDurationClip :: CalendarDiffDays -> Day -> Day

-- | Add months (rolling over to next month), then add days
addJulianDurationRollOver :: CalendarDiffDays -> Day -> Day

-- | Calendrical difference, with as many whole months as possible
diffJulianDurationClip :: Day -> Day -> CalendarDiffDays

-- | Calendrical difference, with as many whole months as possible. Same as
--   <a>diffJulianDurationClip</a> for positive durations.
diffJulianDurationRollOver :: Day -> Day -> CalendarDiffDays


-- | An absolute count of common calendar months.
module Data.Time.Calendar.Month

-- | An absolute count of common calendar months. Number is equal to
--   <tt>(year * 12) + (monthOfYear - 1)</tt>.
newtype Month
MkMonth :: Integer -> Month
addMonths :: Integer -> Month -> Month
diffMonths :: Month -> Month -> Integer

-- | Bidirectional abstract constructor. Invalid months of year will be
--   clipped to the correct range.
pattern YearMonth :: Year -> MonthOfYear -> Month
fromYearMonthValid :: Year -> MonthOfYear -> Maybe Month

-- | Bidirectional abstract constructor. Invalid days of month will be
--   clipped to the correct range.
pattern MonthDay :: Month -> DayOfMonth -> Day
fromMonthDayValid :: Month -> DayOfMonth -> Maybe Day
instance Data.Data.Data Data.Time.Calendar.Month.Month
instance GHC.Classes.Ord Data.Time.Calendar.Month.Month
instance GHC.Classes.Eq Data.Time.Calendar.Month.Month
instance Control.DeepSeq.NFData Data.Time.Calendar.Month.Month
instance GHC.Enum.Enum Data.Time.Calendar.Month.Month
instance GHC.Ix.Ix Data.Time.Calendar.Month.Month
instance GHC.Show.Show Data.Time.Calendar.Month.Month
instance GHC.Read.Read Data.Time.Calendar.Month.Month


-- | Year quarters.
module Data.Time.Calendar.Quarter

-- | Quarters of each year. Each quarter corresponds to three months.
data QuarterOfYear
Q1 :: QuarterOfYear
Q2 :: QuarterOfYear
Q3 :: QuarterOfYear
Q4 :: QuarterOfYear
addQuarters :: Integer -> Quarter -> Quarter
diffQuarters :: Quarter -> Quarter -> Integer

-- | An absolute count of year quarters. Number is equal to <tt>(year * 4)
--   + (quarterOfYear - 1)</tt>.
newtype Quarter
MkQuarter :: Integer -> Quarter

-- | Bidirectional abstract constructor.
pattern YearQuarter :: Year -> QuarterOfYear -> Quarter
monthOfYearQuarter :: MonthOfYear -> QuarterOfYear
monthQuarter :: Month -> Quarter
dayQuarter :: Day -> Quarter
instance GHC.Ix.Ix Data.Time.Calendar.Quarter.QuarterOfYear
instance GHC.Show.Show Data.Time.Calendar.Quarter.QuarterOfYear
instance GHC.Read.Read Data.Time.Calendar.Quarter.QuarterOfYear
instance Data.Data.Data Data.Time.Calendar.Quarter.QuarterOfYear
instance GHC.Classes.Ord Data.Time.Calendar.Quarter.QuarterOfYear
instance GHC.Classes.Eq Data.Time.Calendar.Quarter.QuarterOfYear
instance Data.Data.Data Data.Time.Calendar.Quarter.Quarter
instance GHC.Classes.Ord Data.Time.Calendar.Quarter.Quarter
instance GHC.Classes.Eq Data.Time.Calendar.Quarter.Quarter
instance Control.DeepSeq.NFData Data.Time.Calendar.Quarter.Quarter
instance GHC.Enum.Enum Data.Time.Calendar.Quarter.Quarter
instance GHC.Ix.Ix Data.Time.Calendar.Quarter.Quarter
instance GHC.Show.Show Data.Time.Calendar.Quarter.Quarter
instance GHC.Read.Read Data.Time.Calendar.Quarter.Quarter
instance GHC.Enum.Enum Data.Time.Calendar.Quarter.QuarterOfYear
instance GHC.Enum.Bounded Data.Time.Calendar.Quarter.QuarterOfYear
instance Control.DeepSeq.NFData Data.Time.Calendar.Quarter.QuarterOfYear


-- | Week-based calendars
module Data.Time.Calendar.WeekDate

-- | Year of Common Era.
type Year = Integer

-- | Week of year, by various reckonings, generally in range 0-53 depending
--   on reckoning
type WeekOfYear = Int
data DayOfWeek
Monday :: DayOfWeek
Tuesday :: DayOfWeek
Wednesday :: DayOfWeek
Thursday :: DayOfWeek
Friday :: DayOfWeek
Saturday :: DayOfWeek
Sunday :: DayOfWeek
dayOfWeek :: Day -> DayOfWeek
data FirstWeekType

-- | first week is the first whole week of the year
FirstWholeWeek :: FirstWeekType

-- | first week is the first week with four days in the year
FirstMostWeek :: FirstWeekType

-- | Convert to the given kind of "week calendar". Note that the year
--   number matches the weeks, and so is not always the same as the
--   Gregorian year number.
toWeekCalendar :: FirstWeekType -> DayOfWeek -> Day -> (Year, WeekOfYear, DayOfWeek)

-- | Convert from the given kind of "week calendar". Invalid week and day
--   values will be clipped to the correct range.
fromWeekCalendar :: FirstWeekType -> DayOfWeek -> Year -> WeekOfYear -> DayOfWeek -> Day

-- | Convert from the given kind of "week calendar". Invalid week and day
--   values will return Nothing.
fromWeekCalendarValid :: FirstWeekType -> DayOfWeek -> Year -> WeekOfYear -> DayOfWeek -> Maybe Day

-- | 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 -> (Year, WeekOfYear, Int)

-- | 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 :: Year -> WeekOfYear -> Int -> Day

-- | Bidirectional abstract constructor for ISO 8601 Week Date format.
--   Invalid week values will be clipped to the correct range.
pattern YearWeekDay :: Year -> WeekOfYear -> DayOfWeek -> Day

-- | 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 return Nothing.
fromWeekDateValid :: Year -> WeekOfYear -> Int -> Maybe Day

-- | Show in ISO 8601 Week Date format as yyyy-Www-d (e.g. "2006-W46-3").
showWeekDate :: Day -> String
instance GHC.Classes.Eq Data.Time.Calendar.WeekDate.FirstWeekType


-- | Fast access to the system clock.
module Data.Time.Clock.System

-- | The day of the epoch of <a>SystemTime</a>, 1970-01-01
systemEpochDay :: Day

-- | <a>SystemTime</a> 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 <a>systemNanoseconds</a> of 1E9 to
--   2E9-1 can be used to represent leap seconds.
data SystemTime
MkSystemTime :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Word32 -> SystemTime
[systemSeconds] :: SystemTime -> {-# UNPACK #-} !Int64
[systemNanoseconds] :: SystemTime -> {-# UNPACK #-} !Word32

-- | Map leap-second values to the start of the following second. The
--   resulting <a>systemNanoseconds</a> will always be in the range 0 to
--   1E9-1.
truncateSystemTimeLeapSecond :: SystemTime -> SystemTime

-- | Get the system time, epoch start of 1970 UTC, leap-seconds ignored.
--   <a>getSystemTime</a> is typically much faster than
--   <tt>getCurrentTime</tt>.
getSystemTime :: IO SystemTime

-- | Convert <a>SystemTime</a> to <a>UTCTime</a>, matching zero
--   <a>SystemTime</a> to midnight of <a>systemEpochDay</a> UTC.
systemToUTCTime :: SystemTime -> UTCTime

-- | Convert <a>UTCTime</a> to <a>SystemTime</a>, matching zero
--   <a>SystemTime</a> to midnight of <a>systemEpochDay</a> UTC.
utcToSystemTime :: UTCTime -> SystemTime

-- | Convert <a>SystemTime</a> to <a>AbsoluteTime</a>, matching zero
--   <a>SystemTime</a> to midnight of <a>systemEpochDay</a> TAI.
systemToTAITime :: SystemTime -> AbsoluteTime


-- | POSIX time, if you need to deal with timestamps and the like. Most
--   people won't need this module.
--   
--   You can use <a>POSIXTime</a> to obtain integer/word timestamps. For
--   example:
--   
--   <pre>
--   import Data.Time
--   import Data.Time.Clock.POSIX
--   import Data.Int
--   
--   nanosSinceEpoch :: UTCTime -&gt; Int64
--   nanosSinceEpoch =
--       floor . (1e9 *) . nominalDiffTimeToSeconds . utcTimeToPOSIXSeconds
--   
--   main :: IO ()
--   main = do
--       u &lt;- getCurrentTime
--       print $ nanosSinceEpoch u
--   </pre>
module Data.Time.Clock.POSIX

-- | 86400 nominal seconds in every day
posixDayLength :: NominalDiffTime

-- | POSIX time is the nominal time since 1970-01-01 00:00 UTC
--   
--   To convert from a <a>CTime</a> or <tt>System.Posix.EpochTime</tt>, use
--   <a>realToFrac</a>.
type POSIXTime = NominalDiffTime
posixSecondsToUTCTime :: POSIXTime -> UTCTime
utcTimeToPOSIXSeconds :: UTCTime -> POSIXTime

-- | Get the current POSIX time from the system clock.
getPOSIXTime :: IO POSIXTime

-- | Get the current <a>UTCTime</a> from the system clock.
getCurrentTime :: IO UTCTime
systemToPOSIXTime :: SystemTime -> POSIXTime


-- | The contents of this module is liable to change, or disappear
--   entirely. Please <a>let me know</a> if you depend on anything here.
module Data.Time.Format.Internal
class FormatTime t

formatCharacter :: FormatTime t => Bool -> Char -> Maybe (FormatOptions -> t -> String)

-- | The class of types which can be parsed given a UNIX-style time format
--   string.
class ParseTime t

substituteTimeSpecifier :: ParseTime t => Proxy t -> TimeLocale -> Char -> Maybe String

-- | Get the string corresponding to the given format specifier.
parseTimeSpecifier :: ParseTime t => Proxy t -> TimeLocale -> Maybe ParseNumericPadding -> Char -> ReadP String

-- | Builds a time value from a parsed input string. If the input does not
--   include all the information needed to construct a complete value, any
--   missing parts should be taken from 1970-01-01 00:00:00 +0000 (which
--   was a Thursday). In the absence of <tt>%C</tt> or <tt>%Y</tt>, century
--   is 1969 - 2068.
buildTime :: ParseTime t => TimeLocale -> [(Char, String)] -> Maybe t

module Data.Time.Format
class FormatTime t

-- | Substitute various time-related information for each %-code in the
--   string, as per <a>formatCharacter</a>.
--   
--   The general form is
--   <tt>%&lt;modifier&gt;&lt;width&gt;&lt;alternate&gt;&lt;specifier&gt;</tt>,
--   where <tt>&lt;modifier&gt;</tt>, <tt>&lt;width&gt;</tt>, and
--   <tt>&lt;alternate&gt;</tt> are optional.
--   
--   <h2><tt>&lt;modifier&gt;</tt></h2>
--   
--   glibc-style modifiers can be used before the specifier (here marked as
--   <tt>z</tt>):
--   
--   <ul>
--   <li><i><tt>%-z</tt></i> no padding</li>
--   <li><i><tt>%_z</tt></i> pad with spaces</li>
--   <li><i><tt>%0z</tt></i> pad with zeros</li>
--   <li><i><tt>%^z</tt></i> convert to upper case</li>
--   <li><i><tt>%#z</tt></i> convert to lower case (consistently, unlike
--   glibc)</li>
--   </ul>
--   
--   <h2><tt>&lt;width&gt;</tt></h2>
--   
--   Width digits can also be used after any modifiers and before the
--   specifier (here marked as <tt>z</tt>), for example:
--   
--   <ul>
--   <li><i><tt>%4z</tt></i> pad to 4 characters (with default padding
--   character)</li>
--   <li><i><tt>%_12z</tt></i> pad with spaces to 12 characters</li>
--   </ul>
--   
--   <h2><tt>&lt;alternate&gt;</tt></h2>
--   
--   An optional <tt>E</tt> character indicates an alternate formatting.
--   Currently this only affects <tt>%Z</tt> and <tt>%z</tt>.
--   
--   <ul>
--   <li><i><tt>%Ez</tt></i> alternate formatting</li>
--   </ul>
--   
--   <h2><tt>&lt;specifier&gt;</tt></h2>
--   
--   For all types (note these three are done by <a>formatTime</a>, not by
--   <a>formatCharacter</a>):
--   
--   <ul>
--   <li><i><tt>%%</tt></i> <tt>%</tt></li>
--   <li><i><tt>%t</tt></i> tab</li>
--   <li><i><tt>%n</tt></i> newline</li>
--   </ul>
--   
--   <h3><tt>TimeZone</tt></h3>
--   
--   For <tt>TimeZone</tt> (and <tt>ZonedTime</tt> and <tt>UTCTime</tt>):
--   
--   <ul>
--   <li><i><tt>%z</tt></i> timezone offset in the format
--   <tt>±HHMM</tt></li>
--   <li><i><tt>%Ez</tt></i> timezone offset in the format
--   <tt>±HH:MM</tt></li>
--   <li><i><tt>%Z</tt></i> timezone name (or else offset in the format
--   <tt>±HHMM</tt>)</li>
--   <li><i><tt>%EZ</tt></i> timezone name (or else offset in the format
--   <tt>±HH:MM</tt>)</li>
--   </ul>
--   
--   <h3><tt>LocalTime</tt></h3>
--   
--   For <tt>LocalTime</tt> (and <tt>ZonedTime</tt> and <tt>UTCTime</tt>
--   and <tt>UniversalTime</tt>):
--   
--   <ul>
--   <li><i><tt>%c</tt></i> as <a>dateTimeFmt</a> <tt>locale</tt> (e.g.
--   <tt>%a %b %e %H:%M:%S %Z %Y</tt>)</li>
--   </ul>
--   
--   <h3><tt>TimeOfDay</tt></h3>
--   
--   For <tt>TimeOfDay</tt> (and <tt>LocalTime</tt> and <tt>ZonedTime</tt>
--   and <tt>UTCTime</tt> and <tt>UniversalTime</tt>):
--   
--   <ul>
--   <li><i><tt>%R</tt></i> same as <tt>%H:%M</tt></li>
--   <li><i><tt>%T</tt></i> same as <tt>%H:%M:%S</tt></li>
--   <li><i><tt>%X</tt></i> as <a>timeFmt</a> <tt>locale</tt> (e.g.
--   <tt>%H:%M:%S</tt>)</li>
--   <li><i><tt>%r</tt></i> as <a>time12Fmt</a> <tt>locale</tt> (e.g.
--   <tt>%I:%M:%S %p</tt>)</li>
--   <li><i><tt>%P</tt></i> day-half of day from (<a>amPm</a>
--   <tt>locale</tt>), converted to lowercase, <tt>am</tt>,
--   <tt>pm</tt></li>
--   <li><i><tt>%p</tt></i> day-half of day from (<a>amPm</a>
--   <tt>locale</tt>), <tt>AM</tt>, <tt>PM</tt></li>
--   <li><i><tt>%H</tt></i> hour of day (24-hour), 0-padded to two chars,
--   <tt>00</tt> - <tt>23</tt></li>
--   <li><i><tt>%k</tt></i> hour of day (24-hour), space-padded to two
--   chars, <tt> 0</tt> - <tt>23</tt></li>
--   <li><i><tt>%I</tt></i> hour of day-half (12-hour), 0-padded to two
--   chars, <tt>01</tt> - <tt>12</tt></li>
--   <li><i><tt>%l</tt></i> hour of day-half (12-hour), space-padded to two
--   chars, <tt> 1</tt> - <tt>12</tt></li>
--   <li><i><tt>%M</tt></i> minute of hour, 0-padded to two chars,
--   <tt>00</tt> - <tt>59</tt></li>
--   <li><i><tt>%S</tt></i> second of minute (without decimal part),
--   0-padded to two chars, <tt>00</tt> - <tt>60</tt></li>
--   <li><i><tt>%q</tt></i> picosecond of second, 0-padded to twelve chars,
--   <tt>000000000000</tt> - <tt>999999999999</tt>.</li>
--   <li><i><tt>%Q</tt></i> decimal point and fraction of second, up to 12
--   second decimals, without trailing zeros. For a whole number of
--   seconds, <tt>%Q</tt> omits the decimal point unless padding is
--   specified.</li>
--   </ul>
--   
--   <h3><tt>UTCTime</tt> and <tt>ZonedTime</tt></h3>
--   
--   For <tt>UTCTime</tt> and <tt>ZonedTime</tt>:
--   
--   <ul>
--   <li><i><tt>%s</tt></i> number of whole seconds since the Unix epoch.
--   For times before the Unix epoch, this is a negative number. Note that
--   in <tt>%s.%q</tt> and <tt>%s%Q</tt> the decimals are positive, not
--   negative. For example, 0.9 seconds before the Unix epoch is formatted
--   as <tt>-1.1</tt> with <tt>%s%Q</tt>.</li>
--   </ul>
--   
--   <h3><tt>DayOfWeek</tt></h3>
--   
--   For <tt>DayOfWeek</tt> (and <tt>Day</tt> and <tt>LocalTime</tt> and
--   <tt>ZonedTime</tt> and <tt>UTCTime</tt> and <tt>UniversalTime</tt>):
--   
--   <ul>
--   <li><i><tt>%u</tt></i> day of week number for Week Date format,
--   <tt>1</tt> (= Monday) - <tt>7</tt> (= Sunday)</li>
--   <li><i><tt>%w</tt></i> day of week number, <tt>0</tt> (= Sunday) -
--   <tt>6</tt> (= Saturday)</li>
--   <li><i><tt>%a</tt></i> day of week, short form (<a>snd</a> from
--   <a>wDays</a> <tt>locale</tt>), <tt>Sun</tt> - <tt>Sat</tt></li>
--   <li><i><tt>%A</tt></i> day of week, long form (<a>fst</a> from
--   <a>wDays</a> <tt>locale</tt>), <tt>Sunday</tt> -
--   <tt>Saturday</tt></li>
--   </ul>
--   
--   <h3><tt>Month</tt></h3>
--   
--   For <tt>Month</tt> (and <tt>Day</tt> and <tt>LocalTime</tt> and
--   <tt>ZonedTime</tt> and <tt>UTCTime</tt> and <tt>UniversalTime</tt>):
--   
--   <ul>
--   <li><i><tt>%Y</tt></i> year, no padding. Note <tt>%0Y</tt> and
--   <tt>%_Y</tt> pad to four chars</li>
--   <li><i><tt>%y</tt></i> year of century, 0-padded to two chars,
--   <tt>00</tt> - <tt>99</tt></li>
--   <li><i><tt>%C</tt></i> century, no padding. Note <tt>%0C</tt> and
--   <tt>%_C</tt> pad to two chars</li>
--   <li><i><tt>%B</tt></i> month name, long form (<a>fst</a> from
--   <a>months</a> <tt>locale</tt>), <tt>January</tt> -
--   <tt>December</tt></li>
--   <li><i><tt>%b</tt>, <tt>%h</tt></i> month name, short form (<a>snd</a>
--   from <a>months</a> <tt>locale</tt>), <tt>Jan</tt> - <tt>Dec</tt></li>
--   <li><i><tt>%m</tt></i> month of year, 0-padded to two chars,
--   <tt>01</tt> - <tt>12</tt></li>
--   </ul>
--   
--   <h3><tt>Day</tt></h3>
--   
--   For <tt>Day</tt> (and <tt>LocalTime</tt> and <tt>ZonedTime</tt> and
--   <tt>UTCTime</tt> and <tt>UniversalTime</tt>):
--   
--   <ul>
--   <li><i><tt>%D</tt></i> same as <tt>%m/%d/%y</tt></li>
--   <li><i><tt>%F</tt></i> same as <tt>%Y-%m-%d</tt></li>
--   <li><i><tt>%x</tt></i> as <a>dateFmt</a> <tt>locale</tt> (e.g.
--   <tt>%m/%d/%y</tt>)</li>
--   <li><i><tt>%d</tt></i> day of month, 0-padded to two chars,
--   <tt>01</tt> - <tt>31</tt></li>
--   <li><i><tt>%e</tt></i> day of month, space-padded to two chars, <tt>
--   1</tt> - <tt>31</tt></li>
--   <li><i><tt>%j</tt></i> day of year, 0-padded to three chars,
--   <tt>001</tt> - <tt>366</tt></li>
--   <li><i><tt>%f</tt></i> century for Week Date format, no padding. Note
--   <tt>%0f</tt> and <tt>%_f</tt> pad to two chars</li>
--   <li><i><tt>%V</tt></i> week of year for Week Date format, 0-padded to
--   two chars, <tt>01</tt> - <tt>53</tt></li>
--   <li><i><tt>%U</tt></i> week of year where weeks start on Sunday (as
--   <tt>sundayStartWeek</tt>), 0-padded to two chars, <tt>00</tt> -
--   <tt>53</tt></li>
--   <li><i><tt>%W</tt></i> week of year where weeks start on Monday (as
--   <tt>mondayStartWeek</tt>), 0-padded to two chars, <tt>00</tt> -
--   <tt>53</tt></li>
--   </ul>
--   
--   <h2>Duration types</h2>
--   
--   The specifiers for <tt>DiffTime</tt>, <tt>NominalDiffTime</tt>,
--   <tt>CalendarDiffDays</tt>, and <tt>CalendarDiffTime</tt> are
--   semantically separate from the other types. Specifiers on negative
--   time differences will generally be negative (think <a>rem</a> rather
--   than <a>mod</a>).
--   
--   <h3><tt>NominalDiffTime</tt> and <tt>DiffTime</tt></h3>
--   
--   Note that a "minute" of <tt>DiffTime</tt> is simply 60 SI seconds,
--   rather than a minute of civil time. Use <tt>NominalDiffTime</tt> to
--   work with civil time, ignoring any leap seconds.
--   
--   For <tt>NominalDiffTime</tt> and <tt>DiffTime</tt>:
--   
--   <ul>
--   <li><i><tt>%w</tt></i> total whole weeks</li>
--   <li><i><tt>%d</tt></i> total whole days</li>
--   <li><i><tt>%D</tt></i> whole days of week</li>
--   <li><i><tt>%h</tt></i> total whole hours</li>
--   <li><i><tt>%H</tt></i> whole hours of day</li>
--   <li><i><tt>%m</tt></i> total whole minutes</li>
--   <li><i><tt>%M</tt></i> whole minutes of hour</li>
--   <li><i><tt>%s</tt></i> total whole seconds</li>
--   <li><i><tt>%Es</tt></i> total seconds, with decimal point and up to
--   &lt;width&gt; (default 12) decimal places, without trailing zeros. For
--   a whole number of seconds, <tt>%Es</tt> omits the decimal point unless
--   padding is specified.</li>
--   <li><i><tt>%0Es</tt></i> total seconds, with decimal point and
--   &lt;width&gt; (default 12) decimal places.</li>
--   <li><i><tt>%S</tt></i> whole seconds of minute</li>
--   <li><i><tt>%ES</tt></i> seconds of minute, with decimal point and up
--   to &lt;width&gt; (default 12) decimal places, without trailing zeros.
--   For a whole number of seconds, <tt>%ES</tt> omits the decimal point
--   unless padding is specified.</li>
--   <li><i><tt>%0ES</tt></i> seconds of minute as two digits, with decimal
--   point and &lt;width&gt; (default 12) decimal places.</li>
--   </ul>
--   
--   <h3><tt>CalendarDiffDays</tt></h3>
--   
--   For <tt>CalendarDiffDays</tt> (and <tt>CalendarDiffTime</tt>):
--   
--   <ul>
--   <li><i><tt>%y</tt></i> total years</li>
--   <li><i><tt>%b</tt></i> total months</li>
--   <li><i><tt>%B</tt></i> months of year</li>
--   <li><i><tt>%w</tt></i> total weeks, not including months</li>
--   <li><i><tt>%d</tt></i> total days, not including months</li>
--   <li><i><tt>%D</tt></i> days of week</li>
--   </ul>
--   
--   <h3><tt>CalendarDiffTime</tt></h3>
--   
--   For <tt>CalendarDiffTime</tt>:
--   
--   <ul>
--   <li><i><tt>%h</tt></i> total hours, not including months</li>
--   <li><i><tt>%H</tt></i> hours of day</li>
--   <li><i><tt>%m</tt></i> total minutes, not including months</li>
--   <li><i><tt>%M</tt></i> minutes of hour</li>
--   <li><i><tt>%s</tt></i> total whole seconds, not including months</li>
--   <li><i><tt>%Es</tt></i> total seconds, not including months, with
--   decimal point and up to &lt;width&gt; (default 12) decimal places,
--   without trailing zeros. For a whole number of seconds, <tt>%Es</tt>
--   omits the decimal point unless padding is specified.</li>
--   <li><i><tt>%0Es</tt></i> total seconds, not including months, with
--   decimal point and &lt;width&gt; (default 12) decimal places.</li>
--   <li><i><tt>%S</tt></i> whole seconds of minute</li>
--   <li><i><tt>%ES</tt></i> seconds of minute, with decimal point and up
--   to &lt;width&gt; (default 12) decimal places, without trailing zeros.
--   For a whole number of seconds, <tt>%ES</tt> omits the decimal point
--   unless padding is specified.</li>
--   <li><i><tt>%0ES</tt></i> seconds of minute as two digits, with decimal
--   point and &lt;width&gt; (default 12) decimal places.</li>
--   </ul>
formatTime :: FormatTime t => TimeLocale -> String -> t -> String

-- | Parses a time value given a format string. Missing information will be
--   derived from 1970-01-01 00:00 UTC (which was a Thursday). Supports the
--   same %-codes as <tt>formatTime</tt>, including <tt>%-</tt>,
--   <tt>%_</tt> and <tt>%0</tt> modifiers, however padding widths are not
--   supported. Case is not significant in the input string. Some
--   variations in the input are accepted:
--   
--   <ul>
--   <li><i><tt>%z</tt> <tt>%Ez</tt></i> accepts any of <tt>±HHMM</tt> or
--   <tt>±HH:MM</tt>.</li>
--   <li><i><tt>%Z</tt> <tt>%EZ</tt></i> accepts any string of letters, or
--   any of the formats accepted by <tt>%z</tt>.</li>
--   <li><i><tt>%0Y</tt></i> accepts exactly four digits.</li>
--   <li><i><tt>%0G</tt></i> accepts exactly four digits.</li>
--   <li><i><tt>%0C</tt></i> accepts exactly two digits.</li>
--   <li><i><tt>%0f</tt></i> accepts exactly two digits.</li>
--   </ul>
--   
--   For example, to parse a date in YYYY-MM-DD format, while allowing the
--   month and date to have optional leading zeros (notice the <tt>-</tt>
--   modifier used for <tt>%m</tt> and <tt>%d</tt>):
--   
--   <pre>
--   Prelude Data.Time&gt; parseTimeM True defaultTimeLocale "%Y-%-m-%-d" "2010-3-04" :: Maybe Day
--   Just 2010-03-04
--   </pre>
parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t

-- | Parses a time value given a list of pairs of format and input.
--   Resulting value is constructed from all provided specifiers.
parseTimeMultipleM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> [(String, String)] -> m t

-- | Parse a time value given a format string. Fails if the input could not
--   be parsed using the given format. See <a>parseTimeM</a> for details.
parseTimeOrError :: ParseTime t => Bool -> TimeLocale -> String -> String -> t

-- | Parse a time value given a format string. See <a>parseTimeM</a> for
--   details.
readSTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadS t

-- | Parse a time value given a format string. See <a>parseTimeM</a> for
--   details.
readPTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadP t

-- | The class of types which can be parsed given a UNIX-style time format
--   string.
class ParseTime t
data TimeLocale
TimeLocale :: [(String, String)] -> [(String, String)] -> (String, String) -> String -> [TimeZone] -> TimeLocale

-- | full and abbreviated week days, starting with Sunday
[wDays] :: TimeLocale -> [(String, String)]

-- | full and abbreviated months
[months] :: TimeLocale -> [(String, String)]

-- | AM/PM symbols
[amPm] :: TimeLocale -> (String, String)

-- | formatting strings

-- | formatting strings

-- | formatting strings

-- | formatting strings
[dateTimeFmt, dateFmt, timeFmt, time12Fmt] :: TimeLocale -> String

-- | time zones known by name
[knownTimeZones] :: TimeLocale -> [TimeZone]

-- | Locale representing American usage.
--   
--   <a>knownTimeZones</a> contains only the ten time-zones mentioned in
--   RFC 802 sec. 5: "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

-- | Construct format string according to <a>ISO-8601</a>.
--   
--   The <tt>Maybe String</tt> argument allows to supply an optional time
--   specification. E.g.:
--   
--   <pre>
--   <a>iso8601DateFormat</a> Nothing            == "%Y-%m-%d"           -- i.e. <tt><i>YYYY-MM-DD</i></tt>
--   <a>iso8601DateFormat</a> (Just "%H:%M:%S")  == "%Y-%m-%dT%H:%M:%S"  -- i.e. <tt><i>YYYY-MM-DD</i>T<i>HH:MM:SS</i></tt>
--   </pre>

-- | <i>Deprecated: use <a>Data.Time.Format.ISO8601</a> functions
--   instead</i>
iso8601DateFormat :: Maybe String -> String

-- | Format string according to <a>RFC822</a>.
rfc822DateFormat :: String

module Data.Time.LocalTime

-- | A TimeZone is a whole number of minutes offset from UTC, together with
--   a name and a "just for summer" flag.
data TimeZone
TimeZone :: Int -> Bool -> String -> TimeZone

-- | The number of minutes offset from UTC. Positive means local time will
--   be later in the day than UTC.
[timeZoneMinutes] :: TimeZone -> Int

-- | Is this time zone just persisting for the summer?
[timeZoneSummerOnly] :: TimeZone -> Bool

-- | The name of the zone, typically a three- or four-letter acronym.
[timeZoneName] :: TimeZone -> String

-- | Text representing the offset of this timezone, such as "-0800" or
--   "+0400" (like <tt>%z</tt> in formatTime).
timeZoneOffsetString :: TimeZone -> String

-- | Text representing the offset of this timezone, such as "-0800" or
--   "+0400" (like <tt>%z</tt> in formatTime), with arbitrary padding.
timeZoneOffsetString' :: Maybe Char -> TimeZone -> String

-- | Create a nameless non-summer timezone for this number of minutes.
minutesToTimeZone :: Int -> TimeZone

-- | Create a nameless non-summer timezone for this number of hours.
hoursToTimeZone :: Int -> TimeZone

-- | The UTC time zone.
utc :: TimeZone

-- | Get the local time-zone for a given time (varying as per summertime
--   adjustments).
getTimeZone :: UTCTime -> IO TimeZone

-- | Get the current time-zone.
getCurrentTimeZone :: IO TimeZone

-- | Time of day as represented in hour, minute and second (with
--   picoseconds), typically used to express local time of day.
data TimeOfDay
TimeOfDay :: Int -> Int -> Pico -> TimeOfDay

-- | range 0 - 23
[todHour] :: TimeOfDay -> Int

-- | range 0 - 59
[todMin] :: TimeOfDay -> Int

-- | Note that 0 &lt;= <a>todSec</a> &lt; 61, accomodating leap seconds.
--   Any local minute may have a leap second, since leap seconds happen in
--   all zones simultaneously
[todSec] :: TimeOfDay -> Pico

-- | Hour zero
midnight :: TimeOfDay

-- | Hour twelve
midday :: TimeOfDay
makeTimeOfDayValid :: Int -> Int -> Pico -> Maybe TimeOfDay

-- | 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)

-- | Convert a count of days and a time of day since midnight into a period
--   of time.
daysAndTimeOfDayToTime :: Integer -> TimeOfDay -> NominalDiffTime

-- | 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)

-- | 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)

-- | Get the time of day given a time since midnight. Time more than 24h
--   will be converted to leap-seconds.
timeToTimeOfDay :: DiffTime -> TimeOfDay

-- | Same as <a>timeToTimeOfDay</a>.
pastMidnight :: DiffTime -> TimeOfDay

-- | Get the time since midnight for a given time of day.
timeOfDayToTime :: TimeOfDay -> DiffTime

-- | Same as <a>timeOfDayToTime</a>.
sinceMidnight :: TimeOfDay -> DiffTime

-- | Get the time of day given the fraction of a day since midnight.
dayFractionToTimeOfDay :: Rational -> TimeOfDay

-- | Get the fraction of a day since midnight given a time of day.
timeOfDayToDayFraction :: TimeOfDay -> Rational
calendarTimeDays :: CalendarDiffDays -> CalendarDiffTime
calendarTimeTime :: NominalDiffTime -> CalendarDiffTime

-- | Scale by a factor. Note that <tt>scaleCalendarDiffTime (-1)</tt> will
--   not perfectly invert a duration, due to variable month lengths.
scaleCalendarDiffTime :: Integer -> CalendarDiffTime -> CalendarDiffTime
data CalendarDiffTime
CalendarDiffTime :: Integer -> NominalDiffTime -> CalendarDiffTime
[ctMonths] :: CalendarDiffTime -> Integer
[ctTime] :: CalendarDiffTime -> NominalDiffTime

-- | 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 :: Day -> TimeOfDay -> LocalTime
[localDay] :: LocalTime -> Day
[localTimeOfDay] :: LocalTime -> TimeOfDay

-- | addLocalTime a b = a + b
addLocalTime :: NominalDiffTime -> LocalTime -> LocalTime

-- | diffLocalTime a b = a - b
diffLocalTime :: LocalTime -> LocalTime -> NominalDiffTime

-- | Get the local time of a UTC time in a time zone.
utcToLocalTime :: TimeZone -> UTCTime -> LocalTime

-- | Get the UTC time of a local time in a time zone.
localTimeToUTC :: TimeZone -> LocalTime -> UTCTime

-- | Get the local time of a UT1 time on a particular meridian (in degrees,
--   positive is East).
ut1ToLocalTime :: Rational -> UniversalTime -> LocalTime

-- | Get the UT1 time of a local time on a particular meridian (in degrees,
--   positive is East).
localTimeToUT1 :: Rational -> LocalTime -> UniversalTime

-- | A local time together with a time zone.
--   
--   There is no <a>Eq</a> instance for <tt>ZonedTime</tt>. If you want to
--   compare local times, use <a>zonedTimeToLocalTime</a>. If you want to
--   compare absolute times, use <a>zonedTimeToUTC</a>.
data ZonedTime
ZonedTime :: LocalTime -> TimeZone -> ZonedTime
[zonedTimeToLocalTime] :: ZonedTime -> LocalTime
[zonedTimeZone] :: ZonedTime -> TimeZone
utcToZonedTime :: TimeZone -> UTCTime -> ZonedTime
zonedTimeToUTC :: ZonedTime -> UTCTime
getZonedTime :: IO ZonedTime

utcToLocalZonedTime :: UTCTime -> IO ZonedTime


-- | Types and functions for UTC and UT1
module Data.Time.Clock

-- | 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 :: Rational -> UniversalTime
[getModJulianDate] :: UniversalTime -> Rational

-- | This is a length of time, as measured by a clock. Conversion functions
--   such as <a>fromInteger</a> and <a>realToFrac</a> will treat it as
--   seconds. For example, <tt>(0.010 :: DiffTime)</tt> corresponds to 10
--   milliseconds.
--   
--   It has a precision of one picosecond (= 10^-12 s). Enumeration
--   functions will treat it as picoseconds.
data DiffTime

-- | Create a <a>DiffTime</a> which represents an integral number of
--   seconds.
secondsToDiffTime :: Integer -> DiffTime

-- | Create a <a>DiffTime</a> from a number of picoseconds.
picosecondsToDiffTime :: Integer -> DiffTime

-- | Get the number of picoseconds in a <a>DiffTime</a>.
diffTimeToPicoseconds :: DiffTime -> Integer

-- | 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 :: Day -> DiffTime -> UTCTime

-- | the day
[utctDay] :: UTCTime -> Day

-- | the time from midnight, 0 &lt;= t &lt; 86401s (because of
--   leap-seconds)
[utctDayTime] :: UTCTime -> DiffTime

-- | This is a length of time, as measured by UTC. It has a precision of
--   10^-12 s.
--   
--   Conversion functions such as <a>fromInteger</a> and <a>realToFrac</a>
--   will treat it as seconds. For example, <tt>(0.010 ::
--   NominalDiffTime)</tt> corresponds to 10 milliseconds.
--   
--   It has a precision of one picosecond (= 10^-12 s). Enumeration
--   functions will treat it as picoseconds.
--   
--   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.
data NominalDiffTime

-- | Create a <a>NominalDiffTime</a> from a number of seconds.
secondsToNominalDiffTime :: Pico -> NominalDiffTime

-- | Get the seconds in a <a>NominalDiffTime</a>.
nominalDiffTimeToSeconds :: NominalDiffTime -> Pico

-- | One day in <a>NominalDiffTime</a>.
nominalDay :: NominalDiffTime

-- | addUTCTime a b = a + b
addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime

-- | diffUTCTime a b = a - b
diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime

-- | Get the current <a>UTCTime</a> from the system clock.
getCurrentTime :: IO UTCTime

-- | The resolution of <a>getSystemTime</a>, <tt>getCurrentTime</tt>,
--   <tt>getPOSIXTime</tt>. On UNIX systems this uses
--   <tt>clock_getres</tt>, which may be <a>wrong on WSL2</a>.
getTime_resolution :: DiffTime


-- | TAI and leap-second maps for converting to UTC: most people won't need
--   this module.
module Data.Time.Clock.TAI

-- | AbsoluteTime is TAI, time as measured by a clock.
data AbsoluteTime

-- | The epoch of TAI, which is 1858-11-17 00:00:00 TAI.
taiEpoch :: AbsoluteTime

-- | addAbsoluteTime a b = a + b
addAbsoluteTime :: DiffTime -> AbsoluteTime -> AbsoluteTime

-- | diffAbsoluteTime a b = a - b
diffAbsoluteTime :: AbsoluteTime -> AbsoluteTime -> DiffTime
taiNominalDayStart :: Day -> AbsoluteTime

-- | TAI - UTC during this day. No table is provided, as any program
--   compiled with it would become out of date in six months.
type LeapSecondMap = Day -> Maybe Int
utcDayLength :: LeapSecondMap -> Day -> Maybe DiffTime
utcToTAITime :: LeapSecondMap -> UTCTime -> Maybe AbsoluteTime
taiToUTCTime :: LeapSecondMap -> AbsoluteTime -> Maybe UTCTime

-- | TAI clock, if it exists. Note that it is unlikely to be set correctly,
--   without due care and attention.
taiClock :: Maybe (DiffTime, IO AbsoluteTime)
instance GHC.Show.Show Data.Time.Clock.Internal.AbsoluteTime.AbsoluteTime

module Data.Time.Calendar

-- | The Modified Julian Day is a standard count of days, with zero being
--   the day 1858-11-17.
newtype Day
ModifiedJulianDay :: Integer -> Day
[toModifiedJulianDay] :: Day -> Integer
addDays :: Integer -> Day -> Day
diffDays :: Day -> Day -> Integer
calendarDay :: CalendarDiffDays
calendarMonth :: CalendarDiffDays
calendarWeek :: CalendarDiffDays
calendarYear :: CalendarDiffDays

-- | Scale by a factor. Note that <tt>scaleCalendarDiffDays (-1)</tt> will
--   not perfectly invert a duration, due to variable month lengths.
scaleCalendarDiffDays :: Integer -> CalendarDiffDays -> CalendarDiffDays
data CalendarDiffDays
CalendarDiffDays :: Integer -> Integer -> CalendarDiffDays
[cdMonths] :: CalendarDiffDays -> Integer
[cdDays] :: CalendarDiffDays -> Integer

-- | Year of Common Era.
type Year = Integer

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

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

-- | Convert to proleptic Gregorian calendar.
toGregorian :: Day -> (Year, MonthOfYear, DayOfMonth)

-- | Convert from proleptic Gregorian calendar. Invalid values will be
--   clipped to the correct range, month first, then day.
fromGregorian :: Year -> MonthOfYear -> DayOfMonth -> Day

-- | Bidirectional abstract constructor for the proleptic Gregorian
--   calendar. Invalid values will be clipped to the correct range, month
--   first, then day.
pattern YearMonthDay :: Year -> MonthOfYear -> DayOfMonth -> Day

-- | Convert from proleptic Gregorian calendar. Invalid values will return
--   Nothing
fromGregorianValid :: Year -> MonthOfYear -> DayOfMonth -> Maybe Day

-- | Show in ISO 8601 format (yyyy-mm-dd)
showGregorian :: Day -> String

-- | The number of days in a given month according to the proleptic
--   Gregorian calendar.
gregorianMonthLength :: Year -> MonthOfYear -> DayOfMonth

-- | 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

-- | 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

-- | 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.
addGregorianYearsClip :: Integer -> Day -> Day

-- | Add years, matching month and day, with Feb 29th rolled over to Mar
--   1st if necessary. For instance, 2004-02-29 + 2 years = 2006-03-01.
addGregorianYearsRollOver :: Integer -> Day -> Day

-- | Add months (clipped to last day), then add days
addGregorianDurationClip :: CalendarDiffDays -> Day -> Day

-- | Add months (rolling over to next month), then add days
addGregorianDurationRollOver :: CalendarDiffDays -> Day -> Day

-- | Calendrical difference, with as many whole months as possible
diffGregorianDurationClip :: Day -> Day -> CalendarDiffDays

-- | Calendrical difference, with as many whole months as possible. Same as
--   <a>diffGregorianDurationClip</a> for positive durations.
diffGregorianDurationRollOver :: Day -> Day -> CalendarDiffDays

-- | Is this year a leap year according to the proleptic Gregorian
--   calendar?
isLeapYear :: Year -> Bool
data DayOfWeek
Monday :: DayOfWeek
Tuesday :: DayOfWeek
Wednesday :: DayOfWeek
Thursday :: DayOfWeek
Friday :: DayOfWeek
Saturday :: DayOfWeek
Sunday :: DayOfWeek
dayOfWeek :: Day -> DayOfWeek

-- | <tt>dayOfWeekDiff a b = a - b</tt> in range 0 to 6. The number of days
--   from b to the next a.
dayOfWeekDiff :: DayOfWeek -> DayOfWeek -> Int

-- | The first day-of-week on or after some day
firstDayOfWeekOnAfter :: DayOfWeek -> Day -> Day

module Data.Time.Calendar.Easter

-- | The next Sunday strictly after a given day.
sundayAfter :: Day -> Day

-- | Given a year, find the Paschal full moon according to Orthodox
--   Christian tradition
orthodoxPaschalMoon :: Year -> Day

-- | Given a year, find Easter according to Orthodox Christian tradition
orthodoxEaster :: Year -> Day

-- | Given a year, find the Paschal full moon according to the Gregorian
--   method
gregorianPaschalMoon :: Year -> Day

-- | Given a year, find Easter according to the Gregorian method
gregorianEaster :: Year -> Day


-- | <h1>Quick Start</h1>
--   
--   Use these types for time regardless of location (not caring about
--   leap-seconds):
--   
--   <ul>
--   <li><a>UTCTime</a> for actual times</li>
--   <li><a>NominalDiffTime</a> for differences between times, i.e.
--   durations</li>
--   </ul>
--   
--   Use these types for the ways people refer to time and time
--   differences:
--   
--   <ul>
--   <li><a>Day</a> for something like June 27th 2017</li>
--   <li><a>DayOfWeek</a> for something like Tuesday</li>
--   <li><a>Month</a> for something like August 2021</li>
--   <li><a>QuarterOfYear</a> for something like Q2</li>
--   <li><a>Quarter</a> for something like Q2 of 2023</li>
--   <li><a>TimeOfDay</a> for something like 5pm</li>
--   <li><a>LocalTime</a> for a <a>Day</a> with a <a>TimeOfDay</a></li>
--   <li><a>TimeZone</a> for a time zone offset (not actually the time zone
--   itself) like -0700</li>
--   <li><a>ZonedTime</a> for a <a>LocalTime</a> with a
--   <a>TimeZone</a></li>
--   <li><a>CalendarDiffDays</a> for something like 6 years, 1 month and 5
--   days</li>
--   <li><a>CalendarDiffTime</a> for something like 6 years, 1 month, 5
--   days, 3 hours, 7 minutes and 25.784 seconds</li>
--   </ul>
--   
--   Use this for low-latency timing:
--   
--   <ul>
--   <li><a>SystemTime</a></li>
--   </ul>
--   
--   These are less commonly needed:
--   
--   <ul>
--   <li><a>AbsoluteTime</a> and <a>DiffTime</a> if you do care about
--   leap-seconds.</li>
--   <li><a>LeapSecondMap</a> for tracking the leap-seconds</li>
--   <li><a>UniversalTime</a> for time based on Earth rotation</li>
--   </ul>
module Data.Time

module Data.Time.Format.ISO8601

-- | A text format for a type
data Format t

-- | Show a value in the format, if representable
formatShowM :: Format t -> t -> Maybe String

-- | Show a value in the format, or error if unrepresentable
formatShow :: Format t -> t -> String

-- | Read a value in the format
formatReadP :: Format t -> ReadP t

-- | Parse a value in the format
formatParseM :: MonadFail m => Format t -> String -> m t
class ISO8601 t

-- | The most commonly used ISO 8601 format for this type.
iso8601Format :: ISO8601 t => Format t

-- | Show in the most commonly used ISO 8601 format.
iso8601Show :: ISO8601 t => t -> String

-- | Parse the most commonly used ISO 8601 format.
iso8601ParseM :: (MonadFail m, ISO8601 t) => String -> m t
data FormatExtension

-- | ISO 8601:2004(E) sec. 2.3.4. Use hyphens and colons.
ExtendedFormat :: FormatExtension

-- | ISO 8601:2004(E) sec. 2.3.3. Omit hyphens and colons. "The basic
--   format should be avoided in plain text."
BasicFormat :: FormatExtension

-- | Read a value in either extended or basic format
formatReadPExtension :: (FormatExtension -> Format t) -> ReadP t

-- | Parse a value in either extended or basic format
parseFormatExtension :: MonadFail m => (FormatExtension -> Format t) -> String -> m t

-- | ISO 8601:2004(E) sec. 4.1.2.2
calendarFormat :: FormatExtension -> Format Day

-- | ISO 8601:2004(E) sec. 4.1.2.3(a)
yearMonthFormat :: Format (Integer, Int)

-- | ISO 8601:2004(E) sec. 4.1.2.3(b)
yearFormat :: Format Integer

-- | ISO 8601:2004(E) sec. 4.1.2.3(c)
centuryFormat :: Format Integer

-- | ISO 8601:2004(E) sec. 4.1.2.4(a)
expandedCalendarFormat :: Int -> FormatExtension -> Format Day

-- | ISO 8601:2004(E) sec. 4.1.2.4(b)
expandedYearMonthFormat :: Int -> Format (Integer, Int)

-- | ISO 8601:2004(E) sec. 4.1.2.4(c)
expandedYearFormat :: Int -> Format Integer

-- | ISO 8601:2004(E) sec. 4.1.2.4(d)
expandedCenturyFormat :: Int -> Format Integer

-- | ISO 8601:2004(E) sec. 4.1.3.2
ordinalDateFormat :: FormatExtension -> Format Day

-- | ISO 8601:2004(E) sec. 4.1.3.3
expandedOrdinalDateFormat :: Int -> FormatExtension -> Format Day

-- | ISO 8601:2004(E) sec. 4.1.4.2
weekDateFormat :: FormatExtension -> Format Day

-- | ISO 8601:2004(E) sec. 4.1.4.3
yearWeekFormat :: FormatExtension -> Format (Integer, Int)

-- | ISO 8601:2004(E) sec. 4.1.4.2
expandedWeekDateFormat :: Int -> FormatExtension -> Format Day

-- | ISO 8601:2004(E) sec. 4.1.4.3
expandedYearWeekFormat :: Int -> FormatExtension -> Format (Integer, Int)

-- | ISO 8601:2004(E) sec. 4.2.2.2, 4.2.2.4(a)
timeOfDayFormat :: FormatExtension -> Format TimeOfDay

-- | ISO 8601:2004(E) sec. 4.2.2.3(a), 4.2.2.4(b)
hourMinuteFormat :: FormatExtension -> Format TimeOfDay

-- | ISO 8601:2004(E) sec. 4.2.2.3(b), 4.2.2.4(c)
hourFormat :: Format TimeOfDay

-- | ISO 8601:2004(E) sec. 4.2.2.5
withTimeDesignator :: Format t -> Format t

-- | ISO 8601:2004(E) sec. 4.2.4
withUTCDesignator :: Format t -> Format t

-- | ISO 8601:2004(E) sec. 4.2.5.1
timeOffsetFormat :: FormatExtension -> Format TimeZone

-- | ISO 8601:2004(E) sec. 4.2.5.2
timeOfDayAndOffsetFormat :: FormatExtension -> Format (TimeOfDay, TimeZone)

-- | ISO 8601:2004(E) sec. 4.3.2
localTimeFormat :: Format Day -> Format TimeOfDay -> Format LocalTime

-- | ISO 8601:2004(E) sec. 4.3.2
zonedTimeFormat :: Format Day -> Format TimeOfDay -> FormatExtension -> Format ZonedTime

-- | ISO 8601:2004(E) sec. 4.3.2
utcTimeFormat :: Format Day -> Format TimeOfDay -> Format UTCTime

-- | ISO 8601:2004(E) sec. 4.3.3
dayAndTimeFormat :: Format Day -> Format time -> Format (Day, time)

-- | ISO 8601:2004(E) sec. 4.3.3
timeAndOffsetFormat :: Format t -> FormatExtension -> Format (t, TimeZone)

-- | ISO 8601:2004(E) sec. 4.4.3.2
durationDaysFormat :: Format CalendarDiffDays

-- | ISO 8601:2004(E) sec. 4.4.3.2
durationTimeFormat :: Format CalendarDiffTime

-- | ISO 8601:2004(E) sec. 4.4.3.3
alternativeDurationDaysFormat :: FormatExtension -> Format CalendarDiffDays

-- | ISO 8601:2004(E) sec. 4.4.3.3
alternativeDurationTimeFormat :: FormatExtension -> Format CalendarDiffTime

-- | ISO 8601:2004(E) sec. 4.4.4.1
intervalFormat :: Format a -> Format b -> Format (a, b)

-- | ISO 8601:2004(E) sec. 4.5
recurringIntervalFormat :: Format a -> Format b -> Format (Int, a, b)
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.Calendar.Days.Day
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.LocalTime.Internal.TimeZone.TimeZone
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.LocalTime.Internal.LocalTime.LocalTime
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.LocalTime.Internal.ZonedTime.ZonedTime
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.Clock.Internal.UTCTime.UTCTime
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.Calendar.CalendarDiffDays.CalendarDiffDays
instance Data.Time.Format.ISO8601.ISO8601 Data.Time.LocalTime.Internal.CalendarDiffTime.CalendarDiffTime
instance Data.Fixed.HasResolution Data.Time.Format.ISO8601.E16
instance Data.Fixed.HasResolution Data.Time.Format.ISO8601.E14
