Built-in methods

import "stdlib/builtins_string.ny"

fn main() -> void {
    let s: string = "  Nyra Lang  "
    print(String_toUpperCase(clone s))
    print(String_toLowerCase(clone s))
    print(String_includes(clone s, "Lang"))
    let parts: VecStr = "a,b,c".split(",")
    print(parts.length())
    print(String_replace("hello world", "world", "nyra"))
    print(trim(clone s))
}

fn main() -> void {
    print("hello".after_sep(","))
    print(after_sep("hello", ","))
}

fn main() -> void {
    print("hello".before_sep(","))
    print(before_sep("hello", ","))
}

fn main() -> void {
    print("hello".char_at(1))
    print(char_at("hello", 1))
}

fn main() -> void {
    let s: string = "copy me"
    let c: string = clone s
    print(c)
    print(s)
}

fn main() -> void {
    print("hello".collapse_ws())
}

fn main() -> void {
    print("hamdy.txt".common_prefix_len("arg"))
    print(common_prefix_len("hamdy.txt", "arg"))
}

fn main() -> void {
    print("hello".compare("arg"))
    print(compare("hello", "arg"))
}

fn main() -> void {
    print("hello".contains("ell"))
    print("hello".contains("xyz"))
}

fn main() -> void {
    print("hello".count("ell"))
}

fn main() -> void {
    print("hello".ends_with("llo"))
    print("hello".ends_with("xyz"))
}

fn main() -> void {
    print("hello".equal_fold("arg"))
    print(equal_fold("hello", "arg"))
}

fn main() -> void {
    print("hello".escape_json())
}

fn main() -> void {
    let words = "a b c".fields()
    print(words.len())
}

fn main() -> void {
    print("hello".index_byte(1))
    print(index_byte("hello", 1))
}

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

fn main() -> void {
    print("hello".is_alnum())
}

fn main() -> void {
    print("hello".is_alpha())
}

fn main() -> void {
    print("hello".is_ascii())
}

fn main() -> void {
    print("hello".is_digit())
}

fn main() -> void {
    print("hello".is_empty())
}

fn main() -> void {
    print("hello".last_index_byte(1))
    print(last_index_byte("hello", 1))
}

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

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

fn main() -> void {
    print("abc".length())
}

fn main() -> void {
    print("hello".pad_center(1, "arg"))
    print(pad_center("hello", 1, "arg"))
}

fn main() -> void {
    print("hello".pad_end(1, "arg"))
}

fn main() -> void {
    print("hello".pad_start(1, "arg"))
}

fn main() -> void {
    print("hello".pop())
}

fn main() -> void {
    print("hello".push_char(1))
    print(push_char("hello", 1))
}

fn main() -> void {
    print("hello".repeat(1))
    print(repeat("hello", 1))
}

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

fn main() -> void {
    print("aaa".replacen("a", "b", 2))
}

fn main() -> void {
    print("hello".reverse())
}

fn main() -> void {
    print("hello".split_after(","))
    print(split_after("hello", ","))
}

fn main() -> void {
    print("hello".split_once(","))
}

fn main() -> void {
    let parts: VecStr = "a,b,c".split(",")
    print(parts.length())
    for p in parts {
        print(p)
    }
}

fn main() -> void {
    let parts = "hello".splitn(",", 1)
    print(parts.len())
}

fn main() -> void {
    print("hello".starts_with("hel"))
    print("hello".starts_with("xyz"))
}

fn main() -> void {
    print("hello".strip_ansi())
}

fn main() -> void {
    print("hamdy.txt".strip_prefix(".txt"))
    print(strip_prefix("hamdy.txt", ".txt"))
}

fn main() -> void {
    print("hamdy.txt".strip_suffix(".txt"))
    print(strip_suffix("hamdy.txt", ".txt"))
}

fn main() -> void {
    print("hello".substring(1, 1))
    print(substring("hello", 1, 1))
}

fn main() -> void {
    print("Hello World".to_camel_case())
}

fn main() -> void {
    print("hello world".to_capitalize())
}

fn main() -> void {
    print("Hello World".to_dot_case())
}

fn main() -> void {
    print("Hello World".to_kebab_case())
}

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

fn main() -> void {
    print("Hello World".to_lowercase())
}

fn main() -> void {
    print("Hello World".to_pascal_case())
}

fn main() -> void {
    print("Hello World".to_screaming_snake_case())
}

fn main() -> void {
    print("Hello World".to_snake_case())
}

fn main() -> void {
    print("hello world".to_titlecase())
}

fn main() -> void {
    print("hello world".to_train_case())
}

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

fn main() -> void {
    print("hello".trim_end())
}

fn main() -> void {
    print("hello".trim_start())
}

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

fn main() -> void {
    print("hello".truncate(1))
    print(truncate("hello", 1))
}

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"))
}

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

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

fn mul10(x: i32) -> i32 {
    return x * 10
}

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

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Array_push(v, 1)
    Array_push(v, 2)
    Array_push(v, 3)
    Array_push(v, 4)

    let mapped: ptr = Array_map(v, mul10)
    let evens: ptr = Array_filter(v, is_even)
    let total: i32 = Array_reduce(v, 0, sum)
    let found = Array_find(v, is_even, -1)

    print(Vec_i32_len(mapped))
    print(Vec_i32_len(evens))
    print(total)
    print(found)
    print(Array_pop(v))
}

fn main() -> void {
    let arr: [i32; 3] = [1, 2, 3]
    for n in arr {
        print(n)
    }
}

fn main() -> void {
    let arr: [i32; 4] = [10, 20, 30, 40]
    print(arr.len())
}

fn main() -> void {
    let arr: [i32; 4] = [10, 20, 30, 40]
    print(arr.length())
}

fn main() -> void {
    let nums: [i32; 5] = [10, 1, 2, 8, 5]
    let sorted: [i32; 5] = nums.sort()
    for n in sorted {
        print(n)
    }
    print(nums[0])
}

import "stdlib/vec.ny"

fn main() -> void {
    let v: ptr = Vec_i32_new()
    Vec_i32_push(v, 10)
    Vec_i32_push(v, 20)
    print(Vec_i32_len(v))
    print(Vec_i32_get(v, 0))
    print(Vec_i32_pop(v))
}

// [contrib-dev:vec_i32_capacity]
import "stdlib/vec.ny"

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

import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(1).clear()
    print(v.len())
}

// [contrib-dev:vec_i32_extend]
import "stdlib/vec.ny"

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

// [contrib-dev:vec_i32_extra_methods:vec]
import "stdlib/vec.ny"

fn main() -> void {
    let v = vec()
    print(v.is_empty())
}
// [/contrib-dev:vec_i32_extra_methods:vec]

// [contrib-dev:vec_i32_fill]
import "stdlib/vec.ny"

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

import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(1).push(3).insert(1, 2)
    print(v.get(1))
}

import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(10).push(20).remove(0)
    print(v.len())
}

// [contrib-dev:vec_i32_reserve]
import "stdlib/vec.ny"

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

import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(1).push(2).push(3).reverse()
    print(v.get(0))
}

// [contrib-dev:vec_i32_slice_methods:vec]
import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(1).push(2).push(3).push(4)
    let w = v.window(1, 2)
    print(w.len())
}
// [/contrib-dev:vec_i32_slice_methods:vec]

import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(3).push(1).push(2).sort()
    print(v.get(0))
}

// [contrib-dev:vec_i32_swap_extend:vec]
import "stdlib/vec.ny"

fn main() -> void {
    let v = vec().push(1).push(2).swap(0, 1)
    print(v.get(0))
}
// [/contrib-dev:vec_i32_swap_extend:vec]

// [contrib-dev:vec_i32_swap_remove]
import "stdlib/vec.ny"

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

// [contrib-dev:vec_i32_swap]
import "stdlib/vec.ny"

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

// [contrib-dev:vec_i32_truncate]
import "stdlib/vec.ny"

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

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())
}

import "stdlib/vec_str.ny"

fn main() -> void {
    let mut v = StrVec_new()
    v = v.push("alpha")
    v = v.push("beta")
    print(v.len())
    print(v.get(0))
}

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"))
}

// [contrib-dev:hashmap_extra_methods:map]
import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_i32_new()
    print(m.is_empty())
    let _ = m.insert("k", 1)
    print(m.is_empty())
}
// [/contrib-dev:hashmap_extra_methods:map]

// [contrib-dev:hashmap_i32_get_or:map]
import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_i32_i32_new()
    print(m.get_or(1, 99))
}
// [/contrib-dev:hashmap_i32_get_or:map]

// [contrib-dev:hashmap_i32_i32:map]
import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_i32_i32_new()
    let _ = m.insert(1, 42)
    print(m.get(1))
}
// [/contrib-dev:hashmap_i32_i32:map]

// [contrib-dev:hashmap_or_insert:map]
import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_i32_new().insert("k", 10)
    print(m.or_insert("k", 42))
}
// [/contrib-dev:hashmap_or_insert:map]

// [contrib-dev:hashmap_update:map]
import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_i32_new().insert("k", 10)
    let _ = m.insert("k", 20)
    print(m.get("k"))
}
// [/contrib-dev:hashmap_update:map]

import "stdlib/map.ny"

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

// [contrib-dev:map_i32_i32_clear]
import "stdlib/map.ny"

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

// [contrib-dev:map_i32_i32_len]
import "stdlib/map.ny"

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

// [contrib-dev:map_i32_i32_remove]
import "stdlib/map.ny"

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

import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_i32_new().insert("a", 1).clear()
    print(m.len())
}

import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_i32_new().insert("a", 1).insert("b", 2)
    print(m.len())
}

import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_i32_new().insert("a", 1).insert("b", 2)
    print(m.values().len())
}

import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_str_new().insert("a", "1").clear()
    print(m.len())
}

import "stdlib/map.ny"

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

import "stdlib/map.ny"

fn main() -> void {
    let m = HashMap_str_str_new().insert("a", "1").insert("b", "2")
    print(m.values().len())
}

fn main() -> void {
    let parts: VecStr = "a,b".split(",")
    for s in parts {
        print(s)
    }
}

fn main() -> void {
    let parts: VecStr = "x,y".split(",")
    print(parts.length())
}

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

fn main() -> void {
    let word: string = "AB"
    for c in word {
        print(c)
    }
}

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
}

// [contrib-dev:file_is_symlink:fs_file]
import "stdlib/fs/file.ny"

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

// [contrib-dev:file_mtime:fs_file]
import "stdlib/fs/file.ny"

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

// [contrib-dev:path_is_file:fs_file]
import "stdlib/fs/file.ny"

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

// [contrib-dev:rename_file:fs_file]
import "stdlib/fs/file.ny"

fn main() -> void {
    print("x", "x")
}
// [/contrib-dev:rename_file:fs_file]

// [contrib-dev:option_combinators:option_combinators]
import "stdlib/option/combinators.ny"

fn main() -> void {
    let o = Option_i32_some(5)
    print(Option_i32_unwrap_or(o, 0))
}
// [/contrib-dev:option_combinators:option_combinators]

// [contrib-dev:atomic_and_i32:sync_atomic]
import "stdlib/sync/atomic.ny"

fn main() -> void {
    let a = Atomic_i32_new(7)
    print(atomic_and_i32(a.cell, 3))
}
// [/contrib-dev:atomic_and_i32:sync_atomic]

// [contrib-dev:atomic_or_i32:sync_atomic]
import "stdlib/sync/atomic.ny"

fn main() -> void {
    let a = Atomic_i32_new(1)
    print(atomic_or_i32(a.cell, 2))
}
// [/contrib-dev:atomic_or_i32:sync_atomic]

// [contrib-dev:atomic_sub_i32:sync_atomic]
import "stdlib/sync/atomic.ny"

fn main() -> void {
    let a = Atomic_i32_new(10)
    print(atomic_sub_i32(a.cell, 3))
}
// [/contrib-dev:atomic_sub_i32:sync_atomic]

// [contrib-dev:atomic_xor_i32:sync_atomic]
import "stdlib/sync/atomic.ny"

fn main() -> void {
    let a = Atomic_i32_new(5)
    print(atomic_xor_i32(a.cell, 3))
}
// [/contrib-dev:atomic_xor_i32:sync_atomic]

// [contrib-dev:strvec_insert_extend:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("b").insert(0, "a")
    print(v.get(0))
    print(v.remove_at(1))
}
// [/contrib-dev:strvec_insert_extend:vec_str]

// [contrib-dev:strvec_methods:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("x")
    print(v.is_empty())
    print(v.pop())
}
// [/contrib-dev:strvec_methods:vec_str]

// [contrib-dev:strvec_set_method:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a")
    let _ = v.set(0, "z")
    print(v.get(0))
}
// [/contrib-dev:strvec_set_method:vec_str]

// [contrib-dev:vec_str_clear:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a").clear()
    print(v.len())
}
// [/contrib-dev:vec_str_clear:vec_str]

// [contrib-dev:vec_str_extend:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let a = strs().push("x")
    let b = strs().push("y")
    vec_str_extend(a.handle, b.handle)
    print(a.len())
}
// [/contrib-dev:vec_str_extend:vec_str]

// [contrib-dev:vec_str_insert:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("b").insert(0, "a")
    print(v.get(0))
}
// [/contrib-dev:vec_str_insert:vec_str]

// [contrib-dev:vec_str_pop:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a").push("b")
    print(v.pop())
}
// [/contrib-dev:vec_str_pop:vec_str]

// [contrib-dev:vec_str_remove_at:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a").push("b")
    print(v.remove_at(0))
}
// [/contrib-dev:vec_str_remove_at:vec_str]

// [contrib-dev:vec_str_reverse:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a").push("b").reverse()
    print(v.get(0))
}
// [/contrib-dev:vec_str_reverse:vec_str]

// [contrib-dev:vec_str_set]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a")
    vec_str_set(v.handle, 0, "z")
    print(v.get(0))
}
// [/contrib-dev:vec_str_set]

// [contrib-dev:vec_str_swap:vec_str]
import "stdlib/vec_str.ny"

fn main() -> void {
    let v = strs().push("a").push("b").swap(0, 1)
    print(v.get(0))
}
// [/contrib-dev:vec_str_swap:vec_str]