From 05ff5be5c5076b5c7a402b2eaeb1878e4f52ee2f Mon Sep 17 00:00:00 2001 From: sanjin Date: Sat, 23 May 2026 02:30:45 +0200 Subject: [PATCH] Release 1.0.0-beta.23 stdlib stability tier catalog --- ...ILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md | 73 + .llm/reviews/BETA_23_RELEASE_REVIEW.md | 54 + README.md | 25 +- compiler/Cargo.lock | 2 +- compiler/Cargo.toml | 2 +- docs/POST_BETA_ROADMAP.md | 16 +- docs/compiler/RELEASE_NOTES.md | 30 + docs/compiler/ROADMAP.md | 12 +- docs/language/RELEASE_NOTES.md | 34 +- docs/language/ROADMAP.md | 19 +- docs/language/SPEC-v1.md | 20 +- docs/language/STDLIB_API.md | 1256 +++++++++-------- docs/language/STDLIB_TIERS.md | 68 + lib/std/README.md | 15 +- scripts/check-stdlib-api-tiers.js | 80 ++ scripts/release-gate.sh | 3 + scripts/render-stdlib-api-doc.js | 70 +- 17 files changed, 1132 insertions(+), 647 deletions(-) create mode 100644 .llm/BETA_23_STDLIB_STABILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md create mode 100644 .llm/reviews/BETA_23_RELEASE_REVIEW.md create mode 100644 docs/language/STDLIB_TIERS.md create mode 100755 scripts/check-stdlib-api-tiers.js diff --git a/.llm/BETA_23_STDLIB_STABILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md b/.llm/BETA_23_STDLIB_STABILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md new file mode 100644 index 0000000..3a23836 --- /dev/null +++ b/.llm/BETA_23_STDLIB_STABILITY_TIER_LEDGER_AND_CATALOG_ALIGNMENT.md @@ -0,0 +1,73 @@ +# 1.0.0-beta.23 Standard Library Stability Tier Ledger And Catalog Alignment + +## Scope + +`1.0.0-beta.23` is a documentation/catalog clarity slice for the standard +library. It adds a public stability-tier ledger and aligns the surrounding +README, roadmap, release-note, and specification text with the generated API +catalog boundary. + +This release does not change the source language, typed core, runtime +capabilities, standard-library helper surface, compiler-known runtime names, +ABI/layout policy, or package behavior. It does change generated catalog +output and release-gate checks so tier metadata is visible and enforced. + +## Contract + +The public standard-library docs use exactly these tier labels: + +- `beta-supported` +- `experimental` +- `internal` + +The generated `docs/language/STDLIB_API.md` catalog remains the exact exported +signature inventory generated from `lib/std/*.slo`. The new +`docs/language/STDLIB_TIERS.md` ledger records maturity and stability +expectations for those helpers and surrounding standard-library domains. + +Experimental domains in the beta23 ledger include JSON, loopback networking, +random/time, and filesystem resource-handle helpers. Concrete vector modules +remain beta-supported concrete lanes; they are not a generic collections +freeze and do not imply executable generics, maps, sets, iterators, mutable +vectors, slice/view APIs, runtime collection changes, or stable ABI/layout. + +## Non-Scope + +This scope does not add: + +- source-language syntax +- standard-library helpers +- compiler-known `std.*` runtime names +- runtime C capabilities +- package, workspace, import, or registry behavior +- stable standard-library/API compatibility freeze +- stable manifest schema freeze +- stable Markdown schema freeze +- stable ABI/layout +- performance claims +- beta maturity beyond the existing `1.0.0-beta` line + +## Acceptance Criteria + +- `docs/language/STDLIB_TIERS.md` defines the public tier labels and their + current meaning. +- The tier ledger marks JSON, loopback networking, random/time, and filesystem + resource-handle helpers as experimental domains. +- The tier ledger records concrete vector modules as beta-supported concrete + lanes without claiming generic collection stability. +- README, `lib/std/README.md`, language release notes, language roadmap, + post-beta roadmap, and the v1 spec link or describe the tier ledger. +- Documentation states beta23 is docs/catalog tooling clarity only and does + not add language, stdlib, runtime, stable schema, or stable API behavior. +- The generated API catalog emits tier metadata, and the release gate checks + that experimental tiers remain represented. + +## Suggested Gates + +```bash +node --check scripts/render-stdlib-api-doc.js +node --check scripts/check-stdlib-api-tiers.js +./scripts/render-stdlib-api-doc.sh +./scripts/check-stdlib-api-tiers.js +git diff --check +``` diff --git a/.llm/reviews/BETA_23_RELEASE_REVIEW.md b/.llm/reviews/BETA_23_RELEASE_REVIEW.md new file mode 100644 index 0000000..613a407 --- /dev/null +++ b/.llm/reviews/BETA_23_RELEASE_REVIEW.md @@ -0,0 +1,54 @@ +# Beta23 Release Review + +Verdict: PASS with notes. + +## Findings + +No blocking or non-blocking findings in the reviewed scope. + +## Scope Reviewed + +- `scripts/render-stdlib-api-doc.js` tier rendering. +- `scripts/check-stdlib-api-tiers.js` tier gate. +- `scripts/release-gate.sh` integration. +- Generated `docs/language/STDLIB_API.md`. +- `docs/language/STDLIB_TIERS.md`, README, release notes, roadmaps, and spec updates. +- Compiler package version bump and compiler release documentation. + +## Acceptance Checklist + +- PASS: `docs/language/STDLIB_TIERS.md` defines the public tier labels and explains the current beta meaning. See `docs/language/STDLIB_TIERS.md:21` through `docs/language/STDLIB_TIERS.md:25`. +- PASS: The tier ledger marks JSON, loopback networking, random/time, and filesystem resource-handle helpers as experimental domains. See `docs/language/STDLIB_TIERS.md:46` through `docs/language/STDLIB_TIERS.md:49`. +- PASS: The tier ledger records concrete vector modules as beta-supported concrete lanes without claiming generic collection stability. See `docs/language/STDLIB_TIERS.md:44`. +- PASS: The generated API catalog emits tier metadata and summary counts. See `docs/language/STDLIB_API.md:6` through `docs/language/STDLIB_API.md:24`. +- PASS: Generated catalog classification matches the beta23 contract: filesystem handle helpers are experimental in `docs/language/STDLIB_API.md:115` through `docs/language/STDLIB_API.md:119`; `std.json`, `std.net`, `std.random`, and `std.time` are experimental in `docs/language/STDLIB_API.md:195` through `docs/language/STDLIB_API.md:240`, `docs/language/STDLIB_API.md:294` through `docs/language/STDLIB_API.md:308`, `docs/language/STDLIB_API.md:425` through `docs/language/STDLIB_API.md:432`, and `docs/language/STDLIB_API.md:540` through `docs/language/STDLIB_API.md:547`. +- PASS: Concrete vector modules retain explicit no-generic-collection-freeze notes in generated output. Representative coverage is `docs/language/STDLIB_API.md:549` through `docs/language/STDLIB_API.md:554`, with the same note repeated for the other concrete `std.vec_*` modules. +- PASS: The renderer implements the tier map and emits per-module/per-helper tiers. See `scripts/render-stdlib-api-doc.js:12` through `scripts/render-stdlib-api-doc.js:46`, `scripts/render-stdlib-api-doc.js:245` through `scripts/render-stdlib-api-doc.js:263`, and `scripts/render-stdlib-api-doc.js:297` through `scripts/render-stdlib-api-doc.js:330`. +- PASS: The tier gate checks stale wording, summary tier definitions, experimental module/helper coverage, and vector boundary notes. See `scripts/check-stdlib-api-tiers.js:47` through `scripts/check-stdlib-api-tiers.js:80`. +- PASS: `scripts/release-gate.sh` runs syntax checks for both tier scripts and executes the tier checker after catalog rendering. See `scripts/release-gate.sh:12` through `scripts/release-gate.sh:16`. +- PASS: README, `lib/std/README.md`, language release notes, language roadmap, post-beta roadmap, and v1 spec link or describe the tier ledger and non-scope. Representative references: `README.md:69` through `README.md:79`, `lib/std/README.md:174` through `lib/std/README.md:184`, `docs/language/RELEASE_NOTES.md:53` through `docs/language/RELEASE_NOTES.md:69`, `docs/language/ROADMAP.md:109` through `docs/language/ROADMAP.md:119`, `docs/POST_BETA_ROADMAP.md:121` through `docs/POST_BETA_ROADMAP.md:132`, and `docs/language/SPEC-v1.md:268` through `docs/language/SPEC-v1.md:279`. +- PASS: Documentation states beta23 is documentation/catalog tooling clarity only and does not add language, stdlib, runtime, stable schema, ABI/layout, or stable API behavior. See `docs/language/STDLIB_TIERS.md:10` through `docs/language/STDLIB_TIERS.md:15` and `docs/language/STDLIB_TIERS.md:52` through `docs/language/STDLIB_TIERS.md:68`. +- PASS: Compiler package version and compiler release docs are aligned to `1.0.0-beta.23`. See `compiler/Cargo.toml:3`, `compiler/Cargo.lock:7`, `docs/compiler/RELEASE_NOTES.md:15` through `docs/compiler/RELEASE_NOTES.md:43`, and `docs/compiler/ROADMAP.md:126` through `docs/compiler/ROADMAP.md:132`. + +## Verification + +Ran: + +```bash +node --check scripts/render-stdlib-api-doc.js +node --check scripts/check-stdlib-api-tiers.js +./scripts/check-stdlib-api-tiers.js +git diff --check +rg -n '^- `experimental`' docs/language/STDLIB_API.md +``` + +Result: all focused checks passed. The `rg` inspection confirmed 58 experimental helper signatures across the expected filesystem-handle, JSON, loopback networking, random, and time surfaces. + +Recommended before release tag: + +```bash +./scripts/render-stdlib-api-doc.sh +./scripts/release-gate.sh +``` + +Note: run the full release gate after the generated catalog changes are staged or committed; the gate intentionally fails if `docs/language/STDLIB_API.md` has unstaged generated-doc drift. diff --git a/README.md b/README.md index 60186e2..7439916 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ This repository is the canonical public monorepo for the language design, standard library source, compiler, runtime, examples, benchmarks, and technical documents. -Current release: `1.0.0-beta.22`. +Current release: `1.0.0-beta.23`. ## Repository Layout @@ -24,7 +24,7 @@ scripts/ local release and document tooling ## Beta Scope -`1.0.0-beta.22` keeps the `1.0.0-beta` language baseline, includes the +`1.0.0-beta.23` keeps the `1.0.0-beta` language baseline, includes the `1.0.0-beta.1` tooling/install hardening slice, the `1.0.0-beta.2` runtime/resource foundation bundle, the `1.0.0-beta.3` standard-library stabilization bundle, the `1.0.0-beta.4` language-usability diagnostics @@ -44,7 +44,9 @@ the `1.0.0-beta.17` JSON primitive scalar parsing foundation, the `1.0.0-beta.19` test discovery and user-project conformance foundation, the `1.0.0-beta.20` string search and ASCII trim foundation, and the `1.0.0-beta.21` JSON document scalar parsing foundation, plus the -`1.0.0-beta.22` run manifest and execution report hardening slice. +`1.0.0-beta.22` run manifest and execution report hardening slice, and the +`1.0.0-beta.23` standard-library stability tier ledger and catalog alignment +slice. The language baseline supports practical local command-line, file, and loopback-network programs with: @@ -68,6 +70,13 @@ The generated standard-library API catalog is a beta discovery aid: it lists exported helper signatures from `lib/std/*.slo`, normalizes module-local concrete aliases such as `VecI32` and `ResultU64` to their concrete public types, and omits non-exported helpers and `(type ...)` aliases. +The companion +[`docs/language/STDLIB_TIERS.md`](docs/language/STDLIB_TIERS.md) ledger +defines the public tier labels `beta-supported`, `experimental`, and +`internal`, marks JSON, loopback networking, random/time, and filesystem +resource-handle helpers as experimental domains, and keeps concrete vector +modules as beta-supported concrete lanes rather than a generic collections +freeze. `glagol symbols ` emits deterministic editor-facing S-expression metadata for modules, imports, exports, aliases, structs, enums, functions, tests, source spans, and workspace package names. @@ -177,6 +186,16 @@ syntax, standard-library helpers, compiler-known runtime names, runtime capabilities, package behavior, stable artifact-manifest schema guarantees, stable ABI/layout, or a stable stdlib/API freeze. +The `1.0.0-beta.23` standard-library stability tier ledger and catalog +alignment slice adds the public +[`STDLIB_TIERS.md`](docs/language/STDLIB_TIERS.md) maturity ledger beside the +generated [`STDLIB_API.md`](docs/language/STDLIB_API.md) signature catalog. +It is documentation/catalog tooling clarity only: no source-language syntax, +stdlib helpers, compiler-known runtime names, runtime behavior, stable manifest +schema, stable Markdown schema, stable ABI/layout, or stable stdlib/API freeze +changes. The generated catalog and release gate now expose and check tier +metadata. + Still deferred before stable: executable generics, generic aliases, maps/sets, broad package registry semantics, stable artifact-manifest schema, stable Markdown schema, stable stdlib/API compatibility freeze, DNS/TLS/async diff --git a/compiler/Cargo.lock b/compiler/Cargo.lock index b1c9450..f164ca9 100644 --- a/compiler/Cargo.lock +++ b/compiler/Cargo.lock @@ -4,4 +4,4 @@ version = 3 [[package]] name = "glagol" -version = "1.0.0-beta.22" +version = "1.0.0-beta.23" diff --git a/compiler/Cargo.toml b/compiler/Cargo.toml index 5e29e4a..3a0b760 100644 --- a/compiler/Cargo.toml +++ b/compiler/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "glagol" -version = "1.0.0-beta.22" +version = "1.0.0-beta.23" edition = "2021" description = "Glagol, the first compiler for the Slovo language" license = "MIT OR Apache-2.0" diff --git a/docs/POST_BETA_ROADMAP.md b/docs/POST_BETA_ROADMAP.md index 4bf5a41..ab27869 100644 --- a/docs/POST_BETA_ROADMAP.md +++ b/docs/POST_BETA_ROADMAP.md @@ -118,6 +118,19 @@ bytes `9`, `10`, `11`, `12`, `13`, and `32`. Unicode/grapheme semantics, case folding, regexes, tokenizers, mutable strings, slice/view syntax, new runtime names, and stable stdlib/API promises remain deferred. +Released in `1.0.0-beta.23`: the public +[`docs/language/STDLIB_TIERS.md`](language/STDLIB_TIERS.md) ledger defines the +current standard-library tier labels `beta-supported`, `experimental`, and +`internal`, and aligns the docs around the generated +[`docs/language/STDLIB_API.md`](language/STDLIB_API.md) signature catalog. +JSON, loopback networking, random/time, and filesystem resource-handle helpers +are documented as experimental domains. Concrete vector modules remain +beta-supported concrete lanes, not a generic collections freeze. The slice is +documentation/catalog tooling clarity only: no syntax, helper, runtime, +manifest-schema, Markdown-schema, ABI/layout, or stable stdlib/API behavior +changes. It updates generated catalog output and the release gate so tier +metadata is visible and checked. + Why third: stdlib growth is already broad enough that naming and stability tiers matter more than adding another isolated helper group. @@ -541,7 +554,8 @@ foundation before richer string or data-interchange APIs are credible. Slovo should not become stable until all of these are true: - migration and deprecation policy is documented -- `lib/std` has explicit stable and experimental tiers +- `lib/std` has explicit beta-supported, experimental, and internal tiers plus + a later stable-tier/deprecation policy before `1.0.0` - package/workspace behavior is deterministic - conformance tests cover user-shaped projects - release gates are reproducible on a clean checkout diff --git a/docs/compiler/RELEASE_NOTES.md b/docs/compiler/RELEASE_NOTES.md index a757ba4..3621af1 100644 --- a/docs/compiler/RELEASE_NOTES.md +++ b/docs/compiler/RELEASE_NOTES.md @@ -12,6 +12,36 @@ integration/readiness release, not the first real beta. No active unreleased compiler scope is documented here yet. +## 1.0.0-beta.23 + +Release label: `1.0.0-beta.23` + +Release date: 2026-05-23 + +Release state: standard-library stability tier ledger and catalog alignment + +### Summary + +The beta.23 compiler/tooling slice aligns generated standard-library API +catalog output with the public tier ledger: + +- Bump the `glagol` compiler package version to `1.0.0-beta.23`. +- Render per-module and per-helper `beta-supported` or `experimental` tier + metadata in `docs/language/STDLIB_API.md`. +- Add `scripts/check-stdlib-api-tiers.js` and wire it into the release gate. +- Mark JSON, loopback networking, random/time, and filesystem resource-handle + helpers as experimental in generated catalog output. +- Keep concrete vector modules beta-supported concrete lanes with an explicit + no-generic-collection-freeze note. + +### Explicit Deferrals + +This release does not implement source-language syntax, standard-library +helpers, compiler-known `std.*` runtime names, runtime C capabilities, package +or workspace behavior, stable artifact-manifest schema guarantees, stable +Markdown schemas, LSP/watch/SARIF/daemon protocols, performance claims, +stable ABI/layout, or a stable standard-library compatibility contract. + ## 1.0.0-beta.22 Release label: `1.0.0-beta.22` diff --git a/docs/compiler/ROADMAP.md b/docs/compiler/ROADMAP.md index 87434dc..b4674a7 100644 --- a/docs/compiler/ROADMAP.md +++ b/docs/compiler/ROADMAP.md @@ -21,8 +21,8 @@ general-purpose beta release. A Glagol feature is done only when it has parser/lowerer support, checker behavior, diagnostics for invalid forms, backend behavior or explicit unsupported diagnostics, and tests. -Current stage: `1.0.0-beta.22`, released on 2026-05-23 as run manifest and -execution report hardening. It keeps the +Current stage: `1.0.0-beta.23`, released on 2026-05-23 as standard-library +stability tier ledger and catalog alignment. It keeps the `1.0.0-beta` language/compiler support baseline and includes the `1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2` runtime/resource foundation release, the `1.0.0-beta.3` standard-library stabilization release, @@ -123,6 +123,14 @@ CLI evidence metadata under the existing `slovo.artifact-manifest` version `1` contract, not a stable schema freeze, and it adds no source-language, runtime, package, or standard-library surface. +The beta.23 compiler/tooling slice bumps the package version and updates +generated `docs/language/STDLIB_API.md` output with per-module and per-helper +tier metadata. It adds a release-gate checker for the tier catalog, marks JSON, +loopback networking, random/time, and filesystem resource-handle helpers as +experimental, and keeps concrete vector modules beta-supported concrete lanes +without claiming generic collection stability. It adds no source-language, +runtime, package, or standard-library helper surface. + Generic vectors, generic collections, maps, sets, generic stdlib dispatch, runtime collection changes, collection unification, stable human diagnostic text, stable artifact-manifest or Markdown schema freezes, LSP/watch diff --git a/docs/language/RELEASE_NOTES.md b/docs/language/RELEASE_NOTES.md index 1ea0022..dab773a 100644 --- a/docs/language/RELEASE_NOTES.md +++ b/docs/language/RELEASE_NOTES.md @@ -8,7 +8,7 @@ Historical `exp-*` releases listed here are experimental maturity milestones. The pushed tag `v2.0.0-beta.1` is historical. It is now documented as an experimental integration/readiness release, not as a beta maturity claim. -The current release is `1.0.0-beta.22`, published on 2026-05-23. It keeps the +The current release is `1.0.0-beta.23`, published on 2026-05-23. It keeps the `1.0.0-beta` language surface, includes the first post-beta tooling/install hardening bundle from `1.0.0-beta.1`, and adds the first runtime/resource foundation bundle from `1.0.0-beta.2` plus the first standard-library @@ -32,12 +32,42 @@ foundation from `1.0.0-beta.18`, the test discovery and user-project conformance foundation from `1.0.0-beta.19`, and the string search and ASCII trim foundation from `1.0.0-beta.20`, plus the JSON document scalar parsing foundation from `1.0.0-beta.21`, and the run manifest execution-report -hardening slice from `1.0.0-beta.22`. +hardening slice from `1.0.0-beta.22`, plus the standard-library stability tier +ledger and catalog alignment slice from `1.0.0-beta.23`. ## Unreleased No active unreleased language scope is documented here yet. +## 1.0.0-beta.23 + +Release label: `1.0.0-beta.23` + +Release name: Standard Library Stability Tier Ledger And Catalog Alignment + +Release date: 2026-05-23 + +Status: released beta documentation/catalog clarity on the `1.0.0-beta` +language baseline. + +This release adds [`STDLIB_TIERS.md`](STDLIB_TIERS.md) as the public maturity +ledger for the generated [`STDLIB_API.md`](STDLIB_API.md) standard-library API +catalog. The ledger defines the tier labels `beta-supported`, `experimental`, +and `internal`. + +The beta23 ledger classifies JSON, loopback networking, random/time, and +filesystem resource-handle helpers as experimental domains. Concrete vector +modules remain beta-supported concrete lanes; this is not a generic +collections freeze and does not imply executable generics, maps, sets, +iterators, mutable vectors, slice/view APIs, runtime collection changes, or +stable ABI/layout. + +This release adds no source-language syntax, standard-library helpers, +compiler-known runtime names, runtime behavior, package behavior, stable +artifact-manifest schema, stable Markdown schema, stable ABI/layout, or stable +stdlib/API compatibility freeze. It does update generated catalog output and +the release gate so tier metadata is visible and checked. + ## 1.0.0-beta.22 Release label: `1.0.0-beta.22` diff --git a/docs/language/ROADMAP.md b/docs/language/ROADMAP.md index 6d930b7..f9e4133 100644 --- a/docs/language/ROADMAP.md +++ b/docs/language/ROADMAP.md @@ -8,8 +8,8 @@ Guiding rule: the manifest wins. A feature is not accepted until it has surface Long-horizon planning lives in `.llm/ROADMAP_TO_STABLE.md`. It defines the release train beyond the first real general-purpose beta Slovo contract. -Current stage: `1.0.0-beta.22`, released on 2026-05-23 as post-beta run -manifest and execution-report hardening. It keeps the +Current stage: `1.0.0-beta.23`, released on 2026-05-23 as post-beta +standard-library stability tier ledger and catalog alignment. It keeps the `1.0.0-beta` language contract and includes the `1.0.0-beta.1` tooling hardening release, the `1.0.0-beta.2` runtime/resource foundation release, the `1.0.0-beta.3` @@ -28,7 +28,8 @@ scalar token parsing, `1.0.0-beta.18` JSON string token parsing, `1.0.0-beta.19` test discovery and user-project conformance tooling, and `1.0.0-beta.20` string search and ASCII trim helpers, plus `1.0.0-beta.21` JSON document scalar parsing helpers, and -`1.0.0-beta.22` run manifest execution-report hardening. +`1.0.0-beta.22` run manifest execution-report hardening, plus +`1.0.0-beta.23` standard-library stability tier documentation. `1.0.0-beta.16` adds `std.string` source facades and examples for `byte_at_result`, `slice_result`, `starts_with`, and `ends_with`. These helpers @@ -105,6 +106,18 @@ contract. It is not a stable schema freeze and adds no language syntax, standard-library helpers, runtime capabilities, package/import behavior, stable ABI/layout, or stable stdlib/API guarantees. +`1.0.0-beta.23` is documentation/catalog clarity, not a language or stdlib +behavior feature. It adds [`STDLIB_TIERS.md`](STDLIB_TIERS.md) as the public +stability-tier ledger beside the generated [`STDLIB_API.md`](STDLIB_API.md) +signature catalog. The ledger defines `beta-supported`, `experimental`, and +`internal`; marks JSON, loopback networking, random/time, and filesystem +resource-handle helpers as experimental domains; and keeps concrete vector +modules as beta-supported concrete lanes rather than a generic collections +freeze. It adds no source-language syntax, helpers, runtime names, runtime +behavior, stable manifest schema, stable Markdown schema, stable ABI/layout, +or stable stdlib/API freeze. It does update generated catalog output and the +release gate so tier metadata is visible and checked. + The final experimental precursor scope is `exp-125`, defined in `.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`. Its unsigned direct-value flow, parse/format runtime lanes, and matching staged diff --git a/docs/language/SPEC-v1.md b/docs/language/SPEC-v1.md index 8ce4728..5c5ea21 100644 --- a/docs/language/SPEC-v1.md +++ b/docs/language/SPEC-v1.md @@ -13,10 +13,10 @@ foundation, `1.0.0-beta.18` JSON string token parsing foundation, `1.0.0-beta.19` test discovery and user-project conformance tooling, and `1.0.0-beta.20` string search and ASCII trim foundation, and `1.0.0-beta.21` JSON document scalar parsing foundation, and -`1.0.0-beta.22` run manifest and execution-report hardening. The -language contract -integrates -promoted language slices through `exp-125` and the historical publication +`1.0.0-beta.22` run manifest and execution-report hardening, and +`1.0.0-beta.23` standard-library stability tier ledger and catalog alignment. +The language contract integrates promoted language slices through `exp-125` +and the historical publication baseline through `exp-123`. `1.0.0-beta` is the first real general-purpose beta release. `exp-125` completed the unsigned numeric and stdlib breadth precursor scope, `exp-124` is the last tagged experimental alpha language @@ -265,6 +265,18 @@ Current v1 release surface and explicit experimental targets: add source-language syntax, stdlib helpers, compiler-known runtime names, runtime C capabilities, package/import behavior, stable artifact-manifest schema guarantees, stable ABI/layout, or stable stdlib/API freeze +- `1.0.0-beta.23` standard-library stability tier ledger and catalog + alignment: + [`STDLIB_TIERS.md`](STDLIB_TIERS.md) defines the public tier labels + `beta-supported`, `experimental`, and `internal` beside the generated + [`STDLIB_API.md`](STDLIB_API.md) signature catalog. JSON, loopback + networking, random/time, and filesystem resource-handle helpers are + experimental domains. Concrete vector modules remain beta-supported concrete + lanes, not a generic collections freeze. This target does not add + source-language syntax, stdlib helpers, compiler-known runtime names, + runtime behavior, stable artifact-manifest schema, stable Markdown schema, + stable ABI/layout, or stable stdlib/API freeze. It does update generated + catalog output and the release gate so tier metadata is visible and checked - `exp-1` owned runtime strings: compiler-known `std.string.concat` accepts two `string` values and returns an immutable runtime-owned `string`; existing string equality, length, printing, locals, parameters, returns, and calls work diff --git a/docs/language/STDLIB_API.md b/docs/language/STDLIB_API.md index ff915d2..bb590a1 100644 --- a/docs/language/STDLIB_API.md +++ b/docs/language/STDLIB_API.md @@ -6,12 +6,13 @@ Do not edit this file by hand. ## Stability Tiers - `beta-supported`: exported from `lib/std` and covered by source-search, promotion, or facade gates in the current beta line. -- `experimental`: not used for exported `lib/std` helpers in `1.0.0-beta.22`; future releases may mark new helpers this way before they graduate. +- `experimental`: exported from `lib/std` in `1.0.0-beta.23`, but still has beta caveats around host behavior, resource handles, or API shape. - `internal`: helper names that are not exported from their module; they are intentionally omitted from this catalog. The catalog is a beta API discovery aid, not a stable `1.0.0` standard-library freeze. Module-local concrete aliases are normalized in signatures so names such as `VecI32` and `ResultU64` do not leak into the public catalog. Only exported `(fn ...)` helpers are listed; `(type ...)` aliases and non-exported helpers are omitted. +Concrete `std.vec_*` modules are beta-supported as concrete helper families only; this does not freeze a generic collection API. ## Summary @@ -19,743 +20,750 @@ Only exported `(fn ...)` helpers are listed; `(type ...)` aliases and non-export - Exported helper signatures: 604 - Exported type aliases omitted: 0 - Default tier: `beta-supported` +- `beta-supported` helper signatures: 546 +- `experimental` helper signatures: 58 ## Modules ### std.cli - Path: `lib/std/cli.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 26 -- `arg_text_result ((index i32)) -> (result string i32)` -- `arg_text_option ((index i32)) -> (option string)` -- `arg_i32_result ((index i32)) -> (result i32 i32)` -- `arg_i32_option ((index i32)) -> (option i32)` -- `arg_i32_or_zero ((index i32)) -> i32` -- `arg_i32_or ((index i32) (fallback i32)) -> i32` -- `arg_u32_result ((index i32)) -> (result u32 i32)` -- `arg_u32_option ((index i32)) -> (option u32)` -- `arg_u32_or_zero ((index i32)) -> u32` -- `arg_u32_or ((index i32) (fallback u32)) -> u32` -- `arg_i64_result ((index i32)) -> (result i64 i32)` -- `arg_i64_option ((index i32)) -> (option i64)` -- `arg_i64_or_zero ((index i32)) -> i64` -- `arg_i64_or ((index i32) (fallback i64)) -> i64` -- `arg_u64_result ((index i32)) -> (result u64 i32)` -- `arg_u64_option ((index i32)) -> (option u64)` -- `arg_u64_or_zero ((index i32)) -> u64` -- `arg_u64_or ((index i32) (fallback u64)) -> u64` -- `arg_f64_result ((index i32)) -> (result f64 i32)` -- `arg_f64_option ((index i32)) -> (option f64)` -- `arg_f64_or_zero ((index i32)) -> f64` -- `arg_f64_or ((index i32) (fallback f64)) -> f64` -- `arg_bool_result ((index i32)) -> (result bool i32)` -- `arg_bool_option ((index i32)) -> (option bool)` -- `arg_bool_or_false ((index i32)) -> bool` -- `arg_bool_or ((index i32) (fallback bool)) -> bool` +- `beta-supported` `arg_text_result ((index i32)) -> (result string i32)` +- `beta-supported` `arg_text_option ((index i32)) -> (option string)` +- `beta-supported` `arg_i32_result ((index i32)) -> (result i32 i32)` +- `beta-supported` `arg_i32_option ((index i32)) -> (option i32)` +- `beta-supported` `arg_i32_or_zero ((index i32)) -> i32` +- `beta-supported` `arg_i32_or ((index i32) (fallback i32)) -> i32` +- `beta-supported` `arg_u32_result ((index i32)) -> (result u32 i32)` +- `beta-supported` `arg_u32_option ((index i32)) -> (option u32)` +- `beta-supported` `arg_u32_or_zero ((index i32)) -> u32` +- `beta-supported` `arg_u32_or ((index i32) (fallback u32)) -> u32` +- `beta-supported` `arg_i64_result ((index i32)) -> (result i64 i32)` +- `beta-supported` `arg_i64_option ((index i32)) -> (option i64)` +- `beta-supported` `arg_i64_or_zero ((index i32)) -> i64` +- `beta-supported` `arg_i64_or ((index i32) (fallback i64)) -> i64` +- `beta-supported` `arg_u64_result ((index i32)) -> (result u64 i32)` +- `beta-supported` `arg_u64_option ((index i32)) -> (option u64)` +- `beta-supported` `arg_u64_or_zero ((index i32)) -> u64` +- `beta-supported` `arg_u64_or ((index i32) (fallback u64)) -> u64` +- `beta-supported` `arg_f64_result ((index i32)) -> (result f64 i32)` +- `beta-supported` `arg_f64_option ((index i32)) -> (option f64)` +- `beta-supported` `arg_f64_or_zero ((index i32)) -> f64` +- `beta-supported` `arg_f64_or ((index i32) (fallback f64)) -> f64` +- `beta-supported` `arg_bool_result ((index i32)) -> (result bool i32)` +- `beta-supported` `arg_bool_option ((index i32)) -> (option bool)` +- `beta-supported` `arg_bool_or_false ((index i32)) -> bool` +- `beta-supported` `arg_bool_or ((index i32) (fallback bool)) -> bool` ### std.env - Path: `lib/std/env.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 29 -- `get ((name string)) -> string` -- `get_result ((name string)) -> (result string i32)` -- `get_option ((name string)) -> (option string)` -- `has ((name string)) -> bool` -- `get_or ((name string) (fallback string)) -> string` -- `get_i32_result ((name string)) -> (result i32 i32)` -- `get_i32_option ((name string)) -> (option i32)` -- `get_i32_or_zero ((name string)) -> i32` -- `get_i32_or ((name string) (fallback i32)) -> i32` -- `get_u32_result ((name string)) -> (result u32 i32)` -- `get_u32_option ((name string)) -> (option u32)` -- `get_u32_or_zero ((name string)) -> u32` -- `get_u32_or ((name string) (fallback u32)) -> u32` -- `get_i64_result ((name string)) -> (result i64 i32)` -- `get_i64_option ((name string)) -> (option i64)` -- `get_i64_or_zero ((name string)) -> i64` -- `get_i64_or ((name string) (fallback i64)) -> i64` -- `get_u64_result ((name string)) -> (result u64 i32)` -- `get_u64_option ((name string)) -> (option u64)` -- `get_u64_or_zero ((name string)) -> u64` -- `get_u64_or ((name string) (fallback u64)) -> u64` -- `get_f64_result ((name string)) -> (result f64 i32)` -- `get_f64_option ((name string)) -> (option f64)` -- `get_f64_or_zero ((name string)) -> f64` -- `get_f64_or ((name string) (fallback f64)) -> f64` -- `get_bool_result ((name string)) -> (result bool i32)` -- `get_bool_option ((name string)) -> (option bool)` -- `get_bool_or_false ((name string)) -> bool` -- `get_bool_or ((name string) (fallback bool)) -> bool` +- `beta-supported` `get ((name string)) -> string` +- `beta-supported` `get_result ((name string)) -> (result string i32)` +- `beta-supported` `get_option ((name string)) -> (option string)` +- `beta-supported` `has ((name string)) -> bool` +- `beta-supported` `get_or ((name string) (fallback string)) -> string` +- `beta-supported` `get_i32_result ((name string)) -> (result i32 i32)` +- `beta-supported` `get_i32_option ((name string)) -> (option i32)` +- `beta-supported` `get_i32_or_zero ((name string)) -> i32` +- `beta-supported` `get_i32_or ((name string) (fallback i32)) -> i32` +- `beta-supported` `get_u32_result ((name string)) -> (result u32 i32)` +- `beta-supported` `get_u32_option ((name string)) -> (option u32)` +- `beta-supported` `get_u32_or_zero ((name string)) -> u32` +- `beta-supported` `get_u32_or ((name string) (fallback u32)) -> u32` +- `beta-supported` `get_i64_result ((name string)) -> (result i64 i32)` +- `beta-supported` `get_i64_option ((name string)) -> (option i64)` +- `beta-supported` `get_i64_or_zero ((name string)) -> i64` +- `beta-supported` `get_i64_or ((name string) (fallback i64)) -> i64` +- `beta-supported` `get_u64_result ((name string)) -> (result u64 i32)` +- `beta-supported` `get_u64_option ((name string)) -> (option u64)` +- `beta-supported` `get_u64_or_zero ((name string)) -> u64` +- `beta-supported` `get_u64_or ((name string) (fallback u64)) -> u64` +- `beta-supported` `get_f64_result ((name string)) -> (result f64 i32)` +- `beta-supported` `get_f64_option ((name string)) -> (option f64)` +- `beta-supported` `get_f64_or_zero ((name string)) -> f64` +- `beta-supported` `get_f64_or ((name string) (fallback f64)) -> f64` +- `beta-supported` `get_bool_result ((name string)) -> (result bool i32)` +- `beta-supported` `get_bool_option ((name string)) -> (option bool)` +- `beta-supported` `get_bool_or_false ((name string)) -> bool` +- `beta-supported` `get_bool_or ((name string) (fallback bool)) -> bool` ### std.fs - Path: `lib/std/fs.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported`, `experimental` - Exported helper signatures: 43 -- `read_text ((path string)) -> string` -- `read_text_result ((path string)) -> (result string i32)` -- `read_text_option ((path string)) -> (option string)` -- `write_text_status ((path string) (text string)) -> i32` -- `write_text_result ((path string) (text string)) -> (result i32 i32)` -- `exists ((path string)) -> bool` -- `is_file ((path string)) -> bool` -- `is_dir ((path string)) -> bool` -- `remove_file_result ((path string)) -> (result i32 i32)` -- `create_dir_result ((path string)) -> (result i32 i32)` -- `remove_file_ok ((path string)) -> bool` -- `create_dir_ok ((path string)) -> bool` -- `open_text_read_result ((path string)) -> (result i32 i32)` -- `read_open_text_result ((handle i32)) -> (result string i32)` -- `close_result ((handle i32)) -> (result i32 i32)` -- `read_text_via_handle_result ((path string)) -> (result string i32)` -- `close_ok ((handle i32)) -> bool` -- `read_text_or ((path string) (fallback string)) -> string` -- `write_text_ok ((path string) (text string)) -> bool` -- `read_i32_result ((path string)) -> (result i32 i32)` -- `read_i32_option ((path string)) -> (option i32)` -- `read_i32_or_zero ((path string)) -> i32` -- `read_i32_or ((path string) (fallback i32)) -> i32` -- `read_u32_result ((path string)) -> (result u32 i32)` -- `read_u32_option ((path string)) -> (option u32)` -- `read_u32_or_zero ((path string)) -> u32` -- `read_u32_or ((path string) (fallback u32)) -> u32` -- `read_i64_result ((path string)) -> (result i64 i32)` -- `read_i64_option ((path string)) -> (option i64)` -- `read_i64_or_zero ((path string)) -> i64` -- `read_i64_or ((path string) (fallback i64)) -> i64` -- `read_u64_result ((path string)) -> (result u64 i32)` -- `read_u64_option ((path string)) -> (option u64)` -- `read_u64_or_zero ((path string)) -> u64` -- `read_u64_or ((path string) (fallback u64)) -> u64` -- `read_f64_result ((path string)) -> (result f64 i32)` -- `read_f64_option ((path string)) -> (option f64)` -- `read_f64_or_zero ((path string)) -> f64` -- `read_f64_or ((path string) (fallback f64)) -> f64` -- `read_bool_result ((path string)) -> (result bool i32)` -- `read_bool_option ((path string)) -> (option bool)` -- `read_bool_or_false ((path string)) -> bool` -- `read_bool_or ((path string) (fallback bool)) -> bool` +- `beta-supported` `read_text ((path string)) -> string` +- `beta-supported` `read_text_result ((path string)) -> (result string i32)` +- `beta-supported` `read_text_option ((path string)) -> (option string)` +- `beta-supported` `write_text_status ((path string) (text string)) -> i32` +- `beta-supported` `write_text_result ((path string) (text string)) -> (result i32 i32)` +- `beta-supported` `exists ((path string)) -> bool` +- `beta-supported` `is_file ((path string)) -> bool` +- `beta-supported` `is_dir ((path string)) -> bool` +- `beta-supported` `remove_file_result ((path string)) -> (result i32 i32)` +- `beta-supported` `create_dir_result ((path string)) -> (result i32 i32)` +- `beta-supported` `remove_file_ok ((path string)) -> bool` +- `beta-supported` `create_dir_ok ((path string)) -> bool` +- `experimental` `open_text_read_result ((path string)) -> (result i32 i32)` +- `experimental` `read_open_text_result ((handle i32)) -> (result string i32)` +- `experimental` `close_result ((handle i32)) -> (result i32 i32)` +- `experimental` `read_text_via_handle_result ((path string)) -> (result string i32)` +- `experimental` `close_ok ((handle i32)) -> bool` +- `beta-supported` `read_text_or ((path string) (fallback string)) -> string` +- `beta-supported` `write_text_ok ((path string) (text string)) -> bool` +- `beta-supported` `read_i32_result ((path string)) -> (result i32 i32)` +- `beta-supported` `read_i32_option ((path string)) -> (option i32)` +- `beta-supported` `read_i32_or_zero ((path string)) -> i32` +- `beta-supported` `read_i32_or ((path string) (fallback i32)) -> i32` +- `beta-supported` `read_u32_result ((path string)) -> (result u32 i32)` +- `beta-supported` `read_u32_option ((path string)) -> (option u32)` +- `beta-supported` `read_u32_or_zero ((path string)) -> u32` +- `beta-supported` `read_u32_or ((path string) (fallback u32)) -> u32` +- `beta-supported` `read_i64_result ((path string)) -> (result i64 i32)` +- `beta-supported` `read_i64_option ((path string)) -> (option i64)` +- `beta-supported` `read_i64_or_zero ((path string)) -> i64` +- `beta-supported` `read_i64_or ((path string) (fallback i64)) -> i64` +- `beta-supported` `read_u64_result ((path string)) -> (result u64 i32)` +- `beta-supported` `read_u64_option ((path string)) -> (option u64)` +- `beta-supported` `read_u64_or_zero ((path string)) -> u64` +- `beta-supported` `read_u64_or ((path string) (fallback u64)) -> u64` +- `beta-supported` `read_f64_result ((path string)) -> (result f64 i32)` +- `beta-supported` `read_f64_option ((path string)) -> (option f64)` +- `beta-supported` `read_f64_or_zero ((path string)) -> f64` +- `beta-supported` `read_f64_or ((path string) (fallback f64)) -> f64` +- `beta-supported` `read_bool_result ((path string)) -> (result bool i32)` +- `beta-supported` `read_bool_option ((path string)) -> (option bool)` +- `beta-supported` `read_bool_or_false ((path string)) -> bool` +- `beta-supported` `read_bool_or ((path string) (fallback bool)) -> bool` ### std.io - Path: `lib/std/io.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 41 -- `print_i32_zero ((value i32)) -> i32` -- `print_u32_zero ((value u32)) -> i32` -- `print_i64_zero ((value i64)) -> i32` -- `print_u64_zero ((value u64)) -> i32` -- `print_f64_zero ((value f64)) -> i32` -- `print_string_zero ((value string)) -> i32` -- `print_bool_zero ((value bool)) -> i32` -- `print_i32_value ((value i32)) -> i32` -- `print_u32_value ((value u32)) -> u32` -- `print_i64_value ((value i64)) -> i64` -- `print_u64_value ((value u64)) -> u64` -- `print_f64_value ((value f64)) -> f64` -- `print_string_value ((value string)) -> string` -- `print_bool_value ((value bool)) -> bool` -- `read_stdin_result () -> (result string i32)` -- `read_stdin_option () -> (option string)` -- `read_stdin_or ((fallback string)) -> string` -- `read_stdin_i32_result () -> (result i32 i32)` -- `read_stdin_i32_option () -> (option i32)` -- `read_stdin_i32_or_zero () -> i32` -- `read_stdin_i32_or ((fallback i32)) -> i32` -- `read_stdin_u32_result () -> (result u32 i32)` -- `read_stdin_u32_option () -> (option u32)` -- `read_stdin_u32_or_zero () -> u32` -- `read_stdin_u32_or ((fallback u32)) -> u32` -- `read_stdin_i64_result () -> (result i64 i32)` -- `read_stdin_i64_option () -> (option i64)` -- `read_stdin_i64_or_zero () -> i64` -- `read_stdin_i64_or ((fallback i64)) -> i64` -- `read_stdin_u64_result () -> (result u64 i32)` -- `read_stdin_u64_option () -> (option u64)` -- `read_stdin_u64_or_zero () -> u64` -- `read_stdin_u64_or ((fallback u64)) -> u64` -- `read_stdin_f64_result () -> (result f64 i32)` -- `read_stdin_f64_option () -> (option f64)` -- `read_stdin_f64_or_zero () -> f64` -- `read_stdin_f64_or ((fallback f64)) -> f64` -- `read_stdin_bool_result () -> (result bool i32)` -- `read_stdin_bool_option () -> (option bool)` -- `read_stdin_bool_or_false () -> bool` -- `read_stdin_bool_or ((fallback bool)) -> bool` +- `beta-supported` `print_i32_zero ((value i32)) -> i32` +- `beta-supported` `print_u32_zero ((value u32)) -> i32` +- `beta-supported` `print_i64_zero ((value i64)) -> i32` +- `beta-supported` `print_u64_zero ((value u64)) -> i32` +- `beta-supported` `print_f64_zero ((value f64)) -> i32` +- `beta-supported` `print_string_zero ((value string)) -> i32` +- `beta-supported` `print_bool_zero ((value bool)) -> i32` +- `beta-supported` `print_i32_value ((value i32)) -> i32` +- `beta-supported` `print_u32_value ((value u32)) -> u32` +- `beta-supported` `print_i64_value ((value i64)) -> i64` +- `beta-supported` `print_u64_value ((value u64)) -> u64` +- `beta-supported` `print_f64_value ((value f64)) -> f64` +- `beta-supported` `print_string_value ((value string)) -> string` +- `beta-supported` `print_bool_value ((value bool)) -> bool` +- `beta-supported` `read_stdin_result () -> (result string i32)` +- `beta-supported` `read_stdin_option () -> (option string)` +- `beta-supported` `read_stdin_or ((fallback string)) -> string` +- `beta-supported` `read_stdin_i32_result () -> (result i32 i32)` +- `beta-supported` `read_stdin_i32_option () -> (option i32)` +- `beta-supported` `read_stdin_i32_or_zero () -> i32` +- `beta-supported` `read_stdin_i32_or ((fallback i32)) -> i32` +- `beta-supported` `read_stdin_u32_result () -> (result u32 i32)` +- `beta-supported` `read_stdin_u32_option () -> (option u32)` +- `beta-supported` `read_stdin_u32_or_zero () -> u32` +- `beta-supported` `read_stdin_u32_or ((fallback u32)) -> u32` +- `beta-supported` `read_stdin_i64_result () -> (result i64 i32)` +- `beta-supported` `read_stdin_i64_option () -> (option i64)` +- `beta-supported` `read_stdin_i64_or_zero () -> i64` +- `beta-supported` `read_stdin_i64_or ((fallback i64)) -> i64` +- `beta-supported` `read_stdin_u64_result () -> (result u64 i32)` +- `beta-supported` `read_stdin_u64_option () -> (option u64)` +- `beta-supported` `read_stdin_u64_or_zero () -> u64` +- `beta-supported` `read_stdin_u64_or ((fallback u64)) -> u64` +- `beta-supported` `read_stdin_f64_result () -> (result f64 i32)` +- `beta-supported` `read_stdin_f64_option () -> (option f64)` +- `beta-supported` `read_stdin_f64_or_zero () -> f64` +- `beta-supported` `read_stdin_f64_or ((fallback f64)) -> f64` +- `beta-supported` `read_stdin_bool_result () -> (result bool i32)` +- `beta-supported` `read_stdin_bool_option () -> (option bool)` +- `beta-supported` `read_stdin_bool_or_false () -> bool` +- `beta-supported` `read_stdin_bool_or ((fallback bool)) -> bool` ### std.json - Path: `lib/std/json.slo` -- Tier: `beta-supported` +- Tiers: `experimental` - Exported helper signatures: 40 -- `quote_string ((value string)) -> string` -- `null_value () -> string` -- `bool_value ((value bool)) -> string` -- `i32_value ((value i32)) -> string` -- `u32_value ((value u32)) -> string` -- `i64_value ((value i64)) -> string` -- `u64_value ((value u64)) -> string` -- `f64_value ((value f64)) -> string` -- `parse_string_value_result ((token string)) -> (result string i32)` -- `parse_bool_value_result ((token string)) -> (result bool i32)` -- `parse_i32_value_result ((token string)) -> (result i32 i32)` -- `parse_u32_value_result ((token string)) -> (result u32 i32)` -- `parse_i64_value_result ((token string)) -> (result i64 i32)` -- `parse_u64_value_result ((token string)) -> (result u64 i32)` -- `parse_f64_value_result ((token string)) -> (result f64 i32)` -- `parse_null_value_result ((token string)) -> (result bool i32)` -- `parse_string_document_result ((document string)) -> (result string i32)` -- `parse_bool_document_result ((document string)) -> (result bool i32)` -- `parse_i32_document_result ((document string)) -> (result i32 i32)` -- `parse_u32_document_result ((document string)) -> (result u32 i32)` -- `parse_i64_document_result ((document string)) -> (result i64 i32)` -- `parse_u64_document_result ((document string)) -> (result u64 i32)` -- `parse_f64_document_result ((document string)) -> (result f64 i32)` -- `parse_null_document_result ((document string)) -> (result bool i32)` -- `field_string ((name string) (value string)) -> string` -- `field_bool ((name string) (value bool)) -> string` -- `field_i32 ((name string) (value i32)) -> string` -- `field_u32 ((name string) (value u32)) -> string` -- `field_i64 ((name string) (value i64)) -> string` -- `field_u64 ((name string) (value u64)) -> string` -- `field_f64 ((name string) (value f64)) -> string` -- `field_null ((name string)) -> string` -- `array0 () -> string` -- `array1 ((first string)) -> string` -- `array2 ((first string) (second string)) -> string` -- `array3 ((first string) (second string) (third string)) -> string` -- `object0 () -> string` -- `object1 ((first string)) -> string` -- `object2 ((first string) (second string)) -> string` -- `object3 ((first string) (second string) (third string)) -> string` +- `experimental` `quote_string ((value string)) -> string` +- `experimental` `null_value () -> string` +- `experimental` `bool_value ((value bool)) -> string` +- `experimental` `i32_value ((value i32)) -> string` +- `experimental` `u32_value ((value u32)) -> string` +- `experimental` `i64_value ((value i64)) -> string` +- `experimental` `u64_value ((value u64)) -> string` +- `experimental` `f64_value ((value f64)) -> string` +- `experimental` `parse_string_value_result ((token string)) -> (result string i32)` +- `experimental` `parse_bool_value_result ((token string)) -> (result bool i32)` +- `experimental` `parse_i32_value_result ((token string)) -> (result i32 i32)` +- `experimental` `parse_u32_value_result ((token string)) -> (result u32 i32)` +- `experimental` `parse_i64_value_result ((token string)) -> (result i64 i32)` +- `experimental` `parse_u64_value_result ((token string)) -> (result u64 i32)` +- `experimental` `parse_f64_value_result ((token string)) -> (result f64 i32)` +- `experimental` `parse_null_value_result ((token string)) -> (result bool i32)` +- `experimental` `parse_string_document_result ((document string)) -> (result string i32)` +- `experimental` `parse_bool_document_result ((document string)) -> (result bool i32)` +- `experimental` `parse_i32_document_result ((document string)) -> (result i32 i32)` +- `experimental` `parse_u32_document_result ((document string)) -> (result u32 i32)` +- `experimental` `parse_i64_document_result ((document string)) -> (result i64 i32)` +- `experimental` `parse_u64_document_result ((document string)) -> (result u64 i32)` +- `experimental` `parse_f64_document_result ((document string)) -> (result f64 i32)` +- `experimental` `parse_null_document_result ((document string)) -> (result bool i32)` +- `experimental` `field_string ((name string) (value string)) -> string` +- `experimental` `field_bool ((name string) (value bool)) -> string` +- `experimental` `field_i32 ((name string) (value i32)) -> string` +- `experimental` `field_u32 ((name string) (value u32)) -> string` +- `experimental` `field_i64 ((name string) (value i64)) -> string` +- `experimental` `field_u64 ((name string) (value u64)) -> string` +- `experimental` `field_f64 ((name string) (value f64)) -> string` +- `experimental` `field_null ((name string)) -> string` +- `experimental` `array0 () -> string` +- `experimental` `array1 ((first string)) -> string` +- `experimental` `array2 ((first string) (second string)) -> string` +- `experimental` `array3 ((first string) (second string) (third string)) -> string` +- `experimental` `object0 () -> string` +- `experimental` `object1 ((first string)) -> string` +- `experimental` `object2 ((first string) (second string)) -> string` +- `experimental` `object3 ((first string) (second string) (third string)) -> string` ### std.math - Path: `lib/std/math.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 45 -- `abs_i32 ((value i32)) -> i32` -- `neg_i32 ((value i32)) -> i32` -- `rem_i32 ((left i32) (right i32)) -> i32` -- `bit_and_i32 ((left i32) (right i32)) -> i32` -- `bit_or_i32 ((left i32) (right i32)) -> i32` -- `bit_xor_i32 ((left i32) (right i32)) -> i32` -- `is_even_i32 ((value i32)) -> bool` -- `is_odd_i32 ((value i32)) -> bool` -- `min_i32 ((left i32) (right i32)) -> i32` -- `max_i32 ((left i32) (right i32)) -> i32` -- `clamp_i32 ((value i32) (low i32) (high i32)) -> i32` -- `square_i32 ((value i32)) -> i32` -- `cube_i32 ((value i32)) -> i32` -- `is_zero_i32 ((value i32)) -> bool` -- `is_positive_i32 ((value i32)) -> bool` -- `is_negative_i32 ((value i32)) -> bool` -- `in_range_i32 ((value i32) (low i32) (high i32)) -> bool` -- `abs_i64 ((value i64)) -> i64` -- `neg_i64 ((value i64)) -> i64` -- `rem_i64 ((left i64) (right i64)) -> i64` -- `bit_and_i64 ((left i64) (right i64)) -> i64` -- `bit_or_i64 ((left i64) (right i64)) -> i64` -- `bit_xor_i64 ((left i64) (right i64)) -> i64` -- `is_even_i64 ((value i64)) -> bool` -- `is_odd_i64 ((value i64)) -> bool` -- `min_i64 ((left i64) (right i64)) -> i64` -- `max_i64 ((left i64) (right i64)) -> i64` -- `clamp_i64 ((value i64) (low i64) (high i64)) -> i64` -- `square_i64 ((value i64)) -> i64` -- `cube_i64 ((value i64)) -> i64` -- `is_zero_i64 ((value i64)) -> bool` -- `is_positive_i64 ((value i64)) -> bool` -- `is_negative_i64 ((value i64)) -> bool` -- `in_range_i64 ((value i64) (low i64) (high i64)) -> bool` -- `abs_f64 ((value f64)) -> f64` -- `neg_f64 ((value f64)) -> f64` -- `min_f64 ((left f64) (right f64)) -> f64` -- `max_f64 ((left f64) (right f64)) -> f64` -- `clamp_f64 ((value f64) (low f64) (high f64)) -> f64` -- `square_f64 ((value f64)) -> f64` -- `cube_f64 ((value f64)) -> f64` -- `is_zero_f64 ((value f64)) -> bool` -- `is_positive_f64 ((value f64)) -> bool` -- `is_negative_f64 ((value f64)) -> bool` -- `in_range_f64 ((value f64) (low f64) (high f64)) -> bool` +- `beta-supported` `abs_i32 ((value i32)) -> i32` +- `beta-supported` `neg_i32 ((value i32)) -> i32` +- `beta-supported` `rem_i32 ((left i32) (right i32)) -> i32` +- `beta-supported` `bit_and_i32 ((left i32) (right i32)) -> i32` +- `beta-supported` `bit_or_i32 ((left i32) (right i32)) -> i32` +- `beta-supported` `bit_xor_i32 ((left i32) (right i32)) -> i32` +- `beta-supported` `is_even_i32 ((value i32)) -> bool` +- `beta-supported` `is_odd_i32 ((value i32)) -> bool` +- `beta-supported` `min_i32 ((left i32) (right i32)) -> i32` +- `beta-supported` `max_i32 ((left i32) (right i32)) -> i32` +- `beta-supported` `clamp_i32 ((value i32) (low i32) (high i32)) -> i32` +- `beta-supported` `square_i32 ((value i32)) -> i32` +- `beta-supported` `cube_i32 ((value i32)) -> i32` +- `beta-supported` `is_zero_i32 ((value i32)) -> bool` +- `beta-supported` `is_positive_i32 ((value i32)) -> bool` +- `beta-supported` `is_negative_i32 ((value i32)) -> bool` +- `beta-supported` `in_range_i32 ((value i32) (low i32) (high i32)) -> bool` +- `beta-supported` `abs_i64 ((value i64)) -> i64` +- `beta-supported` `neg_i64 ((value i64)) -> i64` +- `beta-supported` `rem_i64 ((left i64) (right i64)) -> i64` +- `beta-supported` `bit_and_i64 ((left i64) (right i64)) -> i64` +- `beta-supported` `bit_or_i64 ((left i64) (right i64)) -> i64` +- `beta-supported` `bit_xor_i64 ((left i64) (right i64)) -> i64` +- `beta-supported` `is_even_i64 ((value i64)) -> bool` +- `beta-supported` `is_odd_i64 ((value i64)) -> bool` +- `beta-supported` `min_i64 ((left i64) (right i64)) -> i64` +- `beta-supported` `max_i64 ((left i64) (right i64)) -> i64` +- `beta-supported` `clamp_i64 ((value i64) (low i64) (high i64)) -> i64` +- `beta-supported` `square_i64 ((value i64)) -> i64` +- `beta-supported` `cube_i64 ((value i64)) -> i64` +- `beta-supported` `is_zero_i64 ((value i64)) -> bool` +- `beta-supported` `is_positive_i64 ((value i64)) -> bool` +- `beta-supported` `is_negative_i64 ((value i64)) -> bool` +- `beta-supported` `in_range_i64 ((value i64) (low i64) (high i64)) -> bool` +- `beta-supported` `abs_f64 ((value f64)) -> f64` +- `beta-supported` `neg_f64 ((value f64)) -> f64` +- `beta-supported` `min_f64 ((left f64) (right f64)) -> f64` +- `beta-supported` `max_f64 ((left f64) (right f64)) -> f64` +- `beta-supported` `clamp_f64 ((value f64) (low f64) (high f64)) -> f64` +- `beta-supported` `square_f64 ((value f64)) -> f64` +- `beta-supported` `cube_f64 ((value f64)) -> f64` +- `beta-supported` `is_zero_f64 ((value f64)) -> bool` +- `beta-supported` `is_positive_f64 ((value f64)) -> bool` +- `beta-supported` `is_negative_f64 ((value f64)) -> bool` +- `beta-supported` `in_range_f64 ((value f64) (low f64) (high f64)) -> bool` ### std.net - Path: `lib/std/net.slo` -- Tier: `beta-supported` +- Tiers: `experimental` - Exported helper signatures: 9 -- `tcp_connect_loopback_result ((port i32)) -> (result i32 i32)` -- `tcp_listen_loopback_result ((port i32)) -> (result i32 i32)` -- `tcp_bound_port_result ((handle i32)) -> (result i32 i32)` -- `tcp_accept_result ((listener i32)) -> (result i32 i32)` -- `tcp_read_all_result ((handle i32)) -> (result string i32)` -- `tcp_write_text_result ((handle i32) (text string)) -> (result i32 i32)` -- `tcp_close_result ((handle i32)) -> (result i32 i32)` -- `tcp_write_text_ok ((handle i32) (text string)) -> bool` -- `tcp_close_ok ((handle i32)) -> bool` +- `experimental` `tcp_connect_loopback_result ((port i32)) -> (result i32 i32)` +- `experimental` `tcp_listen_loopback_result ((port i32)) -> (result i32 i32)` +- `experimental` `tcp_bound_port_result ((handle i32)) -> (result i32 i32)` +- `experimental` `tcp_accept_result ((listener i32)) -> (result i32 i32)` +- `experimental` `tcp_read_all_result ((handle i32)) -> (result string i32)` +- `experimental` `tcp_write_text_result ((handle i32) (text string)) -> (result i32 i32)` +- `experimental` `tcp_close_result ((handle i32)) -> (result i32 i32)` +- `experimental` `tcp_write_text_ok ((handle i32) (text string)) -> bool` +- `experimental` `tcp_close_ok ((handle i32)) -> bool` ### std.num - Path: `lib/std/num.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 14 -- `i32_to_i64 ((value i32)) -> i64` -- `i32_to_f64 ((value i32)) -> f64` -- `i64_to_f64 ((value i64)) -> f64` -- `i64_to_i32_result ((value i64)) -> (result i32 i32)` -- `f64_to_i32_result ((value f64)) -> (result i32 i32)` -- `f64_to_i64_result ((value f64)) -> (result i64 i32)` -- `i32_to_string ((value i32)) -> string` -- `u32_to_string ((value u32)) -> string` -- `i64_to_string ((value i64)) -> string` -- `u64_to_string ((value u64)) -> string` -- `f64_to_string ((value f64)) -> string` -- `i64_to_i32_or ((value i64) (fallback i32)) -> i32` -- `f64_to_i32_or ((value f64) (fallback i32)) -> i32` -- `f64_to_i64_or ((value f64) (fallback i64)) -> i64` +- `beta-supported` `i32_to_i64 ((value i32)) -> i64` +- `beta-supported` `i32_to_f64 ((value i32)) -> f64` +- `beta-supported` `i64_to_f64 ((value i64)) -> f64` +- `beta-supported` `i64_to_i32_result ((value i64)) -> (result i32 i32)` +- `beta-supported` `f64_to_i32_result ((value f64)) -> (result i32 i32)` +- `beta-supported` `f64_to_i64_result ((value f64)) -> (result i64 i32)` +- `beta-supported` `i32_to_string ((value i32)) -> string` +- `beta-supported` `u32_to_string ((value u32)) -> string` +- `beta-supported` `i64_to_string ((value i64)) -> string` +- `beta-supported` `u64_to_string ((value u64)) -> string` +- `beta-supported` `f64_to_string ((value f64)) -> string` +- `beta-supported` `i64_to_i32_or ((value i64) (fallback i32)) -> i32` +- `beta-supported` `f64_to_i32_or ((value f64) (fallback i32)) -> i32` +- `beta-supported` `f64_to_i64_or ((value f64) (fallback i64)) -> i64` ### std.option - Path: `lib/std/option.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 49 -- `some_i32 ((value i32)) -> (option i32)` -- `none_i32 () -> (option i32)` -- `is_some_i32 ((value (option i32))) -> bool` -- `is_none_i32 ((value (option i32))) -> bool` -- `unwrap_some_i32 ((value (option i32))) -> i32` -- `unwrap_or_i32 ((value (option i32)) (fallback i32)) -> i32` -- `some_or_err_i32 ((value (option i32)) (err_code i32)) -> (result i32 i32)` -- `some_u32 ((value u32)) -> (option u32)` -- `none_u32 () -> (option u32)` -- `is_some_u32 ((value (option u32))) -> bool` -- `is_none_u32 ((value (option u32))) -> bool` -- `unwrap_some_u32 ((value (option u32))) -> u32` -- `unwrap_or_u32 ((value (option u32)) (fallback u32)) -> u32` -- `some_or_err_u32 ((value (option u32)) (err_code i32)) -> (result u32 i32)` -- `some_i64 ((value i64)) -> (option i64)` -- `none_i64 () -> (option i64)` -- `is_some_i64 ((value (option i64))) -> bool` -- `is_none_i64 ((value (option i64))) -> bool` -- `unwrap_some_i64 ((value (option i64))) -> i64` -- `unwrap_or_i64 ((value (option i64)) (fallback i64)) -> i64` -- `some_or_err_i64 ((value (option i64)) (err_code i32)) -> (result i64 i32)` -- `some_u64 ((value u64)) -> (option u64)` -- `none_u64 () -> (option u64)` -- `is_some_u64 ((value (option u64))) -> bool` -- `is_none_u64 ((value (option u64))) -> bool` -- `unwrap_some_u64 ((value (option u64))) -> u64` -- `unwrap_or_u64 ((value (option u64)) (fallback u64)) -> u64` -- `some_or_err_u64 ((value (option u64)) (err_code i32)) -> (result u64 i32)` -- `some_f64 ((value f64)) -> (option f64)` -- `none_f64 () -> (option f64)` -- `is_some_f64 ((value (option f64))) -> bool` -- `is_none_f64 ((value (option f64))) -> bool` -- `unwrap_some_f64 ((value (option f64))) -> f64` -- `unwrap_or_f64 ((value (option f64)) (fallback f64)) -> f64` -- `some_or_err_f64 ((value (option f64)) (err_code i32)) -> (result f64 i32)` -- `some_bool ((value bool)) -> (option bool)` -- `none_bool () -> (option bool)` -- `is_some_bool ((value (option bool))) -> bool` -- `is_none_bool ((value (option bool))) -> bool` -- `unwrap_some_bool ((value (option bool))) -> bool` -- `unwrap_or_bool ((value (option bool)) (fallback bool)) -> bool` -- `some_or_err_bool ((value (option bool)) (err_code i32)) -> (result bool i32)` -- `some_string ((value string)) -> (option string)` -- `none_string () -> (option string)` -- `is_some_string ((value (option string))) -> bool` -- `is_none_string ((value (option string))) -> bool` -- `unwrap_some_string ((value (option string))) -> string` -- `unwrap_or_string ((value (option string)) (fallback string)) -> string` -- `some_or_err_string ((value (option string)) (err_code i32)) -> (result string i32)` +- `beta-supported` `some_i32 ((value i32)) -> (option i32)` +- `beta-supported` `none_i32 () -> (option i32)` +- `beta-supported` `is_some_i32 ((value (option i32))) -> bool` +- `beta-supported` `is_none_i32 ((value (option i32))) -> bool` +- `beta-supported` `unwrap_some_i32 ((value (option i32))) -> i32` +- `beta-supported` `unwrap_or_i32 ((value (option i32)) (fallback i32)) -> i32` +- `beta-supported` `some_or_err_i32 ((value (option i32)) (err_code i32)) -> (result i32 i32)` +- `beta-supported` `some_u32 ((value u32)) -> (option u32)` +- `beta-supported` `none_u32 () -> (option u32)` +- `beta-supported` `is_some_u32 ((value (option u32))) -> bool` +- `beta-supported` `is_none_u32 ((value (option u32))) -> bool` +- `beta-supported` `unwrap_some_u32 ((value (option u32))) -> u32` +- `beta-supported` `unwrap_or_u32 ((value (option u32)) (fallback u32)) -> u32` +- `beta-supported` `some_or_err_u32 ((value (option u32)) (err_code i32)) -> (result u32 i32)` +- `beta-supported` `some_i64 ((value i64)) -> (option i64)` +- `beta-supported` `none_i64 () -> (option i64)` +- `beta-supported` `is_some_i64 ((value (option i64))) -> bool` +- `beta-supported` `is_none_i64 ((value (option i64))) -> bool` +- `beta-supported` `unwrap_some_i64 ((value (option i64))) -> i64` +- `beta-supported` `unwrap_or_i64 ((value (option i64)) (fallback i64)) -> i64` +- `beta-supported` `some_or_err_i64 ((value (option i64)) (err_code i32)) -> (result i64 i32)` +- `beta-supported` `some_u64 ((value u64)) -> (option u64)` +- `beta-supported` `none_u64 () -> (option u64)` +- `beta-supported` `is_some_u64 ((value (option u64))) -> bool` +- `beta-supported` `is_none_u64 ((value (option u64))) -> bool` +- `beta-supported` `unwrap_some_u64 ((value (option u64))) -> u64` +- `beta-supported` `unwrap_or_u64 ((value (option u64)) (fallback u64)) -> u64` +- `beta-supported` `some_or_err_u64 ((value (option u64)) (err_code i32)) -> (result u64 i32)` +- `beta-supported` `some_f64 ((value f64)) -> (option f64)` +- `beta-supported` `none_f64 () -> (option f64)` +- `beta-supported` `is_some_f64 ((value (option f64))) -> bool` +- `beta-supported` `is_none_f64 ((value (option f64))) -> bool` +- `beta-supported` `unwrap_some_f64 ((value (option f64))) -> f64` +- `beta-supported` `unwrap_or_f64 ((value (option f64)) (fallback f64)) -> f64` +- `beta-supported` `some_or_err_f64 ((value (option f64)) (err_code i32)) -> (result f64 i32)` +- `beta-supported` `some_bool ((value bool)) -> (option bool)` +- `beta-supported` `none_bool () -> (option bool)` +- `beta-supported` `is_some_bool ((value (option bool))) -> bool` +- `beta-supported` `is_none_bool ((value (option bool))) -> bool` +- `beta-supported` `unwrap_some_bool ((value (option bool))) -> bool` +- `beta-supported` `unwrap_or_bool ((value (option bool)) (fallback bool)) -> bool` +- `beta-supported` `some_or_err_bool ((value (option bool)) (err_code i32)) -> (result bool i32)` +- `beta-supported` `some_string ((value string)) -> (option string)` +- `beta-supported` `none_string () -> (option string)` +- `beta-supported` `is_some_string ((value (option string))) -> bool` +- `beta-supported` `is_none_string ((value (option string))) -> bool` +- `beta-supported` `unwrap_some_string ((value (option string))) -> string` +- `beta-supported` `unwrap_or_string ((value (option string)) (fallback string)) -> string` +- `beta-supported` `some_or_err_string ((value (option string)) (err_code i32)) -> (result string i32)` ### std.process - Path: `lib/std/process.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 31 -- `argc () -> i32` -- `arg ((index i32)) -> string` -- `arg_result ((index i32)) -> (result string i32)` -- `arg_option ((index i32)) -> (option string)` -- `has_arg ((index i32)) -> bool` -- `arg_or ((index i32) (fallback string)) -> string` -- `arg_or_empty ((index i32)) -> string` -- `arg_i32_result ((index i32)) -> (result i32 i32)` -- `arg_i32_option ((index i32)) -> (option i32)` -- `arg_i32_or_zero ((index i32)) -> i32` -- `arg_i32_or ((index i32) (fallback i32)) -> i32` -- `arg_u32_result ((index i32)) -> (result u32 i32)` -- `arg_u32_option ((index i32)) -> (option u32)` -- `arg_u32_or_zero ((index i32)) -> u32` -- `arg_u32_or ((index i32) (fallback u32)) -> u32` -- `arg_i64_result ((index i32)) -> (result i64 i32)` -- `arg_i64_option ((index i32)) -> (option i64)` -- `arg_i64_or_zero ((index i32)) -> i64` -- `arg_i64_or ((index i32) (fallback i64)) -> i64` -- `arg_u64_result ((index i32)) -> (result u64 i32)` -- `arg_u64_option ((index i32)) -> (option u64)` -- `arg_u64_or_zero ((index i32)) -> u64` -- `arg_u64_or ((index i32) (fallback u64)) -> u64` -- `arg_f64_result ((index i32)) -> (result f64 i32)` -- `arg_f64_option ((index i32)) -> (option f64)` -- `arg_f64_or_zero ((index i32)) -> f64` -- `arg_f64_or ((index i32) (fallback f64)) -> f64` -- `arg_bool_result ((index i32)) -> (result bool i32)` -- `arg_bool_option ((index i32)) -> (option bool)` -- `arg_bool_or_false ((index i32)) -> bool` -- `arg_bool_or ((index i32) (fallback bool)) -> bool` +- `beta-supported` `argc () -> i32` +- `beta-supported` `arg ((index i32)) -> string` +- `beta-supported` `arg_result ((index i32)) -> (result string i32)` +- `beta-supported` `arg_option ((index i32)) -> (option string)` +- `beta-supported` `has_arg ((index i32)) -> bool` +- `beta-supported` `arg_or ((index i32) (fallback string)) -> string` +- `beta-supported` `arg_or_empty ((index i32)) -> string` +- `beta-supported` `arg_i32_result ((index i32)) -> (result i32 i32)` +- `beta-supported` `arg_i32_option ((index i32)) -> (option i32)` +- `beta-supported` `arg_i32_or_zero ((index i32)) -> i32` +- `beta-supported` `arg_i32_or ((index i32) (fallback i32)) -> i32` +- `beta-supported` `arg_u32_result ((index i32)) -> (result u32 i32)` +- `beta-supported` `arg_u32_option ((index i32)) -> (option u32)` +- `beta-supported` `arg_u32_or_zero ((index i32)) -> u32` +- `beta-supported` `arg_u32_or ((index i32) (fallback u32)) -> u32` +- `beta-supported` `arg_i64_result ((index i32)) -> (result i64 i32)` +- `beta-supported` `arg_i64_option ((index i32)) -> (option i64)` +- `beta-supported` `arg_i64_or_zero ((index i32)) -> i64` +- `beta-supported` `arg_i64_or ((index i32) (fallback i64)) -> i64` +- `beta-supported` `arg_u64_result ((index i32)) -> (result u64 i32)` +- `beta-supported` `arg_u64_option ((index i32)) -> (option u64)` +- `beta-supported` `arg_u64_or_zero ((index i32)) -> u64` +- `beta-supported` `arg_u64_or ((index i32) (fallback u64)) -> u64` +- `beta-supported` `arg_f64_result ((index i32)) -> (result f64 i32)` +- `beta-supported` `arg_f64_option ((index i32)) -> (option f64)` +- `beta-supported` `arg_f64_or_zero ((index i32)) -> f64` +- `beta-supported` `arg_f64_or ((index i32) (fallback f64)) -> f64` +- `beta-supported` `arg_bool_result ((index i32)) -> (result bool i32)` +- `beta-supported` `arg_bool_option ((index i32)) -> (option bool)` +- `beta-supported` `arg_bool_or_false ((index i32)) -> bool` +- `beta-supported` `arg_bool_or ((index i32) (fallback bool)) -> bool` ### std.random - Path: `lib/std/random.slo` -- Tier: `beta-supported` +- Tiers: `experimental` - Exported helper signatures: 2 -- `random_i32 () -> i32` -- `random_i32_non_negative () -> bool` +- `experimental` `random_i32 () -> i32` +- `experimental` `random_i32_non_negative () -> bool` ### std.result - Path: `lib/std/result.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 56 -- `ok_i32 ((value i32)) -> (result i32 i32)` -- `err_i32 ((code i32)) -> (result i32 i32)` -- `is_ok_i32 ((value (result i32 i32))) -> bool` -- `is_err_i32 ((value (result i32 i32))) -> bool` -- `unwrap_ok_i32 ((value (result i32 i32))) -> i32` -- `unwrap_err_i32 ((value (result i32 i32))) -> i32` -- `unwrap_or_i32 ((value (result i32 i32)) (fallback i32)) -> i32` -- `ok_or_none_i32 ((value (result i32 i32))) -> (option i32)` -- `ok_u32 ((value u32)) -> (result u32 i32)` -- `err_u32 ((code i32)) -> (result u32 i32)` -- `is_ok_u32 ((value (result u32 i32))) -> bool` -- `is_err_u32 ((value (result u32 i32))) -> bool` -- `unwrap_ok_u32 ((value (result u32 i32))) -> u32` -- `unwrap_err_u32 ((value (result u32 i32))) -> i32` -- `unwrap_or_u32 ((value (result u32 i32)) (fallback u32)) -> u32` -- `ok_or_none_u32 ((value (result u32 i32))) -> (option u32)` -- `ok_i64 ((value i64)) -> (result i64 i32)` -- `err_i64 ((code i32)) -> (result i64 i32)` -- `is_ok_i64 ((value (result i64 i32))) -> bool` -- `is_err_i64 ((value (result i64 i32))) -> bool` -- `unwrap_ok_i64 ((value (result i64 i32))) -> i64` -- `unwrap_err_i64 ((value (result i64 i32))) -> i32` -- `unwrap_or_i64 ((value (result i64 i32)) (fallback i64)) -> i64` -- `ok_or_none_i64 ((value (result i64 i32))) -> (option i64)` -- `ok_u64 ((value u64)) -> (result u64 i32)` -- `err_u64 ((code i32)) -> (result u64 i32)` -- `is_ok_u64 ((value (result u64 i32))) -> bool` -- `is_err_u64 ((value (result u64 i32))) -> bool` -- `unwrap_ok_u64 ((value (result u64 i32))) -> u64` -- `unwrap_err_u64 ((value (result u64 i32))) -> i32` -- `unwrap_or_u64 ((value (result u64 i32)) (fallback u64)) -> u64` -- `ok_or_none_u64 ((value (result u64 i32))) -> (option u64)` -- `ok_string ((value string)) -> (result string i32)` -- `err_string ((code i32)) -> (result string i32)` -- `is_ok_string ((value (result string i32))) -> bool` -- `is_err_string ((value (result string i32))) -> bool` -- `unwrap_ok_string ((value (result string i32))) -> string` -- `unwrap_err_string ((value (result string i32))) -> i32` -- `unwrap_or_string ((value (result string i32)) (fallback string)) -> string` -- `ok_or_none_string ((value (result string i32))) -> (option string)` -- `ok_f64 ((value f64)) -> (result f64 i32)` -- `err_f64 ((code i32)) -> (result f64 i32)` -- `is_ok_f64 ((value (result f64 i32))) -> bool` -- `is_err_f64 ((value (result f64 i32))) -> bool` -- `unwrap_ok_f64 ((value (result f64 i32))) -> f64` -- `unwrap_err_f64 ((value (result f64 i32))) -> i32` -- `unwrap_or_f64 ((value (result f64 i32)) (fallback f64)) -> f64` -- `ok_or_none_f64 ((value (result f64 i32))) -> (option f64)` -- `ok_bool ((value bool)) -> (result bool i32)` -- `err_bool ((code i32)) -> (result bool i32)` -- `is_ok_bool ((value (result bool i32))) -> bool` -- `is_err_bool ((value (result bool i32))) -> bool` -- `unwrap_ok_bool ((value (result bool i32))) -> bool` -- `unwrap_err_bool ((value (result bool i32))) -> i32` -- `unwrap_or_bool ((value (result bool i32)) (fallback bool)) -> bool` -- `ok_or_none_bool ((value (result bool i32))) -> (option bool)` +- `beta-supported` `ok_i32 ((value i32)) -> (result i32 i32)` +- `beta-supported` `err_i32 ((code i32)) -> (result i32 i32)` +- `beta-supported` `is_ok_i32 ((value (result i32 i32))) -> bool` +- `beta-supported` `is_err_i32 ((value (result i32 i32))) -> bool` +- `beta-supported` `unwrap_ok_i32 ((value (result i32 i32))) -> i32` +- `beta-supported` `unwrap_err_i32 ((value (result i32 i32))) -> i32` +- `beta-supported` `unwrap_or_i32 ((value (result i32 i32)) (fallback i32)) -> i32` +- `beta-supported` `ok_or_none_i32 ((value (result i32 i32))) -> (option i32)` +- `beta-supported` `ok_u32 ((value u32)) -> (result u32 i32)` +- `beta-supported` `err_u32 ((code i32)) -> (result u32 i32)` +- `beta-supported` `is_ok_u32 ((value (result u32 i32))) -> bool` +- `beta-supported` `is_err_u32 ((value (result u32 i32))) -> bool` +- `beta-supported` `unwrap_ok_u32 ((value (result u32 i32))) -> u32` +- `beta-supported` `unwrap_err_u32 ((value (result u32 i32))) -> i32` +- `beta-supported` `unwrap_or_u32 ((value (result u32 i32)) (fallback u32)) -> u32` +- `beta-supported` `ok_or_none_u32 ((value (result u32 i32))) -> (option u32)` +- `beta-supported` `ok_i64 ((value i64)) -> (result i64 i32)` +- `beta-supported` `err_i64 ((code i32)) -> (result i64 i32)` +- `beta-supported` `is_ok_i64 ((value (result i64 i32))) -> bool` +- `beta-supported` `is_err_i64 ((value (result i64 i32))) -> bool` +- `beta-supported` `unwrap_ok_i64 ((value (result i64 i32))) -> i64` +- `beta-supported` `unwrap_err_i64 ((value (result i64 i32))) -> i32` +- `beta-supported` `unwrap_or_i64 ((value (result i64 i32)) (fallback i64)) -> i64` +- `beta-supported` `ok_or_none_i64 ((value (result i64 i32))) -> (option i64)` +- `beta-supported` `ok_u64 ((value u64)) -> (result u64 i32)` +- `beta-supported` `err_u64 ((code i32)) -> (result u64 i32)` +- `beta-supported` `is_ok_u64 ((value (result u64 i32))) -> bool` +- `beta-supported` `is_err_u64 ((value (result u64 i32))) -> bool` +- `beta-supported` `unwrap_ok_u64 ((value (result u64 i32))) -> u64` +- `beta-supported` `unwrap_err_u64 ((value (result u64 i32))) -> i32` +- `beta-supported` `unwrap_or_u64 ((value (result u64 i32)) (fallback u64)) -> u64` +- `beta-supported` `ok_or_none_u64 ((value (result u64 i32))) -> (option u64)` +- `beta-supported` `ok_string ((value string)) -> (result string i32)` +- `beta-supported` `err_string ((code i32)) -> (result string i32)` +- `beta-supported` `is_ok_string ((value (result string i32))) -> bool` +- `beta-supported` `is_err_string ((value (result string i32))) -> bool` +- `beta-supported` `unwrap_ok_string ((value (result string i32))) -> string` +- `beta-supported` `unwrap_err_string ((value (result string i32))) -> i32` +- `beta-supported` `unwrap_or_string ((value (result string i32)) (fallback string)) -> string` +- `beta-supported` `ok_or_none_string ((value (result string i32))) -> (option string)` +- `beta-supported` `ok_f64 ((value f64)) -> (result f64 i32)` +- `beta-supported` `err_f64 ((code i32)) -> (result f64 i32)` +- `beta-supported` `is_ok_f64 ((value (result f64 i32))) -> bool` +- `beta-supported` `is_err_f64 ((value (result f64 i32))) -> bool` +- `beta-supported` `unwrap_ok_f64 ((value (result f64 i32))) -> f64` +- `beta-supported` `unwrap_err_f64 ((value (result f64 i32))) -> i32` +- `beta-supported` `unwrap_or_f64 ((value (result f64 i32)) (fallback f64)) -> f64` +- `beta-supported` `ok_or_none_f64 ((value (result f64 i32))) -> (option f64)` +- `beta-supported` `ok_bool ((value bool)) -> (result bool i32)` +- `beta-supported` `err_bool ((code i32)) -> (result bool i32)` +- `beta-supported` `is_ok_bool ((value (result bool i32))) -> bool` +- `beta-supported` `is_err_bool ((value (result bool i32))) -> bool` +- `beta-supported` `unwrap_ok_bool ((value (result bool i32))) -> bool` +- `beta-supported` `unwrap_err_bool ((value (result bool i32))) -> i32` +- `beta-supported` `unwrap_or_bool ((value (result bool i32)) (fallback bool)) -> bool` +- `beta-supported` `ok_or_none_bool ((value (result bool i32))) -> (option bool)` ### std.string - Path: `lib/std/string.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 36 -- `len ((value string)) -> i32` -- `concat ((left string) (right string)) -> string` -- `byte_at_result ((value string) (index i32)) -> (result i32 i32)` -- `slice_result ((value string) (start i32) (count i32)) -> (result string i32)` -- `starts_with ((value string) (prefix string)) -> bool` -- `ends_with ((value string) (suffix string)) -> bool` -- `contains ((value string) (needle string)) -> bool` -- `index_of_option ((value string) (needle string)) -> (option i32)` -- `last_index_of_option ((value string) (needle string)) -> (option i32)` -- `trim_ascii_start ((value string)) -> string` -- `trim_ascii_end ((value string)) -> string` -- `trim_ascii ((value string)) -> string` -- `parse_i32_result ((value string)) -> (result i32 i32)` -- `parse_i32_option ((value string)) -> (option i32)` -- `parse_u32_result ((value string)) -> (result u32 i32)` -- `parse_u32_option ((value string)) -> (option u32)` -- `parse_i64_result ((value string)) -> (result i64 i32)` -- `parse_i64_option ((value string)) -> (option i64)` -- `parse_u64_result ((value string)) -> (result u64 i32)` -- `parse_u64_option ((value string)) -> (option u64)` -- `parse_f64_result ((value string)) -> (result f64 i32)` -- `parse_f64_option ((value string)) -> (option f64)` -- `parse_bool_result ((value string)) -> (result bool i32)` -- `parse_bool_option ((value string)) -> (option bool)` -- `parse_i32_or_zero ((value string)) -> i32` -- `parse_u32_or_zero ((value string)) -> u32` -- `parse_i64_or_zero ((value string)) -> i64` -- `parse_u64_or_zero ((value string)) -> u64` -- `parse_f64_or_zero ((value string)) -> f64` -- `parse_bool_or_false ((value string)) -> bool` -- `parse_i32_or ((value string) (fallback i32)) -> i32` -- `parse_u32_or ((value string) (fallback u32)) -> u32` -- `parse_i64_or ((value string) (fallback i64)) -> i64` -- `parse_u64_or ((value string) (fallback u64)) -> u64` -- `parse_f64_or ((value string) (fallback f64)) -> f64` -- `parse_bool_or ((value string) (fallback bool)) -> bool` +- `beta-supported` `len ((value string)) -> i32` +- `beta-supported` `concat ((left string) (right string)) -> string` +- `beta-supported` `byte_at_result ((value string) (index i32)) -> (result i32 i32)` +- `beta-supported` `slice_result ((value string) (start i32) (count i32)) -> (result string i32)` +- `beta-supported` `starts_with ((value string) (prefix string)) -> bool` +- `beta-supported` `ends_with ((value string) (suffix string)) -> bool` +- `beta-supported` `contains ((value string) (needle string)) -> bool` +- `beta-supported` `index_of_option ((value string) (needle string)) -> (option i32)` +- `beta-supported` `last_index_of_option ((value string) (needle string)) -> (option i32)` +- `beta-supported` `trim_ascii_start ((value string)) -> string` +- `beta-supported` `trim_ascii_end ((value string)) -> string` +- `beta-supported` `trim_ascii ((value string)) -> string` +- `beta-supported` `parse_i32_result ((value string)) -> (result i32 i32)` +- `beta-supported` `parse_i32_option ((value string)) -> (option i32)` +- `beta-supported` `parse_u32_result ((value string)) -> (result u32 i32)` +- `beta-supported` `parse_u32_option ((value string)) -> (option u32)` +- `beta-supported` `parse_i64_result ((value string)) -> (result i64 i32)` +- `beta-supported` `parse_i64_option ((value string)) -> (option i64)` +- `beta-supported` `parse_u64_result ((value string)) -> (result u64 i32)` +- `beta-supported` `parse_u64_option ((value string)) -> (option u64)` +- `beta-supported` `parse_f64_result ((value string)) -> (result f64 i32)` +- `beta-supported` `parse_f64_option ((value string)) -> (option f64)` +- `beta-supported` `parse_bool_result ((value string)) -> (result bool i32)` +- `beta-supported` `parse_bool_option ((value string)) -> (option bool)` +- `beta-supported` `parse_i32_or_zero ((value string)) -> i32` +- `beta-supported` `parse_u32_or_zero ((value string)) -> u32` +- `beta-supported` `parse_i64_or_zero ((value string)) -> i64` +- `beta-supported` `parse_u64_or_zero ((value string)) -> u64` +- `beta-supported` `parse_f64_or_zero ((value string)) -> f64` +- `beta-supported` `parse_bool_or_false ((value string)) -> bool` +- `beta-supported` `parse_i32_or ((value string) (fallback i32)) -> i32` +- `beta-supported` `parse_u32_or ((value string) (fallback u32)) -> u32` +- `beta-supported` `parse_i64_or ((value string) (fallback i64)) -> i64` +- `beta-supported` `parse_u64_or ((value string) (fallback u64)) -> u64` +- `beta-supported` `parse_f64_or ((value string) (fallback f64)) -> f64` +- `beta-supported` `parse_bool_or ((value string) (fallback bool)) -> bool` ### std.time - Path: `lib/std/time.slo` -- Tier: `beta-supported` +- Tiers: `experimental` - Exported helper signatures: 2 -- `monotonic_ms () -> i32` -- `sleep_ms_zero () -> i32` +- `experimental` `monotonic_ms () -> i32` +- `experimental` `sleep_ms_zero () -> i32` ### std.vec_bool - Path: `lib/std/vec_bool.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 35 +- Note: concrete-only vector helper family; no generic collection freeze. -- `empty () -> (vec bool)` -- `append ((values (vec bool)) (value bool)) -> (vec bool)` -- `len ((values (vec bool))) -> i32` -- `at ((values (vec bool)) (position i32)) -> bool` -- `singleton ((value bool)) -> (vec bool)` -- `append2 ((values (vec bool)) (first bool) (second bool)) -> (vec bool)` -- `append3 ((values (vec bool)) (first bool) (second bool) (third bool)) -> (vec bool)` -- `pair ((first bool) (second bool)) -> (vec bool)` -- `triple ((first bool) (second bool) (third bool)) -> (vec bool)` -- `is_empty ((values (vec bool))) -> bool` -- `index_or ((values (vec bool)) (position i32) (fallback bool)) -> bool` -- `first_or ((values (vec bool)) (fallback bool)) -> bool` -- `last_or ((values (vec bool)) (fallback bool)) -> bool` -- `index_option ((values (vec bool)) (position i32)) -> (option bool)` -- `first_option ((values (vec bool))) -> (option bool)` -- `last_option ((values (vec bool))) -> (option bool)` -- `index_of_option ((values (vec bool)) (target bool)) -> (option i32)` -- `last_index_of_option ((values (vec bool)) (target bool)) -> (option i32)` -- `contains ((values (vec bool)) (target bool)) -> bool` -- `count_of ((values (vec bool)) (target bool)) -> i32` -- `concat ((left (vec bool)) (right (vec bool))) -> (vec bool)` -- `take ((values (vec bool)) (count i32)) -> (vec bool)` -- `starts_with ((values (vec bool)) (prefix (vec bool))) -> bool` -- `without_prefix ((values (vec bool)) (prefix (vec bool))) -> (vec bool)` -- `ends_with ((values (vec bool)) (suffix (vec bool))) -> bool` -- `without_suffix ((values (vec bool)) (suffix (vec bool))) -> (vec bool)` -- `drop ((values (vec bool)) (count i32)) -> (vec bool)` -- `reverse ((values (vec bool))) -> (vec bool)` -- `subvec ((values (vec bool)) (start i32) (end_exclusive i32)) -> (vec bool)` -- `insert_at ((values (vec bool)) (position i32) (value bool)) -> (vec bool)` -- `insert_range ((values (vec bool)) (position i32) (inserted (vec bool))) -> (vec bool)` -- `replace_at ((values (vec bool)) (position i32) (replacement bool)) -> (vec bool)` -- `replace_range ((values (vec bool)) (start i32) (end_exclusive i32) (replacement (vec bool))) -> (vec bool)` -- `remove_at ((values (vec bool)) (position i32)) -> (vec bool)` -- `remove_range ((values (vec bool)) (start i32) (end_exclusive i32)) -> (vec bool)` +- `beta-supported` `empty () -> (vec bool)` +- `beta-supported` `append ((values (vec bool)) (value bool)) -> (vec bool)` +- `beta-supported` `len ((values (vec bool))) -> i32` +- `beta-supported` `at ((values (vec bool)) (position i32)) -> bool` +- `beta-supported` `singleton ((value bool)) -> (vec bool)` +- `beta-supported` `append2 ((values (vec bool)) (first bool) (second bool)) -> (vec bool)` +- `beta-supported` `append3 ((values (vec bool)) (first bool) (second bool) (third bool)) -> (vec bool)` +- `beta-supported` `pair ((first bool) (second bool)) -> (vec bool)` +- `beta-supported` `triple ((first bool) (second bool) (third bool)) -> (vec bool)` +- `beta-supported` `is_empty ((values (vec bool))) -> bool` +- `beta-supported` `index_or ((values (vec bool)) (position i32) (fallback bool)) -> bool` +- `beta-supported` `first_or ((values (vec bool)) (fallback bool)) -> bool` +- `beta-supported` `last_or ((values (vec bool)) (fallback bool)) -> bool` +- `beta-supported` `index_option ((values (vec bool)) (position i32)) -> (option bool)` +- `beta-supported` `first_option ((values (vec bool))) -> (option bool)` +- `beta-supported` `last_option ((values (vec bool))) -> (option bool)` +- `beta-supported` `index_of_option ((values (vec bool)) (target bool)) -> (option i32)` +- `beta-supported` `last_index_of_option ((values (vec bool)) (target bool)) -> (option i32)` +- `beta-supported` `contains ((values (vec bool)) (target bool)) -> bool` +- `beta-supported` `count_of ((values (vec bool)) (target bool)) -> i32` +- `beta-supported` `concat ((left (vec bool)) (right (vec bool))) -> (vec bool)` +- `beta-supported` `take ((values (vec bool)) (count i32)) -> (vec bool)` +- `beta-supported` `starts_with ((values (vec bool)) (prefix (vec bool))) -> bool` +- `beta-supported` `without_prefix ((values (vec bool)) (prefix (vec bool))) -> (vec bool)` +- `beta-supported` `ends_with ((values (vec bool)) (suffix (vec bool))) -> bool` +- `beta-supported` `without_suffix ((values (vec bool)) (suffix (vec bool))) -> (vec bool)` +- `beta-supported` `drop ((values (vec bool)) (count i32)) -> (vec bool)` +- `beta-supported` `reverse ((values (vec bool))) -> (vec bool)` +- `beta-supported` `subvec ((values (vec bool)) (start i32) (end_exclusive i32)) -> (vec bool)` +- `beta-supported` `insert_at ((values (vec bool)) (position i32) (value bool)) -> (vec bool)` +- `beta-supported` `insert_range ((values (vec bool)) (position i32) (inserted (vec bool))) -> (vec bool)` +- `beta-supported` `replace_at ((values (vec bool)) (position i32) (replacement bool)) -> (vec bool)` +- `beta-supported` `replace_range ((values (vec bool)) (start i32) (end_exclusive i32) (replacement (vec bool))) -> (vec bool)` +- `beta-supported` `remove_at ((values (vec bool)) (position i32)) -> (vec bool)` +- `beta-supported` `remove_range ((values (vec bool)) (start i32) (end_exclusive i32)) -> (vec bool)` ### std.vec_f64 - Path: `lib/std/vec_f64.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 36 +- Note: concrete-only vector helper family; no generic collection freeze. -- `empty () -> (vec f64)` -- `append ((values (vec f64)) (value f64)) -> (vec f64)` -- `len ((values (vec f64))) -> i32` -- `at ((values (vec f64)) (position i32)) -> f64` -- `singleton ((value f64)) -> (vec f64)` -- `append2 ((values (vec f64)) (first f64) (second f64)) -> (vec f64)` -- `append3 ((values (vec f64)) (first f64) (second f64) (third f64)) -> (vec f64)` -- `pair ((first f64) (second f64)) -> (vec f64)` -- `triple ((first f64) (second f64) (third f64)) -> (vec f64)` -- `is_empty ((values (vec f64))) -> bool` -- `index_or ((values (vec f64)) (position i32) (fallback f64)) -> f64` -- `first_or ((values (vec f64)) (fallback f64)) -> f64` -- `last_or ((values (vec f64)) (fallback f64)) -> f64` -- `index_option ((values (vec f64)) (position i32)) -> (option f64)` -- `first_option ((values (vec f64))) -> (option f64)` -- `last_option ((values (vec f64))) -> (option f64)` -- `index_of_option ((values (vec f64)) (target f64)) -> (option i32)` -- `last_index_of_option ((values (vec f64)) (target f64)) -> (option i32)` -- `contains ((values (vec f64)) (target f64)) -> bool` -- `count_of ((values (vec f64)) (target f64)) -> i32` -- `sum ((values (vec f64))) -> f64` -- `concat ((left (vec f64)) (right (vec f64))) -> (vec f64)` -- `take ((values (vec f64)) (count i32)) -> (vec f64)` -- `starts_with ((values (vec f64)) (prefix (vec f64))) -> bool` -- `without_prefix ((values (vec f64)) (prefix (vec f64))) -> (vec f64)` -- `ends_with ((values (vec f64)) (suffix (vec f64))) -> bool` -- `without_suffix ((values (vec f64)) (suffix (vec f64))) -> (vec f64)` -- `drop ((values (vec f64)) (count i32)) -> (vec f64)` -- `reverse ((values (vec f64))) -> (vec f64)` -- `subvec ((values (vec f64)) (start i32) (end_exclusive i32)) -> (vec f64)` -- `insert_at ((values (vec f64)) (position i32) (value f64)) -> (vec f64)` -- `insert_range ((values (vec f64)) (position i32) (inserted (vec f64))) -> (vec f64)` -- `replace_at ((values (vec f64)) (position i32) (replacement f64)) -> (vec f64)` -- `replace_range ((values (vec f64)) (start i32) (end_exclusive i32) (replacement (vec f64))) -> (vec f64)` -- `remove_at ((values (vec f64)) (position i32)) -> (vec f64)` -- `remove_range ((values (vec f64)) (start i32) (end_exclusive i32)) -> (vec f64)` +- `beta-supported` `empty () -> (vec f64)` +- `beta-supported` `append ((values (vec f64)) (value f64)) -> (vec f64)` +- `beta-supported` `len ((values (vec f64))) -> i32` +- `beta-supported` `at ((values (vec f64)) (position i32)) -> f64` +- `beta-supported` `singleton ((value f64)) -> (vec f64)` +- `beta-supported` `append2 ((values (vec f64)) (first f64) (second f64)) -> (vec f64)` +- `beta-supported` `append3 ((values (vec f64)) (first f64) (second f64) (third f64)) -> (vec f64)` +- `beta-supported` `pair ((first f64) (second f64)) -> (vec f64)` +- `beta-supported` `triple ((first f64) (second f64) (third f64)) -> (vec f64)` +- `beta-supported` `is_empty ((values (vec f64))) -> bool` +- `beta-supported` `index_or ((values (vec f64)) (position i32) (fallback f64)) -> f64` +- `beta-supported` `first_or ((values (vec f64)) (fallback f64)) -> f64` +- `beta-supported` `last_or ((values (vec f64)) (fallback f64)) -> f64` +- `beta-supported` `index_option ((values (vec f64)) (position i32)) -> (option f64)` +- `beta-supported` `first_option ((values (vec f64))) -> (option f64)` +- `beta-supported` `last_option ((values (vec f64))) -> (option f64)` +- `beta-supported` `index_of_option ((values (vec f64)) (target f64)) -> (option i32)` +- `beta-supported` `last_index_of_option ((values (vec f64)) (target f64)) -> (option i32)` +- `beta-supported` `contains ((values (vec f64)) (target f64)) -> bool` +- `beta-supported` `count_of ((values (vec f64)) (target f64)) -> i32` +- `beta-supported` `sum ((values (vec f64))) -> f64` +- `beta-supported` `concat ((left (vec f64)) (right (vec f64))) -> (vec f64)` +- `beta-supported` `take ((values (vec f64)) (count i32)) -> (vec f64)` +- `beta-supported` `starts_with ((values (vec f64)) (prefix (vec f64))) -> bool` +- `beta-supported` `without_prefix ((values (vec f64)) (prefix (vec f64))) -> (vec f64)` +- `beta-supported` `ends_with ((values (vec f64)) (suffix (vec f64))) -> bool` +- `beta-supported` `without_suffix ((values (vec f64)) (suffix (vec f64))) -> (vec f64)` +- `beta-supported` `drop ((values (vec f64)) (count i32)) -> (vec f64)` +- `beta-supported` `reverse ((values (vec f64))) -> (vec f64)` +- `beta-supported` `subvec ((values (vec f64)) (start i32) (end_exclusive i32)) -> (vec f64)` +- `beta-supported` `insert_at ((values (vec f64)) (position i32) (value f64)) -> (vec f64)` +- `beta-supported` `insert_range ((values (vec f64)) (position i32) (inserted (vec f64))) -> (vec f64)` +- `beta-supported` `replace_at ((values (vec f64)) (position i32) (replacement f64)) -> (vec f64)` +- `beta-supported` `replace_range ((values (vec f64)) (start i32) (end_exclusive i32) (replacement (vec f64))) -> (vec f64)` +- `beta-supported` `remove_at ((values (vec f64)) (position i32)) -> (vec f64)` +- `beta-supported` `remove_range ((values (vec f64)) (start i32) (end_exclusive i32)) -> (vec f64)` ### std.vec_i32 - Path: `lib/std/vec_i32.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 39 +- Note: concrete-only vector helper family; no generic collection freeze. -- `empty () -> (vec i32)` -- `append ((values (vec i32)) (value i32)) -> (vec i32)` -- `len ((values (vec i32))) -> i32` -- `at ((values (vec i32)) (position i32)) -> i32` -- `singleton ((value i32)) -> (vec i32)` -- `append2 ((values (vec i32)) (first i32) (second i32)) -> (vec i32)` -- `append3 ((values (vec i32)) (first i32) (second i32) (third i32)) -> (vec i32)` -- `pair ((first i32) (second i32)) -> (vec i32)` -- `triple ((first i32) (second i32) (third i32)) -> (vec i32)` -- `repeat ((value i32) (count i32)) -> (vec i32)` -- `range ((start i32) (end_exclusive i32)) -> (vec i32)` -- `range_from_zero ((count i32)) -> (vec i32)` -- `is_empty ((values (vec i32))) -> bool` -- `index_or ((values (vec i32)) (position i32) (fallback i32)) -> i32` -- `first_or ((values (vec i32)) (fallback i32)) -> i32` -- `last_or ((values (vec i32)) (fallback i32)) -> i32` -- `index_option ((values (vec i32)) (position i32)) -> (option i32)` -- `first_option ((values (vec i32))) -> (option i32)` -- `last_option ((values (vec i32))) -> (option i32)` -- `index_of_option ((values (vec i32)) (target i32)) -> (option i32)` -- `last_index_of_option ((values (vec i32)) (target i32)) -> (option i32)` -- `count_of ((values (vec i32)) (target i32)) -> i32` -- `contains ((values (vec i32)) (target i32)) -> bool` -- `sum ((values (vec i32))) -> i32` -- `concat ((left (vec i32)) (right (vec i32))) -> (vec i32)` -- `take ((values (vec i32)) (count i32)) -> (vec i32)` -- `starts_with ((values (vec i32)) (prefix (vec i32))) -> bool` -- `without_prefix ((values (vec i32)) (prefix (vec i32))) -> (vec i32)` -- `ends_with ((values (vec i32)) (suffix (vec i32))) -> bool` -- `without_suffix ((values (vec i32)) (suffix (vec i32))) -> (vec i32)` -- `drop ((values (vec i32)) (count i32)) -> (vec i32)` -- `reverse ((values (vec i32))) -> (vec i32)` -- `subvec ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)` -- `insert_at ((values (vec i32)) (position i32) (value i32)) -> (vec i32)` -- `insert_range ((values (vec i32)) (position i32) (inserted (vec i32))) -> (vec i32)` -- `replace_at ((values (vec i32)) (position i32) (replacement i32)) -> (vec i32)` -- `replace_range ((values (vec i32)) (start i32) (end_exclusive i32) (replacement (vec i32))) -> (vec i32)` -- `remove_at ((values (vec i32)) (position i32)) -> (vec i32)` -- `remove_range ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)` +- `beta-supported` `empty () -> (vec i32)` +- `beta-supported` `append ((values (vec i32)) (value i32)) -> (vec i32)` +- `beta-supported` `len ((values (vec i32))) -> i32` +- `beta-supported` `at ((values (vec i32)) (position i32)) -> i32` +- `beta-supported` `singleton ((value i32)) -> (vec i32)` +- `beta-supported` `append2 ((values (vec i32)) (first i32) (second i32)) -> (vec i32)` +- `beta-supported` `append3 ((values (vec i32)) (first i32) (second i32) (third i32)) -> (vec i32)` +- `beta-supported` `pair ((first i32) (second i32)) -> (vec i32)` +- `beta-supported` `triple ((first i32) (second i32) (third i32)) -> (vec i32)` +- `beta-supported` `repeat ((value i32) (count i32)) -> (vec i32)` +- `beta-supported` `range ((start i32) (end_exclusive i32)) -> (vec i32)` +- `beta-supported` `range_from_zero ((count i32)) -> (vec i32)` +- `beta-supported` `is_empty ((values (vec i32))) -> bool` +- `beta-supported` `index_or ((values (vec i32)) (position i32) (fallback i32)) -> i32` +- `beta-supported` `first_or ((values (vec i32)) (fallback i32)) -> i32` +- `beta-supported` `last_or ((values (vec i32)) (fallback i32)) -> i32` +- `beta-supported` `index_option ((values (vec i32)) (position i32)) -> (option i32)` +- `beta-supported` `first_option ((values (vec i32))) -> (option i32)` +- `beta-supported` `last_option ((values (vec i32))) -> (option i32)` +- `beta-supported` `index_of_option ((values (vec i32)) (target i32)) -> (option i32)` +- `beta-supported` `last_index_of_option ((values (vec i32)) (target i32)) -> (option i32)` +- `beta-supported` `count_of ((values (vec i32)) (target i32)) -> i32` +- `beta-supported` `contains ((values (vec i32)) (target i32)) -> bool` +- `beta-supported` `sum ((values (vec i32))) -> i32` +- `beta-supported` `concat ((left (vec i32)) (right (vec i32))) -> (vec i32)` +- `beta-supported` `take ((values (vec i32)) (count i32)) -> (vec i32)` +- `beta-supported` `starts_with ((values (vec i32)) (prefix (vec i32))) -> bool` +- `beta-supported` `without_prefix ((values (vec i32)) (prefix (vec i32))) -> (vec i32)` +- `beta-supported` `ends_with ((values (vec i32)) (suffix (vec i32))) -> bool` +- `beta-supported` `without_suffix ((values (vec i32)) (suffix (vec i32))) -> (vec i32)` +- `beta-supported` `drop ((values (vec i32)) (count i32)) -> (vec i32)` +- `beta-supported` `reverse ((values (vec i32))) -> (vec i32)` +- `beta-supported` `subvec ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)` +- `beta-supported` `insert_at ((values (vec i32)) (position i32) (value i32)) -> (vec i32)` +- `beta-supported` `insert_range ((values (vec i32)) (position i32) (inserted (vec i32))) -> (vec i32)` +- `beta-supported` `replace_at ((values (vec i32)) (position i32) (replacement i32)) -> (vec i32)` +- `beta-supported` `replace_range ((values (vec i32)) (start i32) (end_exclusive i32) (replacement (vec i32))) -> (vec i32)` +- `beta-supported` `remove_at ((values (vec i32)) (position i32)) -> (vec i32)` +- `beta-supported` `remove_range ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)` ### std.vec_i64 - Path: `lib/std/vec_i64.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 36 +- Note: concrete-only vector helper family; no generic collection freeze. -- `empty () -> (vec i64)` -- `append ((values (vec i64)) (value i64)) -> (vec i64)` -- `len ((values (vec i64))) -> i32` -- `at ((values (vec i64)) (position i32)) -> i64` -- `singleton ((value i64)) -> (vec i64)` -- `append2 ((values (vec i64)) (first i64) (second i64)) -> (vec i64)` -- `append3 ((values (vec i64)) (first i64) (second i64) (third i64)) -> (vec i64)` -- `pair ((first i64) (second i64)) -> (vec i64)` -- `triple ((first i64) (second i64) (third i64)) -> (vec i64)` -- `is_empty ((values (vec i64))) -> bool` -- `index_or ((values (vec i64)) (position i32) (fallback i64)) -> i64` -- `first_or ((values (vec i64)) (fallback i64)) -> i64` -- `last_or ((values (vec i64)) (fallback i64)) -> i64` -- `index_option ((values (vec i64)) (position i32)) -> (option i64)` -- `first_option ((values (vec i64))) -> (option i64)` -- `last_option ((values (vec i64))) -> (option i64)` -- `index_of_option ((values (vec i64)) (target i64)) -> (option i32)` -- `last_index_of_option ((values (vec i64)) (target i64)) -> (option i32)` -- `contains ((values (vec i64)) (target i64)) -> bool` -- `count_of ((values (vec i64)) (target i64)) -> i32` -- `sum ((values (vec i64))) -> i64` -- `concat ((left (vec i64)) (right (vec i64))) -> (vec i64)` -- `take ((values (vec i64)) (count i32)) -> (vec i64)` -- `starts_with ((values (vec i64)) (prefix (vec i64))) -> bool` -- `without_prefix ((values (vec i64)) (prefix (vec i64))) -> (vec i64)` -- `ends_with ((values (vec i64)) (suffix (vec i64))) -> bool` -- `without_suffix ((values (vec i64)) (suffix (vec i64))) -> (vec i64)` -- `drop ((values (vec i64)) (count i32)) -> (vec i64)` -- `reverse ((values (vec i64))) -> (vec i64)` -- `subvec ((values (vec i64)) (start i32) (end_exclusive i32)) -> (vec i64)` -- `insert_at ((values (vec i64)) (position i32) (value i64)) -> (vec i64)` -- `insert_range ((values (vec i64)) (position i32) (inserted (vec i64))) -> (vec i64)` -- `replace_at ((values (vec i64)) (position i32) (replacement i64)) -> (vec i64)` -- `replace_range ((values (vec i64)) (start i32) (end_exclusive i32) (replacement (vec i64))) -> (vec i64)` -- `remove_at ((values (vec i64)) (position i32)) -> (vec i64)` -- `remove_range ((values (vec i64)) (start i32) (end_exclusive i32)) -> (vec i64)` +- `beta-supported` `empty () -> (vec i64)` +- `beta-supported` `append ((values (vec i64)) (value i64)) -> (vec i64)` +- `beta-supported` `len ((values (vec i64))) -> i32` +- `beta-supported` `at ((values (vec i64)) (position i32)) -> i64` +- `beta-supported` `singleton ((value i64)) -> (vec i64)` +- `beta-supported` `append2 ((values (vec i64)) (first i64) (second i64)) -> (vec i64)` +- `beta-supported` `append3 ((values (vec i64)) (first i64) (second i64) (third i64)) -> (vec i64)` +- `beta-supported` `pair ((first i64) (second i64)) -> (vec i64)` +- `beta-supported` `triple ((first i64) (second i64) (third i64)) -> (vec i64)` +- `beta-supported` `is_empty ((values (vec i64))) -> bool` +- `beta-supported` `index_or ((values (vec i64)) (position i32) (fallback i64)) -> i64` +- `beta-supported` `first_or ((values (vec i64)) (fallback i64)) -> i64` +- `beta-supported` `last_or ((values (vec i64)) (fallback i64)) -> i64` +- `beta-supported` `index_option ((values (vec i64)) (position i32)) -> (option i64)` +- `beta-supported` `first_option ((values (vec i64))) -> (option i64)` +- `beta-supported` `last_option ((values (vec i64))) -> (option i64)` +- `beta-supported` `index_of_option ((values (vec i64)) (target i64)) -> (option i32)` +- `beta-supported` `last_index_of_option ((values (vec i64)) (target i64)) -> (option i32)` +- `beta-supported` `contains ((values (vec i64)) (target i64)) -> bool` +- `beta-supported` `count_of ((values (vec i64)) (target i64)) -> i32` +- `beta-supported` `sum ((values (vec i64))) -> i64` +- `beta-supported` `concat ((left (vec i64)) (right (vec i64))) -> (vec i64)` +- `beta-supported` `take ((values (vec i64)) (count i32)) -> (vec i64)` +- `beta-supported` `starts_with ((values (vec i64)) (prefix (vec i64))) -> bool` +- `beta-supported` `without_prefix ((values (vec i64)) (prefix (vec i64))) -> (vec i64)` +- `beta-supported` `ends_with ((values (vec i64)) (suffix (vec i64))) -> bool` +- `beta-supported` `without_suffix ((values (vec i64)) (suffix (vec i64))) -> (vec i64)` +- `beta-supported` `drop ((values (vec i64)) (count i32)) -> (vec i64)` +- `beta-supported` `reverse ((values (vec i64))) -> (vec i64)` +- `beta-supported` `subvec ((values (vec i64)) (start i32) (end_exclusive i32)) -> (vec i64)` +- `beta-supported` `insert_at ((values (vec i64)) (position i32) (value i64)) -> (vec i64)` +- `beta-supported` `insert_range ((values (vec i64)) (position i32) (inserted (vec i64))) -> (vec i64)` +- `beta-supported` `replace_at ((values (vec i64)) (position i32) (replacement i64)) -> (vec i64)` +- `beta-supported` `replace_range ((values (vec i64)) (start i32) (end_exclusive i32) (replacement (vec i64))) -> (vec i64)` +- `beta-supported` `remove_at ((values (vec i64)) (position i32)) -> (vec i64)` +- `beta-supported` `remove_range ((values (vec i64)) (start i32) (end_exclusive i32)) -> (vec i64)` ### std.vec_string - Path: `lib/std/vec_string.slo` -- Tier: `beta-supported` +- Tiers: `beta-supported` - Exported helper signatures: 35 +- Note: concrete-only vector helper family; no generic collection freeze. -- `empty () -> (vec string)` -- `append ((values (vec string)) (value string)) -> (vec string)` -- `len ((values (vec string))) -> i32` -- `at ((values (vec string)) (position i32)) -> string` -- `singleton ((value string)) -> (vec string)` -- `append2 ((values (vec string)) (first string) (second string)) -> (vec string)` -- `append3 ((values (vec string)) (first string) (second string) (third string)) -> (vec string)` -- `pair ((first string) (second string)) -> (vec string)` -- `triple ((first string) (second string) (third string)) -> (vec string)` -- `is_empty ((values (vec string))) -> bool` -- `index_or ((values (vec string)) (position i32) (fallback string)) -> string` -- `first_or ((values (vec string)) (fallback string)) -> string` -- `last_or ((values (vec string)) (fallback string)) -> string` -- `index_option ((values (vec string)) (position i32)) -> (option string)` -- `first_option ((values (vec string))) -> (option string)` -- `last_option ((values (vec string))) -> (option string)` -- `index_of_option ((values (vec string)) (target string)) -> (option i32)` -- `last_index_of_option ((values (vec string)) (target string)) -> (option i32)` -- `contains ((values (vec string)) (target string)) -> bool` -- `count_of ((values (vec string)) (target string)) -> i32` -- `concat ((left (vec string)) (right (vec string))) -> (vec string)` -- `take ((values (vec string)) (count i32)) -> (vec string)` -- `starts_with ((values (vec string)) (prefix (vec string))) -> bool` -- `without_prefix ((values (vec string)) (prefix (vec string))) -> (vec string)` -- `ends_with ((values (vec string)) (suffix (vec string))) -> bool` -- `without_suffix ((values (vec string)) (suffix (vec string))) -> (vec string)` -- `drop ((values (vec string)) (count i32)) -> (vec string)` -- `reverse ((values (vec string))) -> (vec string)` -- `subvec ((values (vec string)) (start i32) (end_exclusive i32)) -> (vec string)` -- `insert_at ((values (vec string)) (position i32) (value string)) -> (vec string)` -- `insert_range ((values (vec string)) (position i32) (inserted (vec string))) -> (vec string)` -- `replace_at ((values (vec string)) (position i32) (replacement string)) -> (vec string)` -- `replace_range ((values (vec string)) (start i32) (end_exclusive i32) (replacement (vec string))) -> (vec string)` -- `remove_at ((values (vec string)) (position i32)) -> (vec string)` -- `remove_range ((values (vec string)) (start i32) (end_exclusive i32)) -> (vec string)` +- `beta-supported` `empty () -> (vec string)` +- `beta-supported` `append ((values (vec string)) (value string)) -> (vec string)` +- `beta-supported` `len ((values (vec string))) -> i32` +- `beta-supported` `at ((values (vec string)) (position i32)) -> string` +- `beta-supported` `singleton ((value string)) -> (vec string)` +- `beta-supported` `append2 ((values (vec string)) (first string) (second string)) -> (vec string)` +- `beta-supported` `append3 ((values (vec string)) (first string) (second string) (third string)) -> (vec string)` +- `beta-supported` `pair ((first string) (second string)) -> (vec string)` +- `beta-supported` `triple ((first string) (second string) (third string)) -> (vec string)` +- `beta-supported` `is_empty ((values (vec string))) -> bool` +- `beta-supported` `index_or ((values (vec string)) (position i32) (fallback string)) -> string` +- `beta-supported` `first_or ((values (vec string)) (fallback string)) -> string` +- `beta-supported` `last_or ((values (vec string)) (fallback string)) -> string` +- `beta-supported` `index_option ((values (vec string)) (position i32)) -> (option string)` +- `beta-supported` `first_option ((values (vec string))) -> (option string)` +- `beta-supported` `last_option ((values (vec string))) -> (option string)` +- `beta-supported` `index_of_option ((values (vec string)) (target string)) -> (option i32)` +- `beta-supported` `last_index_of_option ((values (vec string)) (target string)) -> (option i32)` +- `beta-supported` `contains ((values (vec string)) (target string)) -> bool` +- `beta-supported` `count_of ((values (vec string)) (target string)) -> i32` +- `beta-supported` `concat ((left (vec string)) (right (vec string))) -> (vec string)` +- `beta-supported` `take ((values (vec string)) (count i32)) -> (vec string)` +- `beta-supported` `starts_with ((values (vec string)) (prefix (vec string))) -> bool` +- `beta-supported` `without_prefix ((values (vec string)) (prefix (vec string))) -> (vec string)` +- `beta-supported` `ends_with ((values (vec string)) (suffix (vec string))) -> bool` +- `beta-supported` `without_suffix ((values (vec string)) (suffix (vec string))) -> (vec string)` +- `beta-supported` `drop ((values (vec string)) (count i32)) -> (vec string)` +- `beta-supported` `reverse ((values (vec string))) -> (vec string)` +- `beta-supported` `subvec ((values (vec string)) (start i32) (end_exclusive i32)) -> (vec string)` +- `beta-supported` `insert_at ((values (vec string)) (position i32) (value string)) -> (vec string)` +- `beta-supported` `insert_range ((values (vec string)) (position i32) (inserted (vec string))) -> (vec string)` +- `beta-supported` `replace_at ((values (vec string)) (position i32) (replacement string)) -> (vec string)` +- `beta-supported` `replace_range ((values (vec string)) (start i32) (end_exclusive i32) (replacement (vec string))) -> (vec string)` +- `beta-supported` `remove_at ((values (vec string)) (position i32)) -> (vec string)` +- `beta-supported` `remove_range ((values (vec string)) (start i32) (end_exclusive i32)) -> (vec string)` diff --git a/docs/language/STDLIB_TIERS.md b/docs/language/STDLIB_TIERS.md new file mode 100644 index 0000000..d1bc632 --- /dev/null +++ b/docs/language/STDLIB_TIERS.md @@ -0,0 +1,68 @@ +# Slovo Standard Library Stability Tiers + +Status: beta public ledger for `1.0.0-beta.23`. + +This document records the current maturity labels for the source-authored +standard-library facade surface. Exact exported helper signatures remain in +[`STDLIB_API.md`](STDLIB_API.md), which is generated from `lib/std/*.slo`. +This ledger explains how to read that catalog during the beta line. + +`1.0.0-beta.23` is documentation and catalog-tooling alignment only. It adds no +source syntax, standard-library helpers, compiler-known runtime names, runtime +behavior, package behavior, manifest schema guarantee, Markdown schema +guarantee, ABI/layout guarantee, or stable standard-library/API compatibility +freeze. It does make the generated API catalog emit tier metadata and makes the +release gate check that experimental tier metadata is present. + +## Tier Labels + +Slovo uses these public standard-library tier labels: + +| Tier | Meaning | +| --- | --- | +| `beta-supported` | Exported from `lib/std`, covered by current beta source-search, promotion, facade, or composition gates, and suitable for beta programs. Names and behavior are still beta contracts, not a stable `1.0.0` freeze. | +| `experimental` | Exported or documented in the beta line, but intentionally fluid because the domain still depends on deferred language, runtime, resource, platform, or schema policy. Use for feedback and narrow programs, not compatibility promises. | +| `internal` | Not public standard-library API. This includes non-exported helper names, module-local concrete aliases, implementation details, generated-document internals, and private runtime symbols. Internal names may be omitted from public catalogs or changed without migration promises. | + +## Catalog Boundary + +[`STDLIB_API.md`](STDLIB_API.md) is the generated signature inventory: it lists +exported `(fn ...)` helpers from `lib/std/*.slo`, normalizes module-local +concrete aliases to public concrete types, and omits non-exported helpers and +`(type ...)` aliases. + +This ledger is the public maturity companion to that generated catalog. If the +catalog lists a signature, read the tier marker beside that signature as the +generated summary of this ledger. The generated catalog is a beta discovery +aid, not a stable Markdown schema or stable API freeze. + +## Current Tier Ledger + +| Surface | Current tier | Notes | +| --- | --- | --- | +| `std.cli`, `std.env`, `std.io`, `std.math`, `std.num`, `std.option`, `std.process`, `std.result`, and byte-oriented `std.string` helpers | `beta-supported` | Current source facade helpers over promoted concrete runtime/value families. The beta label still allows additive changes and scoped migrations before `1.0.0`. | +| Concrete vector modules: `std.vec_i32`, `std.vec_i64`, `std.vec_f64`, `std.vec_bool`, and `std.vec_string` | `beta-supported` | These are concrete immutable vector lanes over existing concrete runtime families. This is not a generic collections freeze and does not imply executable generics, generic aliases, maps, sets, iterators, mutable vectors, slice/view APIs, runtime collection changes, or stable ABI/layout. | +| Basic filesystem text/status helpers such as `read_text`, `write_text_result`, `exists`, `is_file`, `is_dir`, `remove_file_result`, and `create_dir_result` | `beta-supported` | Current concrete file helpers remain beta contracts over host filesystem behavior. Platform-specific errors and richer host-error ADTs remain deferred. | +| Filesystem resource-handle helpers such as `open_text_read_result`, `read_open_text_result`, `close_result`, `read_text_via_handle_result`, and `close_ok` | `experimental` | Handles are beta-scoped opaque `i32` values. Writable handles, directory handles/enumeration, stable handle ABI/layout, and richer platform error policy remain deferred. | +| `std.json` | `experimental` | Includes compact JSON text construction, exact primitive scalar token parsing, ASCII string-token parsing, and scalar document parsing. Object/array parsing, recursive `JsonValue`, parser/tokenizer objects, maps/sets, streaming, broad Unicode escape policy, embedded NUL policy, stable text encoding policy, and stable JSON API compatibility remain deferred. | +| `std.net` | `experimental` | Current blocking loopback TCP facade only. DNS, TLS, UDP, async IO, non-loopback binding, HTTP frameworks, stable socket ABI/layout, and rich host-error ADTs remain deferred. | +| `std.random` and `std.time` | `experimental` | Available as narrow beta host facades, but deterministic testing policy, seeding/time-source contracts, monotonic/wall-clock distinctions, reproducibility guarantees, and stable platform behavior remain deferred. | +| Non-exported helper names, module-local aliases, private runtime symbols, generated catalog internals, and release-tool implementation details | `internal` | Not part of the public standard-library compatibility surface. | + +## Explicit Non-Changes + +This ledger does not promote: + +- source-language syntax +- standard-library helper additions, removals, or renames +- compiler-known runtime names +- runtime behavior changes +- executable generics or generic aliases +- generic stdlib dispatch +- maps, sets, iterators, mutable vectors, or slice/view APIs +- object/array JSON parsing or stable JSON schemas +- DNS, TLS, UDP, async networking, or non-loopback binding +- stable resource-handle ABI/layout +- stable artifact-manifest schema +- stable generated Markdown schema +- stable `1.0.0` standard-library/API compatibility freeze diff --git a/lib/std/README.md b/lib/std/README.md index eca9a86..30fd500 100644 --- a/lib/std/README.md +++ b/lib/std/README.md @@ -47,7 +47,8 @@ whole-document scalar parse facades over `std.string.trim_ascii` and the existing exact value-token parsers; 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. +`string` JSON fragments; `1.0.0-beta.23` adds the public +standard-library stability tier ledger without changing this helper surface. 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 @@ -170,6 +171,18 @@ 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`. +`docs/language/STDLIB_API.md` remains the generated exact signature catalog +for exported helpers in this directory. `docs/language/STDLIB_TIERS.md` is the +beta23 public maturity ledger for that catalog. It defines the tier labels +`beta-supported`, `experimental`, and `internal`; classifies JSON, loopback +networking, random/time, and filesystem resource-handle helpers as +experimental domains; and records the concrete vector modules as +beta-supported concrete lanes, not a generic collections freeze. The tier +ledger is documentation/catalog tooling clarity only and does not add helpers, +syntax, runtime behavior, stable Markdown schema, or a stable stdlib/API +freeze. The generated catalog and release gate now expose and check tier +metadata. + 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, diff --git a/scripts/check-stdlib-api-tiers.js b/scripts/check-stdlib-api-tiers.js new file mode 100755 index 0000000..af3016e --- /dev/null +++ b/scripts/check-stdlib-api-tiers.js @@ -0,0 +1,80 @@ +#!/usr/bin/env node +"use strict"; + +const fs = require("fs"); +const path = require("path"); + +const repoRoot = path.resolve(__dirname, ".."); +const catalogPath = path.join(repoRoot, "docs", "language", "STDLIB_API.md"); +const catalog = fs.readFileSync(catalogPath, "utf8"); + +function fail(message) { + console.error(`stdlib API tier check failed: ${message}`); + process.exit(1); +} + +function requireText(text, message) { + if (!catalog.includes(text)) { + fail(message); + } +} + +function moduleSection(moduleName) { + const marker = `### std.${moduleName}\n`; + const start = catalog.indexOf(marker); + if (start < 0) { + fail(`missing std.${moduleName} module section`); + } + const next = catalog.indexOf("\n### std.", start + marker.length); + return next < 0 ? catalog.slice(start) : catalog.slice(start, next); +} + +function requireModuleTier(moduleName, expectedTier) { + const section = moduleSection(moduleName); + if (!section.includes(`- Tiers: \`${expectedTier}\``)) { + fail(`std.${moduleName} is not marked as ${expectedTier}`); + } +} + +function requireHelperTier(moduleName, helperName, expectedTier) { + const section = moduleSection(moduleName); + const helperPattern = new RegExp(`^- \`${expectedTier}\` \`${helperName} `, "m"); + if (!helperPattern.test(section)) { + fail(`std.${moduleName}.${helperName} is not marked as ${expectedTier}`); + } +} + +if (/experimental`: not used|experimental not used/i.test(catalog)) { + fail("catalog still contains stale wording that says experimental is unused"); +} + +requireText("- `beta-supported`:", "missing beta-supported tier definition"); +requireText("- `experimental`:", "missing experimental tier definition"); +requireText("- `internal`:", "missing internal tier definition"); +requireText("- `experimental` helper signatures:", "missing experimental summary count"); +requireText("Concrete `std.vec_*` modules are beta-supported as concrete helper families only; this does not freeze a generic collection API.", "missing concrete vector boundary"); + +if (!/^- `experimental` `[^`]+`/m.test(catalog)) { + fail("catalog does not list any experimental helper signatures"); +} + +for (const moduleName of ["json", "net", "random", "time"]) { + requireModuleTier(moduleName, "experimental"); +} + +for (const helperName of [ + "open_text_read_result", + "read_open_text_result", + "close_result", + "read_text_via_handle_result", + "close_ok", +]) { + requireHelperTier("fs", helperName, "experimental"); +} + +for (const moduleName of ["vec_bool", "vec_f64", "vec_i32", "vec_i64", "vec_string"]) { + const section = moduleSection(moduleName); + if (!section.includes("- Note: concrete-only vector helper family; no generic collection freeze.")) { + fail(`std.${moduleName} is missing the concrete vector boundary note`); + } +} diff --git a/scripts/release-gate.sh b/scripts/release-gate.sh index fe29126..7b3a3b2 100755 --- a/scripts/release-gate.sh +++ b/scripts/release-gate.sh @@ -9,8 +9,11 @@ cd "${repo_root}" git diff --check bash -n scripts/install.sh bash -n scripts/render-stdlib-api-doc.sh +node --check scripts/render-stdlib-api-doc.js +node --check scripts/check-stdlib-api-tiers.js "${repo_root}/scripts/render-stdlib-api-doc.sh" +"${repo_root}/scripts/check-stdlib-api-tiers.js" git diff --check if ! git diff --quiet -- docs/language/STDLIB_API.md; then echo "standard library API catalog changed; review and commit generated docs before release" >&2 diff --git a/scripts/render-stdlib-api-doc.js b/scripts/render-stdlib-api-doc.js index d6878bc..fdddc79 100755 --- a/scripts/render-stdlib-api-doc.js +++ b/scripts/render-stdlib-api-doc.js @@ -9,6 +9,46 @@ const stdDir = path.join(repoRoot, "lib", "std"); const outputPath = path.join(repoRoot, "docs", "language", "STDLIB_API.md"); const readmePath = path.join(repoRoot, "README.md"); +const TIERS = Object.freeze({ + BETA_SUPPORTED: "beta-supported", + EXPERIMENTAL: "experimental", + INTERNAL: "internal", +}); + +const EXPERIMENTAL_MODULES = new Set(["json", "net", "random", "time"]); + +const EXPERIMENTAL_HELPERS = new Map([ + [ + "fs", + new Set([ + "open_text_read_result", + "read_open_text_result", + "close_result", + "read_text_via_handle_result", + "close_ok", + ]), + ], +]); + +const CONCRETE_VEC_MODULES = new Set(["vec_bool", "vec_f64", "vec_i32", "vec_i64", "vec_string"]); + +function helperTier(moduleName, exportName) { + if (EXPERIMENTAL_MODULES.has(moduleName)) { + return TIERS.EXPERIMENTAL; + } + + const experimentalHelpers = EXPERIMENTAL_HELPERS.get(moduleName); + if (experimentalHelpers && experimentalHelpers.has(exportName)) { + return TIERS.EXPERIMENTAL; + } + + return TIERS.BETA_SUPPORTED; +} + +function uniqueSorted(values) { + return Array.from(new Set(values)).sort(); +} + function tokenize(source) { const tokens = []; let index = 0; @@ -204,7 +244,11 @@ function stdModules() { for (const exported of module.exports) { if (functions.has(exported)) { - signatures.push(functionSignature(functions.get(exported), aliases, relativePath)); + signatures.push({ + name: exported, + signature: functionSignature(functions.get(exported), aliases, relativePath), + tier: helperTier(module.name, exported), + }); } else if (aliases.has(exported)) { omittedAliasExports.push(exported); } else { @@ -216,6 +260,7 @@ function stdModules() { fileName, relativePath, name: module.name, + tiers: uniqueSorted(signatures.map((signature) => signature.tier)), signatures, omittedAliasExports, }; @@ -234,6 +279,15 @@ function releaseVersion() { function render(modules, version) { const totalExports = modules.reduce((count, module) => count + module.signatures.length, 0); const totalOmittedAliases = modules.reduce((count, module) => count + module.omittedAliasExports.length, 0); + const tierCounts = new Map([ + [TIERS.BETA_SUPPORTED, 0], + [TIERS.EXPERIMENTAL, 0], + ]); + for (const module of modules) { + for (const signature of module.signatures) { + tierCounts.set(signature.tier, (tierCounts.get(signature.tier) || 0) + 1); + } + } const out = []; out.push("# Slovo Standard Library API Catalog"); out.push(""); @@ -243,12 +297,13 @@ function render(modules, version) { out.push("## Stability Tiers"); out.push(""); out.push("- `beta-supported`: exported from `lib/std` and covered by source-search, promotion, or facade gates in the current beta line."); - out.push(`- \`experimental\`: not used for exported \`lib/std\` helpers in \`${version}\`; future releases may mark new helpers this way before they graduate.`); + out.push(`- \`experimental\`: exported from \`lib/std\` in \`${version}\`, but still has beta caveats around host behavior, resource handles, or API shape.`); out.push("- `internal`: helper names that are not exported from their module; they are intentionally omitted from this catalog."); out.push(""); out.push("The catalog is a beta API discovery aid, not a stable `1.0.0` standard-library freeze."); out.push("Module-local concrete aliases are normalized in signatures so names such as `VecI32` and `ResultU64` do not leak into the public catalog."); out.push("Only exported `(fn ...)` helpers are listed; `(type ...)` aliases and non-exported helpers are omitted."); + out.push("Concrete `std.vec_*` modules are beta-supported as concrete helper families only; this does not freeze a generic collection API."); out.push(""); out.push("## Summary"); out.push(""); @@ -256,6 +311,8 @@ function render(modules, version) { out.push(`- Exported helper signatures: ${totalExports}`); out.push(`- Exported type aliases omitted: ${totalOmittedAliases}`); out.push("- Default tier: `beta-supported`"); + out.push(`- \`${TIERS.BETA_SUPPORTED}\` helper signatures: ${tierCounts.get(TIERS.BETA_SUPPORTED) || 0}`); + out.push(`- \`${TIERS.EXPERIMENTAL}\` helper signatures: ${tierCounts.get(TIERS.EXPERIMENTAL) || 0}`); out.push(""); out.push("## Modules"); out.push(""); @@ -263,11 +320,14 @@ function render(modules, version) { out.push(`### std.${module.name}`); out.push(""); out.push(`- Path: \`${module.relativePath}\``); - out.push("- Tier: `beta-supported`"); + out.push(`- Tiers: ${module.tiers.map((tier) => `\`${tier}\``).join(", ")}`); out.push(`- Exported helper signatures: ${module.signatures.length}`); + if (CONCRETE_VEC_MODULES.has(module.name)) { + out.push("- Note: concrete-only vector helper family; no generic collection freeze."); + } out.push(""); - for (const signature of module.signatures) { - out.push(`- \`${signature}\``); + for (const { signature, tier } of module.signatures) { + out.push(`- \`${tier}\` \`${signature}\``); } out.push(""); }