Time

use std.time

fn main() {
    const start = time.monotonic_ms()
    time.sleep(200.ms)
    const took = time.monotonic_ms() - start
    print("took at least 200 ms: {took >= 200}")
    print("a date after 2026 began: {time.now_ms() > 1_767_225_600_000}")
}

use std.time

fn main() {
    for tick in time.every_ms(100) {
        print("tick {tick}")
        if tick == 3 {
            break
        }
    }
}

use std.time

fn main() {
    const backup = 2.days
    print(backup.ms)
    print(90.seconds.ms)
    const retries = 3
    print((retries * 5).minutes.ms)
}

use std.time

fn main() {
    print(2.months.ms)
}

use std.time

type Trial {
    started: Int

    fn ended(self) -> Bool
        require self.started >= 0
        example Trial(started: 1_767_225_600_000).ended() == false
    {
        time.now_ms() - self.started >= 30.days.ms
    }
}

test "a trial ends after 30 days" {
    time.freeze(1_767_225_600_000)       // 2026-01-01 00:00 UTC
    const trial = Trial(started: time.now_ms())
    time.sleep(29.days)
    assert not trial.ended()
    time.sleep(1.days)
    assert trial.ended()
}

use std.time

fn main() {
    time.freeze(0)
    print(time.now_ms())
}

use std.time

fn main() ! Error {
    const due = time.Date(year: 2024, month: 1, day: 31)
    print(due.add_months(1).iso())
    print(due.weekday())
    print(due.add_days(30).iso())
    print(due.days_until(time.Date(year: 2024, month: 12, day: 25)))
    print(time.utc(0).iso())
    print(time.is_leap_year(1900))
    print(time.is_leap_year(2000))
    print(time.days_in_month(2026, 2))
    const day = try time.parse_date("2026-11-04")
    print(day.weekday())
    const bad = time.parse_date("2026-02-30") catch e => {
        print("refused: {e}")
        return
    }
    print(bad.iso())
}

use std.time

fn main() {
    const month = 2
    const day = time.Date(year: 2026, month: month, day: 30)
    print(day.iso())
}

use std.time

fn main() ! Error {
    const call = 1_782_907_200_000      // 2026-07-01, 12:00 UTC
    for name in ["Asia/Kolkata", "Europe/Berlin", "America/New_York"] {
        const z = try time.zone(name)
        print("{name}: {z.at(call).iso()}, UTC offset {z.offset_seconds(call) / 60} minutes")
    }
}

use std.time

fn main() ! Error {
    const new_york = try time.zone("America/New_York")
    // That night, the clocks went from 02:00 straight to 03:00.
    const night = time.Date(year: 2026, month: 3, day: 8)
    const alarm = time.DateTime(date: night, time: time.Time(hour: 2, minute: 30, second: 0, ms: 0))
    print("moment: {new_york.at(new_york.moment(alarm)).iso()}")
    match new_york.resolve(alarm) {
        time.Exact(_) => print("02:30 happened once"),
        time.Skipped(earlier, _) => print("an hour early instead: {new_york.at(earlier).iso()}"),
        time.Repeated(_, _) => print("02:30 happened twice"),
    }
}

use std.time

fn main() ! Error {
    const new_york = try time.zone("America/New_York")
    // That night, the clocks went back from 02:00 to 01:00.
    const night = time.Date(year: 2026, month: 11, day: 1)
    const twice = time.DateTime(date: night, time: time.Time(hour: 1, minute: 30, second: 0, ms: 0))
    match new_york.resolve(twice) {
        time.Repeated(earlier, later) => {
            print("first 01:30: {new_york.offset_seconds(earlier) / 3600} h from UTC")
            print("second 01:30: {new_york.offset_seconds(later) / 3600} h from UTC")
            print("moment gives the first: {new_york.moment(twice) == earlier}")
        }
        _ => print("01:30 happened once"),
    }
}

use std.time

fn main() {
    const z = time.zone("Mars/Olympus") catch e => {
        print("refused: {e}")
        print(time.zone_offset("Mars/Olympus", 0))
        return
    }
    print(z.name)
}

use std.time

fn main() ! Error {
    const fixed = try time.zone("+05:30")
    print(fixed.iso(0))
    print((try time.zone("UTC")).iso(0))

    // Kolkata's oldest offset has seconds.
    const kolkata = try time.zone("Asia/Kolkata")
    const long_ago = time.DateTime(date: time.Date(year: 1874, month: 12, day: 1), time: time.Time(hour: 0, minute: 0, second: 0, ms: 0))
    print(kolkata.iso(kolkata.moment(long_ago)))

    for name in ["+24:00", "+5:30"] {
        const _zone = time.zone(name) catch e => {
            print("refused: {e}")
            continue
        }
    }
}

use std.time

fn main() ! Error {
    const at = try time.parse_moment("2026-11-04T14:35:30+05:30")
    print(at)
    const berlin = try time.zone("Europe/Berlin")
    print(berlin.iso(at))
    print((try time.parse_time("09:05")).iso())
    print((try time.parse_datetime("2026-11-04T09:05:30.250")).iso())
    print((try time.parse_time("09:05:30.1239")).ms)
}

use std.time

fn main() {
    for text in ["2026-11-04T09:05:30", "2026-11-04 09:05:30Z"] {
        const _moment = time.parse_moment(text) catch e => {
            print("moment: {e}")
            continue
        }
    }
    for text in ["2026-11-04T09:05:30+05:30", "2026-11-04T9:05:30"] {
        const _wall = time.parse_datetime(text) catch e => {
            print("datetime: {e}")
            continue
        }
    }
    for text in ["9:05", "23:59:60"] {
        const _time = time.parse_time(text) catch e => {
            print("time: {e}")
            continue
        }
    }
    for text in ["2026-11-4", "2026-+1-04"] {
        const _date = time.parse_date(text) catch e => {
            print("date: {e}")
            continue
        }
    }
}

use std.time

fn main() ! Error {
    const old = try time.parse_date("-0005-01-01")
    print(old.iso())
    const far = try time.parse_date("+12345-06-07")
    print(far.iso())
    print((try time.parse_date("12345-06-07")) == far)
}

use std.time

fn expires(at_ms: Int) -> Bool
    require at_ms > time.now_ms()
{
    true
}

fn main() {
    print(expires(0))
}