🥮 mooncakes.io

tempo

UTC date/time library — RFC 3339 parsing, Unix timestamps, arithmetic

datetime
time
date
rfc3339
iso8601
duration
moon add brickfrog/tempo@0.8.1
Download zip
Author
Version
0.8.1
License
Apache-2.0
Repository
Last updated
10 days ago
Downloads
183
README

#tempo

UTC date/time library for MoonBit. RFC 3339 parsing, Unix timestamp conversion, calendar and duration arithmetic. No external dependencies.

In your moon.pkg:

import {
  "brickfrog/tempo/src" @tempo,
}

#Quick start

///|
test {
  let dt = @tempo.DateTime::parse("2026-03-28T14:31:43Z")
  inspect(dt.date.year, content="2026")
  inspect(dt.date.month, content="3")
  inspect(dt.time.hour, content="14")
  inspect(dt.format(), content="2026-03-28T14:31:43Z")
}

#Types

TypeDescription
Dateyear, month (1–12), day (1–31)
Timehour, minute, second, nanosecond
DateTimeCombined UTC date and time
DurationSigned duration, stored as nanoseconds

All types implement Eq, Compare, and Show.

#Constructing values

///|
test {
  let d = @tempo.Date::new(2026, 3, 28)
  let t = @tempo.Time::new(14, 31, 43, 0)
  let dt = @tempo.DateTime::new(d, t)
  inspect(dt.format(), content="2026-03-28T14:31:43Z")
}

#Unix timestamps

///|
test {
  let dt = @tempo.DateTime::from_unix_seconds(0L)
  inspect(dt.format(), content="1970-01-01T00:00:00Z")
  inspect(dt.to_unix_seconds(), content="0")

  let dt2 = @tempo.DateTime::from_unix_nanos(1_000_000_000L)
  inspect(dt2.format(), content="1970-01-01T00:00:01Z")
  inspect(dt2.to_unix_nanos(), content="1000000000")

  let ms = @tempo.DateTime::from_unix_millis(1500L)
  inspect(ms.format(), content="1970-01-01T00:00:01.5Z")
  inspect(ms.to_unix_millis(), content="1500")

  let us = @tempo.DateTime::from_unix_micros(1_500_250L)
  inspect(us.format(), content="1970-01-01T00:00:01.50025Z")
  inspect(us.to_unix_micros(), content="1500250")
}

#Parsing

Accepts RFC 3339 / ISO 8601. UTC markers (Z, +00:00, -00:00) and fixed numeric offsets are accepted. Parsed values are stored as UTC DateTimes; the original offset is not retained. Out-of-range offsets raise TempoError.

///|
test {
  let dt = @tempo.DateTime::parse("2026-03-28T14:31:43.125Z")
  inspect(dt.time.nanosecond, content="125000000")
}

///|
test {
  let dt = @tempo.DateTime::parse("2024-07-21T17:11:00-04:00")
  inspect(dt.format(), content="2024-07-21T21:11:00Z")
}

#Formatting

DateTime::format produces RFC 3339 with a Z suffix. Fractional seconds are included only when nanosecond ≠ 0, trailing zeros trimmed.

///|
test {
  let dt = @tempo.DateTime::from_unix_nanos(1_711_630_303_100_000_000L)
  inspect(dt.format(), content="2024-03-28T14:31:43.1Z")
}

#Arithmetic

///|
test {
  let dt = @tempo.DateTime::parse("2026-03-28T12:00:00Z")
  let dt2 = dt.add(@tempo.Duration::hours(2L))
  inspect(dt2.time.hour, content="14")

  let dt3 = dt.sub(@tempo.Duration::minutes(30L))
  inspect(dt3.time.minute, content="30")

  let gap = dt2.diff(dt)
  inspect(gap.as_hours(), content="2")
}

///|
test {
  let a = @tempo.Duration::hours(1L)
  let b = @tempo.Duration::minutes(30L)
  inspect((a + b).as_minutes(), content="90")
  inspect((-a).as_nanoseconds(), content="-3600000000000")
}

#Duration constructors

///|
test {
  inspect(@tempo.Duration::weeks(1L).as_days(), content="7")
  inspect(@tempo.Duration::days(1L).as_hours(), content="24")
  inspect(@tempo.Duration::hours(1L).as_minutes(), content="60")
  inspect(@tempo.Duration::minutes(1L).as_seconds(), content="60")
  inspect(@tempo.Duration::seconds(1L).as_milliseconds(), content="1000")
  inspect(@tempo.Duration::milliseconds(1L).as_microseconds(), content="1000")
  inspect(@tempo.Duration::microseconds(1L).as_nanoseconds(), content="1000")
}

#Duration accessors

All accessors truncate toward zero (e.g. 90 minutes → 1 hour).

///|
test {
  inspect(@tempo.Duration::days(3L).as_days(), content="3")
  inspect(@tempo.Duration::weeks(1L).as_weeks(), content="1")
  inspect(@tempo.Duration::days(7L).as_weeks(), content="1")
}

#Duration predicates

///|
test {
  assert_eq(@tempo.Duration::seconds(0L).is_zero(), true)
  assert_eq(@tempo.Duration::seconds(1L).is_zero(), false)
  assert_eq(@tempo.Duration::seconds(-1L).is_negative(), true)
  assert_eq(@tempo.Duration::seconds(1L).is_negative(), false)
  assert_eq(@tempo.Duration::seconds(1L).is_positive(), true)
}

#Duration arithmetic

Duration::abs, is_positive, signum, multiply, checked_multiply, and divide cover common signed-duration operations. Duration::divide raises on division by zero and on the Int64::min_value / -1 overflow.

///|
test {
  let d = @tempo.Duration::seconds(-3L)
  inspect(d.abs().as_seconds(), content="3")
  assert_eq(d.signum(), -1)

  let doubled = @tempo.Duration::seconds(2L).multiply(3L)
  inspect(doubled.as_seconds(), content="6")
  assert_eq(
    @tempo.Duration::seconds(2L).checked_multiply(3L),
    Some(@tempo.Duration::seconds(6L)),
  )

  let half = @tempo.Duration::seconds(7L).divide(2L)
  inspect(half.as_seconds(), content="3")
}

#Calendar arithmetic

Date::add_months and Date::add_years clamp to the end of the target month when needed. Date and DateTime both provide start_of_month, end_of_month, start_of_year, and end_of_year; the DateTime variants adjust the date and preserve the time of day.

///|
test {
  let d = @tempo.Date::new(2024, 3, 15)

  // Add/remove days
  let d2 = d.add_days(10)
  inspect(d2.day, content="25")

  // ISO weekday: Monday = 1 … Sunday = 7
  assert_eq(d.day_of_week(), 5) // Friday

  // Day of year (1-based)
  assert_eq(d.day_of_year(), 75)

  // Days between two dates
  let other = @tempo.Date::new(2024, 3, 1)
  assert_eq(d.days_until(other), -14)
}

///|
test {
  let end = @tempo.Date::new(2024, 1, 31)
  inspect(end.add_months(1).format(), content="2024-02-29")

  let leap = @tempo.Date::new(2024, 2, 29)
  inspect(leap.add_years(1).format(), content="2025-02-28")

  let mid = @tempo.Date::new(2024, 3, 15)
  inspect(mid.start_of_month().format(), content="2024-03-01")
  inspect(mid.end_of_month().format(), content="2024-03-31")
  inspect(mid.start_of_year().format(), content="2024-01-01")
  inspect(mid.end_of_year().format(), content="2024-12-31")

  let dt = @tempo.DateTime::parse("2024-03-15T14:31:43Z")
  inspect(dt.start_of_month().format(), content="2024-03-01T14:31:43Z")
  inspect(dt.end_of_year().format(), content="2024-12-31T14:31:43Z")
}

#Field updaters

DateTime::to_date and DateTime::to_time split a timestamp into its parts. Date has with_year/with_month/with_day; Time has with_hour through with_nanosecond; DateTime has with_date/with_time plus with_year through with_nanosecond. Fallible updaters raise on invalid values rather than clamping.

///|
test {
  let d = @tempo.Date::new(2024, 3, 15)
  inspect(d.with_day(1).format(), content="2024-03-01")

  let t = @tempo.Time::new(14, 31, 43, 125_000_000)
  inspect(t.with_nanosecond(0).format(), content="14:31:43")

  let dt = @tempo.DateTime::new(d, t)
  inspect(dt.to_date().format(), content="2024-03-15")
  inspect(dt.to_time().format(), content="14:31:43.125")
  inspect(
    dt.with_year(2025).with_hour(9).format(),
    content="2025-03-15T09:31:43.125Z",
  )
}

#Weekday and Month

Date::weekday and Date::month_enum return enums. Weekday and Month use 1-based numbers for to_int/from_int; next and previous wrap around.

///|
test {
  let d = @tempo.Date::new(2024, 3, 15)
  assert_eq(d.weekday(), @tempo.Friday)
  assert_eq(d.month_enum(), @tempo.March)

  assert_eq(@tempo.Friday.to_int(), 5)
  assert_eq(@tempo.Weekday::from_int(5), Some(@tempo.Friday))
  assert_eq(@tempo.Friday.next(), @tempo.Saturday)
  assert_eq(@tempo.Monday.previous(), @tempo.Sunday)

  assert_eq(@tempo.February.to_int(), 2)
  assert_eq(@tempo.Month::from_int(2), Some(@tempo.February))
  assert_eq(@tempo.February.days_in(2024), 29)
}

#Rounding and truncation

start_of_day/end_of_day, truncate_to(unit) (floor to a TimeUnit), and round_to(unit, mode) snap a DateTime to a boundary. round_to takes a RoundMode of Floor, Ceil, or HalfExpand (ties round up).

///|
test {
  let dt = @tempo.DateTime::parse("2024-03-15T14:31:43.125Z")
  inspect(dt.start_of_day().format(), content="2024-03-15T00:00:00Z")
  inspect(dt.truncate_to(@tempo.Hour).format(), content="2024-03-15T14:00:00Z")

  let half = @tempo.DateTime::parse("2024-03-15T14:30:00Z")
  inspect(
    half.round_to(@tempo.Hour, @tempo.HalfExpand).format(),
    content="2024-03-15T15:00:00Z",
  )
}

#Comparison

Named helpers over the derived ordering: is_before/is_after, min/max, and clamp for Date/Time/DateTime, plus wall-clock DateTime::since/ until (over diff).

///|
test {
  let a = @tempo.Date::new(2024, 1, 1)
  let b = @tempo.Date::new(2024, 2, 1)
  assert_eq(a.is_before(b), true)
  assert_eq(a.max(b), b)

  let dt = @tempo.DateTime::parse("2024-03-15T12:00:00Z")
  let later = dt.add(@tempo.Duration::hours(2L))
  inspect(later.since(dt).as_hours(), content="2")
}

#Intervals

DateInterval is an inclusive [start, end] range of dates; Interval is a half-open [start, end) range of datetimes. Both provide contains, overlaps, and intersection.

///|
test {
  let span = @tempo.DateInterval::{
    start: @tempo.Date::new(2024, 1, 1),
    end: @tempo.Date::new(2024, 1, 10),
  }
  assert_eq(span.contains(@tempo.Date::new(2024, 1, 5)), true)
  inspect(span.length_in_days(), content="10")
}

#Weekday navigation

Date::next/previous find the nearest date on a weekday (strictly after/before); next_or_same/previous_or_same include the date itself; and nth_weekday_of_month finds the nth occurrence (a negative n counts from the end).

///|
test {
  let fri = @tempo.Date::new(2024, 3, 15) // a Friday
  inspect(fri.next(@tempo.Monday).format(), content="2024-03-18")
  inspect(fri.previous(@tempo.Monday).format(), content="2024-03-11")

  // 3rd Tuesday of March 2024
  let t = @tempo.Date::nth_weekday_of_month(2024, 3, @tempo.Tuesday, 3)
  inspect(t.format(), content="2024-03-19")
}

#Hashing

Date, Time, DateTime, and Duration derive Hash, so they work as keys in the stdlib hash Map/Set.

///|
test {
  let counts : Map[@tempo.Date, Int] = {}
  counts.set(@tempo.Date::new(2024, 3, 15), 3)
  assert_eq(counts.get(@tempo.Date::new(2024, 3, 15)), Some(3))
}

#ISO 8601 durations

Duration::format_iso/parse_iso round-trip the PnDTnHnMnS subset (days, hours, minutes, seconds with fractions). Years and months are rejected as calendar units.

///|
test {
  let d = @tempo.Duration::hours(2L) + @tempo.Duration::minutes(30L)
  inspect(d.format_iso(), content="PT2H30M")
  assert_eq(@tempo.Duration::parse_iso("PT2H30M"), d)
}

#JSON

Date, Time, DateTime, and Duration serialize to their canonical strings (RFC 3339 / ISO 8601) via moonbitlang/core/json — not field objects.

///|
test {
  let dt = @tempo.DateTime::parse("2024-07-21T17:11:00Z")
  inspect(dt.to_json().stringify(), content="\"2024-07-21T17:11:00Z\"")
}

#Overflow safety

to_unix_nanos and the add/sub/diff operators wrap silently outside the Int64-nanosecond range (~1677–2262). The checked variants return None instead: to_unix_nanos_checked, DateTime::checked_add/checked_sub/checked_diff, and Duration::checked_add/checked_sub. min_unix_nanos/max_unix_nanos document the bounds.

///|
test {
  let far = @tempo.DateTime::parse("3000-01-01T00:00:00Z")
  assert_eq(far.to_unix_nanos_checked(), None)

  match @tempo.DateTime::epoch().checked_add(@tempo.Duration::hours(1L)) {
    Some(dt) => inspect(dt.format(), content="1970-01-01T01:00:00Z")
    None => ()
  }
}

#Date and Time parsing/formatting

///|
test {
  // Date-only parse/format
  let d = @tempo.Date::parse("2024-03-15")
  inspect(d.format(), content="2024-03-15")

  // Time-only parse/format
  let t = @tempo.Time::parse("14:31:43.500")
  inspect(t.format(), content="14:31:43.5")
}

#Current time

///|
test {
  // Millisecond precision on js/wasm-gc, whole seconds on native.
  let now = @tempo.DateTime::now()
  assert_eq(now > @tempo.DateTime::epoch(), true)
}

#Calendar helpers

///|
test {
  assert_eq(@tempo.is_leap_year(2000), true)
  assert_eq(@tempo.is_leap_year(1900), false)
  assert_eq(@tempo.is_leap_year(2024), true)
  assert_eq(@tempo.days_in_month(2024, 2), 29)
  assert_eq(@tempo.days_in_month(2023, 2), 28)
}

#Year-month

YearMonth is a year-and-month value with no day — useful for billing periods and month-granular keys. length is leap-aware; plus_months / plus_years carry across years; Compare orders chronologically.

///|
test {
  let ym = @tempo.YearMonth::new(2024, 2)
  inspect(ym.format(), content="2024-02")
  inspect(ym.length(), content="29") // February 2024 is a leap year
  inspect(ym.at_day(15).format(), content="2024-02-15")
  inspect(ym.at_end_of_month().format(), content="2024-02-29")
  inspect(ym.plus_months(11).format(), content="2025-01")
  inspect(@tempo.YearMonth::parse("2025-01").format(), content="2025-01")
}

#Periods

Period is a calendar-aware { years, months, days } value — the calendar counterpart to the elapsed-time Duration. It stores its fields exactly and is never auto-normalized (15 months stays 15 months), because applying a period is anchor-dependent: adding one month clamps to the end of a short month, while adding 30 days does not. normalized rolls months into years only. Date::until returns the period between two dates and round-trips with add_period. Operations that would overflow the Int fields raise.

///|
test {
  let p = @tempo.Period::of(1, 2, 10)
  inspect(p.format(), content="P1Y2M10D")
  inspect(@tempo.Period::of(0, 15, 0).normalized().format(), content="P1Y3M")

  // Anchor-dependent: months adjust (with clamping) before days.
  let d = @tempo.Date::new(2024, 1, 31)
  inspect(d.add_period(@tempo.Period::of(0, 1, 0)).format(), content="2024-02-29")
  inspect(d.add_period(@tempo.Period::of(0, 0, 30)).format(), content="2024-03-01")

  // until round-trips with add_period.
  let start = @tempo.Date::new(2024, 1, 15)
  let end = @tempo.Date::new(2024, 3, 20)
  let span = start.until(end)
  inspect(span.format(), content="P2M5D")
  assert_eq(start.add_period(span), end)
}

#ISO week and ordinal dates

Date exposes ISO 8601 week dates and ordinal (day-of-year) dates. The ISO week-numbering year can differ from the calendar year for dates near January 1 and December 31.

///|
test {
  let d = @tempo.Date::new(2021, 1, 1)
  assert_eq(d.iso_week_year(), 2020) // belongs to ISO week-year 2020
  assert_eq(d.iso_week(), 53)
  inspect(d.format_iso_week(), content="2020-W53-5")
  inspect(@tempo.Date::from_iso_week(2020, 53, 5).format(), content="2021-01-01")

  // Ordinal (day-of-year) dates, leap-aware.
  inspect(@tempo.Date::from_ordinal(2024, 60).format(), content="2024-02-29")
  inspect(@tempo.Date::new(2024, 12, 31).format_ordinal(), content="2024-366")

  // Parse the string forms (inverses of the format_* methods).
  inspect(
    @tempo.Date::parse_iso_week("2020-W53-5").format(),
    content="2021-01-01",
  )
  inspect(@tempo.Date::parse_ordinal("2024-060").format(), content="2024-02-29")
}

#Quarters

///|
test {
  let d = @tempo.Date::new(2024, 5, 15)
  assert_eq(d.quarter(), 2)
  inspect(d.start_of_quarter().format(), content="2024-04-01")
  inspect(d.end_of_quarter().format(), content="2024-06-30")
  assert_eq(d.days_in_year(), 366)
  assert_eq(d.is_leap(), true)
}

#Fractional and human-readable durations

as_seconds_f64 / as_minutes_f64 / as_hours_f64 give fractional totals as Double. humanize renders an English elapsed string (days/hours/minutes/ seconds, non-zero components only, - prefix for negatives).

///|
test {
  inspect(@tempo.Duration::minutes(90).as_hours_f64(), content="1.5")
  inspect(@tempo.Duration::milliseconds(1500).as_seconds_f64(), content="1.5")

  let d = @tempo.Duration::hours(2) + @tempo.Duration::minutes(30)
  inspect(d.humanize(), content="2 hours 30 minutes")
  inspect(@tempo.Duration::seconds(1).humanize(), content="1 second")
  inspect(@tempo.Duration::minutes(-90).humanize(), content="-1 hour 30 minutes")
}

#Custom formatting

format_fixed produces a fixed-width timestamp (always nine fractional digits) whose byte order matches chronological order for years 0–9999 — handy for log lines and database keys. format_with is a brace-token DSL: the tokens {YYYY}, {MM}, {DD}, {HH}, {mm}, {ss}, {fff}, and {nnnnnnnnn} substitute, everything else is literal, {{ and }} emit literal braces, and an unknown token or unmatched brace raises.

///|
test {
  let dt = @tempo.DateTime::parse("2024-07-21T17:11:00.5Z")
  inspect(dt.format_fixed(), content="2024-07-21T17:11:00.500000000Z")
  inspect(dt.format_with("{YYYY}/{MM}/{DD} {HH}:{mm}"), content="2024/07/21 17:11")
}

#Not included

  • Timezones / DST — planned as a separate tempo-tz package
  • Locale-aware formatting — strftime patterns, localized names
  • Leap seconds — POSIX ignores them, so does tempo

See ROADMAP.md.

#
TempoError

source
pub(all) suberror TempoError {
  TempoError(String)
}

Error type for all tempo operations.
impl Show for TempoError

#
Date

source
pub struct Date {
  year : Int
  month : Int
  day : Int
} derive(Compare, Eq, Hash, 
Debug)

A calendar date in the proleptic Gregorian calendar (UTC).
impl Show for Date
impl ToJson for Date
impl FromJson for Date

#
Date::add_days

source
fn Date::add_days(self : Date, days : Int) -> Date

Add a signed number of calendar days to this date (proleptic Gregorian).

This infallible operation wraps if the resulting year falls outside the Int year envelope. Use Date::add_days_checked to get None instead.

#
Date::add_days_checked

source
fn Date::add_days_checked(self : Date, days : Int) -> Date?

Add a signed number of calendar days, returning None if the resulting year cannot be represented by Date's Int year field.

#
Date::add_months

source
fn Date::add_months(self : Date, months : Int) -> Date

Add a signed number of calendar months to this date.

If the original day does not exist in the target month, the result is clamped to that month's last day. Clamping is non-sticky: 2024-02-28 plus one month is 2024-03-28, not 2024-03-31.

This infallible operation wraps if the resulting year falls outside the Int year envelope. Use Date::add_months_checked to get None instead.

#
Date::add_months_checked

source
fn Date::add_months_checked(self : Date, months : Int) -> Date?

Add a signed number of calendar months, returning None if the resulting year cannot be represented by Date's Int year field.

#
Date::add_period

source
fn Date::add_period(self : Date, period : Period) -> Date raise TempoError

Add a calendar period to this date.

Years and months are combined into one month adjustment first, using the same end-of-month clamping as Date::add_months; days are added afterward.

#
Date::add_years

source
fn Date::add_years(self : Date, years : Int) -> Date

Add a signed number of calendar years to this date.

If the original day does not exist in the target year/month, the result is clamped to that month's last day, so leap day moves to February 28 in non-leap target years.

This infallible operation wraps if the resulting year falls outside the Int year envelope. Use Date::add_years_checked to get None instead.

#
Date::add_years_checked

source
fn Date::add_years_checked(self : Date, years : Int) -> Date?

Add a signed number of calendar years, returning None if the resulting year cannot be represented by Date's Int year field.

#
Date::clamp

source
fn Date::clamp(self : Date, lo : Date, hi : Date) -> Date

Clamp this date to the inclusive range [lo, hi]. Assumes lo <= hi.

#
Date::day_of_week

source
fn Date::day_of_week(self : Date) -> Int

ISO 8601 weekday: Monday = 1 through Sunday = 7.

#
Date::day_of_year

source
fn Date::day_of_year(self : Date) -> Int

Day of year in 1..366 (1 = January 1).

#
Date::days_in_year

source
fn Date::days_in_year(self : Date) -> Int

Number of days in this date's calendar year.

#
Date::days_until

source
fn Date::days_until(self : Date, other : Date) -> Int

Calendar days from self to other (other minus self). Negative if other is earlier.

#
Date::end_of_month

source
fn Date::end_of_month(self : Date) -> Date

Return the last day of this date's calendar month.

#
Date::end_of_quarter

source
fn Date::end_of_quarter(self : Date) -> Date

Return the last day of this date's calendar quarter.

#
Date::end_of_year

source
fn Date::end_of_year(self : Date) -> Date

Return the last day of this date's calendar year.

#
Date::format

source
fn Date::format(self : Date) -> String

Format this date as 'YYYY-MM-DD'.

#
Date::format_iso_week

source
fn Date::format_iso_week(self : Date) -> String

Format this date as an ISO 8601 week date: YYYY-Www-D.

The ISO week-year is computed with Int64 intermediates, so at the absolute Int year boundary the formatted week-year may be the expanded year just outside Date's representable calendar envelope.

#
Date::format_ordinal

source
fn Date::format_ordinal(self : Date) -> String

Format this date as an ordinal date using ISO 8601 expanded-year output (see pad4_year), followed by day-of-year in 001..366.

#
Date::from_iso_week

source
fn Date::from_iso_week(week_year : Int, week : Int, weekday : Int) -> Date raise TempoError

Create a date from an ISO 8601 week date.

week_year is the ISO week-numbering year, week is 1..52 or 1..53 depending on that year, and weekday is Monday = 1 through Sunday = 7. Raises TempoError if the ISO week fields are invalid or if the computed calendar date falls outside Date's representable Int year envelope.

#
Date::from_ordinal

source
fn Date::from_ordinal(year : Int, day_of_year : Int) -> Date raise TempoError

Create a Date from year and day-of-year in 1..365, or 1..366 for a leap year.

#
Date::is_after

source
fn Date::is_after(self : Date, other : Date) -> Bool

true if this date is later than other.

#
Date::is_before

source
fn Date::is_before(self : Date, other : Date) -> Bool

true if this date is earlier than other.

#
Date::is_leap

source
fn Date::is_leap(self : Date) -> Bool

true if this date's year is a leap year.

#
Date::iso_week

source
fn Date::iso_week(self : Date) -> Int

ISO 8601 week number in 1..53 for this date.

#
Date::iso_week_year

source
fn Date::iso_week_year(self : Date) -> Int

ISO 8601 week-numbering year for this date.

This can differ from the calendar year near New Year; for example, 2021-01-01 belongs to ISO week year 2020.

At the absolute Int year boundary, the true ISO week-year may be one year outside the representable Int range. This infallible accessor wraps in that residual case; Date::format_iso_week still formats the true expanded ISO week-year text.

#
Date::max

source
fn Date::max(self : Date, other : Date) -> Date

Return the later of this date and other.

#
Date::min

source
fn Date::min(self : Date, other : Date) -> Date

Return the earlier of this date and other.

#
Date::month_enum

source
fn Date::month_enum(self : Date) -> Month

Calendar month for this date.

#
Date::new

source
fn Date::new(year : Int, month : Int, day : Int) -> Date raise TempoError

Create a Date, validating that month is 1–12 and day fits the calendar month (accounting for leap years in February).

#
Date::next

source
fn Date::next(self : Date, wd : Weekday) -> Date

Nearest date strictly after this date that falls on wd.

#
Date::next_or_same

source
fn Date::next_or_same(self : Date, wd : Weekday) -> Date

This date if it falls on wd, otherwise the next such date.

#
Date::nth_weekday_of_month

source
fn Date::nth_weekday_of_month(year : Int, month : Int, wd : Weekday, n : Int) -> Date raise TempoError

The nth occurrence of wd in year/month.

Positive n counts from the start of the month; negative n counts from the end, so n == -1 is the last occurrence.

#
Date::parse

source
fn Date::parse(s : String) -> Date raise TempoError

Parse a calendar date in 'YYYY-MM-DD' format.

#
Date::parse_iso_week

source
fn Date::parse_iso_week(s : String) -> Date raise TempoError

Parse an ISO 8601 week date in 'YYYY-Www-D' format.

The leading year is the ISO week-numbering year, which can differ from the resulting calendar year near New Year. This parser is strict: it accepts only an unsigned 4-digit week-year, a literal W, a 2-digit week, a 1-digit weekday, and end-of-input. Expanded-year output from Date::format_iso_week is not accepted.

#
Date::parse_ordinal

source
fn Date::parse_ordinal(s : String) -> Date raise TempoError

Parse an ISO 8601 ordinal date in 'YYYY-DDD' format.

This parser is strict: it accepts only an unsigned 4-digit year, a hyphen, exactly 3 digits for the day-of-year, and end-of-input. Expanded-year output from Date::format_ordinal is not accepted.

#
Date::previous

source
fn Date::previous(self : Date, wd : Weekday) -> Date

Nearest date strictly before this date that falls on wd.

#
Date::previous_or_same

source
fn Date::previous_or_same(self : Date, wd : Weekday) -> Date

This date if it falls on wd, otherwise the previous such date.

#
Date::quarter

source
fn Date::quarter(self : Date) -> Int

Calendar quarter number in 1..4.

#
Date::start_of_month

source
fn Date::start_of_month(self : Date) -> Date

Return the first day of this date's calendar month.

#
Date::start_of_quarter

source
fn Date::start_of_quarter(self : Date) -> Date

Return the first day of this date's calendar quarter.

#
Date::start_of_year

source
fn Date::start_of_year(self : Date) -> Date

Return the first day of this date's calendar year.

#
Date::until

source
fn Date::until(self : Date, other : Date) -> Period raise TempoError

Calendar period from this date until other.

The result round-trips through Date::add_period, including month-end clamping and the day-borrow behavior used by java.time.LocalDate.until.

#
Date::weekday

source
fn Date::weekday(self : Date) -> Weekday

ISO 8601 weekday for this date.

#
Date::with_day

source
fn Date::with_day(self : Date, day : Int) -> Date raise TempoError

Return a copy of this date with day replaced, validating the result.

This does not clamp. Chaining with with_month can raise on an intermediate invalid date before a later update would make it valid.

#
Date::with_month

source
fn Date::with_month(self : Date, month : Int) -> Date raise TempoError

Return a copy of this date with month replaced, validating the result.

This does not clamp. Chaining with with_day can raise on an intermediate invalid date before a later update would make it valid.

#
Date::with_year

source
fn Date::with_year(self : Date, year : Int) -> Date raise TempoError

Return a copy of this date with year replaced, validating the result.

#
DateInterval

source
pub(all) struct DateInterval {
  start : Date
  end : Date
} derive(Eq, 
Debug)

A calendar date interval with an inclusive end date: [start, end].

This mirrors NodaTime's DateInterval-vs-Interval convention split: DateInterval is inclusive-end for whole calendar dates, while Interval is half-open for instants. Assumes start <= end; methods do not validate inverted intervals.

#
DateInterval::contains

source
fn DateInterval::contains(self : DateInterval, d : Date) -> Bool

true if d is in this inclusive-end date interval [start, end].

#
DateInterval::intersection

source
fn DateInterval::intersection(self : DateInterval, other : DateInterval) -> DateInterval?

Return the inclusive-end overlap between this date interval and other.

#
DateInterval::length_in_days

source
fn DateInterval::length_in_days(self : DateInterval) -> Int

Inclusive day count for this date interval.

#
DateInterval::overlaps

source
fn DateInterval::overlaps(self : DateInterval, other : DateInterval) -> Bool

true if this inclusive-end date interval shares at least one date with other.

#
DateTime

source
pub struct DateTime {
  date : Date
  time : Time
} derive(Compare, Eq, Hash, 
Debug)

A combined UTC date and time.
impl Show for DateTime
impl ToJson for DateTime

#
DateTime::add

source
fn DateTime::add(self : DateTime, d : Duration) -> DateTime

Add a Duration to this DateTime.

This wraps on Int64 overflow. Use checked_add when overflow or a DateTime outside the representable Unix-nanoseconds range should return None.

#
DateTime::checked_add

source
fn DateTime::checked_add(self : DateTime, d : Duration) -> DateTime?

Add a Duration to this DateTime, returning None on Int64 overflow or when this DateTime is outside the representable Unix-nanoseconds range.

#
DateTime::checked_diff

source
fn DateTime::checked_diff(self : DateTime, other : DateTime) -> Duration?

Compute self - other as a Duration, returning None on Int64 overflow or when either DateTime is outside the representable Unix-nanoseconds range.

#
DateTime::checked_sub

source
fn DateTime::checked_sub(self : DateTime, d : Duration) -> DateTime?

Subtract a Duration from this DateTime, returning None on Int64 overflow or when this DateTime is outside the representable Unix-nanoseconds range.

#
DateTime::clamp

source
fn DateTime::clamp(self : DateTime, lo : DateTime, hi : DateTime) -> DateTime

Clamp this DateTime to the inclusive range [lo, hi]. Assumes lo <= hi.

#
DateTime::diff

source
fn DateTime::diff(self : DateTime, other : DateTime) -> Duration

Compute self - other as a Duration (may be negative).

This wraps on Int64 overflow. Use checked_diff when overflow or a DateTime outside the representable Unix-nanoseconds range should return None.

#
DateTime::end_of_day

source
fn DateTime::end_of_day(self : DateTime) -> DateTime

Return this DateTime at the end of its calendar day.

#
DateTime::end_of_month

source
fn DateTime::end_of_month(self : DateTime) -> DateTime

Return this DateTime at the end of its calendar month. Preserves the time-of-day; rebuild with DateTime::new and a zero Time if midnight is desired.

#
DateTime::end_of_year

source
fn DateTime::end_of_year(self : DateTime) -> DateTime

Return this DateTime at the end of its calendar year. Preserves the time-of-day; rebuild with DateTime::new and a zero Time if midnight is desired.

#
DateTime::epoch

source
fn DateTime::epoch() -> DateTime

The Unix epoch: 1970-01-01T00:00:00Z.

#
DateTime::format

source
fn DateTime::format(self : DateTime) -> String

Format this DateTime as an RFC 3339-style string (UTC, Z suffix) when the year is in the usual four-digit range; negative years and years ≥ 10000 use ISO 8601 expanded-year conventions (see pad4_year). Sub-second precision is included only when nanoseconds ≠ 0. Note: expanded-year output (years outside 0000–9999) cannot be round-tripped through DateTime::parse, which accepts only 4-digit positive years (RFC 3339).

#
DateTime::format_fixed

source
fn DateTime::format_fixed(self : DateTime) -> String

Format this DateTime as a UTC timestamp with a fixed-width fractional second; for years 0..9999, the whole output is fixed-width and lexicographically sortable: YYYY-MM-DDTHH:MM:SS.nnnnnnnnnZ.

The fractional-second field is always present with exactly 9 nanosecond digits. For years 0..9999, byte-for-byte string comparison of two format_fixed outputs matches chronological order. Outside that year range, expanded or negative year text (especially a leading -) does not preserve that lexicographic ordering guarantee.

#
DateTime::format_with

source
fn DateTime::format_with(self : DateTime, pattern : String) -> String raise TempoError

Format this DateTime with a brace-token pattern.

Supported tokens are {YYYY}, {MM}, {DD}, {HH}, {mm}, {ss}, {fff}, and {nnnnnnnnn}. Non-brace text outside tokens is copied literally. Use {{ and }} to emit literal braces. Unknown tokens and unmatched braces raise TempoError.

#
DateTime::from_unix_micros

source
fn DateTime::from_unix_micros(us : Int64) -> DateTime

Convert a Unix timestamp in microseconds to a DateTime. Negative values represent dates before the Unix epoch.

#
DateTime::from_unix_millis

source
fn DateTime::from_unix_millis(ms : Int64) -> DateTime

Convert a Unix timestamp in milliseconds to a DateTime. Negative values represent dates before the Unix epoch.

#
DateTime::from_unix_nanos

source
fn DateTime::from_unix_nanos(ns : Int64) -> DateTime

Convert a Unix timestamp in nanoseconds to a DateTime. Nanosecond resolution is preserved. Negative values represent dates before the Unix epoch.

#
DateTime::from_unix_seconds

source
fn DateTime::from_unix_seconds(ts : Int64) -> DateTime

Convert a Unix timestamp (seconds since 1970-01-01T00:00:00Z) to a DateTime. Negative values represent dates before the Unix epoch. The year range is limited by what Int64 can represent as days (~±100 billion years).

#
DateTime::is_after

source
fn DateTime::is_after(self : DateTime, other : DateTime) -> Bool

true if this DateTime is later than other.

#
DateTime::is_before

source
fn DateTime::is_before(self : DateTime, other : DateTime) -> Bool

true if this DateTime is earlier than other.

#
DateTime::max

source
fn DateTime::max(self : DateTime, other : DateTime) -> DateTime

Return the later of this DateTime and other.

#
DateTime::max_unix_nanos

source
fn DateTime::max_unix_nanos() -> Int64

Maximum Unix timestamp in nanoseconds representable by an Int64.

#
DateTime::min

source
fn DateTime::min(self : DateTime, other : DateTime) -> DateTime

Return the earlier of this DateTime and other.

#
DateTime::min_unix_nanos

source
fn DateTime::min_unix_nanos() -> Int64

Minimum Unix timestamp in nanoseconds representable by an Int64.

#
DateTime::new

source
fn DateTime::new(date : Date, time : Time) -> DateTime

Create a DateTime from a validated Date and Time. Both arguments should be constructed via Date::new / Time::new (which validate). This constructor performs no additional checks.

#
DateTime::now

source
fn DateTime::now() -> DateTime

Returns the current UTC time. Precision: whole seconds on native, milliseconds on js/wasm-gc.

#
DateTime::parse

source
fn DateTime::parse(s : String) -> DateTime raise TempoError

Parse an RFC 3339 / ISO 8601 datetime string. Fixed numeric offsets are accepted and normalized to UTC.

#
DateTime::round_to

source
fn DateTime::round_to(self : DateTime, unit : TimeUnit, mode : RoundMode) -> DateTime

Round this DateTime to the requested unit boundary.

Floor is equivalent to truncate_to(unit). Ceil rounds to the next boundary only when there is a remainder. HalfExpand rounds to the nearest boundary, with exact half-unit ties rounded up toward the later boundary.

Rounding is anchored to the calendar day and carries with Date::add_days, avoiding Unix-nanosecond conversion for dates outside the Int64 nanosecond timestamp range.

#
DateTime::since

source
fn DateTime::since(self : DateTime, earlier : DateTime) -> Duration

Wall-clock duration elapsed since earlier (self - earlier).

#
DateTime::start_of_day

source
fn DateTime::start_of_day(self : DateTime) -> DateTime

Return this DateTime at the start of its calendar day.

#
DateTime::start_of_month

source
fn DateTime::start_of_month(self : DateTime) -> DateTime

Return this DateTime at the start of its calendar month. Preserves the time-of-day; rebuild with DateTime::new and a zero Time if midnight is desired.

#
DateTime::start_of_year

source
fn DateTime::start_of_year(self : DateTime) -> DateTime

Return this DateTime at the start of its calendar year. Preserves the time-of-day; rebuild with DateTime::new and a zero Time if midnight is desired.

#
DateTime::sub

source
fn DateTime::sub(self : DateTime, d : Duration) -> DateTime

Subtract a Duration from this DateTime.

This wraps on Int64 overflow. Use checked_sub when overflow or a DateTime outside the representable Unix-nanoseconds range should return None.

#
DateTime::to_date

source
fn DateTime::to_date(self : DateTime) -> Date

Return the date component of this DateTime.

#
DateTime::to_time

source
fn DateTime::to_time(self : DateTime) -> Time

Return the time component of this DateTime.

#
DateTime::to_unix_micros

source
fn DateTime::to_unix_micros(self : DateTime) -> Int64

Convert this DateTime to a Unix timestamp in microseconds.

#
DateTime::to_unix_millis

source
fn DateTime::to_unix_millis(self : DateTime) -> Int64

Convert this DateTime to a Unix timestamp in milliseconds.

#
DateTime::to_unix_nanos

source
fn DateTime::to_unix_nanos(self : DateTime) -> Int64

Convert this DateTime to a Unix timestamp in nanoseconds.

Overflow note: this method silently wraps on Int64 overflow. Use to_unix_nanos_checked when dates outside the representable nanosecond range should return None; use to_unix_seconds for wider ranges.

#
DateTime::to_unix_nanos_checked

source
fn DateTime::to_unix_nanos_checked(self : DateTime) -> Int64?

Convert this DateTime to a Unix timestamp in nanoseconds.

Returns None when the instant is outside the representable Int64 nanosecond range.

#
DateTime::to_unix_seconds

source
fn DateTime::to_unix_seconds(self : DateTime) -> Int64

Convert this DateTime to a Unix timestamp in seconds (nanoseconds truncated).

#
DateTime::truncate_to

source
fn DateTime::truncate_to(self : DateTime, unit : TimeUnit) -> DateTime

Floor this DateTime to the requested unit boundary.

Day truncation is anchored to the calendar day: it returns midnight UTC on the same date, rather than truncating a duration since the Unix epoch.

#
DateTime::until

source
fn DateTime::until(self : DateTime, later : DateTime) -> Duration

Wall-clock duration until later (later - self).

#
DateTime::with_date

source
fn DateTime::with_date(self : DateTime, date : Date) -> DateTime

Return a copy of this DateTime with date replaced.

#
DateTime::with_day

source
fn DateTime::with_day(self : DateTime, day : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its date day replaced.

#
DateTime::with_hour

source
fn DateTime::with_hour(self : DateTime, hour : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its time hour replaced.

#
DateTime::with_minute

source
fn DateTime::with_minute(self : DateTime, minute : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its time minute replaced.

#
DateTime::with_month

source
fn DateTime::with_month(self : DateTime, month : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its date month replaced.

#
DateTime::with_nanosecond

source
fn DateTime::with_nanosecond(self : DateTime, nanosecond : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its time nanosecond replaced.

#
DateTime::with_second

source
fn DateTime::with_second(self : DateTime, second : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its time second replaced.

#
DateTime::with_time

source
fn DateTime::with_time(self : DateTime, time : Time) -> DateTime

Return a copy of this DateTime with time replaced.

#
DateTime::with_year

source
fn DateTime::with_year(self : DateTime, year : Int) -> DateTime raise TempoError

Return a copy of this DateTime with its date year replaced.

#
Duration

source
pub struct Duration {
  nanoseconds : Int64
} derive(Compare, Eq, Hash, 
Debug)

A signed duration stored as total nanoseconds.
impl Add for Duration
impl Neg for Duration
impl Show for Duration
impl Sub for Duration
impl ToJson for Duration

#
Duration::abs

source
fn Duration::abs(self : Duration) -> Duration

Absolute value of this duration.

Int64::min_value cannot be negated as an Int64, so that edge saturates to Int64::max_value instead of raising or wrapping.

#
Duration::as_days

source
fn Duration::as_days(self : Duration) -> Int64

Total whole days in this duration (truncated toward zero).

#
Duration::as_hours

source
fn Duration::as_hours(self : Duration) -> Int64

Total whole hours in this duration (truncated toward zero).

#
Duration::as_hours_f64

source
fn Duration::as_hours_f64(self : Duration) -> Double

Total hours in this duration as a Double.

Double has a ~53-bit mantissa, so magnitudes beyond ~2^53 nanoseconds (~104 days) lose sub-unit precision.

#
Duration::as_microseconds

source
fn Duration::as_microseconds(self : Duration) -> Int64

Total whole microseconds in this duration (truncated toward zero).

#
Duration::as_milliseconds

source
fn Duration::as_milliseconds(self : Duration) -> Int64

Total whole milliseconds in this duration (truncated toward zero).

#
Duration::as_minutes

source
fn Duration::as_minutes(self : Duration) -> Int64

Total whole minutes in this duration (truncated toward zero).

#
Duration::as_minutes_f64

source
fn Duration::as_minutes_f64(self : Duration) -> Double

Total minutes in this duration as a Double.

Double has a ~53-bit mantissa, so magnitudes beyond ~2^53 nanoseconds (~104 days) lose sub-unit precision.

#
Duration::as_nanoseconds

source
fn Duration::as_nanoseconds(self : Duration) -> Int64

Total nanoseconds in this duration.

#
Duration::as_seconds

source
fn Duration::as_seconds(self : Duration) -> Int64

Total whole seconds in this duration (truncated toward zero).

#
Duration::as_seconds_f64

source
fn Duration::as_seconds_f64(self : Duration) -> Double

Total seconds in this duration as a Double.

Double has a ~53-bit mantissa, so magnitudes beyond ~2^53 nanoseconds (~104 days) lose sub-unit precision.

#
Duration::as_weeks

source
fn Duration::as_weeks(self : Duration) -> Int64

#
Duration::checked_add

source
fn Duration::checked_add(self : Duration, other : Duration) -> Duration?

Add two durations, returning None on Int64 overflow.

#
Duration::checked_multiply

source
fn Duration::checked_multiply(self : Duration, n : Int64) -> Duration?

Multiply this duration by an Int64 scalar, returning None on overflow.

#
Duration::checked_sub

source
fn Duration::checked_sub(self : Duration, other : Duration) -> Duration?

Subtract one duration from another, returning None on Int64 overflow.

#
Duration::days

source
fn Duration::days(d : Int64) -> Duration

Create a Duration representing the given number of days (86 400 seconds each).

#
Duration::divide

source
fn Duration::divide(self : Duration, n : Int64) -> Duration raise TempoError

Divide this duration by an Int64 scalar, truncating toward zero.

Division by zero raises TempoError. The Int64::min_value / -1 overflow edge also raises TempoError instead of trapping on backends where signed division overflow is a runtime error.

#
Duration::format_iso

source
fn Duration::format_iso(self : Duration) -> String

Format this fixed-length duration as a canonical ISO 8601 duration string.

Calendar units (years and months) are not representable as a fixed nanosecond duration and are therefore never emitted.

#
Duration::hours

source
fn Duration::hours(h : Int64) -> Duration

Create a Duration representing the given number of hours.

#
Duration::humanize

source
fn Duration::humanize(self : Duration) -> String

Format this duration as English elapsed time using day/hour/minute/second units. Sub-second remainder is dropped.

#
Duration::is_negative

source
fn Duration::is_negative(self : Duration) -> Bool

true when this duration is negative.

#
Duration::is_positive

source
fn Duration::is_positive(self : Duration) -> Bool

true when this duration is greater than zero.

#
Duration::is_zero

source
fn Duration::is_zero(self : Duration) -> Bool

true when this duration is exactly zero.

#
Duration::microseconds

source
fn Duration::microseconds(us : Int64) -> Duration

Create a Duration representing the given number of microseconds.

#
Duration::milliseconds

source
fn Duration::milliseconds(ms : Int64) -> Duration

Create a Duration representing the given number of milliseconds.

#
Duration::minutes

source
fn Duration::minutes(m : Int64) -> Duration

Create a Duration representing the given number of minutes.

#
Duration::multiply

source
fn Duration::multiply(self : Duration, n : Int64) -> Duration

Multiply this duration by an Int64 scalar.

This wraps on Int64 overflow. Use checked_multiply when overflow should return None.

#
Duration::nanoseconds

source
fn Duration::nanoseconds(ns : Int64) -> Duration

Create a Duration from a number of nanoseconds.

#
Duration::parse_iso

source
fn Duration::parse_iso(s : String) -> Duration raise TempoError

Parse an ISO 8601 duration string in the fixed-nanosecond subset: PnDTnHnMnS, with optional fractional seconds and leading sign.

Calendar units (Y years or date-part M months) raise TempoError; use a calendar-period representation for those units.

#
Duration::seconds

source
fn Duration::seconds(s : Int64) -> Duration

Create a Duration representing the given number of seconds.

#
Duration::signum

source
fn Duration::signum(self : Duration) -> Int

Sign of this duration: -1 for negative, 0 for zero, 1 for positive.

#
Duration::weeks

source
fn Duration::weeks(w : Int64) -> Duration

Create a Duration representing the given number of weeks (7 × 86 400 seconds).

#
FixedOffsetDateTime

source
pub struct FixedOffsetDateTime {
  // private fields
} derive(Compare, Eq, Hash, 
Debug)

A UTC instant paired with a fixed numeric display offset.

DateTime is tempo's primary timestamp type. Use FixedOffsetDateTime only for wire formats and interop surfaces where a timestamp carries an explicit numeric offset but no IANA time zone. The stored instant is normalized UTC; the offset is retained only as a display hint.

#
FixedOffsetDateTime::format

source
fn FixedOffsetDateTime::format(self : FixedOffsetDateTime) -> String

Format the local wall-clock time with the retained fixed offset.

The local wall-clock is computed as the stored UTC instant plus offset_seconds; the fixed offset suffix is Z for zero and +HH:MM / -HH:MM otherwise. This is for RFC 3339-style interop only; DateTime remains the primary UTC timestamp type.

Note: formatting uses the same infallible day arithmetic as Date; if the local-time projection carries past the absolute Int year envelope, the year wraps. pad4_year itself handles the full Int range and does not abort.

#
FixedOffsetDateTime::from_datetime_and_offset

source
fn FixedOffsetDateTime::from_datetime_and_offset(utc : DateTime, offset_seconds : Int) -> FixedOffsetDateTime raise TempoError

Bundle a UTC instant with a fixed numeric display offset in seconds.

The utc argument is the UTC instant and is stored as-is. DateTime remains tempo's primary timestamp type; this wrapper is for wire-format interop when a timestamp carries an explicit numeric offset but no IANA time zone.

Raises TempoError when offset_seconds is not whole-minute granularity or is outside the RFC 3339 fixed-offset range ±23:59.

#
FixedOffsetDateTime::offset_seconds

source
fn FixedOffsetDateTime::offset_seconds(self : FixedOffsetDateTime) -> Int

Return the retained fixed display offset in seconds.

#
FixedOffsetDateTime::parse

source
fn FixedOffsetDateTime::parse(s : String) -> FixedOffsetDateTime raise TempoError

Parse an RFC 3339 datetime string, retaining the explicit fixed offset.

The stored instant is normalized UTC. The parsed numeric offset is retained only for formatting/interoperability; it is not an IANA time zone.

#
FixedOffsetDateTime::to_utc

source

Return the stored UTC instant.

#
Interval

source
pub(all) struct Interval {
  start : DateTime
  end : DateTime
} derive(Eq, 
Debug)

A DateTime interval with a half-open end instant: [start, end).

This mirrors NodaTime's DateInterval-vs-Interval convention split: DateInterval is inclusive-end for calendar dates, while Interval is half-open for instants. Assumes start <= end; methods do not validate inverted intervals.

#
Interval::contains

source
fn Interval::contains(self : Interval, dt : DateTime) -> Bool

true if dt is in this half-open DateTime interval [start, end).

#
Interval::intersection

source
fn Interval::intersection(self : Interval, other : Interval) -> Interval?

Return the half-open overlap between this DateTime interval and other.

#
Interval::overlaps

source
fn Interval::overlaps(self : Interval, other : Interval) -> Bool

true if this half-open DateTime interval shares at least one instant with other.

#
Interval::to_duration

source
fn Interval::to_duration(self : Interval) -> Duration

Duration of this half-open DateTime interval (end - start).

#
Month

source
pub(all) enum Month {
  January
  February
  March
  April
  May
  June
  July
  August
  September
  October
  November
  December
} derive(Compare, Eq, Hash, 
Debug)

Calendar month, ordered January through December.
impl Show for Month

#
Month::days_in

source
fn Month::days_in(self : Month, year : Int) -> Int

Number of days in this month for year.

#
Month::from_int

source
fn Month::from_int(n : Int) -> Month?

Convert a calendar month number (1..12) to a Month.

#
Month::next

source
fn Month::next(self : Month) -> Month

Next month, wrapping December to January.

#
Month::previous

source
fn Month::previous(self : Month) -> Month

Previous month, wrapping January to December.

#
Month::to_int

source
fn Month::to_int(self : Month) -> Int

Calendar month number: January = 1 through December = 12.

#
Period

source
pub(all) struct Period {
  years : Int
  months : Int
  days : Int
} derive(Eq, Hash, 
Debug)

A calendar-aware date period stored as exact year, month, and day fields.

This is a calendar-field vector, not an elapsed-time scalar. It is never auto-canonicalized: fifteen months stays fifteen months, and thirty days never becomes one month.
impl Show for Period

#
Period::days

source
fn Period::days(self : Period) -> Int

Day field accessor.

#
Period::format

source
fn Period::format(self : Period) -> String

Format this calendar period as ISO 8601 date-period components.

#
Period::is_zero

source
fn Period::is_zero(self : Period) -> Bool

true when all three fields are zero.

#
Period::minus

source
fn Period::minus(self : Period, other : Period) -> Period raise TempoError

Subtract two periods field-wise, without normalization.

#
Period::months

source
fn Period::months(self : Period) -> Int

Month field accessor.

#
Period::negated

source
fn Period::negated(self : Period) -> Period raise TempoError

Negate each period field, without normalization.

#
Period::normalized

source
fn Period::normalized(self : Period) -> Period raise TempoError

Normalize the month field into years. Days are left untouched.

#
Period::of

source
fn Period::of(years : Int, months : Int, days : Int) -> Period

Create a Period, storing the year, month, and day fields exactly.

#
Period::of_days

source
fn Period::of_days(days : Int) -> Period

Create a Period with only a day field.

#
Period::of_months

source
fn Period::of_months(months : Int) -> Period

Create a Period with only a month field.

#
Period::of_weeks

source
fn Period::of_weeks(weeks : Int) -> Period raise TempoError

Create a Period from whole weeks, stored as days.

#
Period::of_years

source
fn Period::of_years(years : Int) -> Period

Create a Period with only a year field.

#
Period::parse

source
fn Period::parse(s : String) -> Period raise TempoError

Parse an ISO 8601 date-period string in the PnYnMnD subset.

Week notation (PnW) is accepted and stored as days. Time components and any T separator are rejected.

#
Period::plus

source
fn Period::plus(self : Period, other : Period) -> Period raise TempoError

Add two periods field-wise, without normalization.

#
Period::to_total_months

source
fn Period::to_total_months(self : Period) -> Int64

Total months represented by the year and month fields. Days are ignored.

#
Period::years

source
fn Period::years(self : Period) -> Int

Year field accessor.

#
Period::zero

source
fn Period::zero() -> Period

The zero period.

#
RoundMode

source
pub(all) enum RoundMode {
  Floor
  Ceil
  HalfExpand
} derive(Compare, Eq, Hash, 
Debug)

Rounding modes for DateTime::round_to, ordered from earlier-boundary preference to nearest-boundary behavior.
impl Show for RoundMode

#
Time

source
pub struct Time {
  hour : Int
  minute : Int
  second : Int
  nanosecond : Int
} derive(Compare, Eq, Hash, 
Debug)

A time of day with nanosecond precision (UTC).
impl Show for Time
impl ToJson for Time
impl FromJson for Time

#
Time::clamp

source
fn Time::clamp(self : Time, lo : Time, hi : Time) -> Time

Clamp this time to the inclusive range [lo, hi]. Assumes lo <= hi.

#
Time::format

source
fn Time::format(self : Time) -> String

Format this time as HH:MM:SS or HH:MM:SS.fraction (nanoseconds trimmed, consistent with DateTime::format).

#
Time::is_after

source
fn Time::is_after(self : Time, other : Time) -> Bool

true if this time is later than other.

#
Time::is_before

source
fn Time::is_before(self : Time, other : Time) -> Bool

true if this time is earlier than other.

#
Time::max

source
fn Time::max(self : Time, other : Time) -> Time

Return the later of this time and other.

#
Time::min

source
fn Time::min(self : Time, other : Time) -> Time

Return the earlier of this time and other.

#
Time::new

source
fn Time::new(hour : Int, minute : Int, second : Int, nanosecond : Int) -> Time raise TempoError

Create a Time, validating that each field is within its canonical range: hour 0–23, minute 0–59, second 0–59, nanosecond 0–999_999_999.

#
Time::parse

source
fn Time::parse(s : String) -> Time raise TempoError

Parse a time-of-day string: HH:MM:SS or HH:MM:SS.fraction.

#
Time::with_hour

source
fn Time::with_hour(self : Time, hour : Int) -> Time raise TempoError

Return a copy of this time with hour replaced, validating the result.

#
Time::with_minute

source
fn Time::with_minute(self : Time, minute : Int) -> Time raise TempoError

Return a copy of this time with minute replaced, validating the result.

#
Time::with_nanosecond

source
fn Time::with_nanosecond(self : Time, nanosecond : Int) -> Time raise TempoError

Return a copy of this time with nanosecond replaced, validating the result.

#
Time::with_second

source
fn Time::with_second(self : Time, second : Int) -> Time raise TempoError

Return a copy of this time with second replaced, validating the result.

#
TimeUnit

source
pub(all) enum TimeUnit {
  Second
  Minute
  Hour
  Day
} derive(Compare, Eq, Hash, 
Debug)

Units supported by DateTime::truncate_to and DateTime::round_to, ordered smallest to largest.
impl Show for TimeUnit

#
Weekday

source
pub(all) enum Weekday {
  Monday
  Tuesday
  Wednesday
  Thursday
  Friday
  Saturday
  Sunday
} derive(Compare, Eq, Hash, 
Debug)

ISO 8601 weekday, ordered Monday through Sunday.
impl Show for Weekday

#
Weekday::from_int

source
fn Weekday::from_int(n : Int) -> Weekday?

Convert an ISO weekday number (1..7) to a Weekday.

#
Weekday::next

source
fn Weekday::next(self : Weekday) -> Weekday

Next weekday, wrapping Sunday to Monday.

#
Weekday::number_from_monday

source
fn Weekday::number_from_monday(self : Weekday) -> Int

ISO 8601 weekday number: Monday = 1 through Sunday = 7.

#
Weekday::number_from_sunday

source
fn Weekday::number_from_sunday(self : Weekday) -> Int

Sunday-based weekday number: Sunday = 1 through Saturday = 7.

#
Weekday::previous

source
fn Weekday::previous(self : Weekday) -> Weekday

Previous weekday, wrapping Monday to Sunday.

#
Weekday::to_int

source
fn Weekday::to_int(self : Weekday) -> Int

ISO 8601 weekday number: Monday = 1 through Sunday = 7.

#
YearMonth

source
pub(all) struct YearMonth {
  year : Int
  month : Int
} derive(Compare, Eq, Hash, 
Debug)

A calendar year and month in the proleptic Gregorian calendar.
impl Show for YearMonth

#
YearMonth::at_day

source
fn YearMonth::at_day(self : YearMonth, day : Int) -> Date raise TempoError

Return the date in this year-month at day, validating the day.

#
YearMonth::at_end_of_month

source
fn YearMonth::at_end_of_month(self : YearMonth) -> Date

Return the last date in this year-month.

#
YearMonth::format

source
fn YearMonth::format(self : YearMonth) -> String

Format this year-month using the same year text as Date::format, followed by - and a zero-padded month. Years in 0..9999 produce YYYY-MM; negative years and years >= 10000 produce expanded-year strings that cannot be round-tripped through YearMonth::parse.

#
YearMonth::length

source
fn YearMonth::length(self : YearMonth) -> Int

Number of days in this year-month.

#
YearMonth::month_enum

source
fn YearMonth::month_enum(self : YearMonth) -> Month

Calendar month for this year-month.

#
YearMonth::new

source
fn YearMonth::new(year : Int, month : Int) -> YearMonth raise TempoError

Create a YearMonth, validating that month is 1–12.

#
YearMonth::parse

source
fn YearMonth::parse(s : String) -> YearMonth raise TempoError

Parse a calendar year-month in 'YYYY-MM' format.

#
YearMonth::plus_months

source
fn YearMonth::plus_months(self : YearMonth, months : Int) -> YearMonth

Add a signed number of calendar months to this year-month.

#
YearMonth::plus_years

source
fn YearMonth::plus_years(self : YearMonth, years : Int) -> YearMonth

Add a signed number of calendar years to this year-month.

#
days_in_month

source
fn days_in_month(year : Int, month : Int) -> Int

Number of days in the given month (1–12). Returns 0 for invalid month values outside 1–12.

#
is_leap_year

source
fn is_leap_year(year : Int) -> Bool

true if year is a leap year in the proleptic Gregorian calendar.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io