Tempo

import stdlib::time::*;

pub struct Duration {
    !nanos: i64,
}

pub fn to_string(self: Duration) -> string

Duration::from_secs(3725).to_string();   // "1h 2m 5s"
Duration::from_millis(1500).to_string(); // "1.50s"

import stdlib::time::*;

fn main() -> i32 {
    let d: Duration = Duration::from_hours(2).add(Duration::from_minutes(30));
    println!(d.to_string());            // "2h 30m 0s"
    println!(d.as_minutes());           // 150
    println!(d.as_millis());            // 9000000

    let a: Duration = Duration::from_secs(90);
    println!(a.is_positive());          // true
    println!(a.before(d));              // true
    println!(a.sub(Duration::from_secs(30)).as_secs());  // 60
    println!(Duration::zero().is_zero());

    let neg: Duration = Duration::from_secs(5).neg();
    println!(neg.is_negative());        // true
    return 0;
}

import stdlib::time::*;

fn main() -> i32 {
    let half_day: Duration = Duration::from_hours(12);
    let day: Duration = half_day.mul(2);
    println!(day.as_hours());                 // 24

    // Fold a running total from the zero() seed.
    let mut total: Duration = Duration::zero();
    total = total.add(Duration::from_minutes(90));
    total = total.add(Duration::from_secs(30));
    println!(total.to_string());              // "1h 30m 30s"
    println!(total.as_secs());                // 5430

    // Conversions truncate toward zero; to_string shows centiseconds.
    let d: Duration = Duration::from_millis(1500);
    println!(d.as_secs());                    // 1  (drops .5)
    println!(d.to_string());                  // "1.50s"

    // Negative span: sign moves to the prefix.
    let back: Duration = Duration::from_secs(5).neg();
    println!(back.to_string());               // "-5s"
    println!(back.is_negative());             // true

    // Comparisons treat equal magnitudes as equal regardless of unit.
    println!(Duration::from_secs(60).equal(Duration::from_minutes(1)));  // true
    println!(Duration::from_secs(30).before(Duration::from_minutes(1))); // true
    println!(Duration::from_hours(2).after(Duration::from_minutes(90))); // true
    return 0;
}

pub struct Time {
    !unix_nanos: i64,
    !tz_offset_min: i32,
}

import stdlib::time::*;

fn main() -> i32 {
    let t: Time = Time::from_datetime(2026, 5, 8, 14, 23, 45);
    println!(t.rfc3339());              // 2026-05-08T14:23:45Z
    println!(t.date_string());          // 2026-05-08
    println!(t.time_string());          // 14:23:45
    println!(t.format("Day, MMMM DD")); // Friday, May 08

    println!(t.year());                 // 2026
    println!(t.month().short_name());   // May
    println!(t.weekday().name());       // Friday
    println!(t.day_of_year());
    println!(t.is_leap_year());

    let a: Time = Time::from_date(2026, 1, 1);
    let b: Time = Time::from_date(2026, 5, 8);
    println!(a.before(b));              // true
    println!(b.diff(a).as_days());      // days between

    let later: Time = t.add(Duration::from_hours(6));
    println!(later.rfc3339());
    return 0;
}

import stdlib::time::*;

fn main() -> i32 {
    let t: Time = Time::from_datetime(2024, 2, 29, 23, 59, 59);
    println!(t.year(), t.month_int(), t.day());   // 2024 2 29
    println!(t.hour(), t.minute(), t.second());   // 23 59 59
    println!(t.is_leap_year());                   // true (2024)
    println!(t.day_of_year());                    // 60
    println!(t.weekday().name());                 // Thursday

    let u: Time = Time::from_unix(1735689600);    // 2025-01-01T00:00:00Z
    println!(u.rfc3339());
    println!(u.unix());                            // 1735689600
    println!(u.unix_millis());                     // 1735689600000
    println!(Time::from_unix_millis(u.unix_millis()).equal(u));  // true

    // Sub-second precision survives from_unix_nanos.
    let p: Time = Time::from_unix_nanos(1500000000_500000000);
    println!(p.nanosecond());                      // 500000000
    return 0;
}

import stdlib::time::*;

fn main() -> i32 {
    let t: Time = Time::from_datetime(2026, 5, 8, 14, 37, 50);

    let later: Time = t.add(Duration::from_hours(2));
    println!(later.time_string());            // 16:37:50
    let earlier: Time = t.sub(Duration::from_minutes(37).add(Duration::from_secs(50)));
    println!(earlier.time_string());          // 14:00:00

    let d: Duration = later.diff(t);
    println!(d.as_hours());                   // 2
    println!(t.diff(later).is_negative());    // true

    println!(t.truncate(Duration::from_hours(1)).time_string());   // 14:00:00
    println!(t.round(Duration::from_hours(1)).time_string());      // 15:00:00 (37m rounds up)
    println!(t.round(Duration::from_minutes(15)).time_string());   // 14:45:00
    println!(t.truncate(Duration::zero()).equal(t));               // true
    return 0;
}

import stdlib::time::*;

fn main() -> i32 {
    let r: !Time = Time::parse_rfc3339("2024-03-21T18:45:30+02:00");
    if r.ok {
        let t: Time = r.val;
        println!("unix:", t.unix());
        println!(t.tz_offset());        // 120
    } else {
        println!("parse failed:", r.err);
    }

    let dr: !Time = Time::parse_date("2026-05-08");
    if dr.ok { println!(dr.val.rfc3339()); }

    let utc: Time = Time::from_datetime(2026, 5, 8, 12, 0, 0);
    println!(utc.with_tz(540).rfc3339()); // ...+09:00 (JST)
    println!(utc.to_utc().tz_offset());   // 0
    return 0;
}

import stdlib::time::*;

fn round_trip(s: string) -> !string {
    let t: Time = Time::parse_rfc3339(s)?;   // propagate err on failure
    return ok(t.rfc3339());
}

fn main() -> i32 {
    let r: !string = round_trip("2024-03-21T18:45:30+02:00");
    if r.ok { println!(r.val); }              // 2024-03-21T18:45:30+02:00

    // Fractional seconds are NOT accepted yet -> err.
    let bad: !Time = Time::parse_rfc3339("2024-03-21T18:45:30.5Z");
    println!(bad.ok);                         // false
    println!(bad.err);                        // rfc3339: expected Z or ±HH:MM

    let dr: !Time = Time::parse_date("2026-05-08");
    if dr.ok { println!(dr.val.rfc3339()); }  // 2026-05-08T00:00:00Z

    // ?? supplies a fallback instant when the parse fails.
    let parsed: Time = Time::parse_rfc3339("nope") ?? Time::epoch();
    println!(parsed.unix());                  // 0
    return 0;
}

pub enum Weekday {
    Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday,
}

pub enum Month {
    January, February, March, April, May, June,
    July, August, September, October, November, December,
}

import stdlib::time::*;

fn main() -> i32 {
    println!(Weekday::from_int(5).short_name());   // Fri
    println!(Weekday::Monday().name());            // Monday
    println!(Month::from_int(5).short_name());     // May
    println!(Month::December().to_int());          // 12
    println!(Month::February().days(2024));        // 29 (leap)
    println!(Month::February().days(2025));        // 28
    return 0;
}

pub struct Stopwatch {
    !start_ns: i64,
}

import stdlib::time::*;

fn work() {
    let mut x: i64 = 0;
    for let i: i32 = 0; i < 10000; i++ { x = x + (i as i64); }
}

fn main() -> i32 {
    // elapsed() is cumulative — the clock keeps running.
    let sw: Stopwatch = Stopwatch::start();
    work();
    let t1: Duration = sw.elapsed();
    work();
    let t2: Duration = sw.elapsed();   // total since start, not since t1
    println!(t1.as_nanos() <= t2.as_nanos());   // true
    println!("elapsed:", t2.to_string());

    // reset() mutates in place — call it via &mut and chain laps.
    let mut lap: Stopwatch = Stopwatch::start();
    work();  let a: Duration = (&mut lap).reset();
    work();  let b: Duration = (&mut lap).reset();
    println!("lap a:", a.as_nanos(), "lap b:", b.as_nanos());
    return 0;
}

import stdlib::time::*;

fn main() -> i32 {
    let timer: chan<i64> = after(Duration::from_millis(50));
    let fired_at: i64 = timer.recv();   // wakes ~50ms later
    println!("fired at", fired_at);

    let beat: chan<i64> = tick(Duration::from_millis(10));
    println!("tick", beat.recv());
    return 0;
}

import stdlib::time::*;

fn _work(c: chan<i32>) {
    sleep_ms(5);
    c.send(42);
}

fn main() -> i32 {
    let work: chan<i32> = make_chan(1);
    spawn _work(work);

    let timeout: chan<i64> = after(Duration::from_millis(200));

    let mut result: i32 = -1;
    select! {
        v = work.recv()    => { result = v; }
        t = timeout.recv() => { result = -1; }
    }

    if result < 0 {
        println!("timed out");
    } else {
        println!("got", result);
    }
    return 0;
}

import stdlib::time::*;

fn _producer(c: chan<i32>) {
    sleep_ms(5);
    c.send(1);
    sleep_ms(5);
    c.send(2);
}

fn main() -> i32 {
    let work: chan<i32> = make_chan(2);
    spawn _producer(work);

    let beat: chan<i64> = tick(Duration::from_millis(1));

    let mut got: i32 = 0;
    let mut beats: i32 = 0;
    while got < 2 {
        select! {
            v = work.recv() => { got = v; }
            t = beat.recv() => { beats = beats + 1; }
        }
    }
    println!("done, received", got);
    return 0;
}

import stdlib::time::*;

fn work() {
    let mut x: i64 = 0;
    for let i: i32 = 0; i < 1000; i++ { x = x + (i as i64); }
}

fn main() -> i32 {
    let t0: i64 = time_now_ns();
    work();
    println!(time_since_ns(t0), "ns");
    println!(time_now_ms(), time_now_us());
    return 0;
}