580 lines
38 KiB
Markdown
580 lines
38 KiB
Markdown
# 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`; 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 released `exp-108`, including the current concrete
|
|
`std/vec_string.slo`, `std/vec_f64.slo`, and `std/vec_bool.slo`
|
|
prefix/suffix helper scopes; `1.0.0-beta.6` networking foundation work releases
|
|
`std/net.slo` as an experimental loopback TCP facade over matching
|
|
compiler-known runtime calls.
|
|
|
|
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;
|
|
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;
|
|
and exp-108 broadens all three non-i32 concrete collection lanes with one
|
|
connected prefix/suffix helper package.
|
|
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, and
|
|
exp-108, `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/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.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`
|
|
|
|
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.
|
|
`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/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.
|