type moment[link]

type moment = struct {
	time::instant,
	tsc: *timescale,
};

A precise moment in time, in reference to a specific timescale. An extension of time::instant coupled with a timescale.

type timescale[link]

type timescale = struct {
	name: str,
	abbr: str,
	convto: *tsconverter,
	convfrom: *tsconverter,
};

Represents a scale of time; a time standard. See convert.

type tsconverter[link]

type tsconverter = fn(ts: *timescale, i: time::instant) ([]time::instant | void);

type error[link]

type error = !(tscmismatch | utciniterror);

All possible errors returned from this module.

type tscmismatch[link]

type tscmismatch = !(*timescale, *timescale);

Timescale mismatch.

type utciniterror[link]

type utciniterror = !(fs::error | io::error | utf8::invalid);

Error initializing the utc timescale.

def UTC_LEAPSECS_PATH[link]

def UTC_LEAPSECS_PATH: str = "/usr/share/zoneinfo/leap-seconds.list";

The filepath of the system's "leap-seconds.list" file, which contains UTC/TAI leap second data.

let gps[link]

const gps: timescale;

Global Positioning System Time

Used for GPS coordination. Based on TAI; constant -19 second offset. Continuous (no leap seconds).

let mtc[link]

const mtc: timescale;

Coordinated Mars Time

Used for timekeeping on Mars. Based on TT; constant factor. Continuous (no leap seconds).

let tai[link]

const tai: timescale;

International Atomic Time

The realisation of proper time on Earth's geoid. Continuous (no leap seconds).

let tt[link]

const tt: timescale;

Terrestrial Time

Used for astronomical timekeeping. Based on TAI; constant +32.184 offset. Continuous (no leap seconds).

let utc[link]

const utc: timescale;

Coordinated Universal Time

Used as the basis of civil timekeeping. Based on TAI; time-dependent offset. Discontinuous (has leap seconds).

During a program's initialization, this timescale initializes by loading its UTC/TAI leapsecond data from UTC_LEAPSECS_PATH; otherwise, fails silently. If failed, any attempt to consult UTC leapsec data (e.g. calling convert on UTC) causes an abort. This includes time::date::in.

let utc_status[link]

let utc_status: (bool | utciniterror);

fn add[link]

fn add(m: *moment, x: time::duration) moment;

Adds a time::duration to a moment with time::add.

fn compare[link]

fn compare(a: *moment, b: *moment) (i8 | tscmismatch);

Compares two moments. Returns -1 if a precedes b, 0 if a and b are simultaneous, or +1 if b precedes a.

tscmismatch is returned if the timescales of the two moments are different.

fn convert[link]

fn convert(m: moment, tscs: *timescale...) []moment;

Converts a moment from one timescale to the next exhaustively. The final conversion result is returned. For each considered pair of timescales, if neither implements conversion from the first to the second, a two-step intermediary tai conversion will occur. If given zero timescales, the given moment is returned.

fn diff[link]

fn diff(a: *moment, b: *moment) (time::duration | tscmismatch);

Returns the time::duration between two moments, from a to b.

tscmismatch is returned if the timescales of the two moments are different.

fn new[link]

fn new(tsc: *timescale, t: time::instant) moment;

Creates a new moment.

fn strerror[link]

fn strerror(e: error) const str;

Converts an error into a human-friendly string. The result may be statically allocated.

fn to_instant[link]

fn to_instant(m: moment) time::instant;

Extracts the time::instant of the given moment.