slovo/lib/std/README.md

Slovo Standard Library Source Layout Alpha

Release: established by exp-30, Standard Library Source Layout Alpha; wrappers updated through exp-31, exp-34, exp-37, and exp-38; math helpers updated through exp-39, exp-56, and exp-57; result helpers updated through exp-35, exp-74, exp-109, and the final exp-125 unsigned precursor scope now absorbed into 1.0.0-beta; option helpers updated through exp-36, exp-75, exp-95, exp-100, exp-102, exp-109, and the final exp-125 unsigned precursor scope now absorbed into 1.0.0-beta; explicit std.math source search promoted in exp-44; explicit std.result and std.option source search promoted in exp-45; workspace-package standard source search promoted in exp-46; explicit host facade source search promoted in exp-47; explicit core facade source search promoted in exp-48; explicit IO facade source search promoted in exp-49; installed standard-library discovery promoted in exp-50; ordered SLOVO_STD_PATH path-list discovery promoted in exp-51; explicit process facade source search promoted in exp-52; explicit CLI facade source search promoted in exp-53; io value helpers updated through exp-73; io stdin helpers updated through exp-111; typed CLI argument helpers updated through exp-54, exp-55, and exp-72; CLI option helpers updated through exp-110; CLI local-source gate aligned in exp-78; string fallback helpers updated through exp-60 and exp-68; string option helpers updated through exp-110; string byte-scanning and token-boundary helpers updated in 1.0.0-beta.16; string search and ASCII trim helpers updated in 1.0.0-beta.20; process fallback helpers updated through exp-61; process typed helpers updated through exp-67 and exp-71; process option helpers updated through exp-110; env fallback helpers updated through exp-62 and exp-69; env typed helpers updated through exp-65; env option helpers updated through exp-110; fs fallback helpers updated through exp-63 and exp-70; fs typed read helpers updated through exp-66; fs option helpers updated through exp-110; num fallback helpers updated through exp-64; concrete vec helpers updated through 1.0.0-beta.12, including the current concrete std/vec_string.slo, std/vec_f64.slo, and std/vec_bool.slo prefix/suffix helper scopes, std/vec_i64.slo query and prefix/suffix parity, and std/vec_f64.slo query parity; 1.0.0-beta.6 networking foundation work releases std/net.slo as an experimental loopback TCP facade over matching compiler-known runtime calls; 1.0.0-beta.7 serialization work releases std/json.slo as an experimental JSON text-construction facade over std.json.quote_string and existing string/number helpers; the Slovo-facing 1.0.0-beta.17 JSON foundation adds primitive scalar token parse facades for booleans, concrete numeric primitives, and exact null; the Slovo-facing 1.0.0-beta.18 JSON foundation adds one ASCII string-token parse facade; the 1.0.0-beta.8 concrete type alias target keeps that same helper surface while using local JsonText and JsonField aliases as transparent names for string JSON fragments.

This directory is the source home for staged standard library modules and examples. exp-44 lets project-mode source explicitly import std/math.slo as (import std.math (...)); exp-45 extends that model to std/result.slo and std/option.slo; exp-46 extends explicit source search to workspace packages; exp-47 extends project-mode source search to std/time.slo, std/random.slo, std/env.slo, and std/fs.slo; exp-48 extends project-mode source search to std/string.slo and std/num.slo; exp-49 extends project-mode source search to std/io.slo; exp-73 extends that facade with value-returning print wrappers; exp-111 extends it again with stdin source helpers over std.io, std.string, and std.result; exp-50 lets explicit standard-source imports find those staged files from installed share/slovo/std layouts; exp-51 lets SLOVO_STD_PATH name an ordered OS path list of standard-library roots; exp-52 extends project-mode source search to std/process.slo; exp-53 extends project-mode source search to std/cli.slo, a source-authored facade that imports std.process and std.string; exp-54 extends that facade with typed argument parse helpers; exp-55 makes the f64 and bool helpers result-based for missing argument indexes; exp-72 extends that facade with typed custom-fallback helpers over those same argument and parse result families; exp-78 records that unchanged CLI helper surface as the Slovo-side contract for the sibling Glagol local-source gate without widening std.cli; exp-60 extends std/string.slo with source-authored parse fallback helpers over the already promoted concrete parse result families; exp-61 extends std/process.slo with source-authored string fallback helpers over arg_result; exp-62 extends std/env.slo with source-authored presence and custom-fallback helpers over get_result; exp-63 extends std/fs.slo with source-authored text fallback/status helpers over the current filesystem result families; exp-64 extends std/num.slo with source-authored checked conversion fallback helpers over the current numeric result families; exp-65 extends std/env.slo with typed parse result/fallback helpers over environment lookup plus the existing concrete parse result families; exp-66 extends std/fs.slo with typed read result/fallback helpers over read_text_result plus the existing concrete parse result families; exp-67 extends std/process.slo with typed argument result/fallback helpers over arg_result plus the existing concrete parse result families; exp-68 extends std/string.slo with typed parse custom-fallback helpers over those same concrete parse result families; exp-69 extends std/env.slo with typed parse custom-fallback helpers over environment lookup plus those same concrete parse result families; exp-70 extends std/fs.slo with typed read custom-fallback helpers over read_text_result plus those same concrete parse result families; exp-71 extends std/process.slo with typed argument custom-fallback helpers over arg_result plus those same concrete parse result families; post-1.0.0-beta.1 main extends std/fs.slo with read-only text resource-handle helpers over std.fs.open_text_read_result, std.fs.read_open_text_result, and std.fs.close_result, plus narrow filesystem status/mutation helpers over std.fs.exists, std.fs.is_file, std.fs.is_dir, std.fs.remove_file_result, and std.fs.create_dir_result, while keeping handles beta-scoped opaque i32 values and leaving directory enumeration deferred; 1.0.0-beta.6 releases std/net.slo as an experimental blocking loopback TCP facade over std.net.tcp_connect_loopback_result, std.net.tcp_listen_loopback_result, std.net.tcp_bound_port_result, std.net.tcp_accept_result, std.net.tcp_read_all_result, std.net.tcp_write_text_result, and std.net.tcp_close_result, while keeping socket handles beta-scoped opaque i32 values and leaving DNS, TLS, async, UDP, non-loopback binding, and stable ABI/layout deferred; 1.0.0-beta.7 releases std/json.slo as an experimental compact JSON text-construction facade over std.json.quote_string, std.string.concat, and the current std.num.*_to_string helpers. The Slovo-facing 1.0.0-beta.17 JSON foundation adds exact primitive scalar token parse facades over promoted std.json bool/numeric runtime helpers and an exact source-only null token helper. The 1.0.0-beta.18 JSON foundation adds parse_string_value_result for one already-isolated ASCII JSON string token over the matching promoted runtime helper. Full JSON document parsing, object/array parsing, recursive JSON values, maps/sets, streaming decoders or encoders, schema validation, Unicode escape decoding/normalization, embedded NUL policy, and stable text encoding policy remain deferred; 1.0.0-beta.8 targets top-level concrete type aliases in source facades and uses JsonText / JsonField only as local transparent aliases inside std/json.slo and matching local JSON fixtures. These aliases are not exported standard-library names and do not add runtime helpers, generic aliases, parameterized aliases, maps/sets, or ABI/layout guarantees; exp-76 extends project-mode source search to std/vec_i32.slo, a concrete source-authored collection facade over the current promoted std.vec.i32 runtime family; exp-77 extends that facade with concrete option-returning query helpers over the current (option i32) family via std.option; exp-79 extends it with narrow recursive transform helpers over that same concrete vec family; exp-80 extends it with narrow generated constructor helpers over that same concrete vec family; exp-81 adds one public range helper over that same concrete vec family; exp-82 adds one public replace_at helper over that same concrete vec family; exp-83 adds one public remove_at helper over that same concrete vec family; exp-84 adds one public insert_at helper over that same concrete vec family; exp-85 adds one public subvec helper over that same concrete vec family; exp-86 adds one public remove_range helper over that same concrete vec family; exp-87 adds one public insert_range helper over that same concrete vec family; exp-88 adds one public replace_range helper over that same concrete vec family; exp-89 adds one public starts_with helper over that same concrete vec family; exp-90 adds one public ends_with helper over that same concrete vec family; exp-91 adds one public without_suffix helper over that same concrete vec family; and exp-92 adds one public without_prefix helper over that same concrete vec family; exp-93 adds one public count_of helper over that same concrete vec family; exp-94 stages std/vec_i64.slo as a concrete source-authored (vec i64) baseline facade over the sibling std.vec.i64 runtime family; exp-96 extends that same facade with concrete option-query helpers over raw current option forms; exp-97 extends it with recursive immutable transform helpers plus subvec; exp-98 adds connected immutable edit helpers over that same helper surface; and exp-99 stages std/vec_string.slo as a concrete source-authored (vec string) baseline facade over the sibling std.vec.string runtime family; exp-103 stages std/vec_f64.slo as a concrete source-authored (vec f64) baseline facade over the sibling std.vec.f64 runtime family; exp-104 stages std/vec_bool.slo as a concrete source-authored (vec bool) baseline facade over the sibling std.vec.bool runtime family; exp-108 broadens all three non-i32 concrete collection lanes with one connected prefix/suffix helper package; and 1.0.0-beta.12 fills concrete vector source parity by adding count_of, starts_with, without_prefix, ends_with, and without_suffix to std/vec_i64.slo, plus count_of to std/vec_f64.slo, matching the existing concrete lane behavior for empty prefixes/suffixes, mismatches, exact removals, and repeated exact counts. It does not make the standard library fully self-hosted, does not add automatic standard-library imports, and does not replace the compiler-known std.* standard-runtime calls cataloged in ../STANDARD_RUNTIME.md.

The current .slo files use flat module declarations such as (module math). For exp-44, exp-45, exp-47, exp-48, exp-49, exp-52, exp-53, exp-76, exp-94, exp-96, exp-97, exp-98, exp-99, exp-103, exp-104, exp-105, exp-107, exp-108, 1.0.0-beta.12, and 1.0.0-beta.16, std/math.slo, std/result.slo, std/option.slo, std/time.slo, std/random.slo, std/env.slo, std/fs.slo, std/net.slo, std/json.slo, std/string.slo, std/num.slo, std/io.slo, std/process.slo, std/cli.slo, std/vec_i32.slo, std/vec_f64.slo, std/vec_i64.slo, and std/vec_string.slo carry explicit export lists. Glagol may address them externally as std.math, std.result, std.option, std.time, std.random, std.env, std.fs, std.string, std.net, std.json, std.num, std.io, std.process, std.cli, std.vec_i32, std.vec_f64, std.vec_bool, std.vec_i64, and std.vec_string. The file layout is the contract:

• std/cli.slo
• std/io.slo
• std/process.slo
• std/vec_i32.slo
• std/vec_f64.slo
• std/vec_bool.slo
• std/vec_i64.slo
• std/vec_string.slo
• std/string.slo
• std/num.slo
• std/result.slo
• std/option.slo
• std/math.slo
• std/time.slo
• std/random.slo
• std/env.slo
• std/fs.slo
• std/net.slo
• std/json.slo

This follows a Zig-like standard-library facade discipline in a Slovo-sized form: flat std/*.slo facade files are the staged source surface now, and a future std.slo aggregator/reexport layer remains deferred until broader import/search semantics exist.

math.slo contains narrow source-authored helpers expressible in current Slovo. exp-39 includes abs, neg, min, max, clamp, square, cube, zero/positive/negative predicates, and inclusive in_range helpers for i32, i64, and finite f64 where the current language can express those helpers directly. exp-56 adds rem_i32, is_even_i32, is_odd_i32, rem_i64, is_even_i64, and is_odd_i64 over the promoted integer remainder operator. exp-57 adds bit_and_i32, bit_or_i32, bit_xor_i32, bit_and_i64, bit_or_i64, and bit_xor_i64 over the promoted integer bitwise heads. The other modules provide small wrapper functions over already promoted compiler-known standard-runtime calls where the current language can express a wrapper cleanly. std/string.slo includes the exp-34 parse_bool_result wrapper over std.string.parse_bool_result. exp-60 adds parse_i32_or_zero, parse_i64_or_zero, parse_f64_or_zero, and parse_bool_or_false as ordinary source match helpers over the existing concrete parse result families. exp-68 adds parse_i32_or, parse_i64_or, parse_f64_or, and parse_bool_or as ordinary source custom-fallback helpers over those same concrete parse result families. exp-110 adds parse_i32_option, parse_i64_option, parse_f64_option, and parse_bool_option as ordinary source option helpers over those same concrete parse result families through the exp-109 std.result.ok_or_none_* bridge helpers. The current Slovo-side exp-125 target adds matching parse_u32_result, parse_u32_option, parse_u32_or_zero, parse_u32_or, parse_u64_result, parse_u64_option, parse_u64_or_zero, and parse_u64_or lanes. 1.0.0-beta.16 adds byte_at_result, slice_result, starts_with, and ends_with as byte-oriented helpers over current runtime strings. Invalid byte indexes and ranges return err 1; empty prefixes and suffixes match. 1.0.0-beta.20 adds contains, index_of_option, last_index_of_option, trim_ascii_start, trim_ascii_end, and trim_ascii as ordinary source helpers over those same byte primitives. Empty needles match at first index 0 and last index (len value). ASCII trim removes only bytes 9, 10, 11, 12, 13, and 32 from the requested edges. This string scanning foundation does not add Unicode scalar or grapheme semantics, full JSON parsing, tokenizer objects, language-level slice/view syntax, mutable strings, stable ABI/layout promises, or a stable stdlib/API freeze. std/num.slo includes the exp-31 f64_to_i64_result wrapper over std.num.f64_to_i64_result. exp-64 adds i64_to_i32_or, f64_to_i32_or, and f64_to_i64_or as ordinary source match helpers over the existing checked numeric conversion result families. The current Slovo-side exp-125 target adds u32_to_string and u64_to_string. std/result.slo includes the exp-33 concrete is_err_* and unwrap_err_* source helpers for the already promoted result families, plus unwrap_or_i32, unwrap_or_i64, unwrap_or_string, and unwrap_or_f64. exp-35 extends that source-authored concrete helper slice with is_ok_bool, is_err_bool, unwrap_ok_bool, unwrap_err_bool, and unwrap_or_bool for (result bool i32), aligned with the exp-34 bool parse result fixture flow. exp-74 adds concrete source constructors ok_i32, err_i32, ok_i64, err_i64, ok_string, err_string, ok_f64, err_f64, ok_bool, and err_bool so source can construct the current promoted result families without repeating raw ok and err type heads. exp-109 adds the concrete bridge helpers ok_or_none_i32, ok_or_none_i64, ok_or_none_string, ok_or_none_f64, and ok_or_none_bool, returning the matching some payload for ok results and the matching none value for err results without importing std.option. The current Slovo-side exp-125 target adds the same concrete helper families for (result u32 i32) and (result u64 i32). std/option.slo includes the exp-36 concrete (option i32) helpers is_some_i32, is_none_i32, unwrap_some_i32, and unwrap_or_i32, written as ordinary Slovo source over existing is_some, is_none, unwrap_some, and if. exp-75 adds some_i32 and none_i32 as concrete source constructors for that same (option i32) family. exp-95 broadens the staged module to concrete (option i64) with some_i64, none_i64, is_some_i64, is_none_i64, unwrap_some_i64, and unwrap_or_i64, still as ordinary source functions over the already promoted option forms. exp-100 broadens the same staged module again to concrete (option string) with some_string, none_string, is_some_string, is_none_string, unwrap_some_string, and unwrap_or_string, still as ordinary source functions over the already promoted option forms. exp-102 broadens the same staged module again to concrete (option f64) with some_f64, none_f64, is_some_f64, is_none_f64, unwrap_some_f64, and unwrap_or_f64, plus concrete (option bool) with some_bool, none_bool, is_some_bool, is_none_bool, unwrap_some_bool, and unwrap_or_bool, still as ordinary source functions over the already promoted option forms. exp-109 adds the concrete bridge helpers some_or_err_i32, some_or_err_i64, some_or_err_f64, some_or_err_bool, and some_or_err_string, returning ok with the matching payload for some values and err err_code for none values without importing std.result. The current Slovo-side exp-125 target adds the same concrete constructor/observer/unwrap/fallback/bridge shape for (option u32) and (option u64). std/time.slo includes the exp-37 narrow source wrappers monotonic_ms over std.time.monotonic_ms and sleep_ms_zero over std.time.sleep_ms, calling std.time.sleep_ms 0 and returning 0 because user-defined unit-return functions are not generally supported. std/random.slo, std/env.slo, and std/fs.slo include the exp-38 narrow source wrappers over already released random, environment, and text filesystem host/runtime calls. exp-62 adds has and get_or to std/env.slo as ordinary source match helpers over the existing (result string i32) environment lookup family. exp-65 extends std/env.slo with get_i32_result, get_i32_or_zero, get_i64_result, get_i64_or_zero, get_f64_result, get_f64_or_zero, get_bool_result, and get_bool_or_false as ordinary source helpers over get_result plus the existing concrete parse result families from std.string. exp-69 extends std/env.slo with get_i32_or, get_i64_or, get_f64_or, and get_bool_or as ordinary source custom-fallback helpers over get_result plus those same concrete parse result families from std.string. exp-110 adds get_option, get_i32_option, get_i64_option, get_f64_option, and get_bool_option as ordinary source option helpers over the existing environment lookup and typed parse result families through the exp-109 std.result.ok_or_none_* bridge helpers. exp-63 adds read_text_or and write_text_ok to std/fs.slo as ordinary source match helpers over the existing (result string i32) and (result i32 i32) text filesystem families. exp-66 extends std/fs.slo with read_i32_result, read_i32_or_zero, read_i64_result, read_i64_or_zero, read_f64_result, read_f64_or_zero, read_bool_result, and read_bool_or_false as ordinary source helpers over read_text_result plus the existing concrete parse result families from std.string. exp-70 extends std/fs.slo with read_i32_or, read_i64_or, read_f64_or, and read_bool_or as ordinary source custom-fallback helpers over read_text_result plus those same concrete parse result families from std.string. exp-110 adds read_text_option, read_i32_option, read_i64_option, read_f64_option, and read_bool_option as ordinary source option helpers over those same read/parse result families through the exp-109 std.result.ok_or_none_* bridge helpers. std/net.slo is the beta.6 networking foundation source facade. It wraps blocking loopback TCP connect/listen/bound-port/accept/read-all/write-text/ close result calls and adds only tcp_write_text_ok and tcp_close_ok source helpers. It is not a general networking module: DNS, TLS, async IO, UDP, non-loopback binding, socket options, rich host errors, and stable handle ABI remain deferred. std/json.slo is the beta.7 serialization/data-interchange source facade. It wraps std.json.quote_string and composes compact JSON scalar, field, small array, and small object text from existing string and number helpers. 1.0.0-beta.17 adds primitive scalar token parse facades for bool, i32, u32, i64, u64, f64, and exact null only. The 1.0.0-beta.18 source facade adds parse_string_value_result for one exact ASCII JSON string token with simple escape decoding. It is not a full JSON parser and does not define object/array parsing, recursive JSON values, maps/sets, streaming decoders or encoders, schema validation, Unicode escape decoding/normalization, embedded NUL policy, or stable text encoding policy beyond the current runtime string ABI. std/process.slo includes the exp-52 narrow source wrappers over already released process argument runtime calls and a source-authored has_arg predicate. exp-61 adds arg_or and arg_or_empty as ordinary source fallback helpers over the existing (result string i32) process argument family. exp-67 extends std/process.slo with arg_i32_result, arg_i32_or_zero, arg_i64_result, arg_i64_or_zero, arg_f64_result, arg_f64_or_zero, arg_bool_result, and arg_bool_or_false as ordinary source helpers over arg_result plus the existing concrete parse result families from std.string. exp-71 extends std/process.slo with arg_i32_or, arg_i64_or, arg_f64_or, and arg_bool_or as ordinary source custom-fallback helpers over arg_result plus those same concrete parse result families from std.string. exp-110 adds arg_option, arg_i32_option, arg_i64_option, arg_f64_option, and arg_bool_option as ordinary source option helpers over those same argument/parse result families through the exp-109 std.result.ok_or_none_* bridge helpers. std/io.slo includes the exp-49 zero-returning print wrappers over the promoted print runtime calls. exp-73 adds print_i32_value, print_i64_value, print_f64_value, print_string_value, and print_bool_value as ordinary source wrappers that preserve the printed value for expression flow without adding new compiler-known runtime names. exp-111 adds a connected stdin helper package over std.io.read_stdin_result, std.string.parse_*_result, and the exp-109 std.result.ok_or_none_* bridge helpers: read_stdin_result, read_stdin_option, read_stdin_or, read_stdin_i32_result, read_stdin_i32_option, read_stdin_i32_or_zero, read_stdin_i32_or, read_stdin_i64_result, read_stdin_i64_option, read_stdin_i64_or_zero, read_stdin_i64_or, read_stdin_f64_result, read_stdin_f64_option, read_stdin_f64_or_zero, read_stdin_f64_or, read_stdin_bool_result, read_stdin_bool_option, read_stdin_bool_or_false, and read_stdin_bool_or. std/cli.slo includes the exp-53 source-authored argument text and i32 parse facade helpers over std.process and std.string. exp-54 adds i64 result/fallback helpers. exp-55 adds result-based f64 and bool helpers plus arg_f64_or_zero and arg_bool_or_false. exp-72 adds arg_i32_or, arg_i64_or, arg_f64_or, and arg_bool_or as ordinary source custom-fallback helpers over those same CLI result helpers. exp-110 adds arg_text_option, arg_i32_option, arg_i64_option, arg_f64_option, and arg_bool_option as ordinary source option helpers over those same CLI result helpers through the exp-109 std.result.ok_or_none_* bridge helpers. The staged CLI facade now directly imports std.result alongside std.process and std.string. exp-78 later records the earlier, narrower local-source contract for the sibling Glagol gate without widening that release's helper list or adding new compiler-known runtime names. std/vec_i32.slo includes the exp-76 concrete (vec i32) collection facade over the already promoted std.vec.i32 runtime family. It adds direct wrappers empty, append, len, and at, builder helpers singleton, append2, append3, pair, and triple, query helpers is_empty, index_or, first_or, and last_or, exp-77 option-query helpers index_option, first_option, last_option, index_of_option, and last_index_of_option, plus simple real-program helpers contains and sum written as ordinary source while loops over the existing vector runtime operations. exp-79 adds transform helpers concat, take, drop, and reverse as ordinary recursive source helpers over append, len, at, and empty. take treats negative counts as zero and returns the original vector when the requested count reaches or exceeds the current length; drop treats negative counts as zero and returns an empty vector when the requested count reaches or exceeds the current length. exp-80 adds generated constructor helpers repeat and range_from_zero as ordinary recursive source helpers over append and empty. repeat returns an empty vector when count <= 0. range_from_zero produces 0, 1, and so on up to but excluding count, and returns an empty vector when count <= 0. exp-81 adds public range ((start i32) (end_exclusive i32)) -> (vec i32) with ascending half-open semantics, allows negative bounds, returns an empty vector when end_exclusive <= start, and may let range_from_zero delegate to range 0 count. exp-82 adds public replace_at ((values (vec i32)) (position i32) (replacement i32)) -> (vec i32) as an ordinary compositional source helper over append, take, drop, and concat; it returns a same-length replacement result for in-range positions and returns values unchanged for negative or out-of-range positions without mutating the source vector. exp-83 adds public remove_at ((values (vec i32)) (position i32)) -> (vec i32) as an ordinary compositional source helper over take, drop, and concat; it removes the in-range position element, preserves the order of the remaining values, returns a len(values) - 1 result in that case, and returns values unchanged for negative or out-of-range positions without mutating the source vector. exp-84 adds public insert_at ((values (vec i32)) (position i32) (value i32)) -> (vec i32) as an ordinary compositional source helper over append, take, drop, and concat; it inserts value before the current element at an in-range position, appends when position == len(values), returns a len(values) + 1 result for those valid insertions, and returns values unchanged for negative or greater-than-length positions without mutating the source vector. exp-85 adds public subvec ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32) as an ordinary compositional source helper over take and drop; it returns a copied contiguous subvector [start, end_exclusive), returns (empty) when start < 0, end_exclusive <= start, or start >= len(values), returns the remaining tail from start when end_exclusive > len(values), preserves source order, and leaves the source vector unchanged without introducing slice/view semantics. exp-86 adds public remove_range ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32) as an ordinary compositional source helper over take, drop, and concat; it removes the half-open range [start, end_exclusive) from values, returns values unchanged when start < 0, end_exclusive <= start, or start >= len(values), removes the tail from start when end_exclusive >= len(values), preserves the order of the remaining elements, and leaves the source vector unchanged. exp-87 adds public insert_range ((values (vec i32)) (position i32) (inserted (vec i32))) -> (vec i32) as an ordinary compositional source helper over take, drop, and concat; it inserts all of inserted before the current element at position when 0 <= position < len(values), appends inserted at the end when position == len(values), returns values unchanged when position < 0 or position > len(values), preserves the order of both vectors, leaves both source vectors unchanged, and returns a len(values) + len(inserted) result for valid positions. exp-88 adds public replace_range ((values (vec i32)) (start i32) (end_exclusive i32) (replacement (vec i32))) -> (vec i32) as an ordinary compositional source helper over take, drop, and concat; it replaces the half-open range [start, end_exclusive) with all of replacement, returns values unchanged when start < 0, end_exclusive <= start, or start >= len(values), replaces the tail from start when end_exclusive >= len(values), preserves the order of the prefix, replacement, and surviving suffix, and leaves both source vectors unchanged. exp-89 adds public starts_with ((values (vec i32)) (prefix (vec i32))) -> bool as an ordinary compositional source helper over take, len, and vec equality; it returns true when values begins with all elements of prefix in order, returns true for an empty prefix, returns false when len(prefix) > len(values), and leaves both source vectors unchanged. exp-90 adds public ends_with ((values (vec i32)) (suffix (vec i32))) -> bool as an ordinary compositional source helper over drop, len, and vec equality; it returns true when values ends with all elements of suffix in order, returns true for an empty suffix, returns false when len(suffix) > len(values), and leaves both source vectors unchanged. exp-91 adds public without_suffix ((values (vec i32)) (suffix (vec i32))) -> (vec i32) as an ordinary compositional source helper over ends_with, take, and len; it returns values with a matching trailing suffix removed, returns values unchanged for empty, longer, or mismatched suffixes, returns (empty) for an exact match, and leaves both source vectors unchanged. exp-92 adds public without_prefix ((values (vec i32)) (prefix (vec i32))) -> (vec i32) as an ordinary compositional source helper over starts_with, drop, and len; it returns values with a matching leading prefix removed, returns values unchanged for empty, longer, or mismatched prefixes, returns (empty) for an exact match, and leaves both source vectors unchanged. exp-93 adds public count_of ((values (vec i32)) (target i32)) -> i32 as an ordinary source helper over len, at, equality, and while; it returns the number of elements equal to target, returns 0 for empty or absent matches, counts repeated matches exactly, and leaves the source vector unchanged. The option-returning helpers stay concrete to (option i32) and construct results through std.option.some_i32 and std.option.none_i32. The module stays concrete to (vec i32) and does not claim generic vectors, slice types, capacity management, mutation-heavy container APIs, sorting, mapping, filtering, or broader collection families. std/vec_i64.slo includes the exp-94 concrete (vec i64) baseline facade over the sibling std.vec.i64 runtime family. It adds direct wrappers empty, append, len, and at, builder helpers singleton, append2, append3, pair, and triple, query helpers is_empty, index_or, first_or, and last_or, plus simple real-program helpers contains and sum written as ordinary source control-flow helpers over the direct runtime wrappers. exp-96 extends that same facade with option-query helpers index_option, first_option, last_option, index_of_option, and last_index_of_option. Those helpers stay concrete to (option i64) and (option i32), construct raw current option values directly instead of importing std.option, and keep the full vec_i64 source family recursive and immutable with no var or set. index_or returns its fallback for negative and out-of-range positions; first_or delegates to index_or values 0 fallback; last_or returns its fallback for empty vectors and the final element otherwise; index_option returns (none i64) for negative and out-of-range positions; first_option delegates to index_option values 0; last_option returns (none i64) for empty vectors and (some i64 ...) otherwise; index_of_option and last_index_of_option return (none i32) when the target is absent; contains returns true exactly when any element equals the target; and sum returns 0i64 for empty vectors. exp-97 adds transform helpers concat, take, drop, and reverse plus the copied half-open range helper subvec as ordinary recursive source helpers over append, len, at, and empty. take treats negative counts as zero and saturates to the full vector. drop treats negative counts as zero and saturates to the empty vector. subvec returns (empty) for negative or empty ranges and saturates end_exclusive to the source tail. exp-98 adds edit helpers insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range as ordinary compositional source helpers over the already released vec_i64 helper surface, especially concat, take, and drop. insert_at and insert_range append at exact tail positions and otherwise return values unchanged for negative or greater-than-length positions. replace_at and remove_at return values unchanged for negative or out-of-range positions. replace_range and remove_range return values unchanged for negative, empty, or past-end starts and saturate end_exclusive to the source tail. The module stays concrete to (vec i64) and does not claim generic vectors, slice types, capacity management, mutation-heavy container APIs, transform/range/edit helper families beyond concat, take, drop, reverse, subvec, insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range, sorting, mapping, filtering, or broader collection families. std/vec_f64.slo includes the exp-103 concrete (vec f64) baseline facade over the sibling std.vec.f64 runtime family. exp-105 broadens the same module with the transform helpers concat, take, drop, reverse, and subvec written as ordinary recursive source helpers over the direct runtime wrappers. exp-106 further broadens the same module with the option-query helpers index_option, first_option, last_option, index_of_option, and last_index_of_option, still written as ordinary recursive immutable source helpers over the same direct runtime wrappers plus the current concrete (option f64) and (option i32) forms where needed. The module gains exp-107 immutable edit helpers insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range, still using only existing helper composition and the same direct runtime wrappers. exp-108 further broadens the same module with starts_with, without_prefix, ends_with, and without_suffix, still using only existing helper composition and the same direct runtime wrappers. The module stays concrete to (vec f64) and does not claim generic vectors, capacity management, mutation-heavy container APIs, sorting, mapping, filtering, or broader collection families. std/vec_bool.slo is the released exp-104 Slovo-side contract for a concrete (vec bool) baseline facade over the sibling std.vec.bool runtime family. exp-105 broadens the same module with the transform helpers concat, take, drop, reverse, and subvec, all written as ordinary deterministic recursive source helpers over the direct runtime wrappers and bool equality. exp-106 further broadens the same module with the option-query helpers index_option, first_option, last_option, index_of_option, and last_index_of_option, still written as ordinary recursive immutable source helpers over the same direct runtime wrappers plus the current concrete (option bool) and (option i32) forms where needed. exp-107 further broadens the same module with immutable edit helpers insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range, still written as ordinary helper composition over the same direct runtime wrappers. exp-108 further broadens the same module with starts_with, without_prefix, ends_with, and without_suffix, again written as ordinary helper composition over the same direct runtime wrappers. This file is present in the released Slovo source tree, and explicit external std.vec_bool resolution now depends on the paired Glagol exp-108 gate set. std/vec_string.slo includes the exp-99 concrete (vec string) baseline facade over the sibling std.vec.string runtime family. It adds direct wrappers empty, append, len, and at, builder helpers singleton, append2, append3, pair, and triple, query helpers is_empty, index_or, first_or, and last_or, plus simple real-program helpers contains and count_of written as ordinary recursive source helpers over the direct runtime wrappers and string equality. exp-101 broadens the same module with the option-query helpers index_option, first_option, last_option, index_of_option, and last_index_of_option, plus the transform helpers concat, take, drop, reverse, and subvec, all still written as ordinary recursive immutable source helpers over the same direct runtime wrappers plus raw current (option string) / (option i32) forms where needed. index_or returns its fallback for negative and out-of-range positions; first_or delegates to index_or values 0 fallback; last_or provides a stable empty-vector fallback; contains returns true exactly when any element equals the target; count_of returns 0 for empty vectors or absent targets while counting repeated matches exactly; and the new transform helpers preserve the current immutable-vector contract. The module gains exp-107 immutable edit helpers insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range, still written as ordinary helper composition over the same direct runtime wrappers and current concrete option forms where needed. exp-108 further broadens the same module with starts_with, without_prefix, ends_with, and without_suffix, still written as ordinary helper composition over the same direct runtime wrappers and current concrete option forms where needed. The module stays concrete to (vec string) and does not claim generics, nested vecs or vecs inside other containers, mutating/capacity APIs, or broader collection families. The string fallback helper uses the existing (result string i32) match shape instead of a string-valued if.

Deferred from exp-30, exp-32, exp-33, exp-34, exp-35, exp-36, exp-37, exp-38, exp-39, exp-44, exp-45, exp-46, exp-47, exp-48, exp-49, exp-50, exp-51, exp-52, exp-53, exp-54, exp-55, exp-56, exp-57, exp-60, exp-61, exp-62, exp-63, exp-64, exp-65, exp-66, exp-67, exp-68, exp-69, exp-70, exp-71, exp-72, exp-73, exp-74, exp-75, exp-76, exp-77, exp-78, exp-79, exp-80, exp-81, exp-82, exp-83, exp-84, exp-85, exp-86, exp-87, exp-88, exp-89, exp-90, exp-91, exp-92, exp-93, exp-94, exp-95, exp-96, exp-97, exp-98, and exp-99: automatic std imports, workspace dependency syntax for std, installed toolchain stdlib paths beyond the exp-50 alpha discovery candidate, a std.slo aggregator, package registry behavior, lockfiles, semantic version solving, replacing compiler-known std.* calls with source implementations, stable APIs, stable ABI/layout, package registry behavior, generics, traits, overloads, generic result helpers, generic option helpers, option payload families beyond (option i32), (option i64), and (option string), std.result.map, generic std.result.unwrap_or, std.result.and_then, broad math, trigonometry, sqrt, pow, floating-point remainder, shifts, bit-not, mixed numeric arithmetic, generic parse, string/bytes parse, bool parsing beyond exact lowercase true/false, rich parse errors, broad result payload families beyond promoted concrete fixture flows, wall-clock/calendar/timezone APIs, high-resolution timers, async timers, cancellation, scheduling guarantees, random seeds, ranges, bytes, floats, UUIDs, crypto/security promises, stable random sequences, environment mutation/enumeration, environment writes, rich host error ADTs, typed file writes, process spawning, exit/status control, current-directory APIs, signal handling, shell parsing, option/flag parsing, subcommands, environment-backed configuration, stable CLI framework APIs, binary file APIs, directory traversal, streaming file IO, async file IO, generic collections, vector payload families beyond (vec i32), (vec i64), (vec f64), and (vec string), option payload families beyond (option i32), (option i64), (option f64), (option bool), and (option string), slice types, push/pop, capacity/reserve/shrink, descending or stepped ranges, inclusive ranges, broader prefix/suffix helpers beyond starts_with, without_prefix, ends_with, and without_suffix, subvector/range-removal/edit helpers beyond insert_range, replace_range, remove_range, subvec, insert_at, replace_at, remove_at, without_prefix, and without_suffix, transform/range/edit helpers for (vec i64) beyond concat, take, drop, reverse, subvec, insert_at, insert_range, replace_at, replace_range, remove_at, and remove_range, sorting, mapping, filtering, iterators, optimizer guarantees, benchmark thresholds, cross-machine performance claims, and beta maturity.