Skip to content

stdlib/datetimeView source ↗

datetime

40 items · generated by scribe fromstdlib/datetime.fd· synced 2026-11-15

stdlib/datetime40 items

Contents

dt_parse

Parse an ISO 8601 datetime to (ok, unix_seconds).

Accepted forms: YYYY-MM-DD YYYY-MM-DD HH:MM[:SS] (space or ‘T’ separator) YYYY-MM-DDTHH:MM[:SS][.frac] any of the above + “Z” or ±HH / ±HHMM / ±HH:MM zone offset

The zone offset is applied (result is always UTC seconds). Dates before 1970 produce negative seconds — fine.

Example: var (ok, ts) = dt_parse(“2026-10-27T14:30:00+02:00”); assert(ok); assert_eq(dt_to_iso(dt_from_seconds(ts)), “2026-10-27T12:30:00Z”); var (bad, _z) = dt_parse(“not a date”); assert(!bad);

pub fn dt_parse(s: str) -> (bool, i64) {

Parameters:

  • s: str

Returns: (bool, i64)

Defined at line 87


dt_parse_or_epoch

Parse an ISO 8601 datetime; returns the unix timestamp, or 0 on failure (combine with dt_parse when the distinction matters).

Example: assert_eq(dt_parse_or_epoch(“1970-01-02”), 86400); assert_eq(dt_parse_or_epoch(“garbage”), 0);

pub fn dt_parse_or_epoch(s: str) -> i64 {

Parameters:

  • s: str

Returns: i64

Defined at line 234


dt_parse_time

Parse an ISO 8601 datetime to a LogicalTime; the epoch on failure.

Example: var t = dt_parse_time(“2024-03-05 08:09”); assert_eq(time_get_minute(t), 9);

pub fn dt_parse_time(s: str) -> LogicalTime {

Parameters:

  • s: str

Returns: LogicalTime

Defined at line 247


dt_is_valid

Is the string a valid ISO 8601 datetime in the forms dt_parse accepts?

Example: assert(dt_is_valid(“2024-01-31T23:59:59Z”)); assert(!dt_is_valid(“2024-13-01”));

pub fn dt_is_valid(s: str) -> bool {

Parameters:

  • s: str

Returns: bool

Defined at line 256


dt_weekday_name

Full weekday name (“Monday”) for weekday index 0=Sunday..6=Saturday.

Example: assert_eq(dt_weekday_name(1), “Monday”);

pub fn dt_weekday_name(wd: i64) -> str {

Parameters:

  • wd: i64

Returns: str

Defined at line 267


dt_weekday_short

Short weekday name (“Mon”).

Example: assert_eq(dt_weekday_short(0), “Sun”);

pub fn dt_weekday_short(wd: i64) -> str {

Parameters:

  • wd: i64

Returns: str

Defined at line 296


dt_month_name

Full month name (“January”) for month 1..12.

Example: assert_eq(dt_month_name(12), “December”);

pub fn dt_month_name(m: i64) -> str {

Parameters:

  • m: i64

Returns: str

Defined at line 304


dt_month_short

Short month name (“Jan”).

Example: assert_eq(dt_month_short(3), “Mar”);

pub fn dt_month_short(m: i64) -> str {

Parameters:

  • m: i64

Returns: str

Defined at line 348


dt_format

Format a LogicalTime with strftime-style codes.

Supported: %Y %y %m %d %e %H %I %M %S %p %A %a %B %b %j %F %T %R %D %z %Z %% Unknown codes are emitted literally (the ’%’ is kept).

Example: var t = time_new(2026, 10, 27, 14, 30, 5); var s = dt_format(t, “%A %d %B %Y, %H:%M:%S”); println(s); assert_eq(s, “Tuesday 27 October 2026, 14:30:05”); assert_eq(dt_format(t, “%F %I%p”), “2026-10-27 02PM”);

pub fn dt_format(t: LogicalTime, fmt: str) -> str {

Parameters:

  • t: LogicalTime
  • fmt: str

Returns: str

Defined at line 391


dt_to_iso

ISO 8601 “YYYY-MM-DDTHH:MM:SSZ” (same as time_to_iso).

Example: assert_eq(dt_to_iso(dt_from_seconds(0)), “1970-01-01T00:00:00Z”);

pub fn dt_to_iso(t: LogicalTime) -> str {

Parameters:

  • t: LogicalTime

Returns: str

Defined at line 512


dt_to_date

Date only “YYYY-MM-DD”.

Example: assert_eq(dt_to_date(time_from_date(2026, 1, 9)), “2026-01-09”);

pub fn dt_to_date(t: LogicalTime) -> str {

Parameters:

  • t: LogicalTime

Returns: str

Defined at line 520


dt_to_rfc2822

RFC 2822 style: “Tue, 27 Oct 2026 14:30:00 +0000”.

Example: assert_eq(dt_to_rfc2822(time_new(2026, 10, 27, 14, 30, 0)), “Tue, 27 Oct 2026 14:30:00 +0000”);

pub fn dt_to_rfc2822(t: LogicalTime) -> str {

Parameters:

  • t: LogicalTime

Returns: str

Defined at line 528


dt_from_seconds

Unix seconds -> LogicalTime.

Example: assert_eq(time_get_year(dt_from_seconds(946684800)), 2000);

pub fn dt_from_seconds(ts: i64) -> LogicalTime {

Parameters:

  • ts: i64

Returns: LogicalTime

Defined at line 536


dt_to_seconds

LogicalTime -> unix seconds.

Example: assert_eq(dt_to_seconds(time_from_date(1970, 1, 2)), 86400);

pub fn dt_to_seconds(t: LogicalTime) -> i64 {

Parameters:

  • t: LogicalTime

Returns: i64

Defined at line 544


dt_now

The current wall-clock time as a LogicalTime (NOT deterministic — reads CLOCK_REALTIME).

Example: assert(time_get_year(dt_now()) >= 2024);

pub fn dt_now() -> LogicalTime {

Returns: LogicalTime

Defined at line 553


Duration

A signed relative timespan in seconds.

Example: var d = dur_add(dur_hours(1), dur_minutes(30)); assert_eq(dur_to_seconds(d), 5400); assert_eq(dur_format(d), “1h30m”);

pub struct Duration {

Fields:

NameType
secondsi64

Defined at line 565


dur_seconds

A Duration of n seconds.

Example: assert_eq(dur_to_seconds(dur_seconds(42)), 42);

pub fn dur_seconds(n: i64) -> Duration {

Parameters:

  • n: i64

Returns: Duration

Defined at line 573


dur_minutes

A Duration of n minutes.

Example: assert_eq(dur_to_seconds(dur_minutes(2)), 120);

pub fn dur_minutes(n: i64) -> Duration {

Parameters:

  • n: i64

Returns: Duration

Defined at line 582


dur_hours

A Duration of n hours.

Example: assert_eq(dur_to_seconds(dur_hours(2)), 7200);

pub fn dur_hours(n: i64) -> Duration {

Parameters:

  • n: i64

Returns: Duration

Defined at line 591


dur_days

A Duration of n days.

Example: assert_eq(dur_to_seconds(dur_days(1)), 86400);

pub fn dur_days(n: i64) -> Duration {

Parameters:

  • n: i64

Returns: Duration

Defined at line 600


dur_weeks

A Duration of n weeks.

Example: assert_eq(dur_format(dur_weeks(1)), “1w”);

pub fn dur_weeks(n: i64) -> Duration {

Parameters:

  • n: i64

Returns: Duration

Defined at line 609


dur_millis

Milliseconds truncated to whole seconds.

Example: assert_eq(dur_to_seconds(dur_millis(2500)), 2);

pub fn dur_millis(n: i64) -> Duration {

Parameters:

  • n: i64

Returns: Duration

Defined at line 618


dur_to_seconds

The Duration’s length in seconds.

Example: assert_eq(dur_to_seconds(dur_minutes(1)), 60);

pub fn dur_to_seconds(d: Duration) -> i64 {

Parameters:

  • d: Duration

Returns: i64

Defined at line 628


dur_to_millis

The Duration’s length in milliseconds.

Example: assert_eq(dur_to_millis(dur_seconds(3)), 3000);

pub fn dur_to_millis(d: Duration) -> i64 {

Parameters:

  • d: Duration

Returns: i64

Defined at line 635


dur_add

Sum of two Durations.

Example: assert_eq(dur_to_seconds(dur_add(dur_seconds(1), dur_seconds(2))), 3);

pub fn dur_add(a: Duration, b: Duration) -> Duration {

Parameters:

  • a: Duration
  • b: Duration

Returns: Duration

Defined at line 643


dur_sub

Difference of two Durations (a - b).

Example: assert_eq(dur_to_seconds(dur_sub(dur_seconds(1), dur_seconds(5))), -4);

pub fn dur_sub(a: Duration, b: Duration) -> Duration {

Parameters:

  • a: Duration
  • b: Duration

Returns: Duration

Defined at line 652


dur_neg

The Duration with its sign flipped.

Example: assert_eq(dur_to_seconds(dur_neg(dur_seconds(5))), -5);

pub fn dur_neg(d: Duration) -> Duration {

Parameters:

  • d: Duration

Returns: Duration

Defined at line 661


dur_abs

The Duration without its sign.

Example: assert_eq(dur_to_seconds(dur_abs(dur_seconds(-5))), 5);

pub fn dur_abs(d: Duration) -> Duration {

Parameters:

  • d: Duration

Returns: Duration

Defined at line 670


dt_diff

Difference between two times as a Duration (a - b).

Example: var a = time_from_date(2024, 1, 2); var b = time_from_date(2024, 1, 1); assert_eq(dur_format(dt_diff(a, b)), “1d”);

pub fn dt_diff(a: LogicalTime, b: LogicalTime) -> Duration {

Parameters:

  • a: LogicalTime
  • b: LogicalTime

Returns: Duration

Defined at line 685


dt_add

Shift a time by a Duration.

Example: var t = dt_add(time_from_date(2024, 1, 1), dur_hours(36)); assert_eq(dt_to_iso(t), “2024-01-02T12:00:00Z”);

pub fn dt_add(t: LogicalTime, d: Duration) -> LogicalTime {

Parameters:

  • t: LogicalTime
  • d: Duration

Returns: LogicalTime

Defined at line 696


dt_sub

Shift a time back by a Duration.

Example: var t = dt_sub(time_from_date(2024, 1, 1), dur_seconds(1)); assert_eq(dt_to_iso(t), “2023-12-31T23:59:59Z”);

pub fn dt_sub(t: LogicalTime, d: Duration) -> LogicalTime {

Parameters:

  • t: LogicalTime
  • d: Duration

Returns: LogicalTime

Defined at line 704


dur_parse

Parse a duration like ”90s”, “1h30m”, “2d”, “1w2d3h4m5s”, “-5m”. Units: s, m, h, d, w (also “ms” is NOT supported — ambiguity with ‘m’). Returns (ok, seconds).

Example: var (ok, secs) = dur_parse(“1h30m”); assert(ok); assert_eq(secs, 5400); var (ok2, _s) = dur_parse(“5x”); assert(!ok2);

pub fn dur_parse(s: str) -> (bool, i64) {

Parameters:

  • s: str

Returns: (bool, i64)

Defined at line 718


dur_parse_or_zero

Parse a duration string, returning 0 seconds on failure.

Example: assert_eq(dur_to_seconds(dur_parse_or_zero(“2d”)), 172800); assert_eq(dur_to_seconds(dur_parse_or_zero(“oops”)), 0);

pub fn dur_parse_or_zero(s: str) -> Duration {

Parameters:

  • s: str

Returns: Duration

Defined at line 781


dur_format

Format a Duration compactly: “2d3h4m5s”, “-1h30m”, “0s”. Zero value formats as “0s”.

Example: assert_eq(dur_format(dur_seconds(93784)), “1d2h3m4s”); assert_eq(dur_format(dur_days(9)), “1w2d”); assert_eq(dur_format(dur_seconds(0)), “0s”);

pub fn dur_format(d: Duration) -> str {

Parameters:

  • d: Duration

Returns: str

Defined at line 800


dur_format_hms

Format a Duration as “HH:MM:SS” (sign applied to the whole value; hours can exceed 23 — this is a timespan, not a clock).

Example: assert_eq(dur_format_hms(dur_seconds(3725)), “01:02:05”);

pub fn dur_format_hms(d: Duration) -> str {

Parameters:

  • d: Duration

Returns: str

Defined at line 845


Generated by scribe, the Fides documentation generator