Standard library

fn main() -> void {
    print(sb().push("hi").push(" ").push_i32(42).build())
    print(cat("x", "y"))
    print(cat3("a", "b", "c"))
    print(cat4("w", "x", "y", "z"))
}

fn is_even(x: i32) -> i32 {
    if x % 2 == 0 { return 1 }
    return 0
}
fn times2(x: i32) -> i32 { return x * 2 }
fn add(a: i32, b: i32) -> i32 { return a + b }

fn main() -> void {
    let xs = vec().push(1).push(2).push(3).push(4)
    print(xs.len())
    print(xs.contains(3))
    print(xs.filter(is_even).len())
    print(xs.map(times2).get(0))
    print(xs.reduce(0, add))
    print(vec_range(0, 3).len())
}

fn longer_than_3(s: string) -> i32 {
    if s.len() > 3 { return 1 }
    return 0
}

fn main() -> void {
    let names = strs().push("ada").push("nyra").push("bob")
    print(names.joined(","))
    print(names.contains("nyra"))
    print(names.filter(longer_than_3).get(0))
    print(lines("a\nb\nc").len())
}

fn main() -> void {
    let mut m = HashMap_str_str_new().insert("a", "1").insert("b", "2")
    print(m.contains("a"))
    m = m.remove("a")
    print(m.contains("a"))
    print(m.get("b"))
}

import "stdlib/builtins_array.ny"
import "stdlib/vec.ny"

fn is_even(x: i32) -> i32 {
    if x % 2 == 0 {
        return 1
    }
    return 0
}

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 1)
    Array_push(v, 2)
    Array_push(v, 3)
    let evens: ptr = Array_filter(v, is_even)
    print(Vec_i32_len(evens))
    print(Vec_i32_get(evens, 0))
}

import "stdlib/builtins_array.ny"
import "stdlib/vec.ny"

fn is_two(x: i32) -> i32 {
    if x == 2 {
        return 1
    }
    return 0
}

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 1)
    Array_push(v, 2)
    print(Array_find(v, is_two, -1))
}

import "stdlib/builtins_array.ny"
import "stdlib/vec.ny"

fn double(x: i32) -> i32 {
    return x * 2
}

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 3)
    Array_push(v, 4)
    let out: ptr = Array_map(v, double)
    print(Vec_i32_get(out, 0))
    print(Vec_i32_get(out, 1))
}

import "stdlib/builtins_array.ny"
import "stdlib/vec.ny"

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 10)
    Array_push(v, 20)
    print(Array_pop(v))
    print(Vec_i32_len(v))
}

import "stdlib/builtins_array.ny"
import "stdlib/vec.ny"

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 1)
    Array_push(v, 2)
    print(Vec_i32_len(v))
}

import "stdlib/builtins_array.ny"
import "stdlib/vec.ny"

fn add(acc: i32, x: i32) -> i32 {
    return acc + x
}

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 10)
    Array_push(v, 20)
    print(Array_reduce(v, 0, add))
}

import "stdlib/builtins_json.ny"

fn main() -> void {
    let raw: string = JSON_stringify("name", "hamdy")
    print(JSON_parse(raw, "name"))
}

import "stdlib/builtins_json.ny"

fn main() -> void {
    print(JSON_stringify("name", "hamdy"))
}

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_ceil(7))
}

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_floor(7))
}

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_max(10, 3))
}

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_min(10, 3))
}

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_random())
}

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_round(7))
}

// random() / random_f64() — compiler builtins (no import required).
fn main() -> void {
    print(random())
    print(random(1, 6))
    print(random_f64())
}

fn main() -> void {
    print(random())
    print(random(1, 6))
    print(random_f64())
}

import "stdlib/random.ny"
import "stdlib/vec.ny"

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Vec_i32_push(v, 10)
    Vec_i32_push(v, 20)
    Vec_i32_push(v, 30)
    print(shuffle_pick(v))
}

import "stdlib/builtins_string.ny"

fn main() -> void {
    print(String_includes("hello", "ell"))
}

import "stdlib/builtins_string.ny"

fn main() -> void {
    print(String_replace("foo-bar", "bar", "baz"))
}

import "stdlib/builtins_string.ny"
import "stdlib/vec_str.ny"

fn main() -> void {
    let parts = String_split("a,b", ",")
    print(Vec_str_len(parts))
}

import "stdlib/builtins_string.ny"

fn main() -> void {
    print(String_toLowerCase("NYRA"))
}

import "stdlib/builtins_string.ny"

fn main() -> void {
    print(String_toUpperCase("nyra"))
}

import "stdlib/builtins_string.ny"

fn main() -> void {
    print(trim("  hi  "))
}

// Compiler math intrinsics: no stdlib prelude required (--no-prelude friendly).
// Build: nyra build examples/builtins/math_intrinsics.ny --release --no-prelude -o math_intrinsics
// Run:   ./target/release/math_intrinsics

fn main() -> void {
    let a = abs_i32(-42)
    let b = min_i32(3, 7)
    let c = max_i32(3, 7)
    let d = clamp_i32(15, 0, 10)
    print(a)
    print(b)
    print(c)
    print(d)
    let x = abs(-5)
    print(x)
}

// [contrib-dev:acos_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(acos_f64(3.0))
}
// [/contrib-dev:acos_f64:math]

// [contrib-dev:asin_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(asin_f64(3.0))
}
// [/contrib-dev:asin_f64:math]

// [contrib-dev:atan_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(atan_f64(3.0))
}
// [/contrib-dev:atan_f64:math]

// [contrib-dev:ceil_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(ceil_f64(3.0))
}
// [/contrib-dev:ceil_f64:math]

// [contrib-dev:ceil_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(ceil_i32(3))
}
// [/contrib-dev:ceil_i32:math]

// [contrib-dev:clamp_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(clamp_f64(3.0, 0.0, 1.0))
}
// [/contrib-dev:clamp_f64:math]

// [contrib-dev:copysign_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(copysign_f64(1.0, 1.0))
}
// [/contrib-dev:copysign_f64:math]

// [contrib-dev:count_ones_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(count_ones_i32(1))
}
// [/contrib-dev:count_ones_i32:math]

// [contrib-dev:deg_to_rad_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(deg_to_rad_f64(1.0))
}
// [/contrib-dev:deg_to_rad_f64:math]

// [contrib-dev:exp_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(exp_f64(3.0))
}
// [/contrib-dev:exp_f64:math]

// [contrib-dev:floor_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(floor_f64(3.0))
}
// [/contrib-dev:floor_f64:math]

// [contrib-dev:floor_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(floor_i32(3))
}
// [/contrib-dev:floor_i32:math]

// [contrib-dev:fmod_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(fmod_f64(5.0, 2.0))
}
// [/contrib-dev:fmod_f64:math]

// [contrib-dev:fract_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(fract_f64(3.0))
}
// [/contrib-dev:fract_f64:math]

// [contrib-dev:gcd_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(gcd_i32(1, 1))
}
// [/contrib-dev:gcd_i32:math]

// [contrib-dev:hypot_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(hypot_f64(3.0, 4.0))
    print(1)
    }
}
// [/contrib-dev:hypot_f64:math]

// [contrib-dev:is_finite_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(is_finite_f64(3.0))
}
// [/contrib-dev:is_finite_f64:math]

// [contrib-dev:is_infinite_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(is_infinite_f64(3.0))
}
// [/contrib-dev:is_infinite_f64:math]

// [contrib-dev:is_nan_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(is_nan_f64(3.0))
}
// [/contrib-dev:is_nan_f64:math]

// [contrib-dev:lcm_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(lcm_i32(1, 1))
}
// [/contrib-dev:lcm_i32:math]

// [contrib-dev:leading_zeros_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(leading_zeros_i32(1))
}
// [/contrib-dev:leading_zeros_i32:math]

// [contrib-dev:lerp_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(lerp_f64(0.0, 10.0, 0.5))
}
// [/contrib-dev:lerp_f64:math]

// [contrib-dev:log_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(log_f64(3.0))
}
// [/contrib-dev:log_f64:math]

// [contrib-dev:log10_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(log10_f64(3.0))
}
// [/contrib-dev:log10_f64:math]

// [contrib-dev:log2_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(log2_f64(3.0))
}
// [/contrib-dev:log2_f64:math]

import "stdlib/builtins_math.ny"

fn main() -> void {
    print(Math_round(7))
    print(Math_floor(7))
    print(Math_ceil(7))
    print(Math_max(10, 3))
    print(Math_min(10, 3))

    print(Math_random())
}

// [contrib-dev:mod_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(mod_i32(1, 1))
}
// [/contrib-dev:mod_i32:math]

// [contrib-dev:pow_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(pow_f64(2.0, 3.0))
}
// [/contrib-dev:pow_f64:math]

// [contrib-dev:pow_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(pow_i32(2, 3))
}
// [/contrib-dev:pow_i32:math]

// [contrib-dev:rad_to_deg_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(rad_to_deg_f64(1.0))
}
// [/contrib-dev:rad_to_deg_f64:math]

// [contrib-dev:rem_euclid_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(rem_euclid_i32(1, 1))
}
// [/contrib-dev:rem_euclid_i32:math]

// [contrib-dev:rotate_left_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(rotate_left_i32(1, 1))
}
// [/contrib-dev:rotate_left_i32:math]

// [contrib-dev:rotate_right_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(rotate_right_i32(1, 1))
}
// [/contrib-dev:rotate_right_i32:math]

// [contrib-dev:round_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(round_f64(3.0))
}
// [/contrib-dev:round_f64:math]

// [contrib-dev:round_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(round_i32(4))
}
// [/contrib-dev:round_i32:math]

// [contrib-dev:saturating_add_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(saturating_add_i32(1, 1))
}
// [/contrib-dev:saturating_add_i32:math]

// [contrib-dev:saturating_sub_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(saturating_sub_i32(1, 1))
}
// [/contrib-dev:saturating_sub_i32:math]

// [contrib-dev:signum_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(is_nan(signum_f64(0.0 / 0.0)))
}
// [/contrib-dev:signum_f64:math]

// [contrib-dev:signum_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(signum_i32(5))
    print(signum_i32(-3))
    print(signum_i32(0))
}
// [/contrib-dev:signum_i32:math]

fn main() -> void {
    print(sin(0.0))
    print(cos(0.0))
    print(max_f64(1.0, 2.0))
}

// [contrib-dev:sqrt_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(sqrt_f64(3.0))
}
// [/contrib-dev:sqrt_f64:math]

// [contrib-dev:trailing_zeros_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(trailing_zeros_i32(1))
}
// [/contrib-dev:trailing_zeros_i32:math]

// [contrib-dev:trunc_f64:math]
import "stdlib/math.ny"

fn main() -> void {
    print(trunc_f64(1.9))
}
// [/contrib-dev:trunc_f64:math]

// [contrib-dev:trunc_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(trunc_i32(7))
}
// [/contrib-dev:trunc_i32:math]

// [contrib-dev:wrapping_add_i32:math]
import "stdlib/math.ny"

fn main() -> void {
    print(wrapping_add_i32(1, 1))
}
// [/contrib-dev:wrapping_add_i32:math]

import "stdlib/builtins_json.ny"

fn main() -> void {
    let raw: string = JSON_stringify("name", "hamdy")
    print(raw)
    print(JSON_parse(raw, "name"))
}

fn main() -> void {
    let m = dict_i32().insert("score", 100)
    print(m.get("score"))
}

fn main() -> void {
    print(jfield("name", "Nyra"))
}

fn main() -> void {
    let o = jparse("{\"user\":{\"id\":1}}")
    let u = jobj(o, "user")
    print(jnum(u, "id"))
}

fn main() -> void {
    let o = jparse("{\"name\":\"Nyra\",\"n\":7,\"ok\":true}")
    print(jstr(o, "name"))
    print(jnum(o, "n"))
    print(jbool(o, "ok"))
}

fn main() -> void {
    let m = obj().insert("a", "1").insert("b", "two")
    print(jstr(m, "a"))
    print(jraw(m, "b"))
    print(jstringify(m))
}

fn main() -> void {
    print(create_dir("/tmp/nyra_docs_cd"))
    print(remove_dir("/tmp/nyra_docs_cd"))
}

fn main() -> void {
    spit("/tmp/nyra_docs_marker.txt", "x")
    print(ls("/tmp").len() > 0)
    print(rm("/tmp/nyra_docs_marker.txt"))
}

fn main() -> void {
    spit("/tmp/nyra_docs_slurp.txt", "hello")
    print(slurp("/tmp/nyra_docs_slurp.txt"))
    spit_append("/tmp/nyra_docs_slurp.txt", "!")
    print(slurp("/tmp/nyra_docs_slurp.txt"))
    rm("/tmp/nyra_docs_slurp.txt")
}

fn main() -> void {
    let t0 = now()
    ms(1).sleep()
    print(if t0.elapsed_ms() >= 0 { 1 } else { 0 })
}

fn main() -> void {
    print(env_or("__NYRA_DOCS_MISSING__", "fallback"))
    env_set("__NYRA_DOCS_TMP__", "ok")
    print(env("__NYRA_DOCS_TMP__"))
    print(env_has("__NYRA_DOCS_TMP__"))
}

fn main() -> void {
    print(cmd("true").run())
    let out = cmd("echo").arg("hi").output()
    print(out.code)
    print(out.stdout.len())
}

fn main() -> void {
    print(uuid().len())
}

fn main() -> void {
    print(b64("hi"))
    print(b64d("aGk="))
    print(url_encode("a b"))
}

import "stdlib/encoding/mod.ny"

fn main() -> void {
    print(hex_decode("4869"))
}

// [contrib-dev:hex_encode_upper:encoding_mod]
import "stdlib/encoding/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:hex_encode_upper:encoding_mod]

// [contrib-dev:hex_encode:encoding_mod]
import "stdlib/encoding/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:hex_encode:encoding_mod]

// [contrib-dev:f64_to_string_prec:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1.0, 1)
}
// [/contrib-dev:f64_to_string_prec:strconv_mod]

// [contrib-dev:format_bool:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1)
}
// [/contrib-dev:format_bool:strconv_mod]

// [contrib-dev:format_f64_pad:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1.0, 1, 1)
}
// [/contrib-dev:format_f64_pad:strconv_mod]

// [contrib-dev:format_i32_bin:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1)
}
// [/contrib-dev:format_i32_bin:strconv_mod]

// [contrib-dev:format_i32_hex_pad:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1, 1)
}
// [/contrib-dev:format_i32_hex_pad:strconv_mod]

// [contrib-dev:format_i32_hex:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1)
}
// [/contrib-dev:format_i32_hex:strconv_mod]

// [contrib-dev:format_i32_oct:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1)
}
// [/contrib-dev:format_i32_oct:strconv_mod]

// [contrib-dev:format_i32_pad:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1, 1)
}
// [/contrib-dev:format_i32_pad:strconv_mod]

// [contrib-dev:format_i64_bin:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(0)
}
// [/contrib-dev:format_i64_bin:strconv_mod]

// [contrib-dev:format_i64_hex:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(0)
}
// [/contrib-dev:format_i64_hex:strconv_mod]

// [contrib-dev:format_i64_pad:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(0, 1)
}
// [/contrib-dev:format_i64_pad:strconv_mod]

// [contrib-dev:format_quote:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:format_quote:strconv_mod]

// [contrib-dev:format_u64_pad:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(0, 1)
}
// [/contrib-dev:format_u64_pad:strconv_mod]

// [contrib-dev:i32_to_string_radix:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(1, 1)
}
// [/contrib-dev:i32_to_string_radix:strconv_mod]

// [contrib-dev:i64_to_string:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(0)
}
// [/contrib-dev:i64_to_string:strconv_mod]

// [contrib-dev:parse_i64_base:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x", 1)
}
// [/contrib-dev:parse_i64_base:strconv_mod]

// [contrib-dev:parse_int_base:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x", 1)
}
// [/contrib-dev:parse_int_base:strconv_mod]

// [contrib-dev:parse_uint_base:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x", 1)
}
// [/contrib-dev:parse_uint_base:strconv_mod]

import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(parse_bool("true"))
    print(parse_bool("false"))
}

// [contrib-dev:str_to_f32:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:str_to_f32:strconv_mod]

// [contrib-dev:str_to_f64:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:str_to_f64:strconv_mod]

// [contrib-dev:str_to_i64:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:str_to_i64:strconv_mod]

// [contrib-dev:str_to_u64:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print("x")
}
// [/contrib-dev:str_to_u64:strconv_mod]

// [contrib-dev:u64_to_string:strconv_mod]
import "stdlib/strconv/mod.ny"

fn main() -> void {
    print(0)
}
// [/contrib-dev:u64_to_string:strconv_mod]

fn main() -> void {
    print(err_json("bad").kind)
    print(err_invalid("x").kind)
}

fn main() -> void {
    let e = err_io("boom").context("open")
    print(e.kind)
    print(e.message)
}

fn main() -> void {
    let jar = cookies()
    let j2 = CookieJar_set(jar, "sid", "abc")
    print(CookieJar_get(j2, "sid"))
    print(CookieJar_header(j2))
    let h = headers().insert("X-Test", "1")
    print(h.get("X-Test"))
}

fn main() -> void {
    print(form().append("a", "1").append("b", "2").urlencoded())
    print(params().append("q", "nyra").to_string())
}

fn main() -> void {
    let init = req().timeout(1000).header("X-Test", "1")
    print(init.timeout_ms)
}

fn main() -> void {
    let sql = qb()
        .select("id, name")
        .from("users")
        .where("active", "=", "1")
        .order("name")
        .limit(10)
        .to_sql()
    print(sql)
}

fn main() -> void {
    write("ok")
    flush()
    print("done")
}

// Interactive — run: nyra run examples/builtins/io/input.ny
fn main() -> void {
    let name: string = input("Name: ")
    print(name.length())
    print(name)
}

fn main() -> void {
    let nums: [i32; 6] = [20, 1, 4, 3, 5, 2]
    print(nums)
    print([1.5, 2.5])
    print(["hello", "Nyra"])
}

fn main() -> void {
    print("ok", color: green)
}

fn main() -> void {
    print(42)
    print("Nyra")
}

fn main() -> void {
    println("line")
    flush()
}

fn main() -> void {
    write("ok")
    flush()
}

fn main() -> void {
    mem_start("work")
    let mut sum: i32 = 0
    for i in 0..1000 {
        sum = sum + i
    }
    mem_end("work")
    print(sum)
}

fn main() -> void {
    time_start("work")
    let mut sum: i32 = 0
    for i in 0..1000 {
        sum = sum + i
    }
    time_end("work")
    print(sum)
}

fn main() -> void {
    let d: Date = date()
    print(d.year)
    print(d.month)
    print(d.day)
    print(d.hour)
    print(d.minute)
    print(d.second)
    print(d.week)
    print(d.millisecond)
    print(d.minutes)
    print(d.seconds)
    print(d.weekday)
}

// Future<string> — typed async with Executor_sleep_ms.
allow_extended

import "stdlib/async/future.ny"

async fn greet() -> string {
    let h = Executor_sleep_ms(10)
    await h
    return "Nyra async v2"
}

fn main() -> void {
    let f = greet()
    print(await f)
}

// async fn + await — call site gets handle immediately; body runs on spawn:task.
allow_extended

import "stdlib/async_v1.ny"

async fn compute() -> i32 {
    return 42
}

fn main() -> void {
    let h = compute()
    print(await h)
}

// async state machine — multiple await in one async fn (cooperative poll loop).
allow_extended

import "stdlib/async_v1.ny"

async fn chain() -> i32 {
    let _ = await Executor_sleep_ms(5)
    let _ = await Executor_sleep_ms(5)
    return 100
}

fn main() -> void {
    let h = chain()
    print(await h)
}

// cpu_count() — compiler builtin logical CPU count.
fn main() -> void {
    print(cpu_count())
}

// parallel for over a fixed array.
allow_extended

fn main() -> void {
    let nums: [i32; 3] = [10, 20, 30]
    parallel for n in nums {
        print(n)
    }
    print(999)
}

// parallel(cpu = P%) — use P percent of logical CPUs as worker count.
allow_extended

fn main() -> void {
    parallel(cpu = 50%) for i in 0..4 {
        print(i)
    }
    print(999)
}

// parallel(threads = N) — exactly N workers (backend still task pool by default).
allow_extended

fn main() -> void {
    parallel(threads = 2) for i in 0..4 {
        print(i)
    }
    print(999)
}

// parallel(mode = balanced) — leave one CPU for responsiveness.
allow_extended

fn main() -> void {
    parallel(mode = balanced) for i in 0..4 {
        print(i)
    }
    print(999)
}

// parallel any / find / all — early-exit parallel search (fork-join + atomic cancel).
allow_extended

fn main() -> void {
    let any_hit = parallel any for i in 0..1000 {
        i == 42
    }
    print(any_hit)

    let idx = parallel find for i in 0..1000 {
        i == 42
    }
    print(idx)

    let all_pos = parallel all for i in 1..10 {
        i > 0
    }
    print(all_pos)
}

// parallel:task(max = N) — cap task-pool workers (alias of bare parallel).
allow_extended

fn main() -> void {
    parallel:task(max = 2) for i in 0..4 {
        print(i)
    }
    print(999)
}

// parallel for — default task-pool backend (same workers as spawn).
allow_extended

fn main() -> void {
    parallel for i in 0..4 {
        print(i)
    }
    print(999)
}

// parallel:thread(max = N) — fork-join OS threads per chunk.
allow_extended

fn main() -> void {
    parallel:thread(max = 2) for i in 0..4 {
        print(i)
    }
    print(999)
}

// progress for — sequential loop with built-in progress bar.
allow_extended

fn main() -> void {
    progress(label = "demo") for i in 0..3 {
        print(i)
    }
}

allow_extended
fn main() -> void {
    let h = spawn {
        print(99)
    }
    h.join()
    print(0)
}

allow_extended
fn main() -> void {
    spawn:thread {
        print(88)
    }
}

allow_extended
fn main() -> void {
    let n: i32 = 42
    spawn {
        print(n)
    }
    print(0)
}

// benchmark { } — wall time, RSS delta, and CPU% for a block.
allow_extended

extern fn blackbox_i32(x: i32) -> i32

fn run() {
    let mut acc: i32 = 0
    for i in 0..10000 {
        acc = blackbox_i32(acc + i)
    }
    blackbox_i32(acc)
}

fn main() -> void {
    benchmark {
        run()
    }
}

// defer runs LIFO (last deferred, first executed).
allow_extended

fn a() {
    print("a")
}

fn b() {
    print("b")
}

fn main() -> void {
    defer b()
    defer a()
    print("body")
}

// defer on return — runs cleanup before function exits.
allow_extended

fn cleanup() {
    print(1)
}

fn main() -> void {
    defer cleanup()
    return
}