Get the current local date.

Get the current local month number.

Get the current local year.

Does the span include the given date ?

Does the period include the given date ? (Here to avoid import cycle).

Try to parse a couple of date string formats: `YYYY-MM-DD`, `YYYYMMDD` or DD, with leading zeros required. For internal use, not quite the same as the journal's "simple dates". >>> parsedateM "20080203" Just 2008-02-03 >>> parsedateM "20080203/" Nothing >>> parsedateM "20080230" Nothing

Render a datespan as a display string, abbreviating into a compact form if possible. Warning, hides whether dates are Exact or Flex.

Show a DateSpan with its begin/end dates, exact or flex.

Like showDateSpan, but show month spans as just the abbreviated month name in the current locale.

Parse a period expression, specifying a date span and optionally a reporting interval. Requires a reference "today" date for resolving any relative start/end dates (only; it is not needed for parsing the reporting interval).

>>> let p = parsePeriodExpr (fromGregorian 2008 11 26)
>>> p "from Aug to Oct"
Right (NoInterval,DateSpan 2008-08-01..2008-09-30)
>>> p "aug to oct"
Right (NoInterval,DateSpan 2008-08-01..2008-09-30)
>>> p "2009q2"
Right (NoInterval,DateSpan 2009Q2)
>>> p "Q3"
Right (NoInterval,DateSpan 2008Q3)
>>> p "every 3 days in Aug"
Right (Days 3,DateSpan 2008-08)
>>> p "daily from aug"
Right (Days 1,DateSpan 2008-08-01..)
>>> p "every week to 2009"
Right (Weeks 1,DateSpan ..2008-12-31)
>>> p "every 2nd day of month"
Right (DayOfMonth 2,DateSpan ..)
>>> p "every 2nd day"
Right (DayOfMonth 2,DateSpan ..)
>>> p "every 2nd day 2009.."
Right (DayOfMonth 2,DateSpan 2009-01-01..)
>>> p "every 2nd day 2009-"
Right (DayOfMonth 2,DateSpan 2009-01-01..)
>>> p "every 29th Nov"
Right (DayOfYear 11 29,DateSpan ..)
>>> p "every 29th nov ..2009"
Right (DayOfYear 11 29,DateSpan ..2008-12-31)
>>> p "every nov 29th"
Right (DayOfYear 11 29,DateSpan ..)
>>> p "every Nov 29th 2009.."
Right (DayOfYear 11 29,DateSpan 2009-01-01..)
>>> p "every 11/29 from 2009"
Right (DayOfYear 11 29,DateSpan 2009-01-01..)
>>> p "every 11/29 since 2009"
Right (DayOfYear 11 29,DateSpan 2009-01-01..)
>>> p "every 2nd Thursday of month to 2009"
Right (WeekdayOfMonth 2 4,DateSpan ..2008-12-31)
>>> p "every 1st monday of month to 2009"
Right (WeekdayOfMonth 1 1,DateSpan ..2008-12-31)
>>> p "every tue"
Right (DaysOfWeek [2],DateSpan ..)
>>> p "every 2nd day of week"
Right (DaysOfWeek [2],DateSpan ..)
>>> p "every 2nd day of month"
Right (DayOfMonth 2,DateSpan ..)
>>> p "every 2nd day"
Right (DayOfMonth 2,DateSpan ..)
>>> p "every 2nd day 2009.."
Right (DayOfMonth 2,DateSpan 2009-01-01..)
>>> p "every 2nd day of month 2009.."
Right (DayOfMonth 2,DateSpan 2009-01-01..)

Parse a period expression to an Interval and overall DateSpan using the provided reference date, or return a parse error.

Like parsePeriodExpr, but call error' on failure.

An exact datespan of zero length, that matches no date.

Get the 0-2 years mentioned explicitly in a DateSpan.

Get overall span enclosing multiple sequentially ordered spans. The start and end date will be exact or flexible depending on the first span's start date and last span's end date.

Calculate the intersection of two datespans.

For non-intersecting spans, gives an empty span beginning on the second's start date: >>> DateSpan (Just $ Flex $ fromGregorian 2018 01 01) (Just $ Flex $ fromGregorian 2018 01 03) spanIntersect DateSpan (Just $ Flex $ fromGregorian 2018 01 03) (Just $ Flex $ fromGregorian 2018 01 05) DateSpan 2018-01-03..2018-01-02

Calculate the intersection of a number of datespans.

Fill any unspecified dates in the first span with the dates from the second one (if specified there). Sort of a one-way spanIntersect.

Extend the first span to include any definite end dates of the second. Unlike spanUnion, open ends in the second are ignored. If the first span was open-ended, it still will be after being extended.

>>> ys2024 = fromGregorian 2024 01 01
>>> ys2025 = fromGregorian 2025 01 01
>>> to2024 = DateSpan Nothing               (Just $ Exact ys2024)
>>> all2024 = DateSpan (Just $ Exact ys2024) (Just $ Exact ys2025)
>>> partof2024 = DateSpan (Just $ Exact $ fromGregorian 2024 03 01) (Just $ Exact $ fromGregorian 2024 09 01)
>>> spanExtend to2024 all2024
DateSpan 2024
>>> spanExtend all2024 to2024
DateSpan 2024
>>> spanExtend partof2024 all2024
DateSpan 2024
>>> spanExtend all2024 partof2024
DateSpan 2024

Calculate the union of two datespans. If either span is open-ended, the union will be too.

>>> ys2024 = fromGregorian 2024 01 01
>>> ys2025 = fromGregorian 2025 01 01
>>> to2024 = DateSpan Nothing               (Just $ Exact ys2024)
>>> in2024 = DateSpan (Just $ Exact ys2024) (Just $ Exact ys2025)
>>> spanUnion to2024 in2024
DateSpan ..2024-12-31
>>> spanUnion in2024 to2024
DateSpan ..2024-12-31

Calculate the union of a number of datespans.

Calculate the minimal DateSpan containing all of the given Days (in the usual exclusive-end-date sense: beginning on the earliest, and ending on the day after the latest).

Select the DateSpan containing a given Day, if any, from a given list of DateSpans.

If the DateSpans are non-overlapping, this returns the unique containing DateSpan, if it exists. If the DateSpans are overlapping, it will return the containing DateSpan with the latest start date, and then latest end date.

Parse a date in any of the formats allowed in Ledger's period expressions, and some others. Assumes any text in the parse stream has been lowercased. Returns a SmartDate, to be converted to a full date later (see fixSmartDate).

Examples:

2004                                        (start of year, which must have 4+ digits)
2004/10                                     (start of month, which must be 1-12)
2004/10/1                                   (exact date, day must be 1-31)
10/1                                        (month and day in current year)
21                                          (day in current month)
october, oct                                (start of month in current year)
yesterday, today, tomorrow                  (-1, 0, 1 days from today)
last/this/next day/week/month/quarter/year  (-1, 0, 1 periods from the current period)
in n days/weeks/months/quarters/years       (n periods from the current period)
n days/weeks/months/quarters/years ago      (-n periods from the current period)
20181201                                    (8 digit YYYYMMDD with valid year month and day)
201812                                      (6 digit YYYYMM with valid year and month)

Note malformed digit sequences might give surprising results:

201813                                      (6 digits with an invalid month is parsed as start of 6-digit year)
20181301                                    (8 digits with an invalid month is parsed as start of 8-digit year)
20181232                                    (8 digits with an invalid day gives an error)
201801012                                   (9+ digits beginning with a valid YYYYMMDD gives an error)

Eg:

YYYYMMDD is parsed as year-month-date if those parts are valid (>=4 digits, 1-12, and 1-31 respectively): >>> parsewith (smartdate <* eof) "20181201" Right (SmartCompleteDate 2018-12-01)

YYYYMM is parsed as year-month-01 if year and month are valid: >>> parsewith (smartdate <* eof) "201804" Right (SmartAssumeStart 2018 (Just 4))

With an invalid month, it's parsed as a year: >>> parsewith (smartdate <* eof) "201813" Right (SmartAssumeStart 201813 Nothing)

A 9+ digit number beginning with valid YYYYMMDD gives an error: >>> parsewith (smartdate <* eof) "201801012" Left (...)

Big numbers not beginning with a valid YYYYMMDD are parsed as a year: >>> parsewith (smartdate <* eof) "201813012" Right (SmartAssumeStart 201813012 Nothing)

Split a DateSpan into consecutive exact spans of the specified Interval. If the first argument is true and the interval is Weeks, Months, Quarters or Years, the start date will be adjusted backward if needed to nearest natural interval boundary (a monday, first of month, first of quarter or first of year). If no interval is specified, the original span is returned. If the original span is the null date span, ie unbounded, the null date span is returned. If the original span is empty, eg if the end date is <= the start date, no spans are returned.

Examples:

>>> let t i y1 m1 d1 y2 m2 d2 = splitSpan True i $ DateSpan (Just $ Flex $ fromGregorian y1 m1 d1) (Just $ Flex $ fromGregorian y2 m2 d2)
>>> t NoInterval 2008 01 01 2009 01 01
[DateSpan 2008]
>>> t (Quarters 1) 2008 01 01 2009 01 01
[DateSpan 2008Q1,DateSpan 2008Q2,DateSpan 2008Q3,DateSpan 2008Q4]
>>> splitSpan True (Quarters 1) nulldatespan
[DateSpan ..]
>>> t (Days 1) 2008 01 01 2008 01 01  -- an empty datespan
[]
>>> t (Quarters 1) 2008 01 01 2008 01 01
[]
>>> t (Months 1) 2008 01 01 2008 04 01
[DateSpan 2008-01,DateSpan 2008-02,DateSpan 2008-03]
>>> t (Months 2) 2008 01 01 2008 04 01
[DateSpan 2008-01-01..2008-02-29,DateSpan 2008-03-01..2008-04-30]
>>> t (Weeks 1) 2008 01 01 2008 01 15
[DateSpan 2007-12-31W01,DateSpan 2008-01-07W02,DateSpan 2008-01-14W03]
>>> t (Weeks 2) 2008 01 01 2008 01 15
[DateSpan 2007-12-31..2008-01-13,DateSpan 2008-01-14..2008-01-27]
>>> t (DayOfMonth 2) 2008 01 01 2008 04 01
[DateSpan 2007-12-02..2008-01-01,DateSpan 2008-01-02..2008-02-01,DateSpan 2008-02-02..2008-03-01,DateSpan 2008-03-02..2008-04-01]
>>> t (WeekdayOfMonth 2 4) 2011 01 01 2011 02 15
[DateSpan 2010-12-09..2011-01-12,DateSpan 2011-01-13..2011-02-09,DateSpan 2011-02-10..2011-03-09]
>>> t (DaysOfWeek [2]) 2011 01 01 2011 01 15
[DateSpan 2010-12-28..2011-01-03,DateSpan 2011-01-04..2011-01-10,DateSpan 2011-01-11..2011-01-17]
>>> t (DayOfYear 11 29) 2011 10 01 2011 10 15
[DateSpan 2010-11-29..2011-11-28]
>>> t (DayOfYear 11 29) 2011 12 01 2012 12 15
[DateSpan 2011-11-29..2012-11-28,DateSpan 2012-11-29..2013-11-28]

Construct a list of exact DateSpans from a list of boundaries, which fit within a given range.

Group elements based on where they fall in a list of DateSpans without gaps. The precondition is not checked.

Convert a SmartDate to a specific date using the provided reference date. This date will be exact or flexible depending on whether the day was specified exactly. (Missing least-significant parts produces a flex date.)

Examples:

>>> :set -XOverloadedStrings
>>> let t = fixSmartDateStr (fromGregorian 2008 11 26)
>>> t "0000-01-01"
"0000-01-01"
>>> t "1999-12-02"
"1999-12-02"
>>> t "1999.12.02"
"1999-12-02"
>>> t "1999/3/2"
"1999-03-02"
>>> t "19990302"
"1999-03-02"
>>> t "2008/2"
"2008-02-01"
>>> t "0020/2"
"0020-02-01"
>>> t "1000"
"1000-01-01"
>>> t "4/2"
"2008-04-02"
>>> t "2"
"2008-11-02"
>>> t "January"
"2008-01-01"
>>> t "feb"
"2008-02-01"
>>> t "today"
"2008-11-26"
>>> t "yesterday"
"2008-11-25"
>>> t "tomorrow"
"2008-11-27"
>>> t "this day"
"2008-11-26"
>>> t "last day"
"2008-11-25"
>>> t "next day"
"2008-11-27"
>>> t "this week"  -- last monday
"2008-11-24"
>>> t "last week"  -- previous monday
"2008-11-17"
>>> t "next week"  -- next monday
"2008-12-01"
>>> t "this month"
"2008-11-01"
>>> t "last month"
"2008-10-01"
>>> t "next month"
"2008-12-01"
>>> t "this quarter"
"2008-10-01"
>>> t "last quarter"
"2008-07-01"
>>> t "next quarter"
"2009-01-01"
>>> t "this year"
"2008-01-01"
>>> t "last year"
"2007-01-01"
>>> t "next year"
"2009-01-01"

t "last wed" "2008-11-19" t "next friday" "2008-11-28" t "next january" "2009-01-01"

>>> t "in 5 days"
"2008-12-01"
>>> t "in 7 months"
"2009-06-01"
>>> t "in -2 weeks"
"2008-11-10"
>>> t "1 quarter ago"
"2008-07-01"
>>> t "1 week ahead"
"2008-12-01"

Convert a smart date string to an explicit yyyy/mm/dd string using the provided reference date, or raise an error.

A safe version of fixSmartDateStr.

Parse a year number from a Text, making sure that at least four digits are used.

Count the days in a DateSpan, or if it is open-ended return Nothing.