5771 lines
215 KiB
Markdown
5771 lines
215 KiB
Markdown
# Slovo Release Notes
|
|
|
|
## Release Maturity Policy
|
|
|
|
Historical `exp-*` releases listed here are experimental maturity milestones.
|
|
`1.0.0-beta` is the first real general-purpose beta release.
|
|
|
|
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.2`, published on 2026-05-22. 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.
|
|
|
|
## Unreleased
|
|
|
|
No unreleased changes yet.
|
|
|
|
## 1.0.0-beta.2
|
|
|
|
Release label: `1.0.0-beta.2`
|
|
|
|
Release name: Runtime Resource Foundation Bundle
|
|
|
|
Release date: 2026-05-22
|
|
|
|
Status: released beta runtime/resource foundation update on the `1.0.0-beta`
|
|
language baseline.
|
|
|
|
`1.0.0-beta.2` contains the first runtime/resource foundation slice:
|
|
|
|
- `std.fs.open_text_read_result : (string) -> (result i32 i32)` opens a
|
|
read-only text file and returns an opaque positive `i32` handle
|
|
- `std.fs.read_open_text_result : (i32) -> (result string i32)` reads remaining
|
|
text from an open read handle
|
|
- `std.fs.close_result : (i32) -> (result i32 i32)` closes an open handle
|
|
- `std.fs.exists : (string) -> bool`, `std.fs.is_file : (string) -> bool`,
|
|
and `std.fs.is_dir : (string) -> bool` expose narrow filesystem status
|
|
checks
|
|
- `std.fs.remove_file_result : (string) -> (result i32 i32)` removes a file
|
|
and `std.fs.create_dir_result : (string) -> (result i32 i32)` creates one
|
|
directory, both returning `ok 0` or `err 1`
|
|
- `lib/std/fs.slo` wraps those calls with explicit source facades
|
|
`open_text_read_result`, `read_open_text_result`, `close_result`,
|
|
`read_text_via_handle_result`, `close_ok`, status helpers, and narrow
|
|
file/directory mutation helpers
|
|
|
|
This release keeps handles beta-scoped. It does not add writable handles,
|
|
binary IO, directory handles, directory enumeration, recursive filesystem
|
|
operations, process handles, sockets, async IO, platform error codes, rich
|
|
host-error ADTs, or stable handle ABI/layout promises.
|
|
|
|
## 1.0.0-beta.1
|
|
|
|
Release label: `1.0.0-beta.1`
|
|
|
|
Release name: First Post-Beta Tooling Hardening Bundle
|
|
|
|
Release date: 2026-05-22
|
|
|
|
Status: released beta tooling update on the `1.0.0-beta` language baseline.
|
|
|
|
`1.0.0-beta.1` contains tooling hardening only:
|
|
|
|
- `glagol run <file.slo|project>` builds and executes through the hosted native
|
|
toolchain using `.slovo/build` when `-o` is not provided
|
|
- `glagol clean <file.slo|project>` removes generated `.slovo/build` artifacts
|
|
- `glagol new --template binary|library|workspace` scaffolds binary projects,
|
|
library projects, and local package workspaces using existing manifest rules
|
|
- `scripts/install.sh` installs the compiler, `lib/std`, and runtime C input
|
|
under a configurable prefix
|
|
- installed `glagol` discovers `share/slovo/std` and
|
|
`share/slovo/runtime/runtime.c` relative to its executable, with environment
|
|
overrides still available
|
|
- the release gate prints a concise final success line after all checks pass
|
|
|
|
This beta.1 slice does not add source-language syntax, stable ABI/layout
|
|
guarantees, networking, package registry behavior, or a stable standard-library
|
|
freeze.
|
|
|
|
## 1.0.0-beta
|
|
|
|
Release label: `1.0.0-beta`
|
|
|
|
Release name: First Real General-Purpose Beta
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released beta language contract.
|
|
|
|
The normative Slovo-side beta contract is `.llm/V1_0_0_BETA.md`.
|
|
|
|
`1.0.0-beta` includes:
|
|
|
|
- `i32`, `i64`, `u32`, `u64`, `f64`, `bool`, and `string`
|
|
- current fixed immutable arrays, current concrete vector families, structs,
|
|
enums, option/result, and lexical `unsafe` gating
|
|
- explicit `std/*.slo` imports for strings, numerics, IO, CLI, process args,
|
|
env, text FS, time, randomness, result/option, and concrete vectors
|
|
- local packages, workspaces, deterministic dependency handling, generated
|
|
docs, formatter modes, JSON diagnostics, and the paired local release gate
|
|
|
|
`1.0.0-beta` still defers generics, maps/sets, remote registries,
|
|
networking/async, and stable ABI/layout/ownership guarantees.
|
|
|
|
## exp-125 (final experimental precursor scope)
|
|
|
|
Release label: `exp-125`
|
|
|
|
Release name: Unsigned U32 U64 Numeric And Stdlib Breadth Alpha
|
|
|
|
Target date: 2026-05-21
|
|
|
|
Status: completed experimental precursor scope absorbed into `1.0.0-beta`.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_125_UNSIGNED_U32_U64_NUMERIC_AND_STDLIB_BREADTH_ALPHA.md`.
|
|
|
|
exp-125 broadens the numeric and staged stdlib surface with one connected
|
|
unsigned scope:
|
|
|
|
- direct `u32` and `u64` value flow
|
|
- decimal suffixed literals `42u32` and `42u64`
|
|
- same-type unsigned arithmetic and comparison
|
|
- compiler-known `std.io.print_u32`, `std.io.print_u64`,
|
|
`std.num.u32_to_string`, `std.num.u64_to_string`,
|
|
`std.string.parse_u32_result`, and `std.string.parse_u64_result`
|
|
- source helper parity across `std.result`, `std.option`, `std.string`,
|
|
`std.num`, `std.io`, `std.env`, `std.fs`, `std.process`, and `std.cli`
|
|
|
|
The matching Slovo-side fixtures include
|
|
`examples/supported/u32-numeric-primitive.slo`,
|
|
`examples/supported/u64-numeric-primitive.slo`,
|
|
`examples/supported/unsigned-integer-to-string.slo`,
|
|
`examples/supported/string-parse-u32-result.slo`,
|
|
`examples/supported/string-parse-u64-result.slo`, their formatter mirrors,
|
|
and the widened explicit import fixtures under `examples/projects/std-import-*`.
|
|
|
|
exp-125 itself did not claim beta maturity, implicit numeric promotion, mixed
|
|
signed/unsigned arithmetic, broader cast families, unsigned widths beyond
|
|
`u32`/`u64`, generic numeric helpers, unsigned collections, unsigned enum
|
|
payloads or struct fields, stable ABI/layout/ownership, or released compiler
|
|
support before the sibling Glagol work landed.
|
|
|
|
## exp-124 (released experimental alpha)
|
|
|
|
Release label: `exp-124`
|
|
|
|
Release name: Fixed Array Enum And Struct Elements Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_124_FIXED_ARRAY_ENUM_AND_STRUCT_ELEMENTS_ALPHA.md`.
|
|
|
|
exp-124 broadens the fixed immutable array surface with two connected element
|
|
lanes:
|
|
|
|
- direct known enum elements
|
|
- current known non-recursive struct elements
|
|
|
|
The release promotes immutable locals, parameters, returns, calls returning
|
|
arrays, and checked `i32` indexing over those new element families. It adds
|
|
`examples/supported/array-enum.slo`,
|
|
`examples/formatter/array-enum.slo`,
|
|
`examples/supported/array-struct-elements.slo`, and
|
|
`examples/formatter/array-struct-elements.slo`.
|
|
|
|
exp-124 does not add zero-length arrays, mutable arrays, element mutation,
|
|
array equality, array printing, nested arrays, slices, generics, stable
|
|
ABI/layout/ownership claims, or beta maturity.
|
|
|
|
## exp-123 (released experimental alpha)
|
|
|
|
Release label: `exp-123`
|
|
|
|
Release name: Owned Vector Benchmark Suite Extension And Whitepaper Refresh Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha documentation/tooling contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_123_OWNED_VECTOR_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`.
|
|
|
|
exp-123 keeps the exp-121 language surface unchanged and refreshes the current
|
|
publication baseline around one connected benchmark/documentation scope:
|
|
|
|
- `docs/SLOVO_WHITEPAPER.md` refreshed from the earlier exp-122 publication
|
|
framing to the current language/tooling state through exp-121
|
|
- benchmark methodology widened from seven kernels to nine:
|
|
`math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`,
|
|
`string-eq-loop`, `array-struct-field-loop`, `enum-struct-payload-loop`,
|
|
`vec-i32-index-loop`, and `vec-string-eq-loop`
|
|
- paired same-machine benchmark refresh targets widened from seven rows to
|
|
nine rows for the controller-owned publication pass
|
|
- local-machine-only wording, no threshold claim, and no cross-machine claim
|
|
retained
|
|
- `docs/README.md`, README release metadata, and spec/roadmap wording aligned
|
|
to the refreshed publication baseline
|
|
|
|
The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and
|
|
`WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data
|
|
refresh and release publication pass.
|
|
|
|
exp-123 does not add new source syntax, type forms, standard-library APIs,
|
|
compiler-known runtime names, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, stable ABI/layout/ownership claims, or beta
|
|
maturity.
|
|
|
|
## exp-122 (released experimental alpha)
|
|
|
|
Release label: `exp-122`
|
|
|
|
Release name: Composite Data Benchmark Suite Extension And Whitepaper Refresh Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha documentation/tooling contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_122_COMPOSITE_DATA_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`.
|
|
|
|
exp-122 keeps the exp-121 language surface unchanged and refreshes the current
|
|
publication baseline around one connected benchmark/documentation scope:
|
|
|
|
- `docs/SLOVO_WHITEPAPER.md` refreshed from the earlier exp-119 publication
|
|
framing to the current language/tooling state through exp-121
|
|
- benchmark methodology widened from five kernels to seven:
|
|
`math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`,
|
|
`string-eq-loop`, `array-struct-field-loop`, and
|
|
`enum-struct-payload-loop`
|
|
- paired same-machine benchmark refresh targets widened from five rows to
|
|
seven rows for the controller-owned publication pass
|
|
- local-machine-only wording, no threshold claim, and no cross-machine claim
|
|
retained
|
|
- `docs/README.md`, README release metadata, and spec/roadmap wording aligned
|
|
to the refreshed publication baseline
|
|
|
|
The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and
|
|
`WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data
|
|
refresh and release publication pass.
|
|
|
|
exp-122 does not add new source syntax, type forms, standard-library APIs,
|
|
compiler-known runtime names, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, stable ABI/layout/ownership claims, or beta
|
|
maturity.
|
|
|
|
## exp-121 (released experimental alpha)
|
|
|
|
Release label: `exp-121`
|
|
|
|
Release name: Non-Recursive Struct Enum Payloads Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_121_NON_RECURSIVE_STRUCT_ENUM_PAYLOADS_ALPHA.md`.
|
|
|
|
exp-121 broadens the enum payload surface with one connected struct-payload
|
|
scope:
|
|
|
|
- unary enum payload variants may use current known non-recursive struct types
|
|
- payload variants in one enum still share the same payload type when payload
|
|
variants are present
|
|
- qualified payload constructors over those struct types
|
|
- immutable enum locals, parameters, returns, calls, tests, and `main`
|
|
- exhaustive `match` with one immutable payload binding
|
|
- existing field access behavior on bound struct payloads, including array
|
|
field access and checked indexing where already promoted by exp-120
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/enum-payload-structs.slo` and
|
|
`examples/formatter/enum-payload-structs.slo`.
|
|
|
|
exp-121 does not add enum equality requirements for struct-payload enums,
|
|
direct array/vec/option/result payloads, multiple payload fields,
|
|
recursive/cyclic payloads, mutation, generics, stable ABI/layout/ownership
|
|
claims, or beta maturity.
|
|
|
|
## exp-120 (released experimental alpha)
|
|
|
|
Release label: `exp-120`
|
|
|
|
Release name: Fixed Array Struct Fields Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_120_FIXED_ARRAY_STRUCT_FIELDS_ALPHA.md`.
|
|
|
|
exp-120 broadens the struct-field surface with one connected fixed-array
|
|
scope:
|
|
|
|
- direct struct field declarations over `(array i32 N)`, `(array i64 N)`,
|
|
`(array f64 N)`, `(array bool N)`, and `(array string N)`
|
|
- struct construction from matching fixed-array expressions
|
|
- immutable struct locals initialized from matching struct-valued expressions
|
|
- struct parameters and returns for structs carrying those field types
|
|
- calls returning structs carrying those field types
|
|
- field access returning the declared fixed-array type
|
|
- checked indexing through field access with `i32` expressions only
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/array-struct-fields.slo` and
|
|
`examples/formatter/array-struct-fields.slo`.
|
|
|
|
The earlier `array*` fixtures remain valid as the underlying fixed-array
|
|
lanes. The earlier `enum-struct-fields.slo`, `primitive-struct-fields.slo`,
|
|
`numeric-struct-fields.slo`, and `composite-struct-fields.slo` fixtures remain
|
|
valid as narrower or sibling struct-field lanes.
|
|
|
|
exp-120 does not add zero-length arrays, mutable arrays, element mutation,
|
|
field mutation, array equality, array printing, nested arrays, arrays of
|
|
unsupported element kinds, arrays inside unsupported containers, slices,
|
|
generics, stable ABI/layout/ownership claims, or beta maturity.
|
|
|
|
## exp-119 (released experimental alpha)
|
|
|
|
Release label: `exp-119`
|
|
|
|
Release name: Benchmark Suite Extension And Whitepaper Refresh Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha documentation/tooling contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_119_BENCHMARK_SUITE_EXTENSION_AND_WHITEPAPER_REFRESH_ALPHA.md`.
|
|
|
|
exp-119 keeps the exp-118 language surface unchanged and refreshes the current
|
|
publication baseline around one connected benchmark/documentation scope:
|
|
|
|
- `docs/SLOVO_WHITEPAPER.md` refreshed from the older exp-59 framing to the
|
|
current language/tooling state through exp-118
|
|
- benchmark methodology widened from three kernels to five:
|
|
`math-loop`, `branch-loop`, `parse-loop`, `array-index-loop`, and
|
|
`string-eq-loop`
|
|
- benchmark result tables widened from three rows to five rows for paired
|
|
same-machine publication refresh
|
|
- local-machine-only wording, no threshold claim, and no cross-machine claim
|
|
retained
|
|
- `docs/README.md`, release metadata, and spec/roadmap wording aligned to the
|
|
refreshed publication baseline
|
|
|
|
The matching publication artifacts remain `docs/SLOVO_WHITEPAPER.pdf` and
|
|
`WHITEPAPER.pdf`, regenerated after the paired controller-side benchmark data
|
|
refresh and release publication pass.
|
|
|
|
exp-119 does not add new source syntax, type forms, standard-library APIs,
|
|
compiler-known runtime names, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, stable ABI/layout/ownership claims, or beta
|
|
maturity.
|
|
|
|
## exp-118 (released experimental alpha)
|
|
|
|
Release label: `exp-118`
|
|
|
|
Release name: String Fixed Arrays Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_118_STRING_FIXED_ARRAYS_ALPHA.md`.
|
|
|
|
exp-118 broadens the fixed-array surface with one connected string-array
|
|
scope:
|
|
|
|
- fixed array types over `string`
|
|
- positive literal lengths only
|
|
- direct array constructors over `string`
|
|
- immutable array locals initialized from matching array-valued expressions
|
|
- fixed-array parameters and returns over `string`
|
|
- calls returning arrays over `string`
|
|
- checked literal indexing and runtime-checked dynamic indexing
|
|
- `i32` index expressions only
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/array-string.slo`,
|
|
`examples/formatter/array-string.slo`,
|
|
`examples/supported/array-string-value-flow.slo`, and
|
|
`examples/formatter/array-string-value-flow.slo`.
|
|
|
|
The earlier `examples/supported/array.slo` and
|
|
`examples/supported/array-value-flow.slo` fixtures remain valid as narrower
|
|
`i32`-only predecessors. The earlier `array-direct-scalars*` fixtures remain
|
|
valid as the direct scalar widening lane from exp-117.
|
|
|
|
exp-118 does not add zero-length arrays, mutable arrays, element mutation,
|
|
array equality, printing arrays, nested arrays, arrays in struct fields,
|
|
arrays of other unsupported element types, slices, generics, stable
|
|
ABI/layout/ownership claims for string elements, or beta maturity.
|
|
|
|
## exp-117 (released experimental alpha)
|
|
|
|
Release label: `exp-117`
|
|
|
|
Release name: Direct Scalar Fixed Arrays Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_117_DIRECT_SCALAR_FIXED_ARRAYS_ALPHA.md`.
|
|
|
|
exp-117 broadens the fixed-array surface with one connected direct-scalar
|
|
scope:
|
|
|
|
- fixed array types over `i32`, `i64`, `f64`, and `bool`
|
|
- positive literal lengths only
|
|
- direct array constructors over those element families
|
|
- immutable array locals initialized from matching array-valued expressions
|
|
- fixed-array parameters and returns over those element families
|
|
- calls returning arrays over those element families
|
|
- checked literal indexing and runtime-checked dynamic indexing
|
|
- `i32` index expressions only
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/array-direct-scalars.slo`,
|
|
`examples/formatter/array-direct-scalars.slo`,
|
|
`examples/supported/array-direct-scalars-value-flow.slo`, and
|
|
`examples/formatter/array-direct-scalars-value-flow.slo`.
|
|
|
|
The earlier `examples/supported/array.slo` and
|
|
`examples/supported/array-value-flow.slo` fixtures remain valid as narrower
|
|
`i32`-only predecessors.
|
|
|
|
exp-117 does not add zero-length arrays, mutable arrays, element mutation,
|
|
array equality, printing arrays, nested arrays, arrays in struct fields, string
|
|
arrays, arrays of other unsupported element types, slices, generics, stable
|
|
ABI/layout claims, or beta maturity.
|
|
|
|
## exp-116 (released experimental alpha)
|
|
|
|
Release label: `exp-116`
|
|
|
|
Release name: Direct Scalar And String Enum Payloads Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_116_DIRECT_SCALAR_AND_STRING_ENUM_PAYLOADS_ALPHA.md`.
|
|
|
|
exp-116 broadens the user-defined enum payload surface with one connected
|
|
direct-payload scope:
|
|
|
|
- payloadless variants remain supported
|
|
- unary `(Variant i32)` payload variants remain supported
|
|
- unary direct `(Variant i64)` payload variants
|
|
- unary direct `(Variant f64)` payload variants
|
|
- unary direct `(Variant bool)` payload variants
|
|
- unary direct `(Variant string)` payload variants
|
|
- qualified zero-argument payloadless constructors and qualified one-argument
|
|
payload constructors
|
|
- immutable enum locals, parameters, returns, calls, top-level tests, and
|
|
`main`
|
|
- exhaustive enum `match` with one immutable arm-local payload binding for
|
|
payload variants
|
|
- same-enum equality by tag for payloadless variants and by tag plus payload
|
|
for unary direct payload variants
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/enum-payload-direct-scalars.slo` and
|
|
`examples/formatter/enum-payload-direct-scalars.slo`.
|
|
|
|
exp-116 does not add mixed payload kinds inside one enum, multiple payloads,
|
|
record variants, tuple variants beyond one direct payload, vec/array/option/
|
|
result/struct/enum payloads, enum mutation, richer pattern families, generic
|
|
enums, methods, traits, new compiler-known runtime names, manifest schema
|
|
changes, or beta maturity.
|
|
|
|
## exp-115 (released experimental alpha)
|
|
|
|
Release label: `exp-115`
|
|
|
|
Release name: Composite Struct Fields And Nested Structs Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_115_COMPOSITE_STRUCT_FIELDS_AND_NESTED_STRUCTS_ALPHA.md`.
|
|
|
|
exp-115 broadens the struct-field surface with one connected composite-field
|
|
scope:
|
|
|
|
- direct struct fields over `(vec i32)`, `(vec i64)`, `(vec f64)`,
|
|
`(vec bool)`, and `(vec string)`
|
|
- direct struct fields over `(option i32)`, `(option i64)`, `(option f64)`,
|
|
`(option bool)`, and `(option string)`
|
|
- direct struct fields over `(result i32 i32)`, `(result i64 i32)`,
|
|
`(result f64 i32)`, `(result bool i32)`, and `(result string i32)`
|
|
- direct struct fields over current known non-recursive struct types
|
|
- coexistence with the already supported direct scalar, immutable string, and
|
|
current enum field families
|
|
- immutable struct locals, parameters, returns, calls, top-level tests, and
|
|
`main` for structs carrying those fields
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/composite-struct-fields.slo` and
|
|
`examples/formatter/composite-struct-fields.slo`.
|
|
|
|
exp-115 does not add arrays as struct fields, mutable arrays, field mutation,
|
|
vector element mutation, option/result payload mutation, enum payload
|
|
mutation, recursive or cyclic struct layouts, new compiler-known runtime
|
|
names, manifest schema changes, or beta maturity.
|
|
|
|
## exp-114 (released experimental alpha)
|
|
|
|
Release label: `exp-114`
|
|
|
|
Release name: Mutable Composite Locals Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_114_MUTABLE_COMPOSITE_LOCALS_ALPHA.md`.
|
|
|
|
exp-114 broadens the local-value surface with one connected mutable-composite
|
|
scope:
|
|
|
|
- same-type mutable whole-value `var` / `set` reassignment for `string`
|
|
- same-type mutable whole-value `var` / `set` reassignment for `(vec i32)`,
|
|
`(vec i64)`, `(vec f64)`, `(vec bool)`, and `(vec string)`
|
|
- same-type mutable whole-value `var` / `set` reassignment for current
|
|
concrete option/result families
|
|
- same-type mutable whole-value `var` / `set` reassignment for current known
|
|
struct values and current enum values
|
|
- ordinary function bodies, top-level tests, and `main`
|
|
|
|
The matching supported and formatter fixtures are
|
|
`examples/supported/composite-locals.slo` and
|
|
`examples/formatter/composite-locals.slo`.
|
|
|
|
exp-114 does not add array mutation or mutable arrays, field mutation, vector
|
|
element mutation, option/result payload mutation, enum payload mutation,
|
|
mixed-type assignment, new compiler-known runtime names, manifest schema
|
|
changes, or beta maturity.
|
|
|
|
## exp-113 (released experimental alpha)
|
|
|
|
Release label: `exp-113`
|
|
|
|
Release name: Mutable Scalar Locals Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_113_MUTABLE_SCALAR_LOCALS_ALPHA.md`.
|
|
|
|
exp-113 broadens the local-value surface with one connected mutable-scalar
|
|
scope:
|
|
|
|
- direct mutable `var` locals declared as `bool`, `i64`, and `f64`
|
|
- same-type `set` reassignment from already promoted scalar expressions for
|
|
those declared local types
|
|
- ordinary function bodies, top-level tests, and `main`
|
|
|
|
The matching supported and formatter fixtures remain
|
|
`examples/supported/local-variables.slo` and
|
|
`examples/formatter/local-variables.slo`, now broadened to include mutable
|
|
`bool`, `i64`, and `f64` local var/set flows alongside the earlier i32 local
|
|
forms and exp-112 immutable bool locals.
|
|
|
|
exp-113 does not add mutable `string` locals, vector mutation, option/result
|
|
mutation, struct or enum mutation, mixed-type assignment, new compiler-known
|
|
runtime names, manifest schema changes, or beta maturity.
|
|
|
|
## exp-112 (released experimental alpha)
|
|
|
|
Release label: `exp-112`
|
|
|
|
Release name: Immutable Bool Locals Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha language contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_112_IMMUTABLE_BOOL_LOCALS_ALPHA.md`.
|
|
|
|
exp-112 broadens the local-value surface with one connected immutable-bool
|
|
scope:
|
|
|
|
- direct immutable `let` locals declared as `bool`
|
|
- local initializers from already promoted bool literals, parameters, calls
|
|
returning bool, and `if` expressions returning bool
|
|
- local references in existing predicate, return, call, top-level test, and
|
|
`main` positions
|
|
|
|
The matching supported and formatter fixtures remain
|
|
`examples/supported/local-variables.slo` and
|
|
`examples/formatter/local-variables.slo`, now broadened to include direct
|
|
immutable bool locals alongside the earlier i32 local forms. The current
|
|
`examples/projects/std-import-io/` explicit import fixture also now uses
|
|
direct bool locals in its stdin bool-fallback helper path.
|
|
|
|
exp-112 does not add mutable bool locals, bool assignment, `var bool`, new
|
|
boolean operators, broader local-type widening, new compiler-known runtime
|
|
names, manifest schema changes, or beta maturity.
|
|
|
|
## exp-111 (released experimental alpha)
|
|
|
|
Release label: `exp-111`
|
|
|
|
Release name: Standard IO Stdin Source Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_111_STANDARD_IO_STDIN_SOURCE_HELPERS_ALPHA.md`.
|
|
|
|
exp-111 broadens `std/io.slo` with one connected stdin helper package:
|
|
|
|
- `read_stdin_result`
|
|
- `read_stdin_option`
|
|
- `read_stdin_or`
|
|
- `read_stdin_i32_result`
|
|
- `read_stdin_i32_option`
|
|
- `read_stdin_i32_or_zero`
|
|
- `read_stdin_i32_or`
|
|
- `read_stdin_i64_result`
|
|
- `read_stdin_i64_option`
|
|
- `read_stdin_i64_or_zero`
|
|
- `read_stdin_i64_or`
|
|
- `read_stdin_f64_result`
|
|
- `read_stdin_f64_option`
|
|
- `read_stdin_f64_or_zero`
|
|
- `read_stdin_f64_or`
|
|
- `read_stdin_bool_result`
|
|
- `read_stdin_bool_option`
|
|
- `read_stdin_bool_or_false`
|
|
- `read_stdin_bool_or`
|
|
|
|
The existing zero-returning and value-returning print helper surfaces remain
|
|
in place. All new helpers remain ordinary Slovo source over the already
|
|
promoted `std.io.read_stdin_result`, the released `std.string.parse_*_result`
|
|
helpers, and the exp-109 `std.result.ok_or_none_*` bridge helpers. The
|
|
scope adds no new compiler-known `std.*` names, no generics, and no new
|
|
runtime calls. The matching explicit import fixture
|
|
`examples/projects/std-import-io/` now exercises the expanded stdin helper
|
|
lane structurally instead of assuming a fixed runner stdin payload.
|
|
|
|
exp-111 does not add trap-based `std.io.read_stdin`, line/read-line APIs,
|
|
prompt APIs, terminal mode, binary stdin, streaming stdin, async IO,
|
|
generics, compiler-known `std.*` runtime names beyond the already released
|
|
lane, or beta maturity.
|
|
|
|
## exp-110 (released experimental alpha)
|
|
|
|
Release label: `exp-110`
|
|
|
|
Release name: Standard String, Env, Fs, Process, And Cli Option Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_110_STANDARD_STRING_ENV_FS_PROCESS_AND_CLI_OPTION_HELPERS_ALPHA.md`.
|
|
|
|
exp-110 broadens `std/string.slo`, `std/env.slo`, `std/fs.slo`,
|
|
`std/process.slo`, and `std/cli.slo` with one connected option-helper
|
|
package:
|
|
|
|
- `std.string`: `parse_i32_option`, `parse_i64_option`,
|
|
`parse_f64_option`, `parse_bool_option`
|
|
- `std.env`: `get_option`, `get_i32_option`, `get_i64_option`,
|
|
`get_f64_option`, `get_bool_option`
|
|
- `std.fs`: `read_text_option`, `read_i32_option`, `read_i64_option`,
|
|
`read_f64_option`, `read_bool_option`
|
|
- `std.process`: `arg_option`, `arg_i32_option`, `arg_i64_option`,
|
|
`arg_f64_option`, `arg_bool_option`
|
|
- `std.cli`: `arg_text_option`, `arg_i32_option`, `arg_i64_option`,
|
|
`arg_f64_option`, `arg_bool_option`
|
|
|
|
The existing direct/result/fallback helper surfaces remain in place for all
|
|
five staged modules. All new helpers remain ordinary Slovo source over the
|
|
existing concrete result lanes through the exp-109 `std.result.ok_or_none_*`
|
|
bridge helpers. The scope adds no new compiler-known `std.*` names, no
|
|
generics, no new runtime calls, no stdin helpers, and no vec work.
|
|
|
|
The matching explicit import fixtures,
|
|
`examples/projects/std-import-string/`,
|
|
`examples/projects/std-import-env/`,
|
|
`examples/projects/std-import-fs/`,
|
|
`examples/projects/std-import-process/`, and
|
|
`examples/projects/std-import-cli/`, now deterministically exercise the new
|
|
option helpers alongside the earlier result and fallback lanes.
|
|
|
|
exp-110 does not add generic option/result combinators, automatic or
|
|
compiler-loaded std imports, stable ABI/layout claims, or beta maturity.
|
|
|
|
## exp-109 (released experimental alpha)
|
|
|
|
Release label: `exp-109`
|
|
|
|
Release name: Standard Option And Result Bridge Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_109_STANDARD_OPTION_AND_RESULT_BRIDGE_HELPERS_ALPHA.md`.
|
|
|
|
exp-109 broadens `std/option.slo` and `std/result.slo` with one connected
|
|
bridge-helper package between the current concrete option and result
|
|
families:
|
|
|
|
- `std/option.slo`: `some_or_err_i32`, `some_or_err_i64`,
|
|
`some_or_err_f64`, `some_or_err_bool`, `some_or_err_string`
|
|
- `std/result.slo`: `ok_or_none_i32`, `ok_or_none_i64`,
|
|
`ok_or_none_string`, `ok_or_none_f64`, `ok_or_none_bool`
|
|
|
|
The existing concrete constructor, observer, unwrap, and fallback helpers
|
|
remain in place for both staged modules. All new helpers remain ordinary
|
|
Slovo source. `some_or_err_*` uses the existing raw `is_some`,
|
|
`unwrap_some`, `ok`, and `err` forms to produce `(result <payload> i32)`
|
|
without importing `std.result`. `ok_or_none_*` uses the existing
|
|
`std.result.is_ok`, `std.result.unwrap_ok`, `some`, and `none` forms to
|
|
produce `(option <payload>)` without importing `std.option`.
|
|
|
|
The matching explicit import fixtures,
|
|
`examples/projects/std-import-option/`,
|
|
`examples/workspaces/std-import-option/`, and
|
|
`examples/projects/std-import-result/`, now deterministically exercise the
|
|
new bridge helpers alongside the earlier concrete helper surfaces. The
|
|
project option fixture now passes 26 deterministic tests, the workspace
|
|
option fixture passes 1 deterministic test, and the project result fixture
|
|
passes 18 deterministic tests.
|
|
|
|
exp-109 does not add compiler-known `std.*` names, generic bridge helpers,
|
|
generic `map`/`and_then`/`transpose`/`flatten`, new payload families,
|
|
automatic or compiler-loaded std imports, stable ABI/layout claims, or beta
|
|
maturity.
|
|
|
|
## exp-108 (released experimental alpha)
|
|
|
|
Release label: `exp-108`
|
|
|
|
Release name: Standard Vec String, F64, And Bool Prefix And Suffix Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_108_STANDARD_VEC_STRING_F64_AND_BOOL_PREFIX_AND_SUFFIX_HELPERS_ALPHA.md`.
|
|
|
|
exp-108 broadens `std/vec_string.slo`, `std/vec_f64.slo`, and
|
|
`std/vec_bool.slo` from their released edit baselines with one connected
|
|
immutable prefix/suffix package:
|
|
|
|
- `starts_with`
|
|
- `without_prefix`
|
|
- `ends_with`
|
|
- `without_suffix`
|
|
|
|
The baseline direct wrappers, builder helpers, query helpers, option-query
|
|
helpers, transform helpers, subvec helper, edit helpers, and simple
|
|
real-program helpers remain in place for the three concrete vec families.
|
|
All new helpers remain ordinary Slovo source over the four already released
|
|
runtime calls for each family plus existing helper composition. Empty
|
|
prefixes and suffixes behave as identity boundaries, exact whole-vector
|
|
prefix/suffix matches collapse to `empty`, and mismatched prefixes or
|
|
suffixes leave the input vector unchanged for the corresponding
|
|
`without_prefix` or `without_suffix` call.
|
|
|
|
The matching explicit import fixtures,
|
|
`examples/projects/std-import-vec_string/`,
|
|
`examples/projects/std-import-vec_f64/`, and
|
|
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
|
|
baseline, option-query, prefix/suffix, transform, subvec, edit, and
|
|
real-program helper groups through explicit imports. Each project now passes
|
|
19 deterministic fixture tests.
|
|
|
|
exp-108 does not add compiler-known `std.*` names beyond the already
|
|
released vec-string, vec-f64, and vec-bool runtime families, generics,
|
|
sorting, mapping, filtering, nested/container vecs, mutating/capacity APIs,
|
|
automatic or compiler-loaded std imports, stable ABI/layout claims, or beta
|
|
maturity.
|
|
|
|
## exp-107 (released experimental alpha)
|
|
|
|
Release label: `exp-107`
|
|
|
|
Release name: Standard Vec String, F64, And Bool Edit Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_107_STANDARD_VEC_STRING_F64_AND_BOOL_EDIT_HELPERS_ALPHA.md`.
|
|
|
|
exp-107 broadens `std/vec_string.slo`, `std/vec_f64.slo`, and
|
|
`std/vec_bool.slo` from their released option-query and transform baselines
|
|
with one connected immutable edit package:
|
|
|
|
- `insert_at`
|
|
- `insert_range`
|
|
- `replace_at`
|
|
- `replace_range`
|
|
- `remove_at`
|
|
- `remove_range`
|
|
|
|
The baseline direct wrappers, builder helpers, query helpers, option-query
|
|
helpers, transform helpers, subvec helper, and simple real-program helpers
|
|
remain in place for the three concrete vec families. All new helpers remain
|
|
ordinary Slovo source over the four already released runtime calls for each
|
|
family plus existing helper composition. `insert_at` appends on exact-length
|
|
positions and otherwise leaves invalid negative or past-end positions
|
|
unchanged; `insert_range` behaves the same for whole-vector insertion;
|
|
`replace_at` changes one in-range position or returns the original vector;
|
|
`replace_range` replaces a half-open in-range segment with tail saturation;
|
|
`remove_at` removes one in-range position or returns the original vector;
|
|
and `remove_range` removes a half-open in-range segment with tail saturation.
|
|
|
|
The matching explicit import fixtures,
|
|
`examples/projects/std-import-vec_string/`,
|
|
`examples/projects/std-import-vec_f64/`, and
|
|
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
|
|
baseline, option-query, transform, subvec, edit, and real-program helper
|
|
groups through explicit imports. Each project now passes 15 deterministic
|
|
fixture tests.
|
|
|
|
exp-107 does not add compiler-known `std.*` names beyond the already
|
|
released vec-string, vec-f64, and vec-bool runtime families, generics,
|
|
prefix/suffix helpers, sorting, mapping, filtering, nested/container vecs,
|
|
mutating/capacity APIs, automatic or compiler-loaded std imports, stable
|
|
ABI/layout claims, or beta maturity.
|
|
|
|
## exp-106 (released experimental alpha)
|
|
|
|
Release label: `exp-106`
|
|
|
|
Release name: Standard Vec F64 And Bool Option Query Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_106_STANDARD_VEC_F64_AND_BOOL_OPTION_QUERY_HELPERS_ALPHA.md`.
|
|
|
|
exp-106 broadens `std/vec_f64.slo` and `std/vec_bool.slo` from their
|
|
released transform baselines with one connected option-query package:
|
|
|
|
- `index_option`
|
|
- `first_option`
|
|
- `last_option`
|
|
- `index_of_option`
|
|
- `last_index_of_option`
|
|
|
|
The baseline direct wrappers, builder helpers, query helpers, transform
|
|
helpers, subvec helper, and simple real-program helpers remain in place for
|
|
both concrete vec families. All new helpers remain ordinary Slovo source
|
|
over the four already released runtime calls for each family and the already
|
|
promoted concrete option families they return. `index_option` returns `none`
|
|
for negative and out-of-range positions; `first_option` delegates to
|
|
`index_option values 0`; `last_option` returns `none` for empty vectors and
|
|
`some` of the last element otherwise; `index_of_option` returns the first
|
|
matching position or `none`; and `last_index_of_option` returns the last
|
|
matching position or `none`.
|
|
|
|
The matching explicit import fixtures,
|
|
`examples/projects/std-import-vec_f64/` and
|
|
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
|
|
baseline, option-query, transform, subvec, and real-program helper groups
|
|
through explicit `(import std.vec_f64 (...))` and `(import std.vec_bool
|
|
(...))`. Each project now passes 9 deterministic fixture tests.
|
|
|
|
exp-106 does not add compiler-known `std.*` names beyond the already
|
|
released vec-f64 and vec-bool runtime families, generics, edit helpers,
|
|
nested/container vecs, mutating/capacity APIs, automatic or compiler-loaded
|
|
std imports, stable ABI/layout claims, or beta maturity.
|
|
|
|
## exp-105 (released experimental alpha)
|
|
|
|
Release label: `exp-105`
|
|
|
|
Release name: Standard Vec F64 And Bool Transform Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_105_STANDARD_VEC_F64_AND_BOOL_TRANSFORM_HELPERS_ALPHA.md`.
|
|
|
|
exp-105 broadens `std/vec_f64.slo` and `std/vec_bool.slo` from their
|
|
released baselines with one connected transform-helper package:
|
|
|
|
- `concat`
|
|
- `take`
|
|
- `drop`
|
|
- `reverse`
|
|
- `subvec`
|
|
|
|
The baseline direct wrappers, builder helpers, query helpers, and simple
|
|
real-program helpers remain in place for both concrete vec families. All new
|
|
helpers remain ordinary Slovo source over the four already released runtime
|
|
calls for each family. `take` treats negative counts as zero and saturates
|
|
to the full source vector, `drop` treats negative counts as zero and
|
|
saturates at the source tail, `reverse` returns a copied reverse-order
|
|
vector, and `subvec` returns a copied half-open range or `empty` for
|
|
negative or empty starts.
|
|
|
|
The matching explicit import fixtures,
|
|
`examples/projects/std-import-vec_f64/` and
|
|
`examples/projects/std-import-vec_bool/`, now deterministically exercise the
|
|
baseline, transform, subvec, and real-program helper groups through explicit
|
|
`(import std.vec_f64 (...))` and `(import std.vec_bool (...))`. Each project
|
|
now passes 8 deterministic fixture tests.
|
|
|
|
exp-105 does not add compiler-known `std.*` names beyond the already
|
|
released vec-f64 and vec-bool runtime families, generics, option/result
|
|
helpers, edit helpers, nested/container vecs, mutating/capacity APIs,
|
|
automatic or compiler-loaded std imports, stable ABI/layout claims, or beta
|
|
maturity.
|
|
|
|
## exp-104 (released experimental alpha)
|
|
|
|
Release label: `exp-104`
|
|
|
|
Release name: Standard Vec Bool Baseline Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract, not beta.
|
|
|
|
The normative Slovo-side contract target is
|
|
`.llm/EXP_104_STANDARD_VEC_BOOL_BASELINE_ALPHA.md`.
|
|
|
|
exp-104 stages `std/vec_bool.slo` as the first source-authored `(vec bool)`
|
|
facade over the sibling concrete `std.vec.bool` runtime family.
|
|
|
|
The frozen source helper surface is:
|
|
|
|
- direct wrappers: `empty`, `append`, `len`, `at`
|
|
- builder helpers: `singleton`, `append2`, `append3`, `pair`, `triple`
|
|
- query helpers: `is_empty`, `index_or`, `first_or`, `last_or`
|
|
- simple real-program helpers: `contains`, `count_of`
|
|
|
|
All helpers remain ordinary Slovo source over the four released vec-bool
|
|
runtime calls. `index_or` returns its fallback for negative and out-of-range
|
|
positions, `first_or` delegates to `index_or values 0 fallback`, `last_or`
|
|
returns its fallback for empty vectors and the final element otherwise,
|
|
`contains` returns `true` exactly when some element equals the target, and
|
|
`count_of` returns `0` for empty vectors and counts repeated matches exactly.
|
|
|
|
The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_bool/`, freezes deterministic direct,
|
|
builder, query, and real-program helper coverage through explicit
|
|
`(import std.vec_bool (...))`. The matching supported and formatter fixtures,
|
|
`examples/supported/vec-bool.slo` and `examples/formatter/vec-bool.slo`,
|
|
exercise the intended raw `std.vec.bool.*` runtime surface, append
|
|
immutability, concrete `(vec bool)` flow, and same-family vector equality on
|
|
the Slovo side.
|
|
|
|
exp-104 does not add compiler-known `std.*` names beyond the released vec-bool
|
|
runtime family, generics, option/result helpers, transform/range/edit
|
|
helpers, nested/container vecs, mutating/capacity APIs, automatic or
|
|
compiler-loaded std imports, stable ABI/layout claims, or beta maturity.
|
|
|
|
## exp-103 (released experimental alpha)
|
|
|
|
Release label: `exp-103`
|
|
|
|
Release name: Standard Vec F64 Baseline Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract plus concrete
|
|
vector-family contract. This is experimental maturity and not a beta
|
|
maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_103_STANDARD_VEC_F64_BASELINE_ALPHA.md`.
|
|
|
|
exp-103 adds `std/vec_f64.slo` as the first usable source-authored
|
|
`(vec f64)` facade over the sibling concrete `std.vec.f64` runtime family.
|
|
|
|
The staged source helper surface is:
|
|
|
|
- direct wrappers: `empty`, `append`, `len`, `at`
|
|
- builder helpers: `singleton`, `append2`, `append3`, `pair`, `triple`
|
|
- query helpers: `is_empty`, `index_or`, `first_or`, `last_or`
|
|
- simple real-program helpers: `contains`, `sum`
|
|
|
|
All helpers remain ordinary Slovo source over the four promoted vec-f64
|
|
runtime calls. `index_or` returns its fallback for negative and out-of-range
|
|
positions, `first_or` delegates to `index_or values 0 fallback`, `last_or`
|
|
returns its fallback for empty vectors and the final element otherwise,
|
|
`contains` returns `true` exactly when some element equals the target, and
|
|
`sum` returns `0.0` for empty vectors.
|
|
|
|
The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_f64/`, deterministically exercises the
|
|
direct wrappers, builder helpers, query helpers, and real-program helpers
|
|
through explicit `(import std.vec_f64 (...))`. The matching supported and
|
|
formatter fixtures, `examples/supported/vec-f64.slo` and
|
|
`examples/formatter/vec-f64.slo`, exercise the compiler-known
|
|
`std.vec.f64.*` runtime surface, append immutability, concrete `(vec f64)`
|
|
flow, and same-family vector equality.
|
|
|
|
exp-103 does not add compiler-known `std.*` names beyond the vec-f64 runtime
|
|
family, generics, option-query helpers, transform/range/edit helpers,
|
|
nested/container vecs, automatic or compiler-loaded std imports, stable
|
|
ABI/layout claims, or beta maturity.
|
|
|
|
## exp-102 (released experimental alpha)
|
|
|
|
Release label: `exp-102`
|
|
|
|
Release name: Standard Option Bool And F64 Baseline Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha source/core-language contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_102_STANDARD_OPTION_BOOL_AND_F64_BASELINE_ALPHA.md`.
|
|
|
|
exp-102 broadens the staged `std/option.slo` helper surface and the current
|
|
core-language option slice from concrete `(option i32)`, `(option i64)`, and
|
|
`(option string)` to those families plus concrete `(option f64)` and
|
|
`(option bool)`.
|
|
|
|
The staged source helper surface is now:
|
|
|
|
- `(option i32)`: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`,
|
|
`unwrap_some_i32`, `unwrap_or_i32`
|
|
- `(option i64)`: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`,
|
|
`unwrap_some_i64`, `unwrap_or_i64`
|
|
- `(option f64)`: `some_f64`, `none_f64`, `is_some_f64`, `is_none_f64`,
|
|
`unwrap_some_f64`, `unwrap_or_f64`
|
|
- `(option bool)`: `some_bool`, `none_bool`, `is_some_bool`, `is_none_bool`,
|
|
`unwrap_some_bool`, `unwrap_or_bool`
|
|
- `(option string)`: `some_string`, `none_string`, `is_some_string`,
|
|
`is_none_string`, `unwrap_some_string`, `unwrap_or_string`
|
|
|
|
All helpers remain ordinary Slovo source over the already promoted option
|
|
forms, observers, extraction, `if`, parameters, and explicit signatures.
|
|
The release also broadens the supported and formatter `option-result*`
|
|
fixtures so raw option returns, immutable value flow, payload extraction, and
|
|
source-level `match` now cover `(option f64)` and `(option bool)` as well.
|
|
|
|
The matching explicit import fixture,
|
|
`examples/projects/std-import-option/`, now deterministically exercises the
|
|
`i32`, `i64`, `f64`, `bool`, and `string` helper families, with 16 passed
|
|
tests in the explicit project fixture. The matching workspace fixture,
|
|
`examples/workspaces/std-import-option/`, broadens the same staged helper
|
|
surface through the existing explicit workspace source-search lane.
|
|
|
|
exp-102 does not add compiler-known `std.option.*` runtime names, generic
|
|
option helpers, option payload families beyond `i32`, `i64`, `f64`, `bool`,
|
|
and `string`, option equality, option printing, nested/container option
|
|
support, automatic or compiler-loaded std imports, stable ABI/layout claims,
|
|
or beta maturity.
|
|
|
|
## exp-101 (released experimental alpha)
|
|
|
|
Release label: `exp-101`
|
|
|
|
Release name: Standard Vec String Option And Transform Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_101_STANDARD_VEC_STRING_OPTION_AND_TRANSFORM_HELPERS_ALPHA.md`.
|
|
|
|
exp-101 broadens `std/vec_string.slo` from the exp-99 baseline with one
|
|
connected helper package:
|
|
|
|
- option-query helpers:
|
|
`index_option`, `first_option`, `last_option`, `index_of_option`,
|
|
`last_index_of_option`
|
|
- transform helpers:
|
|
`concat`, `take`, `drop`, `reverse`, `subvec`
|
|
|
|
The baseline direct wrappers, builder helpers, query helpers, and simple
|
|
real-program helpers remain in place. The new helpers stay ordinary Slovo
|
|
source over the existing `std.vec.string.*` facade operations, string
|
|
equality, integer comparisons, and raw current `(option string)` /
|
|
`(option i32)` forms. The lane stays recursive and immutable with no `var`
|
|
or `set`.
|
|
|
|
The matching explicit import fixture, `examples/projects/std-import-vec_string/`,
|
|
now deterministically exercises the baseline, option-query, transform,
|
|
subvec, and real-program helper groups, with 9 passed tests in the explicit
|
|
project fixture.
|
|
|
|
exp-101 does not add compiler-known `std.*` runtime names, generics, vec
|
|
element families beyond `i32`, `i64`, and `string`, edit helpers,
|
|
prefix/suffix helpers, nested vecs or vecs inside other containers,
|
|
mutating/capacity APIs, stable ABI/layout claims, or beta maturity.
|
|
|
|
## exp-100 (released experimental alpha)
|
|
|
|
Release label: `exp-100`
|
|
|
|
Release name: Standard Option String Baseline Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha source/core-language contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_100_STANDARD_OPTION_STRING_BASELINE_ALPHA.md`.
|
|
|
|
exp-100 broadens the staged `std/option.slo` helper surface and the current
|
|
core-language option slice from concrete `(option i32)` plus `(option i64)`
|
|
to concrete `(option i32)`, `(option i64)`, and `(option string)`.
|
|
|
|
The staged source helper surface is now:
|
|
|
|
- `(option i32)`: `some_i32`, `none_i32`, `is_some_i32`, `is_none_i32`,
|
|
`unwrap_some_i32`, `unwrap_or_i32`
|
|
- `(option i64)`: `some_i64`, `none_i64`, `is_some_i64`, `is_none_i64`,
|
|
`unwrap_some_i64`, `unwrap_or_i64`
|
|
- `(option string)`: `some_string`, `none_string`, `is_some_string`,
|
|
`is_none_string`, `unwrap_some_string`, `unwrap_or_string`
|
|
|
|
All helpers remain ordinary Slovo source over the already promoted option
|
|
forms, tag observers, extraction, `if`, parameters, and explicit
|
|
signatures. The release also broadens the supported and formatter
|
|
`option-result*` fixtures so raw option returns, immutable value flow,
|
|
payload extraction, and source-level `match` now cover `(option string)` as
|
|
well.
|
|
|
|
The matching explicit import fixture,
|
|
`examples/projects/std-import-option/`, now deterministically exercises the
|
|
`i32`, `i64`, and `string` helper families, with 10 passed tests in the
|
|
explicit project fixture. The matching workspace fixture,
|
|
`examples/workspaces/std-import-option/`, broadens the same staged helper
|
|
surface through the existing explicit workspace source-search lane.
|
|
|
|
exp-100 does not add compiler-known `std.option.*` runtime names, generic
|
|
option helpers, option payload families beyond `i32`, `i64`, and `string`,
|
|
option equality, option printing, nested/container option support, automatic
|
|
or compiler-loaded std imports, stable ABI/layout claims, or beta maturity.
|
|
|
|
## exp-99 (released experimental alpha)
|
|
|
|
Release label: `exp-99`
|
|
|
|
Release name: Standard Vec String Baseline Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_99_STANDARD_VEC_STRING_BASELINE_ALPHA.md`.
|
|
|
|
exp-99 adds `std/vec_string.slo` as the first usable source-authored
|
|
`(vec string)` facade over the sibling concrete `std.vec.string` runtime
|
|
family. Its public surface is:
|
|
|
|
- direct wrappers: `empty`, `append`, `len`, and `at`
|
|
- builder helpers: `singleton`, `append2`, `append3`, `pair`, and `triple`
|
|
- query helpers: `is_empty`, `index_or`, `first_or`, and `last_or`
|
|
- simple real-program helpers: `contains` and `count_of`
|
|
|
|
The direct wrappers call only `std.vec.string.empty`,
|
|
`std.vec.string.append`, `std.vec.string.len`, and `std.vec.string.index`.
|
|
The remaining helpers are ordinary deterministic Slovo source helpers over
|
|
that direct surface, string equality, integer comparison, and `i32`
|
|
counting. `index_or` returns its fallback for negative and out-of-range
|
|
positions, `first_or` delegates to `index_or values 0 fallback`, `last_or`
|
|
provides a stable empty-vector fallback, `contains` returns `true` exactly
|
|
when any element equals the target, and `count_of` returns `0` for empty
|
|
vectors or absent targets while counting repeated matches exactly.
|
|
|
|
The matching explicit import fixture, `examples/projects/std-import-vec_string/`,
|
|
deterministically exercises the direct facade plus the builder, query,
|
|
contains, and count_of helpers, with 6 passed tests in the explicit project
|
|
fixture. The release also adds `examples/supported/vec-string.slo` with
|
|
matching formatter coverage in `examples/formatter/vec-string.slo` for the raw
|
|
`std.vec.string.*` runtime surface, vector equality, and append immutability.
|
|
|
|
exp-99 does not add generics, vec element families beyond `i32`, `i64`, and
|
|
`string`, option-query helpers, transform/range/edit helpers, nested vecs or
|
|
vecs inside other containers, mutating/capacity APIs, stable ABI/layout
|
|
claims, or beta maturity.
|
|
|
|
## exp-98 (released experimental alpha)
|
|
|
|
Release label: `exp-98`
|
|
|
|
Release name: Standard Vec I64 Edit Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_98_STANDARD_VEC_I64_EDIT_HELPERS_ALPHA.md`.
|
|
|
|
exp-98 extends `std/vec_i64.slo` with exactly six new public helpers over
|
|
the existing concrete vec i64 runtime family:
|
|
|
|
- `insert_at`
|
|
- `insert_range`
|
|
- `replace_at`
|
|
- `replace_range`
|
|
- `remove_at`
|
|
- `remove_range`
|
|
|
|
The helper surface stays concrete to `(vec i64)` and remains source-authored
|
|
and compositional over the already released vec_i64 helper surface,
|
|
especially `concat`, `take`, `drop`, and `append`. The full `vec_i64`
|
|
source family stays recursive and immutable: there are no `var` or `set`
|
|
locals in `std/vec_i64.slo`.
|
|
|
|
`insert_at ((values (vec i64)) (position i32) (value i64)) -> (vec i64)`
|
|
inserts before the current element at an in-range `position`, appends at
|
|
`position == len(values)`, and returns `values` unchanged for negative or
|
|
greater-than-length positions. `insert_range ((values (vec i64))
|
|
(position i32) (inserted (vec i64))) -> (vec i64)` follows the same
|
|
position rules while preserving the order of both vectors. `replace_at`
|
|
replaces one in-range element and returns `values` unchanged for negative or
|
|
out-of-range positions. `replace_range ((values (vec i64)) (start i32)
|
|
(end_exclusive i32) (replacement (vec i64))) -> (vec i64)` replaces the
|
|
half-open range `[start, end_exclusive)`, returns `values` unchanged for
|
|
negative, empty, or past-end starts, and replaces the tail when
|
|
`end_exclusive` extends past the source length. `remove_at` removes one
|
|
in-range element and otherwise returns `values` unchanged. `remove_range`
|
|
removes the half-open range `[start, end_exclusive)`, returns `values`
|
|
unchanged for negative, empty, or past-end starts, and removes the tail
|
|
when `end_exclusive` extends past the source length.
|
|
|
|
The matching explicit import fixture, `examples/projects/std-import-vec_i64/`,
|
|
deterministically exercises the new edit helper package alongside the
|
|
earlier builder, query, option-query, transform, subvec, and real-program
|
|
groups, with 15 passed tests in the explicit project fixture.
|
|
|
|
exp-98 does not add generics, new compiler-known `std.*` runtime names,
|
|
mutation/capacity APIs, iterators, sort/map/filter, or beta maturity.
|
|
|
|
## exp-97 (released experimental alpha)
|
|
|
|
Release label: `exp-97`
|
|
|
|
Release name: Standard Vec I64 Transform Helpers Alpha
|
|
|
|
Release date: 2026-05-21
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_97_STANDARD_VEC_I64_TRANSFORM_HELPERS_ALPHA.md`.
|
|
|
|
exp-97 extends `std/vec_i64.slo` with exactly five new public helpers over
|
|
the existing concrete vec i64 runtime family:
|
|
|
|
- `concat`
|
|
- `take`
|
|
- `drop`
|
|
- `reverse`
|
|
- `subvec`
|
|
|
|
The helper surface stays concrete to `(vec i64)` and remains source-authored
|
|
over the existing `append`, `len`, `at`, and `empty` facade operations only.
|
|
The full `vec_i64` source family stays recursive and immutable: there are no
|
|
`var` or `set` locals in `std/vec_i64.slo`.
|
|
|
|
`concat ((left (vec i64)) (right (vec i64))) -> (vec i64)` preserves the
|
|
order of both inputs and returns a copied left-then-right result. `take`
|
|
treats negative counts as zero and returns the original vector when the
|
|
requested count reaches or exceeds the current length. `drop` treats
|
|
negative counts as zero and returns an empty vector when the requested count
|
|
reaches or exceeds the current length. `reverse` returns a copied vector in
|
|
reverse order. `subvec ((values (vec i64)) (start i32) (end_exclusive i32))
|
|
-> (vec i64)` returns a copied half-open range, returns `(empty)` for
|
|
negative or empty ranges, and returns the remaining tail when
|
|
`end_exclusive` extends past the source length.
|
|
|
|
The matching explicit import fixture, `examples/projects/std-import-vec_i64/`,
|
|
deterministically exercises the new transform helper package alongside the
|
|
earlier direct-wrapper, builder, query, option-query, contains, and sum
|
|
groups, with 9 passed tests in the explicit project fixture.
|
|
|
|
exp-97 does not add insert/replace/remove helpers for `(vec i64)`, generics,
|
|
new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators,
|
|
sort/map/filter, or beta maturity.
|
|
|
|
## exp-96 (released experimental alpha)
|
|
|
|
Release label: `exp-96`
|
|
|
|
Release name: Standard Vec I64 Option Query Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_96_STANDARD_VEC_I64_OPTION_QUERY_HELPERS_ALPHA.md`.
|
|
|
|
exp-96 extends `std/vec_i64.slo` with exactly five new public helpers over
|
|
the existing concrete vec i64 runtime family:
|
|
|
|
- `index_option`
|
|
- `first_option`
|
|
- `last_option`
|
|
- `index_of_option`
|
|
- `last_index_of_option`
|
|
|
|
The option-returning helper surface stays concrete to `(option i64)` and
|
|
`(option i32)`. The module stays self-contained and explicit by constructing
|
|
raw current `some` and `none` option values directly instead of importing
|
|
`std.option`.
|
|
|
|
`index_option ((values (vec i64)) (position i32)) -> (option i64)` returns
|
|
`(none i64)` for negative and out-of-range positions and `(some i64 ...)`
|
|
for in-range positions. `first_option` delegates to `index_option values 0`.
|
|
`last_option` returns `(none i64)` for empty vectors and the final element as
|
|
`(some i64 ...)` otherwise. `index_of_option` returns the first matching
|
|
position as `(some i32 ...)` and `(none i32)` when the target is absent.
|
|
`last_index_of_option` returns the last matching position as `(some i32 ...)`
|
|
and `(none i32)` when the target is absent.
|
|
|
|
The full `vec_i64` source family now stays recursive and immutable: there are
|
|
no `var` or `set` locals in `std/vec_i64.slo`. The matching explicit import
|
|
fixture, `examples/projects/std-import-vec_i64/`, deterministically exercises
|
|
the new option-query helper group alongside the earlier direct-wrapper,
|
|
builder, query, contains, and sum groups, with 7 passed tests in the explicit
|
|
project fixture.
|
|
|
|
exp-96 does not add transform/range/edit helpers for `(vec i64)`, generics,
|
|
new compiler-known `std.*` runtime names, mutation/capacity APIs, iterators,
|
|
sort/map/filter, or beta maturity.
|
|
|
|
## exp-95 (released experimental alpha)
|
|
|
|
Release label: `exp-95`
|
|
|
|
Release name: Standard Option I64 Baseline Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha source/core-language contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_95_STANDARD_OPTION_I64_BASELINE_ALPHA.md`.
|
|
|
|
exp-95 broadens the conservative option slice from only `(option i32)` to
|
|
concrete `(option i32)` plus `(option i64)`.
|
|
|
|
On the staged standard-library side, `std/option.slo` now includes:
|
|
|
|
- constructors: `some_i32`, `none_i32`, `some_i64`, `none_i64`
|
|
- observers: `is_some_i32`, `is_none_i32`, `is_some_i64`, `is_none_i64`
|
|
- extract/fallback helpers: `unwrap_some_i32`, `unwrap_or_i32`,
|
|
`unwrap_some_i64`, and `unwrap_or_i64`
|
|
|
|
On the conservative core-language side, exp-95 broadens immutable option value
|
|
flow, direct constructor returns, tag observation, trap-based payload
|
|
extraction, and source-level `match` to `(option i64)`. The matching Slovo
|
|
fixtures now exercise raw `(option i64)` returns, value flow, payload access,
|
|
and `match`, and the explicit `std.option` import project now exercises both
|
|
the `i32` and `i64` helper families.
|
|
|
|
exp-95 does not add compiler-known `std.*` runtime names, automatic `std`
|
|
imports/search, generic option helpers, option payload families beyond `i32`
|
|
and `i64`, nested/container option support, option equality or printing,
|
|
stable ABI/layout claims, manifest schema changes, or beta maturity.
|
|
|
|
## exp-94 (released experimental alpha)
|
|
|
|
Release label: `exp-94`
|
|
|
|
Release name: Standard Vec I64 Baseline Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_94_STANDARD_VEC_I64_BASELINE_ALPHA.md`.
|
|
|
|
exp-94 adds `std/vec_i64.slo` as the first usable source-authored `(vec i64)`
|
|
facade over the sibling concrete vec runtime family. Its public surface is:
|
|
|
|
- direct wrappers: `empty`, `append`, `len`, and `at`
|
|
- builder helpers: `singleton`, `append2`, `append3`, `pair`, and `triple`
|
|
- query helpers: `is_empty`, `index_or`, `first_or`, and `last_or`
|
|
- simple real-program helpers: `contains` and `sum`
|
|
|
|
The direct wrappers call only `std.vec.i64.empty`, `std.vec.i64.append`,
|
|
`std.vec.i64.len`, and `std.vec.i64.index`. The remaining helpers are
|
|
ordinary deterministic Slovo source helpers over that direct surface, current
|
|
control flow, integer comparison, equality, and `i64` addition. `index_or`
|
|
returns its fallback for negative and out-of-range positions, `first_or` and
|
|
`last_or` provide stable empty-vector fallbacks, `contains` returns `true`
|
|
exactly when any element equals the target, and `sum` returns `0i64` for empty
|
|
vectors.
|
|
The matching explicit import fixture, `examples/projects/std-import-vec_i64/`,
|
|
deterministically exercises the direct wrappers plus the builder, query,
|
|
contains, and sum helpers, with 6 passed tests in the explicit project
|
|
fixture. The release also adds `examples/supported/vec-i64.slo` with matching
|
|
formatter coverage in `examples/formatter/vec-i64.slo` for the raw
|
|
`std.vec.i64.*` runtime surface, vector equality, and append immutability.
|
|
|
|
exp-94 does not add generic vectors, `vec f64`, `vec string`,
|
|
option/result payload widening, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names on the Slovo side, transform/range-edit helper families for `(vec i64)`,
|
|
mutating vec APIs, capacity or reserve management, sorting, mapping,
|
|
filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or
|
|
beta maturity.
|
|
|
|
## exp-93 (released experimental alpha)
|
|
|
|
Release label: `exp-93`
|
|
|
|
Release name: Standard Vec I32 Count-Of Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_93_STANDARD_VEC_I32_COUNT_OF_HELPER_ALPHA.md`.
|
|
|
|
exp-93 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `count_of`
|
|
|
|
This is an ordinary Slovo source function over the existing `len`, `at`,
|
|
equality, and `while` surface; it adds no new runtime calls, compiler
|
|
semantic changes, private recursive helper, or compiler-known `std.*` names.
|
|
`count_of ((values (vec i32)) (target i32)) -> i32` returns the number of
|
|
elements of `values` equal to `target`. It returns `0` for an empty vector
|
|
and when `target` is absent, counts repeated matches exactly, and leaves the
|
|
source vector unchanged. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
|
|
repeated-match, single-match, no-match, and unchanged-source cases alongside
|
|
the earlier vec helper groups, with 22 passed tests in the explicit project
|
|
fixture.
|
|
|
|
exp-93 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader vec aggregation or filter families beyond
|
|
the current concrete helper surface, mutating vec APIs, capacity or reserve
|
|
management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-92 (released experimental alpha)
|
|
|
|
Release label: `exp-92`
|
|
|
|
Release name: Standard Vec I32 Without-Prefix Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_92_STANDARD_VEC_I32_WITHOUT_PREFIX_HELPER_ALPHA.md`.
|
|
|
|
exp-92 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `without_prefix`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`starts_with`, `drop`, and `len` helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `without_prefix ((values (vec i32)) (prefix (vec i32))) ->
|
|
(vec i32)` removes a matching leading prefix from `values`. It returns
|
|
`values` unchanged for an empty prefix, a longer prefix, or a mismatched
|
|
prefix, returns `(empty)` when `values` exactly equals `prefix`, and leaves
|
|
both source vectors unchanged. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
|
|
exact, shorter matching, longer non-matching, mismatched, and unchanged-source
|
|
prefix cases alongside the earlier vec helper groups, with 21 passed tests in
|
|
the explicit project fixture.
|
|
|
|
exp-92 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader prefix/suffix helper families beyond
|
|
`starts_with`, `without_prefix`, `ends_with`, and `without_suffix`, broader
|
|
copied subvector/range-edit helper families beyond `insert_range`,
|
|
`replace_range`, `remove_range`, `subvec`, `without_prefix`, and
|
|
`without_suffix`, mutating vec APIs, capacity or reserve management,
|
|
sorting, mapping, filtering, iterators, stable ABI/layout/ownership,
|
|
optimizer guarantees, or beta maturity.
|
|
|
|
## exp-91 (released experimental alpha)
|
|
|
|
Release label: `exp-91`
|
|
|
|
Release name: Standard Vec I32 Without-Suffix Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_91_STANDARD_VEC_I32_WITHOUT_SUFFIX_HELPER_ALPHA.md`.
|
|
|
|
exp-91 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `without_suffix`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`ends_with`, `take`, and `len` helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `without_suffix ((values (vec i32)) (suffix (vec i32))) ->
|
|
(vec i32)` removes a matching trailing suffix from `values`. It returns
|
|
`values` unchanged for an empty suffix, a longer suffix, or a mismatched
|
|
suffix, returns `(empty)` when `values` exactly equals `suffix`, and leaves
|
|
both source vectors unchanged. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
|
|
exact, shorter matching, longer non-matching, mismatched, and unchanged-source
|
|
suffix cases alongside the earlier vec helper groups, with 20 passed tests in
|
|
the explicit project fixture.
|
|
|
|
exp-91 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader prefix/suffix helper families beyond
|
|
`starts_with`, `ends_with`, and `without_suffix`, broader copied
|
|
subvector/range-edit helper families beyond `insert_range`, `replace_range`,
|
|
`remove_range`, `subvec`, and `without_suffix`, mutating vec APIs, capacity
|
|
or reserve management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-90 (released experimental alpha)
|
|
|
|
Release label: `exp-90`
|
|
|
|
Release name: Standard Vec I32 Ends-With Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_90_STANDARD_VEC_I32_ENDS_WITH_HELPER_ALPHA.md`.
|
|
|
|
exp-90 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `ends_with`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`drop`, `len`, and vec equality helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `ends_with ((values (vec i32)) (suffix (vec i32))) -> bool`
|
|
returns `true` exactly when `values` ends with all elements of `suffix` in
|
|
order. It returns `true` for an empty suffix, `false` when `len(suffix) >
|
|
len(values)`, `true` for equal vectors and shorter matching suffixes, and
|
|
`false` for mismatched suffixes. The helper leaves both source vectors
|
|
unchanged. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
|
|
equal, shorter matching, longer non-matching, mismatched, and unchanged-source
|
|
suffix cases alongside the earlier vec helper groups, with 19 passed tests in
|
|
the explicit project fixture.
|
|
|
|
exp-90 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader prefix/suffix query helpers beyond
|
|
`starts_with` and `ends_with`, broader copied subvector/range-edit helper
|
|
families beyond `insert_range`, `replace_range`, `remove_range`, and
|
|
`subvec`, mutating vec APIs, capacity or reserve management, sorting,
|
|
mapping, filtering, iterators, stable ABI/layout/ownership, optimizer
|
|
guarantees, or beta maturity.
|
|
|
|
## exp-89 (released experimental alpha)
|
|
|
|
Release label: `exp-89`
|
|
|
|
Release name: Standard Vec I32 Starts-With Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_89_STANDARD_VEC_I32_STARTS_WITH_HELPER_ALPHA.md`.
|
|
|
|
exp-89 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `starts_with`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`take`, `len`, and vec equality helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `starts_with ((values (vec i32)) (prefix (vec i32))) -> bool`
|
|
returns `true` exactly when `values` begins with all elements of `prefix` in
|
|
order. It returns `true` for an empty prefix, `false` when `len(prefix) >
|
|
len(values)`, `true` for equal vectors and shorter matching prefixes, and
|
|
`false` for mismatched prefixes. The helper leaves both source vectors
|
|
unchanged. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises empty,
|
|
equal, shorter matching, longer non-matching, mismatched, and unchanged-source
|
|
cases alongside the earlier vec helper groups, with 18 passed tests in the
|
|
explicit project fixture.
|
|
|
|
exp-89 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader prefix/suffix query helpers beyond
|
|
`starts_with`, broader copied subvector/range-edit helper families beyond
|
|
`insert_range`, `replace_range`, `remove_range`, and `subvec`, mutating vec
|
|
APIs, capacity or reserve management, sorting, mapping, filtering,
|
|
iterators, stable ABI/layout/ownership, optimizer guarantees, or beta
|
|
maturity.
|
|
|
|
## exp-88 (released experimental alpha)
|
|
|
|
Release label: `exp-88`
|
|
|
|
Release name: Standard Vec I32 Replace Range Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_88_STANDARD_VEC_I32_REPLACE_RANGE_HELPER_ALPHA.md`.
|
|
|
|
exp-88 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `replace_range`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `replace_range ((values (vec i32)) (start i32)
|
|
(end_exclusive i32) (replacement (vec i32))) -> (vec i32)` replaces the
|
|
half-open range `[start, end_exclusive)` with all of `replacement` when the
|
|
start is valid. If `start < 0`, `end_exclusive <= start`, or
|
|
`start >= len(values)`, it returns `values` unchanged. If
|
|
`end_exclusive >= len(values)`, it replaces the tail from `start`. The
|
|
helper preserves prefix order, then replacement order, then surviving suffix
|
|
order, and does not mutate either source vector. The matching explicit
|
|
import fixture, `examples/projects/std-import-vec_i32/`, deterministically
|
|
exercises middle replacement, tail replacement, unchanged invalid-range,
|
|
unchanged-source-vector, unchanged-replacement-vector, and preserved-order
|
|
cases alongside the earlier vec helper groups, with 17 passed tests in the
|
|
explicit project fixture.
|
|
|
|
exp-88 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader copied subvector/range-edit helper
|
|
families beyond `insert_range`, `replace_range`, `remove_range`, and
|
|
`subvec`, public insert/remove/edit families beyond `insert_range`,
|
|
`replace_range`, `remove_range`, `subvec`, `insert_at`, `replace_at`, and
|
|
`remove_at`, mutating vec APIs, capacity or reserve management, sorting,
|
|
mapping, filtering, iterators, stable ABI/layout/ownership, optimizer
|
|
guarantees, or beta maturity.
|
|
|
|
## exp-87 (released experimental alpha)
|
|
|
|
Release label: `exp-87`
|
|
|
|
Release name: Standard Vec I32 Insert Range Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_87_STANDARD_VEC_I32_INSERT_RANGE_HELPER_ALPHA.md`.
|
|
|
|
exp-87 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `insert_range`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `insert_range ((values (vec i32)) (position i32)
|
|
(inserted (vec i32))) -> (vec i32)` returns a new vector when `position` is
|
|
valid: if `0 <= position < len(values)`, it inserts all of `inserted` before
|
|
the current element at `position`, and if `position == len(values)`, it
|
|
appends `inserted` at the end. The result length is then
|
|
`len(values) + len(inserted)`. If `position < 0` or `position > len(values)`,
|
|
it returns `values` unchanged. The helper preserves the order of both
|
|
vectors and does not mutate either source vector. The matching explicit
|
|
import fixture, `examples/projects/std-import-vec_i32/`, deterministically
|
|
exercises middle insertion, append-at-end insertion, negative-position,
|
|
out-of-range-position, and unchanged-source-vector cases alongside the
|
|
earlier vec helper groups.
|
|
|
|
exp-87 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader copied subvector/range-edit helper
|
|
families beyond `insert_range`, `remove_range`, and `subvec`, public
|
|
insert/remove/edit families beyond `insert_range`, `remove_range`, `subvec`,
|
|
`insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or
|
|
reserve management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-86 (released experimental alpha)
|
|
|
|
Release label: `exp-86`
|
|
|
|
Release name: Standard Vec I32 Remove Range Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_86_STANDARD_VEC_I32_REMOVE_RANGE_HELPER_ALPHA.md`.
|
|
|
|
exp-86 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `remove_range`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `remove_range ((values (vec i32)) (start i32)
|
|
(end_exclusive i32)) -> (vec i32)` removes the half-open range
|
|
`[start, end_exclusive)` from `values` while preserving the order of the
|
|
remaining elements. If `start < 0`, `end_exclusive <= start`, or
|
|
`start >= len(values)`, it returns `values` unchanged. If
|
|
`end_exclusive >= len(values)`, it removes the tail from `start`. The helper
|
|
leaves the source vector unchanged. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises
|
|
middle-range removal, tail removal, `end_exclusive <= start`,
|
|
out-of-range-start, negative-start, and unchanged-source cases alongside the
|
|
earlier vec helper groups.
|
|
|
|
exp-86 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader subvector/range-removal helper families
|
|
beyond `remove_range` and `subvec`, public insert/remove/edit families beyond
|
|
`remove_range`, `subvec`, `insert_at`, `replace_at`, and `remove_at`,
|
|
mutating vec APIs, capacity or reserve management, sorting, mapping,
|
|
filtering, iterators, stable ABI/layout/ownership, optimizer guarantees, or
|
|
beta maturity.
|
|
|
|
## exp-85 (released experimental alpha)
|
|
|
|
Release label: `exp-85`
|
|
|
|
Release name: Standard Vec I32 Subvec Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_85_STANDARD_VEC_I32_SUBVEC_HELPER_ALPHA.md`.
|
|
|
|
exp-85 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `subvec`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`take` and `drop` vec helpers; it adds no new runtime calls, compiler
|
|
semantic changes, private recursive helper, or compiler-known `std.*` names.
|
|
`subvec ((values (vec i32)) (start i32) (end_exclusive i32)) -> (vec i32)`
|
|
returns a copied contiguous subvector `[start, end_exclusive)`. If
|
|
`start < 0`, `end_exclusive <= start`, or `start >= len(values)`, it returns
|
|
`(empty)`. If `end_exclusive > len(values)`, it returns the remaining tail
|
|
from `start`. The helper preserves source order, leaves the source vector
|
|
unchanged, and remains an ordinary copied vec helper rather than a slice/view
|
|
type. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises
|
|
middle-range, tail-truncation, empty-range, out-of-range, negative-start,
|
|
and unchanged-source cases alongside the earlier vec helper groups.
|
|
|
|
exp-85 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice/view types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, broader copied subvector/window helpers beyond
|
|
`subvec`, public insert/remove/edit families beyond `subvec`, `insert_at`,
|
|
`replace_at`, and `remove_at`, mutating vec APIs, capacity or reserve
|
|
management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-84 (released experimental alpha)
|
|
|
|
Release label: `exp-84`
|
|
|
|
Release name: Standard Vec I32 Insert Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_84_STANDARD_VEC_I32_INSERT_HELPER_ALPHA.md`.
|
|
|
|
exp-84 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `insert_at`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`append`, `take`, `drop`, and `concat` vec helpers; it adds no new runtime
|
|
calls, compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `insert_at ((values (vec i32)) (position i32) (value i32)) ->
|
|
(vec i32)` returns a new vector when `position` is valid: if
|
|
`0 <= position < len(values)`, it inserts `value` before the current element
|
|
at `position`, and if `position == len(values)`, it appends `value` at the
|
|
end. The result length is then `len(values) + 1`. If `position < 0` or
|
|
`position > len(values)`, it returns `values` unchanged. The helper does not
|
|
mutate the source vector. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises
|
|
middle-insert, append-at-end, negative, and out-of-range insertion cases
|
|
alongside the earlier vec helper groups.
|
|
|
|
exp-84 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, public insert/remove/edit families beyond
|
|
`insert_at`, `replace_at`, and `remove_at`, mutating vec APIs, capacity or
|
|
reserve management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-83 (released experimental alpha)
|
|
|
|
Release label: `exp-83`
|
|
|
|
Release name: Standard Vec I32 Remove Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_83_STANDARD_VEC_I32_REMOVE_HELPER_ALPHA.md`.
|
|
|
|
exp-83 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `remove_at`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`take`, `drop`, and `concat` vec helpers; it adds no new runtime calls,
|
|
compiler semantic changes, private recursive helper, or compiler-known
|
|
`std.*` names. `remove_at ((values (vec i32)) (position i32)) -> (vec i32)`
|
|
returns a new vector with the element at `position` removed when
|
|
`0 <= position < len(values)`, preserving the order of the remaining
|
|
elements. The result length is then `len(values) - 1`. If `position < 0` or
|
|
`position >= len(values)`, it returns `values` unchanged. The helper does not
|
|
mutate the source vector. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises
|
|
in-range, negative, and out-of-range removal cases alongside the earlier vec
|
|
helper groups.
|
|
|
|
exp-83 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, public insert/remove/edit families beyond
|
|
`replace_at` and `remove_at`, mutating vec APIs, capacity or reserve
|
|
management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-82 (released experimental alpha)
|
|
|
|
Release label: `exp-82`
|
|
|
|
Release name: Standard Vec I32 Replace Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_82_STANDARD_VEC_I32_REPLACE_HELPER_ALPHA.md`.
|
|
|
|
exp-82 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `replace_at`
|
|
|
|
This is an ordinary compositional Slovo source function over the existing
|
|
`append`, `take`, `drop`, and `concat` vec helpers; it adds no new runtime
|
|
calls, compiler semantic changes, or compiler-known `std.*` names.
|
|
`replace_at ((values (vec i32)) (position i32) (replacement i32)) -> (vec i32)`
|
|
returns a new vector with the same length and order as `values` except that
|
|
the in-range `position` slot becomes `replacement`. If `position < 0` or
|
|
`position >= len(values)`, it returns `values` unchanged. The helper does not
|
|
mutate the source vector. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises in-range,
|
|
negative, and out-of-range replacement cases alongside the earlier vec helper
|
|
groups.
|
|
|
|
exp-82 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, public insert/remove/edit families beyond
|
|
`replace_at`, mutating vec APIs, capacity or reserve management, sorting,
|
|
mapping, filtering, iterators, stable ABI/layout/ownership, optimizer
|
|
guarantees, or beta maturity.
|
|
|
|
## exp-81 (released experimental alpha)
|
|
|
|
Release label: `exp-81`
|
|
|
|
Release name: Standard Vec I32 Range Helper Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_81_STANDARD_VEC_I32_RANGE_HELPER_ALPHA.md`.
|
|
|
|
exp-81 extends `std/vec_i32.slo` with exactly one new public helper over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `range`
|
|
|
|
This is an ordinary Slovo source function over the existing `append` and
|
|
`empty` vec facade operations, with private recursive generation only.
|
|
`range ((start i32) (end_exclusive i32)) -> (vec i32)` produces an ascending
|
|
half-open sequence from `start` up to but excluding `end_exclusive`.
|
|
Negative bounds are allowed, and it returns an empty vector when
|
|
`end_exclusive <= start`. `range_from_zero` remains public and may delegate
|
|
to `range 0 count`. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, deterministically exercises
|
|
negative, empty, and positive ascending range cases alongside the earlier
|
|
vec helper groups.
|
|
|
|
exp-81 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, descending or stepped range variants, inclusive
|
|
range variants, edit helpers, mutating vec APIs, capacity or reserve
|
|
management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-80 (released experimental alpha)
|
|
|
|
Release label: `exp-80`
|
|
|
|
Release name: Standard Vec I32 Generated Constructor Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_80_STANDARD_VEC_I32_GENERATED_CONSTRUCTOR_HELPERS_ALPHA.md`.
|
|
|
|
exp-80 extends `std/vec_i32.slo` with narrow generated constructor helpers
|
|
over the already promoted concrete vec runtime family:
|
|
|
|
- `repeat`
|
|
- `range_from_zero`
|
|
|
|
These are ordinary Slovo source functions over the existing `append` and
|
|
`empty` vec facade operations. `repeat` returns an empty vector when
|
|
`count <= 0`. `range_from_zero` produces `0`, `1`, and so on up to but
|
|
excluding `count`, and returns an empty vector when `count <= 0`. The
|
|
matching explicit import fixture, `examples/projects/std-import-vec_i32/`,
|
|
now deterministically exercises this constructor helper group alongside the
|
|
earlier direct, builder, fallback query, option-query, transform, and
|
|
real-program vec helpers.
|
|
|
|
exp-80 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, mutating vec APIs, capacity or reserve
|
|
management, public `range`, descending or stepped range variants, inclusive
|
|
range variants, edit helpers, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership,
|
|
optimizer guarantees, or beta maturity.
|
|
|
|
## exp-79 (released experimental alpha)
|
|
|
|
Release label: `exp-79`
|
|
|
|
Release name: Standard Vec I32 Transform Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_79_STANDARD_VEC_I32_TRANSFORM_HELPERS_ALPHA.md`.
|
|
|
|
exp-79 extends `std/vec_i32.slo` with narrow transform helpers over the
|
|
already promoted concrete vec runtime family:
|
|
|
|
- `concat`
|
|
- `take`
|
|
- `drop`
|
|
- `reverse`
|
|
|
|
These are ordinary Slovo source functions over the existing `append`, `len`,
|
|
`at`, and `empty` vec facade operations. `concat`, `take`, `drop`, and
|
|
`reverse` are expressed with private recursive helpers instead of mutable vec
|
|
locals. Negative counts behave as zero; `take` returns the original vector
|
|
when the requested count reaches or exceeds the current length, and `drop`
|
|
returns an empty vector in that same case. The matching explicit import
|
|
fixture, `examples/projects/std-import-vec_i32/`, now deterministically
|
|
exercises this transform helper group alongside the earlier direct, builder,
|
|
fallback query, option-query, and real-program vec helpers.
|
|
|
|
exp-79 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, slice types, automatic standard-library imports,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` runtime
|
|
names, mutable vec locals, mutating vec APIs, capacity or reserve
|
|
management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-78 (released experimental alpha)
|
|
|
|
Release label: `exp-78`
|
|
|
|
Release name: Standard CLI Local Source Facade Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_78_STANDARD_CLI_LOCAL_SOURCE_FACADE_ALPHA.md`.
|
|
|
|
exp-78 records the staged `std/cli.slo` facade as the Slovo-side contract for
|
|
the sibling Glagol local-source gate without widening the `std.cli` helper
|
|
surface. `std/cli.slo` itself remains unchanged for this release, and the
|
|
released helper list stays:
|
|
|
|
- `arg_text_result`
|
|
- `arg_i32_result`
|
|
- `arg_i32_or_zero`
|
|
- `arg_i32_or`
|
|
- `arg_i64_result`
|
|
- `arg_i64_or_zero`
|
|
- `arg_i64_or`
|
|
- `arg_f64_result`
|
|
- `arg_f64_or_zero`
|
|
- `arg_f64_or`
|
|
- `arg_bool_result`
|
|
- `arg_bool_or_false`
|
|
- `arg_bool_or`
|
|
|
|
The facade remains ordinary Slovo source over existing `std.process` and
|
|
`std.string` surface only, with no additional standard-source dependencies.
|
|
The existing explicit import fixture, `examples/projects/std-import-cli/`,
|
|
remains valid, and the paired Glagol local-source gate is expected to mirror
|
|
the same composition pattern.
|
|
|
|
exp-78 does not add new `std.cli` helpers, automatic standard-library
|
|
imports, compiler-loaded standard-library source, a `std.slo` aggregator,
|
|
package std dependency syntax, new compiler-known `std.*` runtime names,
|
|
process spawning, exit/status control, current-directory APIs, signal
|
|
handling, shell parsing, option or flag parsing, subcommands,
|
|
environment-backed configuration, richer CLI framework APIs, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-77 (released experimental alpha)
|
|
|
|
Release label: `exp-77`
|
|
|
|
Release name: Standard Vec I32 Option Query Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_77_STANDARD_VEC_I32_OPTION_QUERY_HELPERS_ALPHA.md`.
|
|
|
|
exp-77 extends `std/vec_i32.slo` with concrete option-returning query helpers
|
|
over the already promoted concrete vec runtime family:
|
|
|
|
- `index_option`
|
|
- `first_option`
|
|
- `last_option`
|
|
- `index_of_option`
|
|
- `last_index_of_option`
|
|
|
|
These are ordinary Slovo source functions over the existing `len`, `at`, and
|
|
`while` vec facade operations plus `std.option.some_i32` and
|
|
`std.option.none_i32`. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, now deterministically exercises this
|
|
option-query helper group alongside the earlier direct, builder, fallback
|
|
query, and real-program vec helpers.
|
|
|
|
exp-77 does not add generic collections, vector payload families beyond
|
|
`(vec i32)`, option payload families beyond `(option i32)`, automatic
|
|
standard-library imports, compiler-loaded standard-library source, new
|
|
compiler-known `std.*` runtime names, mutating vec APIs, capacity or reserve
|
|
management, sorting, mapping, filtering, iterators, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-76 (released experimental alpha)
|
|
|
|
Release label: `exp-76`
|
|
|
|
Release name: Standard Vec I32 Source Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_76_STANDARD_VEC_I32_SOURCE_HELPERS_ALPHA.md`.
|
|
|
|
exp-76 extends `std/vec_i32.slo` with a concrete `(vec i32)` source-authored
|
|
collection facade over the already promoted `std.vec.i32` runtime family:
|
|
|
|
- direct wrappers:
|
|
- `empty`
|
|
- `append`
|
|
- `len`
|
|
- `at`
|
|
- builder helpers:
|
|
- `singleton`
|
|
- `append2`
|
|
- `append3`
|
|
- `pair`
|
|
- `triple`
|
|
- query helpers:
|
|
- `is_empty`
|
|
- `index_or`
|
|
- `first_or`
|
|
- `last_or`
|
|
- real-program helpers:
|
|
- `contains`
|
|
- `sum`
|
|
|
|
These are ordinary Slovo source functions over the existing vector runtime
|
|
calls plus simple source `while` loops. The matching explicit import fixture,
|
|
`examples/projects/std-import-vec_i32/`, now exercises the direct facade and
|
|
the staged helper groups through explicit `std.vec_i32` imports.
|
|
|
|
exp-76 does not add generic vectors, vector payload families beyond
|
|
`(vec i32)`, automatic standard-library imports, compiler-loaded
|
|
standard-library source, capacity or reserve management, push/pop helpers,
|
|
sorting, mapping, filtering, iterators, new compiler-known `std.*` runtime
|
|
names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-75 (released experimental alpha)
|
|
|
|
Release label: `exp-75`
|
|
|
|
Release name: Standard Option Constructors Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_75_STANDARD_OPTION_CONSTRUCTORS_ALPHA.md`.
|
|
|
|
exp-75 extends `std/option.slo` with concrete source constructors for the
|
|
currently promoted `(option i32)` family:
|
|
|
|
- `some_i32`
|
|
- `none_i32`
|
|
|
|
These are ordinary Slovo source functions over the existing `some` and
|
|
`none` forms, fixed to the current released `(option i32)` family. The
|
|
matching explicit import fixture, `examples/projects/std-import-option/`, now
|
|
uses those constructors instead of repeating raw typed `some` and `none`
|
|
forms.
|
|
|
|
exp-75 does not add generic option helpers, new option payload families,
|
|
automatic standard-library imports, compiler-loaded standard-library source,
|
|
new compiler-known `std.*` runtime names, stable ABI/layout/ownership,
|
|
optimizer guarantees, or beta maturity.
|
|
|
|
## exp-74 (released experimental alpha)
|
|
|
|
Release label: `exp-74`
|
|
|
|
Release name: Standard Result Constructor Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_74_STANDARD_RESULT_CONSTRUCTOR_HELPERS_ALPHA.md`.
|
|
|
|
exp-74 extends `std/result.slo` with concrete source constructors for the
|
|
currently promoted result families:
|
|
|
|
- `ok_i32`
|
|
- `err_i32`
|
|
- `ok_i64`
|
|
- `err_i64`
|
|
- `ok_string`
|
|
- `err_string`
|
|
- `ok_f64`
|
|
- `err_f64`
|
|
- `ok_bool`
|
|
- `err_bool`
|
|
|
|
These are ordinary Slovo source functions over the existing `ok` and `err`
|
|
forms, fixed to the current released `(result <payload> i32)` families. The
|
|
matching explicit import fixture, `examples/projects/std-import-result/`, now
|
|
uses those constructors instead of repeating raw typed `ok` and `err` forms.
|
|
|
|
exp-74 does not add generic result helpers, new result payload families,
|
|
generic `map`/`and_then`, richer error ADTs, automatic standard-library
|
|
imports, compiler-loaded standard-library source, new compiler-known `std.*`
|
|
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
|
|
maturity.
|
|
|
|
## exp-73 (released experimental alpha)
|
|
|
|
Release label: `exp-73`
|
|
|
|
Release name: Standard Io Value Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_73_STANDARD_IO_VALUE_HELPERS_ALPHA.md`.
|
|
|
|
exp-73 extends `std/io.slo` with source-authored value-returning print
|
|
helpers over the already promoted print runtime calls:
|
|
|
|
- `print_i32_value`
|
|
- `print_i64_value`
|
|
- `print_f64_value`
|
|
- `print_string_value`
|
|
- `print_bool_value`
|
|
|
|
These are ordinary Slovo source functions over `std.io.print_i32`,
|
|
`std.io.print_i64`, `std.io.print_f64`, `std.io.print_string`, and
|
|
`std.io.print_bool`, followed by returning the original value. The matching
|
|
explicit import fixture, `examples/projects/std-import-io/`, now exercises
|
|
both the earlier zero-returning wrappers and the new value-preserving cases.
|
|
|
|
exp-73 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, stderr facade helpers, stdin facade helpers, line
|
|
iteration, prompt APIs, terminal control, binary IO, streaming IO, async IO,
|
|
new compiler-known `std.*` runtime names, stable ABI/layout/ownership,
|
|
optimizer guarantees, or beta maturity.
|
|
|
|
## exp-72 (released experimental alpha)
|
|
|
|
Release label: `exp-72`
|
|
|
|
Release name: Standard Cli Custom Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_72_STANDARD_CLI_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-72 extends `std/cli.slo` with source-authored typed argument
|
|
custom-fallback helpers over the already promoted argument lookup and concrete
|
|
parse result families:
|
|
|
|
- `arg_i32_or`
|
|
- `arg_i64_or`
|
|
- `arg_f64_or`
|
|
- `arg_bool_or`
|
|
|
|
These are ordinary Slovo source functions over `arg_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-cli/`, now exercises both the earlier
|
|
zero/false fallbacks and the new typed custom-fallback cases.
|
|
|
|
exp-72 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, process spawning, exit/status control, current
|
|
directory APIs, signal handling, shell parsing, subcommands, richer CLI
|
|
framework APIs, generic configuration helpers, new compiler-known `std.*`
|
|
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
|
|
maturity.
|
|
|
|
## exp-71 (released experimental alpha)
|
|
|
|
## exp-71 (released experimental alpha)
|
|
|
|
Release label: `exp-71`
|
|
|
|
Release name: Standard Process Custom Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_71_STANDARD_PROCESS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-71 extends `std/process.slo` with source-authored typed argument
|
|
custom-fallback helpers over the already promoted argument lookup and concrete
|
|
parse result families:
|
|
|
|
- `arg_i32_or`
|
|
- `arg_i64_or`
|
|
- `arg_f64_or`
|
|
- `arg_bool_or`
|
|
|
|
These are ordinary Slovo source functions over `arg_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-process/`, now exercises both the
|
|
earlier zero/false fallbacks and the new typed custom-fallback cases.
|
|
|
|
exp-71 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, process spawning, exit/status control, current
|
|
directory APIs, signal handling, shell parsing, subcommands, richer CLI
|
|
framework APIs, generic configuration helpers, new compiler-known `std.*`
|
|
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
|
|
maturity.
|
|
|
|
## exp-70 (released experimental alpha)
|
|
|
|
## exp-70 (released experimental alpha)
|
|
|
|
Release label: `exp-70`
|
|
|
|
Release name: Standard Fs Custom Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_70_STANDARD_FS_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-70 extends `std/fs.slo` with source-authored typed read custom-fallback
|
|
helpers over the already promoted text-read and concrete parse result
|
|
families:
|
|
|
|
- `read_i32_or`
|
|
- `read_i64_or`
|
|
- `read_f64_or`
|
|
- `read_bool_or`
|
|
|
|
These are ordinary Slovo source functions over `read_text_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-fs/`, now exercises both the earlier
|
|
zero/false fallbacks and the new typed custom-fallback cases.
|
|
|
|
exp-70 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, binary file APIs, directory traversal, streaming
|
|
file IO, async file IO, typed file writes, rich host errors, new
|
|
compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer
|
|
guarantees, or beta maturity.
|
|
|
|
## exp-69 (released experimental alpha)
|
|
|
|
## exp-69 (released experimental alpha)
|
|
|
|
Release label: `exp-69`
|
|
|
|
Release name: Standard Env Custom Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_69_STANDARD_ENV_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-69 extends `std/env.slo` with source-authored typed parse
|
|
custom-fallback helpers over the already promoted environment lookup and
|
|
concrete parse result families:
|
|
|
|
- `get_i32_or`
|
|
- `get_i64_or`
|
|
- `get_f64_or`
|
|
- `get_bool_or`
|
|
|
|
These are ordinary Slovo source functions over `get_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-env/`, now exercises both the earlier
|
|
zero/false fallbacks and the new typed custom-fallback cases.
|
|
|
|
exp-69 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, generic configuration helpers, environment mutation,
|
|
environment enumeration, environment writes, rich host errors, new
|
|
compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer
|
|
guarantees, or beta maturity.
|
|
|
|
## exp-68 (released experimental alpha)
|
|
|
|
Release label: `exp-68`
|
|
|
|
Release name: Standard String Custom Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_68_STANDARD_STRING_CUSTOM_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-68 extends `std/string.slo` with source-authored typed parse
|
|
custom-fallback helpers over the already promoted concrete parse result
|
|
families:
|
|
|
|
- `parse_i32_or`
|
|
- `parse_i64_or`
|
|
- `parse_f64_or`
|
|
- `parse_bool_or`
|
|
|
|
These are ordinary Slovo source functions over `parse_i32_result`,
|
|
`parse_i64_result`, `parse_f64_result`, and `parse_bool_result` plus source
|
|
`match`. The matching explicit import fixture,
|
|
`examples/projects/std-import-string/`, now exercises both the earlier
|
|
zero/false fallbacks and the new typed custom-fallback cases.
|
|
|
|
exp-68 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, generic parse helpers, whitespace trimming,
|
|
case-insensitive bool parsing, rich parse errors, new compiler-known `std.*`
|
|
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
|
|
maturity.
|
|
|
|
## exp-67 (released experimental alpha)
|
|
|
|
Release label: `exp-67`
|
|
|
|
Release name: Standard Process Typed Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_67_STANDARD_PROCESS_TYPED_HELPERS_ALPHA.md`.
|
|
|
|
exp-67 extends `std/process.slo` with source-authored typed argument
|
|
result/fallback helpers over process arguments plus the already promoted
|
|
concrete parse result families:
|
|
|
|
- `arg_i32_result`
|
|
- `arg_i32_or_zero`
|
|
- `arg_i64_result`
|
|
- `arg_i64_or_zero`
|
|
- `arg_f64_result`
|
|
- `arg_f64_or_zero`
|
|
- `arg_bool_result`
|
|
- `arg_bool_or_false`
|
|
|
|
These are ordinary Slovo source functions over `arg_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-process/`, now exercises the existing
|
|
process wrappers, deterministic missing-argument cases, and deterministic
|
|
invalid-present fallback behavior through `arg 0`.
|
|
|
|
exp-67 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, process spawning, exit/status control, current
|
|
directory APIs, shell parsing, subcommands, richer CLI framework APIs, rich
|
|
host errors, new compiler-known `std.*` runtime names, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-66 (released experimental alpha)
|
|
|
|
Release label: `exp-66`
|
|
|
|
Release name: Standard Fs Typed Read Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_66_STANDARD_FS_TYPED_READ_HELPERS_ALPHA.md`.
|
|
|
|
exp-66 extends `std/fs.slo` with source-authored typed read
|
|
result/fallback helpers over text-file reads plus the already promoted
|
|
concrete parse result families:
|
|
|
|
- `read_i32_result`
|
|
- `read_i32_or_zero`
|
|
- `read_i64_result`
|
|
- `read_i64_or_zero`
|
|
- `read_f64_result`
|
|
- `read_f64_or_zero`
|
|
- `read_bool_result`
|
|
- `read_bool_or_false`
|
|
|
|
These are ordinary Slovo source functions over `read_text_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-fs/`, now exercises the existing fs
|
|
wrappers, typed parse success cases, and deterministic invalid/missing
|
|
fallback behavior.
|
|
|
|
exp-66 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, binary file APIs, directory traversal, streaming
|
|
file IO, async file IO, typed file writes, rich host errors, generic
|
|
configuration helpers, new compiler-known `std.*` runtime names, stable
|
|
ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-65 (released experimental alpha)
|
|
|
|
Release label: `exp-65`
|
|
|
|
Release name: Standard Env Typed Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_65_STANDARD_ENV_TYPED_HELPERS_ALPHA.md`.
|
|
|
|
exp-65 extends `std/env.slo` with source-authored typed parse
|
|
result/fallback helpers over environment lookup plus the already promoted
|
|
concrete parse result families:
|
|
|
|
- `get_i32_result`
|
|
- `get_i32_or_zero`
|
|
- `get_i64_result`
|
|
- `get_i64_or_zero`
|
|
- `get_f64_result`
|
|
- `get_f64_or_zero`
|
|
- `get_bool_result`
|
|
- `get_bool_or_false`
|
|
|
|
These are ordinary Slovo source functions over `get_result`,
|
|
`parse_i32_result`, `parse_i64_result`, `parse_f64_result`, and
|
|
`parse_bool_result` plus source `match`. The matching explicit import
|
|
fixture, `examples/projects/std-import-env/`, now exercises the existing env
|
|
wrappers, typed parse success cases, and deterministic invalid/missing
|
|
fallback behavior.
|
|
|
|
exp-65 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, environment mutation, environment enumeration,
|
|
environment writes, rich host errors, generic configuration helpers, new
|
|
compiler-known `std.*` runtime names, stable ABI/layout/ownership, optimizer
|
|
guarantees, or beta maturity.
|
|
|
|
## exp-64 (released experimental alpha)
|
|
|
|
Release label: `exp-64`
|
|
|
|
Release name: Standard Num Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_64_STANDARD_NUM_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-64 extends `std/num.slo` with source-authored checked conversion
|
|
fallback helpers over the already promoted numeric result families:
|
|
|
|
- `i64_to_i32_or`
|
|
- `f64_to_i32_or`
|
|
- `f64_to_i64_or`
|
|
|
|
These are ordinary Slovo source functions over `i64_to_i32_result`,
|
|
`f64_to_i32_result`, and `f64_to_i64_result` plus source `match`. The
|
|
matching explicit import fixture, `examples/projects/std-import-num/`, now
|
|
exercises both the existing conversion wrappers and the new fallback helpers.
|
|
|
|
exp-64 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, unchecked narrowing conversions, saturating
|
|
conversions, generic numeric traits, new compiler-known `std.*` runtime
|
|
names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-63 (released experimental alpha)
|
|
|
|
Release label: `exp-63`
|
|
|
|
Release name: Standard Fs Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_63_STANDARD_FS_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-63 extends `std/fs.slo` with source-authored text fallback/status
|
|
helpers over the already promoted filesystem result families:
|
|
|
|
- `read_text_or`
|
|
- `write_text_ok`
|
|
|
|
These are ordinary Slovo source functions over `read_text_result` and
|
|
`write_text_result` plus source `match`. The matching explicit import fixture,
|
|
`examples/projects/std-import-fs/`, now exercises both the existing fs
|
|
wrappers and the new fallback/status helpers.
|
|
|
|
exp-63 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, binary file APIs, directory traversal, streaming
|
|
file IO, async file IO, rich host errors, new compiler-known `std.*` runtime
|
|
names, stable ABI/layout/ownership, optimizer guarantees, or beta maturity.
|
|
|
|
## exp-62 (released experimental alpha)
|
|
|
|
Release label: `exp-62`
|
|
|
|
Release name: Standard Env Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_62_STANDARD_ENV_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-62 extends `std/env.slo` with source-authored environment fallback
|
|
helpers over the already promoted `(result string i32)` environment lookup
|
|
family:
|
|
|
|
- `has`
|
|
- `get_or`
|
|
|
|
These are ordinary Slovo source functions over `get_result` plus source
|
|
`match`. The matching explicit import fixture,
|
|
`examples/projects/std-import-env/`, now exercises both the existing env
|
|
wrappers and the new presence/fallback helpers.
|
|
|
|
exp-62 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, environment mutation, environment enumeration,
|
|
platform/configuration APIs, rich host errors, new compiler-known `std.*`
|
|
runtime names, stable ABI/layout/ownership, optimizer guarantees, or beta
|
|
maturity.
|
|
|
|
## exp-61 (released experimental alpha)
|
|
|
|
Release label: `exp-61`
|
|
|
|
Release name: Standard Process Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_61_STANDARD_PROCESS_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-61 extends `std/process.slo` with source-authored fallback helpers over
|
|
the already promoted `(result string i32)` process argument family:
|
|
|
|
- `arg_or`
|
|
- `arg_or_empty`
|
|
|
|
These are ordinary Slovo source functions over `arg_result` plus source
|
|
`match`. The matching explicit import fixture,
|
|
`examples/projects/std-import-process/`, now exercises both the existing
|
|
process wrappers and the new fallback helpers.
|
|
|
|
exp-61 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, option/flag parsing, subcommands, process spawning,
|
|
exit/status control, shell parsing, rich host errors, new compiler-known
|
|
`std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or
|
|
beta maturity.
|
|
|
|
## exp-60 (released experimental alpha)
|
|
|
|
Release label: `exp-60`
|
|
|
|
Release name: Standard String Fallback Helpers Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha stdlib/source contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_60_STANDARD_STRING_FALLBACK_HELPERS_ALPHA.md`.
|
|
|
|
exp-60 extends `std/string.slo` with source-authored fallback helpers over
|
|
the already promoted concrete parse result families:
|
|
|
|
- `parse_i32_or_zero`
|
|
- `parse_i64_or_zero`
|
|
- `parse_f64_or_zero`
|
|
- `parse_bool_or_false`
|
|
|
|
These are ordinary Slovo source functions over the existing `parse_*_result`
|
|
helpers plus source `match` on the concrete `i32`, `i64`, `f64`, and `bool`
|
|
result families. The matching explicit import fixture,
|
|
`examples/projects/std-import-string/`, now exercises both the direct parse
|
|
result wrappers and the new fallback helpers.
|
|
|
|
exp-60 does not add automatic standard-library imports, compiler-loaded
|
|
standard-library source, generic parse helpers, whitespace trimming,
|
|
case-insensitive bool parsing, rich parse errors, new compiler-known
|
|
`std.*` runtime names, stable ABI/layout/ownership, optimizer guarantees, or
|
|
beta maturity.
|
|
|
|
## exp-59 (released experimental alpha)
|
|
|
|
Release label: `exp-59`
|
|
|
|
Release name: Hosted Build Optimization And Benchmark Publication Alpha
|
|
|
|
Release date: 2026-05-20
|
|
|
|
Status: released experimental alpha documentation/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_59_HOSTED_BUILD_OPTIMIZATION_AND_BENCHMARK_PUBLICATION_ALPHA.md`.
|
|
|
|
exp-59 does not change the exp-58 source-language surface. It records the
|
|
paired Glagol exp-59 hosted-build optimization, refreshes the then-current
|
|
benchmark methodology and local benchmark evidence, and adds a repo-local PDF
|
|
rendering script for the whitepaper and manifest artifacts.
|
|
|
|
exp-59 does not add source syntax, type forms, standard-library APIs, stable
|
|
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, package registry behavior, or beta
|
|
maturity.
|
|
|
|
## exp-58 (released experimental alpha)
|
|
|
|
Release label: `exp-58`
|
|
|
|
Release name: Boolean Logic Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language contract. This is experimental
|
|
maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is `.llm/EXP_58_BOOLEAN_LOGIC_ALPHA.md`.
|
|
|
|
exp-58 promotes `(and left right)`, `(or left right)`, and `(not value)` for
|
|
boolean values. `and` and `or` lower through existing `if` semantics, so they
|
|
short-circuit in the deterministic test runner and hosted lowering.
|
|
|
|
The new supported fixture is `examples/supported/boolean-logic.slo`, with
|
|
matching formatter coverage in `examples/formatter/boolean-logic.slo`.
|
|
|
|
exp-58 does not add truthiness, variadic boolean operators, pattern guards,
|
|
macro expansion, stable ABI/layout/ownership, optimizer guarantees, benchmark
|
|
thresholds, or beta maturity.
|
|
|
|
## exp-57 (released experimental alpha)
|
|
|
|
Release label: `exp-57`
|
|
|
|
Release name: Integer Bitwise Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/stdlib contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is `.llm/EXP_57_INTEGER_BITWISE_ALPHA.md`.
|
|
|
|
exp-57 promotes explicit `bit_and`, `bit_or`, and `bit_xor` binary heads for
|
|
same-width signed integer operands: `i32` with `i32`, and `i64` with `i64`.
|
|
|
|
The release also extends `std/math.slo` with `bit_and_i32`, `bit_or_i32`,
|
|
`bit_xor_i32`, `bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`.
|
|
|
|
The new supported fixture is `examples/supported/integer-bitwise.slo`, with
|
|
matching formatter coverage in `examples/formatter/integer-bitwise.slo`.
|
|
|
|
exp-57 does not add shifts, bit-not, unsigned arithmetic,
|
|
bit-width-specific integer families, floating-point bitwise operations,
|
|
generic math, mixed numeric arithmetic, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-56 (released experimental alpha)
|
|
|
|
Release label: `exp-56`
|
|
|
|
Release name: Integer Remainder Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/stdlib contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is `.llm/EXP_56_INTEGER_REMAINDER_ALPHA.md`.
|
|
|
|
exp-56 promotes the `%` binary operator for same-width signed integer
|
|
operands: `i32 % i32 -> i32` and `i64 % i64 -> i64`. The deterministic
|
|
fixture covers positive and negative dividends for both widths.
|
|
|
|
The release also extends `std/math.slo` with `rem_i32`, `is_even_i32`,
|
|
`is_odd_i32`, `rem_i64`, `is_even_i64`, and `is_odd_i64`.
|
|
|
|
The new supported fixture is `examples/supported/integer-remainder.slo`, with
|
|
matching formatter coverage in `examples/formatter/integer-remainder.slo`.
|
|
|
|
exp-56 does not add floating-point remainder, Euclidean modulo, unsigned
|
|
arithmetic, bit operations, generic math, mixed numeric arithmetic, stable
|
|
ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta
|
|
maturity.
|
|
|
|
## exp-55 (released experimental alpha)
|
|
|
|
Release label: `exp-55`
|
|
|
|
Release name: Result F64 Bool Source Flow Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_55_RESULT_F64_BOOL_SOURCE_FLOW_ALPHA.md`.
|
|
|
|
exp-55 promotes source constructors and source `match` payload bindings for
|
|
the already existing concrete `(result f64 i32)` and `(result bool i32)`
|
|
families. It also lets `std/cli.slo` propagate missing argument indexes as
|
|
`err 1` for `arg_f64_result` and `arg_bool_result`.
|
|
|
|
The new supported fixture is
|
|
`examples/supported/result-f64-bool-match.slo`.
|
|
|
|
exp-55 does not add generic result types, result payload families beyond the
|
|
already promoted concrete families, generic `map`/`and_then`, exception
|
|
handling, automatic standard-library imports, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-54 (released experimental alpha)
|
|
|
|
Release label: `exp-54`
|
|
|
|
Release name: Standard CLI Typed Arguments Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_54_STANDARD_CLI_TYPED_ARGUMENTS_ALPHA.md`.
|
|
|
|
exp-54 extends `std/cli.slo` with `i64`, `f64`, and `bool` typed argument
|
|
parse helpers while keeping the facade source-authored. The matching fixture
|
|
imports the expanded `std.cli` helper list explicitly without a local copied
|
|
module.
|
|
|
|
`arg_i64_result` and `arg_i64_or_zero` propagate missing argument indexes
|
|
through current source-supported result constructors. `arg_f64_result` and
|
|
`arg_bool_result` return parse results over `std.process.arg`, so
|
|
out-of-range argument indexes still follow the existing trap behavior.
|
|
|
|
exp-54 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, lockfiles, package std dependencies,
|
|
new compiler-known runtime names, `err f64 i32` or `err bool i32` source
|
|
constructors, source `match` over `(result f64 i32)` or `(result bool i32)`,
|
|
shell parsing, option/flag parsing, subcommands, environment-backed
|
|
configuration, stable CLI framework APIs, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-53 (released experimental alpha)
|
|
|
|
Release label: `exp-53`
|
|
|
|
Release name: Standard CLI Source Facade Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_53_STANDARD_CLI_SOURCE_FACADE_ALPHA.md`.
|
|
|
|
exp-53 adds `std/cli.slo`, a narrow source-authored CLI facade that composes
|
|
`std.process` and `std.string` source modules. The matching fixture imports
|
|
`std.cli` explicitly without a local copied module.
|
|
|
|
The new fixture is `examples/projects/std-import-cli/`.
|
|
|
|
exp-53 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, lockfiles, package std dependencies,
|
|
new compiler-known runtime names, shell parsing, option/flag parsing,
|
|
subcommands, environment-backed configuration, stable CLI framework APIs,
|
|
stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or
|
|
beta maturity.
|
|
|
|
## exp-52 (released experimental alpha)
|
|
|
|
Release label: `exp-52`
|
|
|
|
Release name: Standard Process Facade Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_52_STANDARD_PROCESS_FACADE_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-52 adds `std/process.slo`, a narrow source-authored facade over already
|
|
promoted process argument runtime calls. The matching fixture imports
|
|
`std.process` explicitly without a local copied module.
|
|
|
|
The new fixture is `examples/projects/std-import-process/`.
|
|
|
|
exp-52 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, lockfiles, package std dependencies,
|
|
new compiler-known process runtime names, process spawning, exit/status
|
|
control, current-directory APIs, signal handling, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-51 (released experimental alpha)
|
|
|
|
Release label: `exp-51`
|
|
|
|
Release name: Standard Library Path List Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_51_STANDARD_LIBRARY_PATH_LIST_ALPHA.md`.
|
|
|
|
exp-51 refines explicit standard-source discovery so `SLOVO_STD_PATH` may
|
|
name an ordered OS path list of standard-library roots. This allows an
|
|
override root to sit before an installed or checkout root without copying the
|
|
entire `std/` tree.
|
|
|
|
exp-51 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, lockfiles, package std dependencies,
|
|
semantic version solving, stable package manager behavior, broad
|
|
standard-library APIs, stable ABI/layout/ownership, optimizer guarantees,
|
|
benchmark thresholds, or beta maturity.
|
|
|
|
## exp-50 (released experimental alpha)
|
|
|
|
Release label: `exp-50`
|
|
|
|
Release name: Installed Standard Library Discovery Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_50_INSTALLED_STANDARD_LIBRARY_DISCOVERY_ALPHA.md`.
|
|
|
|
exp-50 extends the explicit standard-source import contract to installed
|
|
toolchain discovery. Glagol may now discover staged `std/*.slo` files from an
|
|
installed `share/slovo/std` layout near the compiler executable, while keeping
|
|
`SLOVO_STD_PATH` and checkout discovery available.
|
|
|
|
exp-50 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, lockfiles, package std dependencies,
|
|
new standard-library modules, stable install layout guarantees, stable
|
|
ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta
|
|
maturity.
|
|
|
|
## exp-49 (released experimental alpha)
|
|
|
|
Release label: `exp-49`
|
|
|
|
Release name: Standard IO Facade Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_49_STANDARD_IO_FACADE_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-49 extends explicit project-mode standard-library source search to
|
|
`std.io`. `std/io.slo` now carries an export list, and the matching fixture
|
|
imports the module without a local copy.
|
|
|
|
The new fixture is `examples/projects/std-import-io/`.
|
|
|
|
exp-49 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, installed toolchain stdlib paths, new
|
|
compiler-known IO names, formatted output APIs, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-48 (released experimental alpha)
|
|
|
|
Release label: `exp-48`
|
|
|
|
Release name: Standard Core Facade Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_48_STANDARD_CORE_FACADE_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-48 extends explicit project-mode standard-library source search to the
|
|
pure source facade modules `std.string` and `std.num`. `std/string.slo` and
|
|
`std/num.slo` now carry export lists, and the matching fixtures import those
|
|
modules without local copies.
|
|
|
|
The new fixtures are `examples/projects/std-import-string/` and
|
|
`examples/projects/std-import-num/`.
|
|
|
|
exp-48 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, installed toolchain stdlib paths,
|
|
generic parse/format APIs, broad numeric casts, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-47 (released experimental alpha)
|
|
|
|
Release label: `exp-47`
|
|
|
|
Release name: Standard Host Facade Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_47_STANDARD_HOST_FACADE_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-47 extends explicit project-mode standard-library source search to the
|
|
host facade modules `std.time`, `std.random`, `std.env`, and `std.fs`.
|
|
`std/time.slo`, `std/random.slo`, `std/env.slo`, and `std/fs.slo` now carry
|
|
export lists, and the matching fixtures import those modules without local
|
|
copies.
|
|
|
|
The new fixtures are `examples/projects/std-import-time/`,
|
|
`examples/projects/std-import-random/`, `examples/projects/std-import-env/`,
|
|
and `examples/projects/std-import-fs/`.
|
|
|
|
exp-47 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, workspace dependency syntax for std, package registry behavior,
|
|
installed toolchain stdlib paths, broad host APIs, stable ABI/layout/ownership,
|
|
optimizer guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-46 (released experimental alpha)
|
|
|
|
Release label: `exp-46`
|
|
|
|
Release name: Workspace Standard Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_46_WORKSPACE_STANDARD_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-46 extends explicit standard-library source search from single projects to
|
|
workspace packages. The new fixture `examples/workspaces/std-import-option/`
|
|
imports `(import std.option (...))` without a local copied `option.slo`.
|
|
|
|
exp-46 does not add automatic standard-library imports, workspace dependency
|
|
syntax for std, package registry behavior, installed toolchain stdlib paths,
|
|
a `std.slo` aggregator, generic option helpers, broad standard-library APIs,
|
|
stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or
|
|
beta maturity.
|
|
|
|
## exp-45 (released experimental alpha)
|
|
|
|
Release label: `exp-45`
|
|
|
|
Release name: Standard Result And Option Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_45_STANDARD_RESULT_OPTION_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-45 extends the explicit standard-library source-search path to
|
|
`std.result` and `std.option`. Ordinary project code may import
|
|
`(import std.result (...))` and `(import std.option (...))`, and Glagol
|
|
resolves those imports to repo-root `std/result.slo` and `std/option.slo`
|
|
without local module copies.
|
|
|
|
`std/result.slo` and `std/option.slo` now carry their own export lists. The
|
|
matching contract fixtures are `examples/projects/std-import-result/` and
|
|
`examples/projects/std-import-option/`.
|
|
|
|
exp-45 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, workspace/package `std` imports,
|
|
generic result helpers, generic option helpers, broad standard-library APIs,
|
|
stable ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or
|
|
beta maturity.
|
|
|
|
## exp-44 (released experimental alpha)
|
|
|
|
Release label: `exp-44`
|
|
|
|
Release name: Standard Library Source Search Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha language/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_44_STANDARD_LIBRARY_SOURCE_SEARCH_ALPHA.md`.
|
|
|
|
exp-44 promotes the first explicit standard-library source search path:
|
|
ordinary project code may import the staged math helpers with
|
|
`(import std.math (...))` and Glagol resolves that import to repo-root
|
|
`std/math.slo` without copying `math.slo` into the project.
|
|
|
|
`std/math.slo` now carries its own export list so it can be imported as real
|
|
source. The matching contract fixture is
|
|
`examples/projects/std-import-math/`.
|
|
|
|
exp-44 does not add automatic standard-library imports, a `std.slo`
|
|
aggregator, package registry behavior, workspace/package `std` imports,
|
|
broad standard-library APIs, stable ABI/layout/ownership, optimizer
|
|
guarantees, benchmark thresholds, or beta maturity.
|
|
|
|
## exp-43 (released experimental alpha)
|
|
|
|
Release label: `exp-43`
|
|
|
|
Release name: Technical Whitepapers And Skills Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha documentation/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_43_TECHNICAL_WHITEPAPERS_AND_SKILLS_ALPHA.md`.
|
|
|
|
exp-43 publishes `docs/SLOVO_WHITEPAPER.md`, generated PDF publication
|
|
artifacts, and a repository-local beta language-design skill under
|
|
`.llm/skills/`.
|
|
|
|
exp-43 does not add source syntax, type forms, standard-library APIs, stable
|
|
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, package registry behavior, or beta maturity.
|
|
|
|
## exp-42 (released experimental alpha)
|
|
|
|
Release label: `exp-42`
|
|
|
|
Release name: Hot Loop Benchmark Mode Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha tooling contract. This is experimental
|
|
maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_42_HOT_LOOP_BENCHMARK_MODE_ALPHA.md`.
|
|
|
|
exp-42 keeps the Slovo language surface unchanged and pairs with Glagol
|
|
benchmark-suite gates that separate `cold-process` timing from
|
|
startup-amortized `hot-loop` timing.
|
|
|
|
exp-42 does not add source syntax, type forms, standard-library APIs, stable
|
|
ABI/layout/ownership, high-resolution timing APIs, optimizer guarantees,
|
|
benchmark thresholds, cross-machine performance claims, package registry
|
|
behavior, or beta maturity.
|
|
|
|
## exp-41 (released experimental alpha)
|
|
|
|
Release label: `exp-41`
|
|
|
|
Release name: Lisp Benchmark Comparison Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha tooling contract. This is experimental
|
|
maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_41_LISP_BENCHMARK_COMPARISON_ALPHA.md`.
|
|
|
|
exp-41 keeps the Slovo language surface unchanged and pairs with Glagol
|
|
benchmark-suite gates that compare two Lisp-family implementations:
|
|
Clojure and Common Lisp/SBCL.
|
|
|
|
exp-41 does not add source syntax, type forms, standard-library APIs, stable
|
|
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, package registry behavior, or beta maturity.
|
|
|
|
## exp-40 (released experimental alpha)
|
|
|
|
Release label: `exp-40`
|
|
|
|
Release name: Benchmark Suite And License Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha governance/tooling contract. This is
|
|
experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_40_BENCHMARK_SUITE_AND_LICENSE_ALPHA.md`.
|
|
|
|
exp-40 adds project licensing as `MIT OR Apache-2.0`, records alpha/beta
|
|
release naming criteria, and pairs with Glagol benchmark-suite gates for
|
|
Slovo/C/Rust/Python/Clojure local timing comparisons.
|
|
|
|
exp-40 does not add source syntax, type forms, standard-library APIs, stable
|
|
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
|
|
cross-machine performance claims, package registry behavior, or beta maturity.
|
|
|
|
## exp-39 (released experimental alpha)
|
|
|
|
Release label: `exp-39`
|
|
|
|
Release name: Standard Math Extensions And Benchmark Scaffold Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, benchmark scaffold, gates, and review workflow are
|
|
required before broader compiler-support claims. This is experimental maturity
|
|
and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_39_STANDARD_MATH_EXTENSIONS_AND_BENCHMARK_SCAFFOLD_ALPHA.md`.
|
|
|
|
exp-39 extends staged `std/math.slo` with source-authored helpers for `i32`,
|
|
`i64`, and finite `f64`: `neg_*`, `cube_*`, `is_zero_*`, `is_positive_*`,
|
|
`is_negative_*`, and inclusive `in_range_*`. The existing exp-32 `abs`,
|
|
`min`, `max`, `clamp`, and `square` helpers remain.
|
|
|
|
The matching Glagol release adds a local `math-loop` benchmark scaffold for
|
|
comparing Slovo executable timing against C, Rust, and Python on the same
|
|
machine. Those timings are local tooling evidence only, not performance
|
|
thresholds or optimizer guarantees.
|
|
|
|
exp-39 does not add automatic `std` imports, repo-root `std/` search,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` operation
|
|
names, trigonometry, `sqrt`, `pow`, modulo, bit operations, generic math,
|
|
overloads, traits, mixed numeric arithmetic, optimizer guarantees, benchmark
|
|
thresholds, stable standard-library APIs, stable ABI/layout/ownership,
|
|
manifest schema changes, or beta maturity.
|
|
|
|
## exp-38 (released experimental alpha)
|
|
|
|
Release label: `exp-38`
|
|
|
|
Release name: Standard Host Source Facades Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_38_STANDARD_HOST_SOURCE_FACADES_ALPHA.md`.
|
|
|
|
exp-38 adds staged source facades over already released host/runtime calls:
|
|
|
|
- `std/random.slo` with `random_i32 : () -> i32` and
|
|
`random_i32_non_negative : () -> bool`
|
|
- `std/env.slo` with `get : (string) -> string` and
|
|
`get_result : (string) -> (result string i32)`
|
|
- `std/fs.slo` with `read_text`, `read_text_result`, `write_text_status`, and
|
|
`write_text_result`
|
|
|
|
The standard-library organization policy remains the exp-30 staged layout:
|
|
flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer
|
|
only after import/search semantics exist. This follows the Zig-like flat
|
|
standard facade policy adapted to current Slovo.
|
|
|
|
exp-38 does not add automatic `std` imports, repo-root `std/` search,
|
|
compiler-loaded standard-library source, new compiler-known `std.*` operation
|
|
names, standard-runtime catalog entries, seed/range/bytes/floats/UUID/crypto
|
|
random APIs, environment mutation/enumeration, rich host error ADTs,
|
|
binary/directory/streaming/async filesystem APIs, stable standard-library APIs,
|
|
stable ABI/layout/ownership, manifest schema changes, or beta maturity.
|
|
|
|
## exp-37 (released experimental alpha)
|
|
|
|
Release label: `exp-37`
|
|
|
|
Release name: Standard Time Source Facade Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_37_STANDARD_TIME_SOURCE_FACADE_ALPHA.md`.
|
|
|
|
exp-37 adds the staged `std/time.slo` source facade with narrow wrappers over
|
|
the already released exp-8 host time calls:
|
|
|
|
- `monotonic_ms : () -> i32`
|
|
- `sleep_ms_zero : () -> i32`
|
|
|
|
`monotonic_ms` returns `std.time.monotonic_ms`. `sleep_ms_zero` calls
|
|
`std.time.sleep_ms 0` and then returns `0`, because user-defined unit-return
|
|
functions are not generally supported today and positive-duration timing
|
|
assertions remain deferred. exp-37 adds no compiler-known runtime names and no
|
|
entries to `STANDARD_RUNTIME.md`.
|
|
|
|
The standard-library organization policy remains the exp-30 staged layout:
|
|
flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer
|
|
only after import/search semantics exist. This follows the Zig-like flat
|
|
standard facade policy adapted to current Slovo.
|
|
|
|
exp-37 does not add automatic `std` imports, repo-root `std/` search,
|
|
compiler-loaded standard-library source, wall-clock/calendar/timezone APIs,
|
|
high-resolution timers, async timers, cancellation, scheduling guarantees, new
|
|
compiler-known `std.*` operation names, stable standard-library APIs, stable
|
|
ABI/layout/ownership, manifest schema changes, or beta maturity.
|
|
|
|
## exp-36 (released experimental alpha)
|
|
|
|
Release label: `exp-36`
|
|
|
|
Release name: Standard Option Source Helpers Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_36_STANDARD_OPTION_SOURCE_HELPERS_ALPHA.md`.
|
|
|
|
exp-36 adds the staged `std/option.slo` source facade with concrete helpers for
|
|
the already supported `(option i32)` family:
|
|
|
|
- `is_some_i32`
|
|
- `is_none_i32`
|
|
- `unwrap_some_i32`
|
|
- `unwrap_or_i32`
|
|
|
|
These are ordinary Slovo source functions over existing `is_some`, `is_none`,
|
|
`unwrap_some`, and `if` behavior. `unwrap_or_i32` returns the `some` payload
|
|
when present and otherwise returns the supplied fallback. exp-36 adds no
|
|
compiler-known runtime names and no entries to `STANDARD_RUNTIME.md`.
|
|
|
|
The standard-library organization policy remains the exp-30 staged layout:
|
|
flat `std/*.slo` facades now, with a future `std.slo` aggregator/reexport layer
|
|
only after import/search semantics exist. This is inspired by Zig's
|
|
facade/reexport approach but adapted to current Slovo.
|
|
|
|
exp-36 does not add automatic `std` imports, repo-root `std/` search,
|
|
compiler-loaded standard-library source, generic option helpers, option
|
|
payloads beyond `i32`, new compiler-known `std.*` operation names, stable
|
|
standard-library APIs, stable ABI/layout/ownership, manifest schema changes,
|
|
or beta maturity. exp-45 later promotes only explicit `std.option` source
|
|
search for this helper module.
|
|
|
|
## exp-35 (released experimental alpha)
|
|
|
|
Release label: `exp-35`
|
|
|
|
Release name: Standard Result Bool Source Helpers Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_35_STANDARD_RESULT_BOOL_SOURCE_HELPERS_ALPHA.md`.
|
|
|
|
exp-35 extends the staged `std/result.slo` source file with concrete bool
|
|
helpers for the exp-34 returned `(result bool i32)` family:
|
|
|
|
- `is_ok_bool`
|
|
- `is_err_bool`
|
|
- `unwrap_ok_bool`
|
|
- `unwrap_err_bool`
|
|
- `unwrap_or_bool`
|
|
|
|
These are ordinary Slovo source functions over existing compiler-known
|
|
`std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and
|
|
`std.result.unwrap_err` support for the exp-34 bool parse result flow.
|
|
`unwrap_or_bool` returns the ok payload when present and otherwise returns the
|
|
supplied fallback. exp-35 adds no compiler-known runtime names and no entries
|
|
to `STANDARD_RUNTIME.md`.
|
|
|
|
At exp-35, Slovo still did not promote automatic `std` imports, a repo-root
|
|
`std/` search path, compiler-loaded standard library source, source-authored
|
|
generic result helpers, source constructors for `(result bool i32)`, or
|
|
general source `match` over `(result bool i32)` beyond the
|
|
compiler-supported fixture flow. exp-45 later promotes only explicit
|
|
`std.result` source search for this helper module.
|
|
|
|
exp-35 does not add supported/formatter example fixtures. It does not add
|
|
generic `std.result.map`, generic `std.result.unwrap_or`,
|
|
`std.result.and_then`, option helper names, broad result payload families,
|
|
automatic standard-library imports, replacement of compiler-known `std.*`
|
|
calls, new compiler-known `std.*` operation names, stable standard-library
|
|
APIs, stable ABI/layout/ownership, manifest schema changes, or beta maturity.
|
|
|
|
## exp-34 (released experimental alpha)
|
|
|
|
Release label: `exp-34`
|
|
|
|
Release name: String Parse Bool Result Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_34_STRING_PARSE_BOOL_RESULT_ALPHA.md`.
|
|
|
|
exp-34 promotes exactly one string parse standard-runtime call:
|
|
|
|
- `std.string.parse_bool_result : (string) -> (result bool i32)`
|
|
|
|
The call parses exactly complete ASCII lowercase `true` and `false`. Success
|
|
returns `ok true` or `ok false`; the empty string, uppercase or mixed-case
|
|
text, leading or trailing whitespace, numeric text, and any other text return
|
|
`err 1`. It does not trap for ordinary parse failure.
|
|
|
|
The release adds byte-identical fixtures
|
|
`examples/supported/string-parse-bool-result.slo` and
|
|
`examples/formatter/string-parse-bool-result.slo`.
|
|
|
|
exp-34 does not add generic parse APIs, trap-based parse, bool parsing beyond
|
|
exact lowercase `true`/`false`, string/bytes parse, whitespace trimming,
|
|
case-insensitive parsing, locale or Unicode boolean parsing, numeric boolean
|
|
parsing, rich parse errors, source-authored `std/result.slo` bool wrappers,
|
|
automatic `std` imports, compiler-loaded `std` source, stable helper
|
|
ABI/layout/ownership, manifest schema changes, or beta maturity.
|
|
|
|
## exp-33 (released experimental alpha)
|
|
|
|
Release label: `exp-33`
|
|
|
|
Release name: Standard Result Source Helpers Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_33_STANDARD_RESULT_SOURCE_HELPERS_ALPHA.md`.
|
|
|
|
exp-33 extends the staged `std/result.slo` source file with source helpers for
|
|
already promoted concrete result families. It fills out missing
|
|
`is_err_i64`, `unwrap_err_i64`, `is_err_string`, `unwrap_err_string`,
|
|
`is_err_f64`, and `unwrap_err_f64` wrappers alongside the existing i32
|
|
helpers, and adds concrete `unwrap_or_i32`, `unwrap_or_i64`,
|
|
`unwrap_or_string`, and `unwrap_or_f64` helpers.
|
|
|
|
The numeric `unwrap_or_*` helpers are ordinary Slovo source functions
|
|
implemented with `std.result.is_ok`, `std.result.unwrap_ok`, `if`,
|
|
parameters, and explicit signatures. `unwrap_or_string` uses the existing
|
|
`(result string i32)` `match` shape to return the payload or fallback.
|
|
exp-33 adds no compiler-known runtime names and no entries to
|
|
`STANDARD_RUNTIME.md`.
|
|
|
|
At exp-33, Slovo still did not promote automatic `std` imports, a repo-root
|
|
`std/` search path, or compiler-loaded standard library source. exp-45 later
|
|
promotes explicit `std.result` source search while keeping automatic imports
|
|
deferred.
|
|
|
|
exp-33 does not add supported/formatter example fixtures. It does not add
|
|
generic `std.result.map`, generic `std.result.unwrap_or`,
|
|
`std.result.and_then`, option helper names, result payload families beyond the
|
|
already promoted concrete ones, automatic standard-library imports, replacement
|
|
of compiler-known `std.*` calls, new compiler-known `std.*` operation names,
|
|
stable standard-library APIs, stable ABI/layout/ownership, manifest schema
|
|
changes, or beta maturity.
|
|
|
|
## exp-32 (released experimental alpha)
|
|
|
|
Release label: `exp-32`
|
|
|
|
Release name: Standard Math Source Helpers Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol source
|
|
checking, formatter, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_32_STANDARD_MATH_SOURCE_HELPERS_ALPHA.md`.
|
|
|
|
exp-32 extends the staged `std/math.slo` source file with source-authored
|
|
helpers expressible in current Slovo:
|
|
|
|
- `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, and `square_i64`
|
|
- `abs_f64`, `min_f64`, `max_f64`, and `clamp_f64`
|
|
|
|
The existing exp-30 `i32` helpers and `square_f64` remain in place. The
|
|
helpers use existing same-type arithmetic/comparison, `if`, literals, calls,
|
|
and explicit signatures. They add no compiler-known runtime names and no
|
|
entries to `STANDARD_RUNTIME.md`.
|
|
|
|
At exp-32, Slovo did not yet promote automatic `std` imports, a repo-root
|
|
`std/` search path, or compiler-loaded standard library source. exp-44 later
|
|
promotes the first explicit `std.math` source-search path while keeping
|
|
automatic imports deferred.
|
|
|
|
exp-32 does not add supported/formatter example fixtures. It does not add
|
|
automatic standard-library imports, replacement of compiler-known `std.*`
|
|
calls, new compiler-known `std.*` operation names, a broad math library,
|
|
trigonometry, `sqrt`, `pow`, `f32`, unsigned or narrower integers, generics,
|
|
traits, overloads, mixed numeric arithmetic, numeric containers, stable
|
|
standard-library APIs, stable ABI/layout/ownership, manifest schema changes,
|
|
or beta maturity.
|
|
|
|
## exp-31 (released experimental alpha)
|
|
|
|
Release label: `exp-31`
|
|
|
|
Release name: Checked F64 To I64 Result Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_31_CHECKED_F64_TO_I64_RESULT_ALPHA.md`.
|
|
|
|
exp-31 promotes exactly one checked `f64` to `i64` result standard-runtime
|
|
call:
|
|
|
|
- `std.num.f64_to_i64_result : (f64) -> (result i64 i32)`
|
|
|
|
The call returns `ok value` only when the input is finite, exactly integral,
|
|
and within the signed `i64` range `-9223372036854775808` through
|
|
`9223372036854775807`. It returns `err 1` for non-finite, fractional, or
|
|
out-of-range input, without trapping for ordinary conversion failure.
|
|
|
|
The release adds byte-identical fixtures
|
|
`examples/supported/f64-to-i64-result.slo` and
|
|
`examples/formatter/f64-to-i64-result.slo`, plus a `std/num.slo` wrapper over
|
|
the promoted compiler-known call. The out-of-range fixture value is the
|
|
formatter-stable conservative `9223372036854776000.0`; the accepted exact
|
|
`9223372036854775808.0` spelling formats to that value. Detailed edge behavior
|
|
near the `f64`/`i64` limits remains implementation-owned Glagol test coverage.
|
|
|
|
exp-31 does not add unchecked casts, unchecked `f64` to `i64`, cast syntax,
|
|
generic `cast_checked`, `f32`, unsigned or narrower integer families,
|
|
additional numeric conversion families, mixed numeric arithmetic, broad math,
|
|
numeric containers, stable helper ABI/layout/ownership, manifest schema
|
|
changes, or beta maturity.
|
|
|
|
## exp-30 (released experimental alpha)
|
|
|
|
Release label: `exp-30`
|
|
|
|
Release name: Standard Library Source Layout Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_30_STANDARD_LIBRARY_SOURCE_LAYOUT_ALPHA.md`.
|
|
|
|
exp-30 establishes `std/` as the Slovo source home for staged standard library
|
|
modules and examples. It adds `std/README.md`, `std/io.slo`,
|
|
`std/string.slo`, `std/num.slo`, `std/result.slo`, and `std/math.slo`.
|
|
|
|
`std/math.slo` contains narrow source-authored helpers expressible with the
|
|
current language: `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`,
|
|
`square_i32`, and `square_f64`. The other `std/*.slo` files provide small
|
|
source wrappers over already promoted compiler-known standard-runtime calls
|
|
where current Slovo can express the wrapper cleanly.
|
|
|
|
The release adds the conservative formatter example
|
|
`examples/formatter/std-source-layout-alpha.slo`. It demonstrates the helper
|
|
shape and layout contract without claiming repo-root `std` import/search
|
|
support.
|
|
|
|
exp-30 does not add automatic standard-library imports, replace
|
|
compiler-known `std.*` calls with source implementations, add compiler-known
|
|
`std.*` operation names, change `STANDARD_RUNTIME.md`, add generics, traits,
|
|
overloads, package registry behavior, manifest schema changes, stable
|
|
standard-library APIs, stable ABI/layout/ownership, broad math, trigonometry,
|
|
`pow`, `sqrt`, `f32`, unsigned or narrower integers, mixed numeric
|
|
arithmetic, numeric containers, or beta maturity.
|
|
|
|
## exp-29 (released experimental alpha)
|
|
|
|
Release label: `exp-29`
|
|
|
|
Release name: Numeric Struct Fields Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_29_NUMERIC_STRUCT_FIELDS_ALPHA.md`.
|
|
|
|
exp-29 promotes direct immutable struct field declarations whose field types
|
|
are exactly `i64` or `f64`, alongside already supported direct `i32`, `bool`,
|
|
immutable `string`, and current enum fields.
|
|
|
|
It supports struct constructors with `i64` and finite `f64` field
|
|
initializers, immutable value flow through locals, parameters, returns, and
|
|
calls, field access returning `i64` or `f64`, and use of accessed fields with
|
|
existing same-type arithmetic/comparison and existing numeric print/format
|
|
helpers where already supported.
|
|
|
|
The release adds byte-identical fixtures
|
|
`examples/supported/numeric-struct-fields.slo` and
|
|
`examples/formatter/numeric-struct-fields.slo`.
|
|
|
|
exp-29 keeps the exp-20 finite-only `f64` policy. It does not add struct field
|
|
mutation, nested structs, arrays/vectors/options/results as fields, enum
|
|
payload widening, numeric containers, `f32`, unsigned or narrower integer
|
|
families, mixed numeric arithmetic, implicit conversions, new parse/format
|
|
APIs, generic structs, methods, traits, stable ABI/layout/ownership, manifest
|
|
schema changes, FFI layout claims, or beta maturity.
|
|
|
|
## exp-28 (released experimental alpha)
|
|
|
|
Release label: `exp-28`
|
|
|
|
Release name: String Parse F64 Result Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_28_STRING_PARSE_F64_RESULT_ALPHA.md`.
|
|
|
|
exp-28 promotes exactly one string parse standard-runtime call:
|
|
|
|
- `std.string.parse_f64_result : (string) -> (result f64 i32)`
|
|
|
|
The call parses complete finite ASCII decimal `f64` text. Success returns
|
|
`ok value`; ordinary parse failure, non-finite text, trailing or leading
|
|
unsupported characters, and out-of-domain input return `err 1`. It does not
|
|
trap for ordinary parse or domain failure.
|
|
|
|
The release adds byte-identical fixtures
|
|
`examples/supported/string-parse-f64-result.slo` and
|
|
`examples/formatter/string-parse-f64-result.slo`.
|
|
|
|
exp-28 does not add generic parse, bool/string/bytes parse, locale parsing,
|
|
Unicode digit parsing, underscores, rich parse errors, stable helper
|
|
ABI/layout/ownership, result genericity, f64 containers, mixed numeric
|
|
arithmetic, manifest schema changes, or beta maturity.
|
|
|
|
## exp-27 (released experimental alpha)
|
|
|
|
Release label: `exp-27`
|
|
|
|
Release name: Checked F64 To I32 Result Alpha
|
|
|
|
Release date: 2026-05-19
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_27_F64_TO_I32_RESULT_ALPHA.md`.
|
|
|
|
exp-27 promotes exactly one checked `f64` to `i32` result standard-runtime
|
|
call:
|
|
|
|
- `std.num.f64_to_i32_result : (f64) -> (result i32 i32)`
|
|
|
|
The call returns `ok value` only when the input is finite, exactly integral,
|
|
and within the signed `i32` range `-2147483648` through `2147483647`. It
|
|
returns `err 1` for non-finite, fractional, or out-of-range input, without
|
|
trapping for ordinary conversion failure.
|
|
|
|
The release adds byte-identical fixtures
|
|
`examples/supported/f64-to-i32-result.slo` and
|
|
`examples/formatter/f64-to-i32-result.slo`.
|
|
|
|
exp-27 does not add unchecked `f64` to `i32`, casts or cast syntax, generic
|
|
`cast_checked`, `f32`, unsigned or narrower integer families, additional
|
|
numeric conversion families, `f64` parse, mixed numeric arithmetic, numeric
|
|
containers, stable helper ABI/layout/ownership, manifest schema changes, or
|
|
beta maturity.
|
|
|
|
## exp-26 (released experimental alpha)
|
|
|
|
Release label: `exp-26`
|
|
|
|
Release name: F64 To String Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is `.llm/EXP_26_F64_TO_STRING_ALPHA.md`.
|
|
|
|
exp-26 promotes exactly one finite `f64` formatting standard-runtime call:
|
|
|
|
- `std.num.f64_to_string : (f64) -> string`
|
|
|
|
The release adds byte-identical fixtures
|
|
`examples/supported/f64-to-string.slo` and
|
|
`examples/formatter/f64-to-string.slo`.
|
|
|
|
exp-26 does not add `f32`, `f64` parse, generic format/display/interpolation,
|
|
locale/base/radix/grouping/padding/precision controls, stable NaN/infinity
|
|
text, implicit conversion, stable helper ABI/layout/ownership, manifest schema
|
|
changes, or beta maturity.
|
|
|
|
## exp-25 (released experimental alpha)
|
|
|
|
Release label: `exp-25`
|
|
|
|
Release name: String Parse I64 Result Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_25_STRING_PARSE_I64_RESULT_ALPHA.md`.
|
|
|
|
exp-25 promotes exactly one string parse standard-runtime call:
|
|
|
|
- `std.string.parse_i64_result : (string) -> (result i64 i32)`
|
|
|
|
The call parses an entire non-empty ASCII signed decimal `i64` string with an
|
|
optional leading `-`. Success returns `ok value`; parse failure or
|
|
out-of-range input returns `err 1`. It does not trap for ordinary parse or
|
|
range failure.
|
|
|
|
The release also adds byte-identical fixtures
|
|
`examples/supported/string-parse-i64-result.slo` and
|
|
`examples/formatter/string-parse-i64-result.slo`.
|
|
|
|
exp-25 does not add `f64` parse, generic parse APIs, a leading `+`,
|
|
whitespace trimming, underscores, base/radix prefixes, locale-aware parsing,
|
|
Unicode digit parsing, rich parse errors, stable helper ABI/layout/ownership,
|
|
manifest schema changes, or beta maturity.
|
|
|
|
## exp-24 (released experimental alpha)
|
|
|
|
Release label: `exp-24`
|
|
|
|
Release name: Integer To String Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_24_INTEGER_TO_STRING_ALPHA.md`.
|
|
|
|
exp-24 promotes exactly two integer formatting standard-runtime calls:
|
|
|
|
- `std.num.i32_to_string : (i32) -> string`
|
|
- `std.num.i64_to_string : (i64) -> string`
|
|
|
|
Each call returns a decimal signed ASCII string for the input value. Negative
|
|
values include a leading `-`; non-negative values have no leading `+`. The
|
|
operations are compiler/runtime-backed for now and may later be rewritten in
|
|
Slovo `std` source once the language can host them.
|
|
|
|
The release also adds byte-identical fixtures
|
|
`examples/supported/integer-to-string.slo` and
|
|
`examples/formatter/integer-to-string.slo`.
|
|
|
|
exp-24 does not add `f64` formatting, parse APIs, locale/base/radix/grouping
|
|
or padding controls, generic format/display traits, implicit conversions,
|
|
stable standard-library implementation source, stable helper ABI/layout and
|
|
ownership, manifest schema changes, or beta maturity.
|
|
|
|
## exp-23 (released experimental alpha)
|
|
|
|
Release label: `exp-23`
|
|
|
|
Release name: Checked I64-To-I32 Conversion Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_23_CHECKED_I64_TO_I32_CONVERSION_ALPHA.md`.
|
|
|
|
exp-23 promotes exactly one checked narrowing standard-runtime call:
|
|
|
|
- `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`
|
|
|
|
The call returns `ok value` when the signed `i64` input is within the signed
|
|
`i32` range `-2147483648` through `2147483647`, and returns `err 1` when the
|
|
input is outside that range. It does not trap on range failure.
|
|
|
|
The release also adds byte-identical fixtures
|
|
`examples/supported/checked-i64-to-i32-conversion.slo` and
|
|
`examples/formatter/checked-i64-to-i32-conversion.slo`.
|
|
|
|
The operation is an explicit call returning the existing concrete
|
|
`(result i32 i32)` family. exp-23 does not add implicit numeric promotion,
|
|
cast syntax, `std.num.cast`, checked cast generics, mixed numeric operators,
|
|
any other narrowing conversion, `f64` conversions, unsigned or narrower
|
|
integer families, numeric parse/format APIs, standard-library implementation
|
|
promises, stable ABI/layout, manifest schema changes, or beta maturity.
|
|
|
|
## exp-22 (released experimental alpha)
|
|
|
|
Release label: `exp-22`
|
|
|
|
Release name: Numeric Widening Conversions Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental alpha Slovo contract. Matching Glagol
|
|
implementation, tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_22_NUMERIC_WIDENING_CONVERSIONS_ALPHA.md`.
|
|
|
|
exp-22 promotes exactly three explicit standard-runtime numeric widening
|
|
calls:
|
|
|
|
- `std.num.i32_to_i64 : (i32) -> i64`
|
|
- `std.num.i32_to_f64 : (i32) -> f64`
|
|
- `std.num.i64_to_f64 : (i64) -> f64`
|
|
|
|
The release also adds byte-identical fixtures
|
|
`examples/supported/numeric-widening-conversions.slo` and
|
|
`examples/formatter/numeric-widening-conversions.slo`.
|
|
|
|
These operations are explicit calls. exp-22 does not add implicit numeric
|
|
promotion, mixed `i32`/`i64`/`f64` arithmetic or comparison, narrowing
|
|
conversions, checked numeric conversion result APIs, numeric cast syntax,
|
|
`f32`, unsigned or narrower integer families, numeric parse/format APIs,
|
|
stable floating rounding or formatting guarantees, stable ABI/layout, manifest
|
|
schema changes, or beta maturity.
|
|
|
|
## exp-21 (released experimental contract)
|
|
|
|
Release label: `exp-21`
|
|
|
|
Release name: I64 Numeric Primitive Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract. Matching Glagol implementation,
|
|
tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_21_I64_NUMERIC_PRIMITIVE_ALPHA.md`.
|
|
|
|
exp-21 allows direct `i64` value flow, explicit signed decimal `i64` literal
|
|
atoms, same-type arithmetic/comparison, and one print operation:
|
|
|
|
```slo
|
|
(fn adjust ((value i64) (delta i64)) -> i64
|
|
(+ value delta))
|
|
```
|
|
|
|
It promotes:
|
|
|
|
- direct `i64` function parameters and returns
|
|
- immutable `let` locals declared as `i64`
|
|
- explicit signed decimal `i64` literal atoms such as `2147483648i64`,
|
|
`42i64`, and `-7i64`
|
|
- calls passing and returning `i64`
|
|
- same-type `i64` `+`, `-`, `*`, and `/`
|
|
- same-type `i64` `=`, `<`, `>`, `<=`, and `>=`
|
|
- `std.io.print_i64`
|
|
- byte-identical fixtures
|
|
`examples/supported/i64-numeric-primitive.slo` and
|
|
`examples/formatter/i64-numeric-primitive.slo`
|
|
|
|
Unsuffixed integer literals remain the existing `i32` surface, and `main`
|
|
continues to return `i32`.
|
|
|
|
exp-21 does not add `f32`, unsigned integers, narrower integer widths beyond
|
|
existing `i32`, `char`, `bytes`, `decimal`, numeric casts, implicit promotion,
|
|
mixed `i32`/`i64`/`f64` arithmetic, generic numeric operators, i64
|
|
arrays/vectors/options/results/enum payloads/struct fields, mutable `i64`
|
|
locals, `parse_i64`, random `i64`, broader math APIs, stable divide-by-zero or
|
|
overflow diagnostics, stable ABI/layout, manifest schema changes, or beta
|
|
maturity.
|
|
|
|
## exp-20 (released experimental contract)
|
|
|
|
Release label: `exp-20`
|
|
|
|
Release name: F64 Numeric Primitive Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract. Matching Glagol implementation,
|
|
tests, gates, and review workflow are required before broader
|
|
compiler-support claims. This is experimental maturity and not a beta maturity
|
|
claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_20_F64_NUMERIC_PRIMITIVE_ALPHA.md`.
|
|
|
|
exp-20 allows direct `f64` value flow, same-type arithmetic/comparison, and
|
|
one print operation:
|
|
|
|
```slo
|
|
(fn half ((value f64)) -> f64
|
|
(/ value 2.0))
|
|
```
|
|
|
|
It promotes:
|
|
|
|
- direct `f64` function parameters and returns
|
|
- immutable `let` locals declared as `f64`
|
|
- decimal `f64` literals in `f64` contexts
|
|
- calls passing and returning `f64`
|
|
- same-type `f64` `+`, `-`, `*`, and `/`
|
|
- same-type `f64` `=`, `<`, `>`, `<=`, and `>=`
|
|
- `std.io.print_f64`
|
|
- byte-identical fixtures
|
|
`examples/supported/f64-numeric-primitive.slo` and
|
|
`examples/formatter/f64-numeric-primitive.slo`
|
|
|
|
exp-20 does not add `f32`, `i64/u64/u32/u16/u8/i16/i8`, `char`, `bytes`,
|
|
`decimal`, numeric casts, implicit promotion, mixed `i32`/`f64` arithmetic,
|
|
generic numeric operators, f64 arrays/vectors/options/results/enum payloads/
|
|
struct fields, mutable `f64` locals, `parse_f64`, random floats, broader math
|
|
library calls, stable NaN/infinity/rounding semantics, stable print text
|
|
formatting beyond newline-terminated output, stable ABI/layout, manifest
|
|
schema changes, or beta maturity.
|
|
|
|
## exp-19 (released experimental contract)
|
|
|
|
Release label: `exp-19`
|
|
|
|
Release name: Primitive Struct Fields Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract. Matching Glagol implementation,
|
|
tests, gates, and review workflow are required before broader compiler-support
|
|
claims. This is experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_19_PRIMITIVE_STRUCT_FIELDS_ALPHA.md`.
|
|
|
|
exp-19 allows direct `bool` and immutable `string` field types alongside
|
|
already supported direct `i32` fields and exp-18 direct enum fields:
|
|
|
|
```slo
|
|
(struct PrimitiveRecord
|
|
(id i32)
|
|
(active bool)
|
|
(label string))
|
|
```
|
|
|
|
It promotes:
|
|
|
|
- struct field declarations using direct `bool` and immutable `string`
|
|
field types
|
|
- struct construction with `i32`, `bool`, and immutable `string` field values
|
|
- field access returning the declared primitive field type
|
|
- bool field access in existing predicate positions
|
|
- string field access in existing string equality and `std.string.len`
|
|
- immutable local, parameter, return, call, test, and `main` flow for structs
|
|
carrying primitive fields
|
|
- byte-identical fixtures
|
|
`examples/supported/primitive-struct-fields.slo` and
|
|
`examples/formatter/primitive-struct-fields.slo`
|
|
|
|
exp-19 does not add arrays, vectors, options, or results containing
|
|
primitive-field structs, primitive fields inside containers, nested structs,
|
|
struct mutation, string mutation, ownership/cleanup guarantees beyond existing
|
|
string behavior, broader string operations, printing beyond existing calls,
|
|
generics, methods, traits, manifest schema changes, package/import widening,
|
|
stable ABI/layout, or beta maturity.
|
|
|
|
## exp-18 (released experimental contract)
|
|
|
|
Release label: `exp-18`
|
|
|
|
Release name: Enum Struct Fields Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract. Matching Glagol implementation,
|
|
tests, gates, and review workflow are required before broader compiler-support
|
|
claims. This is experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_18_ENUM_STRUCT_FIELDS_ALPHA.md`.
|
|
|
|
exp-18 allows current user-defined enum types as direct struct field types:
|
|
|
|
```slo
|
|
(enum Status Ready Blocked)
|
|
|
|
(enum Reading
|
|
Missing
|
|
(Value i32))
|
|
|
|
(struct TaggedReading
|
|
(status Status)
|
|
(reading Reading))
|
|
```
|
|
|
|
It promotes:
|
|
|
|
- struct field declarations using current enum type names directly
|
|
- struct construction with payloadless and unary `i32` enum field values
|
|
- field access returning the declared enum type
|
|
- same-enum equality on field access
|
|
- exhaustive enum `match` on field access
|
|
- immutable local, parameter, return, call, test, and `main` flow for structs
|
|
carrying enum fields
|
|
- byte-identical fixtures
|
|
`examples/supported/enum-struct-fields.slo` and
|
|
`examples/formatter/enum-struct-fields.slo`
|
|
|
|
The enum surface is exactly exp-4 payloadless variants plus exp-16 unary
|
|
`i32` payload variants. exp-18 does not add payload types other than `i32`,
|
|
multiple payloads, record variants, tuple variants beyond one `i32`, arrays,
|
|
vectors, options, or results containing enum values, nested structs, struct
|
|
mutation, enum mutation, printing, ordering, hashing, reflection, stable
|
|
ABI/layout, manifest schema changes, import aliases/globs/re-exports,
|
|
registry/package-manager claims, generics, or beta maturity.
|
|
|
|
## exp-17 (released experimental contract)
|
|
|
|
Release label: `exp-17`
|
|
|
|
Release name: Project Enum Imports Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract. Matching Glagol implementation,
|
|
tests, gates, and review workflow are required before broader compiler-support
|
|
claims. This is experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_17_PROJECT_ENUM_IMPORTS_ALPHA.md`.
|
|
|
|
exp-17 extends the existing explicit project/workspace module export and
|
|
import lists so top-level user-defined enum names can cross local module
|
|
boundaries:
|
|
|
|
```slo
|
|
(module readings (export Reading))
|
|
|
|
(import readings (Reading))
|
|
```
|
|
|
|
It promotes imported enum type use in:
|
|
|
|
- function signatures
|
|
- immutable locals
|
|
- calls and returns
|
|
- same-enum equality
|
|
- exhaustive enum matches
|
|
- qualified constructors
|
|
|
|
The enum surface is exactly exp-4 payloadless variants plus exp-16 unary
|
|
`i32` payload variants. Payloadless constructors remain zero-argument
|
|
qualified constructors, and unary payload constructors still take exactly one
|
|
`i32` argument.
|
|
|
|
The exp-17 project fixture is:
|
|
|
|
```text
|
|
examples/projects/enum-imports/slovo.toml
|
|
examples/projects/enum-imports/src/readings.slo
|
|
examples/projects/enum-imports/src/main.slo
|
|
```
|
|
|
|
exp-17 does not add payload types other than `i32`, multiple payloads, record
|
|
variants, tuple variants beyond one `i32`, generics, containers, mutation,
|
|
printing, ordering, hashing, reflection, unqualified variant constructors,
|
|
stable ABI/layout, manifest schema changes, registry/package-manager claims,
|
|
or beta maturity.
|
|
|
|
## exp-16 (released experimental contract)
|
|
|
|
Release label: `exp-16`
|
|
|
|
Release name: Unary I32 Enum Payloads Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract. Matching Glagol implementation,
|
|
tests, gates, and review workflow are required before broader compiler-support
|
|
claims. This is experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_16_UNARY_I32_ENUM_PAYLOADS_ALPHA.md`.
|
|
|
|
exp-16 extends user-defined enums to allow payloadless variants plus unary
|
|
`i32` payload variants:
|
|
|
|
```slo
|
|
(enum Reading
|
|
Missing
|
|
(Value i32)
|
|
(Offset i32))
|
|
```
|
|
|
|
It promotes:
|
|
|
|
- qualified unary payload constructors such as `(Reading.Value value)`
|
|
- payloadless constructors such as `(Reading.Missing)` unchanged
|
|
- enum `match` arms with payloadless patterns and one immutable arm-local
|
|
payload binding for payload variants
|
|
- immutable local, parameter, return, call, test, and `main` flow for enum
|
|
values
|
|
- same-enum equality where payload variants compare by tag and payload, and
|
|
payloadless variants compare by tag
|
|
- byte-identical fixtures
|
|
`examples/supported/enum-payload-i32.slo` and
|
|
`examples/formatter/enum-payload-i32.slo`
|
|
|
|
exp-16 does not add payload types other than `i32`, multiple payloads, record
|
|
variants, tuple variants beyond one `i32`, string/bool/struct/enum payloads,
|
|
generic enums, generic functions, type aliases, traits, methods, derives,
|
|
wildcard/rest/nested enum patterns, pattern guards, enum payload mutation,
|
|
enum values inside arrays/structs/options/results/vectors, enum printing,
|
|
ordering, hashing, reflection, discriminants, stable ABI/layout, manifest
|
|
schema changes, runtime ABI/layout claims, moving option/result to ordinary
|
|
standard-library types, or beta maturity.
|
|
|
|
## exp-15 (released experimental contract)
|
|
|
|
Release label: `exp-15`
|
|
|
|
Release name: Result Helper Standard Names Alpha
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental Slovo contract with matching Glagol
|
|
implementation, tests, gates, and review workflow. This is experimental
|
|
maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_15_RESULT_HELPER_STANDARD_NAMES_ALPHA.md`.
|
|
|
|
exp-15 is a narrow result helper standard-name alpha:
|
|
|
|
- promotes preferred source-level names `std.result.is_ok`,
|
|
`std.result.is_err`, `std.result.unwrap_ok`, and `std.result.unwrap_err`
|
|
- accepts those names only for `(result i32 i32)` and `(result string i32)`
|
|
- keeps legacy unqualified `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err`
|
|
documented as compatibility syntax where already supported
|
|
- reuses existing result observer and trap-based unwrap semantics
|
|
- adds byte-identical fixtures
|
|
`examples/supported/result-helpers.slo` and
|
|
`examples/formatter/result-helpers.slo`
|
|
- keeps `slovo.artifact-manifest` schema version `1`
|
|
|
|
exp-15 does not add `std.result.map`, `std.result.unwrap_or`,
|
|
`std.result.and_then`, option helper standard names, new payload families,
|
|
generic result, user-defined error payloads, runtime ABI/layout claims,
|
|
manifest schema changes, enum payloads, or beta maturity.
|
|
|
|
## exp-14 (released experimental contract)
|
|
|
|
Release label: `exp-14`
|
|
|
|
Release name: Standard Runtime Conformance Alignment
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental conformance alignment after matching Glagol
|
|
exp-14 implementation, tests, focused conformance gate, full release gate, and
|
|
review passed. This is experimental maturity and not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_14_STANDARD_RUNTIME_CONFORMANCE_ALIGNMENT.md`.
|
|
|
|
exp-14 is a conformance/readiness alignment seed over the released exp-13
|
|
surface:
|
|
|
|
- catalogs every promoted compiler-known `std.*` operation through exp-13 in
|
|
`STANDARD_RUNTIME.md`
|
|
- keeps the supported fixture inventory explicit
|
|
- adds byte-identical canonical fixtures for the already released exp-8 time
|
|
operations:
|
|
`examples/supported/time-sleep.slo` and
|
|
`examples/formatter/time-sleep.slo`
|
|
- requires Slovo/Glagol supported and formatter fixtures to stay byte-aligned
|
|
where matching files exist
|
|
- requires a fresh-project workflow covering `new`, `check`, `fmt --check`,
|
|
`test`, `doc`, and `build` where the hosted toolchain exists
|
|
- requires an integrated workflow over already released features: modules/
|
|
imports, tests, strings, `std.string.concat`,
|
|
`std.string.parse_i32_result`, result `match`, `(vec i32)`, enum `match`,
|
|
and `std.io.print_i32`
|
|
- keeps the release gate strict: diff checks, `cargo fmt --check`,
|
|
`cargo test`, ignored promotion gate, binary smoke, LLVM smoke, and review
|
|
`PASS`
|
|
|
|
The exp-14 release gate passed with Slovo/Glagol diff checks,
|
|
`cargo fmt --check`, `cargo test`, ignored promotion gate, binary smoke, LLVM
|
|
smoke, focused conformance gate, and review `PASS`.
|
|
|
|
exp-14 adds no new source syntax, type forms, runtime APIs, compiler-known
|
|
`std.*` names, standard library functions, manifest schema version,
|
|
ABI/layout promise, runtime headers/libraries, or beta maturity.
|
|
|
|
## exp-13 (released experimental contract)
|
|
|
|
Release label: `exp-13`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-13
|
|
implementation, tests, review, and full release gate coverage passed. This is
|
|
not a beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_13_STRING_PARSE_I32_RESULT_ALPHA.md`.
|
|
|
|
exp-13 is a narrow string parse i32 result alpha:
|
|
|
|
- `std.string.parse_i32_result: (string) -> (result i32 i32)`
|
|
- parses the entire input string as ASCII decimal signed `i32`
|
|
- accepts an optional leading `-` and at least one ASCII digit
|
|
- success returns `(ok i32 i32 value)`
|
|
- empty input, non-digits, plus signs, whitespace, trailing bytes,
|
|
non-ASCII digits, and out-of-range values return `(err i32 i32 1)`
|
|
- only ordinary parse error code `err 1` is promised
|
|
- the operation composes structurally with
|
|
`std.io.read_stdin_result` by matching the stdin result and parsing only the
|
|
`ok` string payload
|
|
|
|
Release fixtures:
|
|
|
|
```text
|
|
examples/supported/string-parse-i32-result.slo
|
|
examples/formatter/string-parse-i32-result.slo
|
|
```
|
|
|
|
exp-13 does not add trap-based `std.string.parse_i32`, parsing floats, bools,
|
|
strings, or bytes, whitespace/locale/base-prefix/underscore/plus-sign parsing,
|
|
generic parse APIs, parse error messages or richer codes, Unicode digit
|
|
parsing, string indexing or slicing, tokenizer/scanner APIs, stdin line APIs,
|
|
stable helper ABI/layout, manifest schema fields, or beta maturity.
|
|
|
|
## exp-12 (released experimental contract)
|
|
|
|
Release label: `exp-12`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-12
|
|
implementation, tests, review, and release gate coverage passed. This is not a
|
|
beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_12_STDIN_RESULT_ALPHA.md`.
|
|
|
|
exp-12 is a narrow standard input result alpha:
|
|
|
|
- `std.io.read_stdin_result: () -> (result string i32)`
|
|
- reads remaining standard input as text
|
|
- success returns `(ok string i32 text)`
|
|
- ordinary EOF with no bytes is success with the empty string
|
|
- ordinary host/input failure returns `(err string i32 1)`
|
|
- only ordinary failure code `err 1` is promised
|
|
- Glagol test-runner behavior may use an implementation-owned fixed input
|
|
string as `ok`
|
|
- existing exp-3 and exp-10 host calls stay unchanged
|
|
|
|
Release fixtures:
|
|
|
|
```text
|
|
examples/supported/stdin-result.slo
|
|
examples/formatter/stdin-result.slo
|
|
```
|
|
|
|
exp-12 does not add trap-based `std.io.read_stdin`, line iteration, prompt
|
|
APIs, terminal mode, binary stdin, streaming, async, encoding/Unicode promises
|
|
beyond existing string bytes, stable helper ABI/layout, manifest schema
|
|
changes, or beta maturity.
|
|
|
|
## exp-11 (released experimental contract)
|
|
|
|
Release label: `exp-11`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-11
|
|
implementation, tests, review, and release gate coverage passed. This is not a
|
|
beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_11_BASIC_RANDOMNESS_ALPHA.md`.
|
|
|
|
exp-11 is a narrow basic randomness alpha:
|
|
|
|
- `std.random.i32: () -> i32`
|
|
- returns a non-negative implementation-owned pseudo-random or host-random
|
|
`i32`
|
|
- suitable only for basic CLI use
|
|
- deterministic-enough Glagol test-runner behavior through an
|
|
implementation-owned non-negative sample or sequence
|
|
- runtime/host inability to produce a value traps exactly as
|
|
`slovo runtime error: random i32 unavailable`
|
|
|
|
Release fixtures:
|
|
|
|
```text
|
|
examples/supported/random.slo
|
|
examples/formatter/random.slo
|
|
```
|
|
|
|
exp-11 does not claim seed APIs, cryptographic/security suitability, bytes
|
|
APIs, ranges or bounds arguments, floats, random strings, UUIDs, broad
|
|
`std.random.*`, randomness-specific manifest fields, stable ABI/layout/helper
|
|
symbols, or beta maturity.
|
|
|
|
## exp-10 (released experimental contract)
|
|
|
|
Release label: `exp-10`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-10
|
|
implementation, tests, review, and release gate coverage passed. This is not a
|
|
beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_10_RESULT_BASED_HOST_ERRORS_ALPHA.md`.
|
|
|
|
exp-10 is a narrow result-based host errors alpha:
|
|
|
|
- concrete `(result string i32)` only
|
|
- `std.process.arg_result: (i32) -> (result string i32)`
|
|
- `std.env.get_result: (string) -> (result string i32)`
|
|
- `std.fs.read_text_result: (string) -> (result string i32)`
|
|
- `std.fs.write_text_result: (string string) -> (result i32 i32)`
|
|
- ordinary host failure as `err 1`
|
|
- exp-3 calls unchanged
|
|
|
|
Release fixtures:
|
|
|
|
```text
|
|
examples/supported/host-io-result.slo
|
|
examples/formatter/host-io-result.slo
|
|
```
|
|
|
|
exp-10 does not claim general host error ADTs, `result string Error`,
|
|
platform-specific codes, error messages, result equality/printing/mapping,
|
|
broader host APIs, stable ABI/layout/helper symbols, manifest schema changes,
|
|
or beta maturity.
|
|
|
|
## exp-9 (released experimental contract)
|
|
|
|
Release label: `exp-9`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-9
|
|
implementation, tests, review, and release gate coverage passed. This is not a
|
|
beta maturity claim.
|
|
|
|
The normative release contract is
|
|
`.llm/EXP_9_RELIABILITY_PERFORMANCE_ECOSYSTEM_HARDENING.md`.
|
|
|
|
exp-9 is hardening-only over the released exp-8 baseline. It requires
|
|
reliability, performance, and ecosystem gates for the existing promoted
|
|
experimental surface: property/fuzz-style parser, formatter, diagnostic,
|
|
project graph, and runtime API tests where feasible; a source-reachable panic
|
|
audit; benchmark fixtures or documented benchmark smoke; compatibility
|
|
inventory for promoted experimental features; and a migration guide from
|
|
`v2.0.0-beta.1` and exp releases.
|
|
|
|
exp-9 adds no source language syntax, type-system behavior, standard-runtime
|
|
names, package features, manifest schema versions, stable ABI/layout promises,
|
|
public performance guarantees, or beta maturity.
|
|
|
|
## exp-8 (released experimental contract)
|
|
|
|
Release label: `exp-8`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-8
|
|
implementation, tests, review, and release gate coverage passed. This is not a
|
|
beta maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-8 narrows the broad concurrency and long-running programs roadmap category
|
|
to host time and sleep alpha for long-running command-line programs:
|
|
|
|
- compiler-known `std.time.monotonic_ms: () -> i32`
|
|
- compiler-known `std.time.sleep_ms: (i32) -> unit`
|
|
- host monotonic elapsed milliseconds with implementation-owned epoch
|
|
- valid `sleep_ms 0` behavior
|
|
- negative sleep durations rejected or trapped with
|
|
`slovo runtime error: sleep_ms negative duration`
|
|
- deterministic test-runner handling for `sleep_ms 0`
|
|
- conservative structural or non-negative host-value test-runner support for
|
|
`monotonic_ms`
|
|
- standard-runtime time usage recorded in artifact manifests only if existing
|
|
manifest patterns already support standard-runtime usage metadata
|
|
|
|
The normative release contract is `.llm/EXP_8_HOST_TIME_SLEEP_ALPHA.md`.
|
|
exp-8 adds no source language syntax and does not claim threads, channels,
|
|
async, cancellation, actors, shared memory, data-race freedom, scheduling,
|
|
timers, wall-clock/calendar/timezone APIs, high-resolution timers, signal
|
|
handling, stable ABI/layout, or stable runtime helper symbols.
|
|
|
|
## exp-7 (released experimental contract)
|
|
|
|
Release label: `exp-7`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-7
|
|
implementation, tests, review, and release gate coverage. This is not a beta
|
|
maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-7 is deliberately limited to test selection and richer test-run metadata:
|
|
|
|
- `glagol test <file.slo|project> --filter <substring>`
|
|
- legacy `glagol --run-tests --filter <substring> <file.slo>` while Glagol
|
|
keeps the legacy route
|
|
- deterministic substring selection against test display names
|
|
- selected tests execute in the existing deterministic order
|
|
- non-selected discovered tests are skipped and counted
|
|
- zero matches is a successful run with explicit discovered/selected/passed/
|
|
failed/skipped counts
|
|
- additive text-output and artifact-manifest test-run metadata
|
|
|
|
The normative contract is `.llm/EXP_7_TEST_SELECTION_ALPHA.md`. exp-7 adds no
|
|
source language syntax and does not claim LSP, debug metadata, source maps,
|
|
SARIF, watch/daemon protocols, documentation comments, lint categories, or
|
|
benchmarks.
|
|
|
|
## exp-6 (released experimental contract)
|
|
|
|
Release label: `exp-6`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-6
|
|
implementation, tests, review, and release gate coverage. This is not a beta
|
|
maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-6 is deliberately limited to C FFI scalar imports:
|
|
|
|
- top-level imported C function declarations such as
|
|
`(import_c c_add ((lhs i32) (rhs i32)) -> i32)`
|
|
- `i32`-only scalar parameters and `i32` or internal builtin `unit` returns
|
|
- a conservative C symbol name subset matching the Slovo import name
|
|
- lexical `(unsafe ...)` required at every imported C call site
|
|
- explicit local C source linking through `glagol build --link-c <path>`
|
|
- artifact-manifest recording of `foreign_imports` and `c_link_inputs`
|
|
- an interpreter-style test-runner diagnostic when a test reaches an imported
|
|
C call
|
|
|
|
The normative contract is `.llm/EXP_6_C_FFI_SCALAR_IMPORTS_ALPHA.md`. The
|
|
minimal fixture target is `examples/ffi/exp-6-c-add/`.
|
|
|
|
## exp-6 Deferrals
|
|
|
|
exp-6 does not support pointer types, allocation/deallocation, raw unsafe head
|
|
execution, ownership or lifetime rules, C exports, callbacks, headers,
|
|
libraries, broad linker configuration, foreign globals, foreign structs,
|
|
unions, enums, layout annotations, stable ABI, or stable layout.
|
|
|
|
## exp-5 (released experimental contract)
|
|
|
|
Release label: `exp-5`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-5
|
|
implementation, tests, review, and release gate coverage. This is not a beta
|
|
maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-5 is deliberately limited to local packages and workspace hygiene:
|
|
|
|
- workspace `slovo.toml` manifests with explicit local member lists
|
|
- package `slovo.toml` manifests with package name/version metadata
|
|
- local path dependencies between workspace members
|
|
- deterministic package graph ordering
|
|
- explicit package-qualified imports for dependency modules
|
|
- package graph recording in artifact manifests
|
|
- diagnostics for missing package, dependency cycle, duplicate package name,
|
|
path escape, invalid package name/version, and private visibility across
|
|
package boundaries
|
|
|
|
The normative contract is `.llm/EXP_5_LOCAL_PACKAGES_ALPHA.md`. The minimal
|
|
fixture target is `examples/workspaces/exp-5-local/`.
|
|
|
|
## exp-5 Deferrals
|
|
|
|
exp-5 does not support remote registries, version solving, lockfiles beyond
|
|
deterministic local graph recording, build scripts, generated code, published
|
|
packages, semver compatibility promises, macros, package-level generics,
|
|
cross-package ABI stability, package re-exports, package archives, package
|
|
publishing, registry authentication, feature flags, optional dependencies, dev
|
|
dependencies, or target dependencies.
|
|
|
|
## exp-4 (released experimental contract)
|
|
|
|
Release label: `exp-4`
|
|
|
|
Release date: 2026-05-18
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-4
|
|
implementation, tests, review, and release gate coverage. This is not a beta
|
|
maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-4 narrows user-defined data types to payloadless enums only:
|
|
|
|
```slo
|
|
(enum Name VariantA VariantB)
|
|
```
|
|
|
|
Variant values are constructed through zero-argument qualified calls such as
|
|
`(Name.VariantA)`. Enum values may flow through immutable locals, parameters,
|
|
returns, calls, equality with `=`, and top-level tests.
|
|
|
|
Enum `match` requires exhaustive payloadless variant arms:
|
|
|
|
```slo
|
|
(match value
|
|
((Name.VariantA)
|
|
body...)
|
|
((Name.VariantB)
|
|
body...))
|
|
```
|
|
|
|
Arms have one or more expression bodies and a common final result type,
|
|
following the existing option/result match rule.
|
|
|
|
## Runtime And Layout
|
|
|
|
The runtime/backend representation is compiler-owned. exp-4 makes no stable
|
|
layout, discriminant value, ABI, helper-symbol, reflection, or conversion to
|
|
`i32` promise.
|
|
|
|
## Fixtures
|
|
|
|
exp-4 adds these current compiler-supported fixtures:
|
|
|
|
```text
|
|
examples/supported/enum-basic.slo
|
|
examples/formatter/enum-basic.slo
|
|
```
|
|
|
|
They are current exp-4 fixtures.
|
|
|
|
## exp-4 Deferrals
|
|
|
|
exp-4 does not support payload variants, tuple variants, record variants,
|
|
generic enums, generic functions, type aliases, traits, interfaces, protocols,
|
|
methods, derives, variant payload binding, wildcard patterns, rest patterns,
|
|
guards, nested patterns, enum values in arrays, enum values in struct fields,
|
|
enum values in options, enum values in results, enum values in vectors, enum
|
|
mutation, enum printing, enum ordering, enum hashing, reflection, explicit
|
|
discriminants, enum constructors with arguments, unqualified variant
|
|
constructors, stable ABI/layout, stable helper symbols, or moving
|
|
option/result to ordinary standard-library types.
|
|
|
|
## exp-3 (released experimental contract)
|
|
|
|
Release label: `exp-3`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-3
|
|
implementation, tests, review, and release gate coverage. This is not a beta
|
|
maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-3 narrows standard IO and host environment support to exactly six
|
|
compiler-known functions:
|
|
|
|
```text
|
|
std.io.eprint: (string) -> unit
|
|
std.process.argc: () -> i32
|
|
std.process.arg: (i32) -> string
|
|
std.env.get: (string) -> string
|
|
std.fs.read_text: (string) -> string
|
|
std.fs.write_text: (string string) -> i32
|
|
```
|
|
|
|
`std.io.eprint` writes to stderr without adding a newline. `std.process.argc`
|
|
returns the process argument count, and `std.process.arg` returns a zero-based
|
|
argument string. `std.env.get` returns the environment variable value, with a
|
|
missing variable returning the empty string in this stage.
|
|
`std.fs.read_text` reads a whole text file, and `std.fs.write_text` writes a
|
|
whole string to a path.
|
|
|
|
## Runtime Behavior
|
|
|
|
Out-of-range process argument access traps with:
|
|
|
|
```text
|
|
slovo runtime error: process argument index out of bounds
|
|
```
|
|
|
|
Host file read failure traps with:
|
|
|
|
```text
|
|
slovo runtime error: file read failed
|
|
```
|
|
|
|
Both messages are written to stderr with a trailing newline and exit with code
|
|
`1`.
|
|
|
|
`std.fs.write_text` returns `0` on success and `1` on host failure for this
|
|
stage.
|
|
|
|
## Fixture Targets
|
|
|
|
exp-3 adds these current compiler-supported fixture targets:
|
|
|
|
```text
|
|
examples/supported/host-io.slo
|
|
examples/formatter/host-io.slo
|
|
```
|
|
|
|
They are current exp-3 fixtures.
|
|
|
|
## exp-3 Deferrals
|
|
|
|
exp-3 does not support networking, async IO, binary file APIs, directory
|
|
traversal, terminal control, platform abstraction, general host error ADTs,
|
|
`result string Error`, package interaction, stdin full read or line iteration,
|
|
randomness, time, stable ABI/layout, or stable runtime helper symbols.
|
|
|
|
## exp-2 (released experimental contract)
|
|
|
|
Release label: `exp-2`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
Status: released experimental compiler support after matching Glagol exp-2
|
|
implementation, tests, review, and release gate coverage. This is not a beta
|
|
maturity claim.
|
|
|
|
## Summary
|
|
|
|
exp-2 narrows collections to one concrete growable vector type:
|
|
|
|
```text
|
|
(vec i32)
|
|
```
|
|
|
|
The only promoted operations are compiler-known standard-runtime names:
|
|
|
|
```text
|
|
std.vec.i32.empty: () -> (vec i32)
|
|
std.vec.i32.append: ((vec i32), i32) -> (vec i32)
|
|
std.vec.i32.len: ((vec i32)) -> i32
|
|
std.vec.i32.index: ((vec i32), i32) -> i32
|
|
```
|
|
|
|
`std.vec.i32.append` returns a new immutable runtime-owned vector and does not
|
|
mutate its input. `(vec i32)` values may flow through immutable locals,
|
|
parameters, returns, calls, and top-level tests. Vector equality with `=`
|
|
compares lengths and `i32` elements in order.
|
|
|
|
## Runtime Behavior
|
|
|
|
Allocation failure traps with:
|
|
|
|
```text
|
|
slovo runtime error: vector allocation failed
|
|
```
|
|
|
|
Index failure traps with:
|
|
|
|
```text
|
|
slovo runtime error: vector index out of bounds
|
|
```
|
|
|
|
Both messages are written to stderr with a trailing newline and exit with code
|
|
`1`. Vector cleanup is compiler/runtime-owned and not source-visible.
|
|
|
|
## Fixture Targets
|
|
|
|
exp-2 adds these current compiler-supported fixture targets:
|
|
|
|
```text
|
|
examples/supported/vec-i32.slo
|
|
examples/formatter/vec-i32.slo
|
|
```
|
|
|
|
They are current exp-2 fixtures.
|
|
|
|
## exp-2 Deferrals
|
|
|
|
exp-2 does not support generic vectors, element types other than `i32`, vector
|
|
mutation, vector `var` or `set`, vector literals beyond empty/append
|
|
construction, a `push` alias, nested vectors, vectors in arrays, structs,
|
|
options, or results, iterators, slices, maps, sets, user-visible deallocation,
|
|
stable ABI/layout/helper symbols, packages, or IO expansion.
|
|
|
|
## exp-1 (released experimental contract)
|
|
|
|
Release label: `exp-1`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
Status: current experimental compiler support after matching Glagol exp-1
|
|
implementation, tests, review, and release gate coverage.
|
|
|
|
## Summary
|
|
|
|
exp-1 is the first narrow step toward the future `1.0.0-beta` general-purpose
|
|
language threshold. It promotes one heap-created string operation:
|
|
|
|
```slo
|
|
(std.string.concat left right)
|
|
```
|
|
|
|
The exact signature is `(string, string) -> string`. The result is an
|
|
immutable runtime-owned `string`. Existing string equality, `std.string.len`,
|
|
`std.io.print_string`, string locals, parameters, returns, and calls returning
|
|
`string` apply to runtime-owned strings as they do to literal-backed strings.
|
|
|
|
No legacy `string_concat` alias is introduced. `std.string.concat` is a
|
|
compiler-known standard-runtime name, not a user module, import, package
|
|
dependency, foreign function, or stable C ABI symbol.
|
|
|
|
## Runtime Behavior
|
|
|
|
Allocation failure traps with:
|
|
|
|
```text
|
|
slovo runtime error: string allocation failed
|
|
```
|
|
|
|
The message is written to stderr with a trailing newline and exits with code
|
|
`1`. Runtime-owned string cleanup is compiler/runtime-owned and not
|
|
source-visible.
|
|
|
|
## Fixture Targets
|
|
|
|
exp-1 adds these current compiler-supported fixture targets:
|
|
|
|
```text
|
|
examples/supported/owned-string-concat.slo
|
|
examples/formatter/owned-string-concat.slo
|
|
```
|
|
|
|
They are current exp-1 fixtures.
|
|
|
|
## exp-1 Deferrals
|
|
|
|
exp-1 does not support mutable strings, string containers, string indexing or
|
|
slicing, interpolation, formatting APIs, Unicode scalar/grapheme/display-width
|
|
APIs, user-visible allocation or deallocation, file IO, environment variables,
|
|
process arguments, time, randomness, packages, workspaces, generics,
|
|
overloading, user-defined standard modules, growable collections, raw-memory
|
|
execution, FFI, stable ABI, or stable layout.
|
|
|
|
## v2.0.0-beta.1
|
|
|
|
Release tag: `v2.0.0-beta.1`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo `v2.0.0-beta.1` is an experimental integration/readiness release based
|
|
on v1.7. It does not add new source language syntax or semantics unless that
|
|
behavior is already implemented and gate-proven in Glagol.
|
|
|
|
Experimental readiness means Slovo is usable for small real flat local
|
|
projects with:
|
|
|
|
- `glagol new`
|
|
- `glagol check`
|
|
- `glagol fmt --check`
|
|
- `glagol fmt --write`
|
|
- `glagol test`
|
|
- `glagol build`
|
|
- `glagol doc`
|
|
- artifact manifests
|
|
- JSON diagnostics
|
|
- the release-gate script
|
|
|
|
## Experimental-Supported Surface
|
|
|
|
The experimental language surface is the accumulated v1.1-v1.7 surface:
|
|
`i32`, `bool`, builtin internal `unit`, top-level tests, locals, `if`,
|
|
`while`, structs, fixed direct scalar arrays with checked indexing, string
|
|
value flow, option/result values and the exact v1.4 match slice,
|
|
standard-runtime alpha names, and the v1.6 lexical unsafe boundary with
|
|
reserved unsafe heads.
|
|
|
|
Basic IO is exactly `std.io.print_i32`, `std.io.print_string`,
|
|
`std.io.print_bool`, and `std.string.len`. There is no file IO, environment
|
|
variable IO, process argument IO, process control, or time/clock API in this
|
|
experimental release.
|
|
|
|
## Experimental Deferrals
|
|
|
|
Vectors and growable collections are deferred until future beta work unless
|
|
separately implemented and gate-proven in Glagol. Fixed direct scalar arrays
|
|
with checked indexing satisfy the experimental gate because this is an
|
|
integration/readiness release for small flat local projects; growable
|
|
collections require allocation, ownership/lifetime, mutation, capacity,
|
|
diagnostics, lowering, runtime tests, and documentation that remain future beta
|
|
work.
|
|
|
|
Slovo `v2.0.0-beta.1` also makes no stable ABI/layout, FFI, raw-memory
|
|
execution, LSP, debug metadata, source-map, file/env/process/time IO, or
|
|
package registry promise.
|
|
|
|
## v1.7
|
|
|
|
Release tag: `v1.7`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.7 is a conservative developer experience hardening release over the
|
|
v1.6 language contract. It adds tooling contracts only and does not promote new
|
|
source language syntax, type-system behavior, runtime semantics, standard
|
|
runtime names, ABI/layout guarantees, LSP support, stable debug metadata, or
|
|
stable source maps.
|
|
|
|
v1.7 promotes contracts for:
|
|
|
|
- `glagol new <project-dir> [--name <name>]`
|
|
- `glagol fmt --check <file-or-project>`
|
|
- `glagol fmt --write <file-or-project>`
|
|
- `glagol doc <file-or-project> -o <dir>`
|
|
- a local release-gate script
|
|
|
|
## Project Scaffolding
|
|
|
|
`glagol new` creates a valid v1.3-style project containing `slovo.toml` and
|
|
`src/main.slo`. The generated main module must be small, testable, and limited
|
|
to already-supported language forms.
|
|
|
|
The command must fail without overwriting non-empty target directories.
|
|
|
|
## Formatter Modes
|
|
|
|
Plain `glagol fmt <file.slo>` remains stdout formatting and does not write the
|
|
input file.
|
|
|
|
`glagol fmt --check <file-or-project>` checks canonical formatting without
|
|
writing. `glagol fmt --write <file-or-project>` writes canonical formatting for
|
|
one file or for all immediate `.slo` project source modules in deterministic
|
|
module order.
|
|
|
|
## Documentation Generator
|
|
|
|
`glagol doc <file-or-project> -o <dir>` generates deterministic Markdown from
|
|
current source structure: modules, imports/exports, structs, functions, and
|
|
tests. It is a documentation generator, not a semantic reflection API.
|
|
|
|
## Release Gate
|
|
|
|
The repo must provide a script or documented command entry point that runs the
|
|
full v1 release gate locally without network, tag, push, or release-publication
|
|
side effects.
|
|
|
|
## v1.7 Deferrals
|
|
|
|
Slovo v1.7 does not support new language syntax or semantics, package
|
|
management, dependency management, stdin formatting, recursive directory
|
|
formatting, LSP, SARIF, watch mode, daemon protocols, debug adapters, stable
|
|
debug metadata, DWARF, stable standalone source-map files, semantic reflection,
|
|
runtime reflection, stable ABI, or stable layout.
|
|
|
|
## v1.6
|
|
|
|
Release tag: `v1.6`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.6 is a conservative memory and unsafe design slice over the v1.5
|
|
contract. It does not promote raw memory, pointers, allocation, deallocation,
|
|
unchecked indexing, reinterpretation, or FFI execution.
|
|
|
|
Lexical `(unsafe ...)` remains the only unsafe boundary. v1.6 reserves these
|
|
compiler-known unsafe operation heads:
|
|
|
|
- `alloc`
|
|
- `dealloc`
|
|
- `load`
|
|
- `store`
|
|
- `ptr_add`
|
|
- `unchecked_index`
|
|
- `reinterpret`
|
|
- `ffi_call`
|
|
|
|
Safe code using one of these heads must receive `UnsafeRequired` before normal
|
|
call lookup. Code inside `(unsafe ...)` using one of these heads must receive
|
|
`UnsupportedUnsafeOperation` until a future release defines syntax, type
|
|
rules, lowering, runtime behavior, diagnostics, and tests.
|
|
|
|
User functions, imports, exports, and parameters cannot shadow the reserved
|
|
unsafe heads. Such declarations must be rejected with a structured
|
|
duplicate/reserved-name diagnostic.
|
|
|
|
## Memory Direction
|
|
|
|
v1.6 keeps safe values as the default Slovo memory model. Future memory work is
|
|
staged toward affine ownership plus explicit unsafe regions, but v1.6 does not
|
|
freeze ownership, pointer/reference types, allocator behavior, aliasing,
|
|
cleanup, or unsafe-region escape rules.
|
|
|
|
No stable ABI, layout, FFI, allocator, ownership, or raw-memory execution
|
|
promise is made in v1.6.
|
|
|
|
## Supported Fixture Changes
|
|
|
|
v1.6 adds no new supported source fixture because no raw unsafe operation is
|
|
promoted. The supported unsafe fixture remains:
|
|
|
|
```text
|
|
examples/supported/unsafe.slo
|
|
```
|
|
|
|
The speculative raw-memory example remains speculative:
|
|
|
|
```text
|
|
examples/speculative/unsafe-memory.slo
|
|
```
|
|
|
|
## v1.6 Deferrals
|
|
|
|
Slovo v1.6 does not support pointer types, raw allocation, raw deallocation,
|
|
pointer load/store, pointer arithmetic, unchecked indexing, raw
|
|
reinterpretation, FFI calls, foreign symbol execution, stable object/library or
|
|
header output, stable C ABI symbols, stable runtime layout, allocator APIs,
|
|
ownership transfer, or safe abstractions over unsafe operations.
|
|
|
|
## v1.5
|
|
|
|
Release tag: `v1.5`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.5 is a conservative standard library alpha over the v1.4 contract. It
|
|
promotes stable source-level standard-runtime names for existing runtime
|
|
behavior without adding new data types, IO breadth, imports, packages,
|
|
allocation, Unicode length semantics, or ABI promises.
|
|
|
|
The matching Glagol v1.5 release implements this contract. v1.5 promotes:
|
|
|
|
- `std.io.print_i32`
|
|
- `std.io.print_string`
|
|
- `std.io.print_bool`
|
|
- `std.string.len`
|
|
|
|
These are compiler-known v1.5 standard-runtime names. They do not require
|
|
imports, do not name user modules, do not create package dependencies, and are
|
|
not stable C ABI symbols.
|
|
|
|
Legacy `print_i32`, `print_string`, `print_bool`, and `string_len` remain
|
|
compatibility aliases. New examples prefer the promoted `std.*` names.
|
|
|
|
## Standard Runtime Alpha
|
|
|
|
The promoted forms are:
|
|
|
|
```slo
|
|
(std.io.print_i32 value)
|
|
(std.io.print_string value)
|
|
(std.io.print_bool value)
|
|
(std.string.len value)
|
|
```
|
|
|
|
`std.io.print_i32` accepts exactly one `i32`, returns builtin `unit`, and keeps
|
|
the same stdout behavior as legacy `print_i32`.
|
|
|
|
`std.io.print_string` accepts exactly one `string`, returns builtin `unit`, and
|
|
keeps the same stdout behavior and source string-literal constraints as legacy
|
|
`print_string`.
|
|
|
|
`std.io.print_bool` accepts exactly one `bool`, returns builtin `unit`, and
|
|
keeps the same stdout behavior as legacy `print_bool`.
|
|
|
|
`std.string.len` accepts exactly one `string`, returns `i32`, and keeps the
|
|
same decoded-byte count semantics as legacy `string_len`.
|
|
|
|
## Diagnostics
|
|
|
|
Unknown or unpromoted `std.*` calls must produce structured diagnostics. The
|
|
suggested diagnostic code is `UnsupportedStandardLibraryCall`.
|
|
|
|
Arity and type mismatches for promoted `std.*` calls use the existing
|
|
arity/type diagnostics where applicable. Promoted `std.*` names are reserved
|
|
from user function/export shadowing.
|
|
|
|
## Supported Fixture Additions
|
|
|
|
v1.5 adds these Slovo fixtures:
|
|
|
|
```text
|
|
examples/supported/standard-runtime.slo
|
|
examples/formatter/standard-runtime.slo
|
|
```
|
|
|
|
## v1.5 Deferrals
|
|
|
|
Slovo v1.5 does not support `std.io.print_unit`, file IO, environment
|
|
variables, process arguments, time or clocks, vectors/maps/sets or other
|
|
collections, allocation, deallocation, ownership, user-defined standard
|
|
modules, imports or packages for standard-runtime names, overloading, generic
|
|
standard-library APIs, Unicode scalar/grapheme/display-width string length,
|
|
stable C ABI symbols, runtime layout promises, or FFI contracts.
|
|
|
|
## v1.4
|
|
|
|
Release tag: `v1.4`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.4 is a conservative core-language expansion over the v1.3
|
|
project-mode contract. It promotes source-level `match` only for existing
|
|
`(option i32)` and `(result i32 i32)` values. It does not add user-defined
|
|
enums/ADTs, generic payloads, mutation, vectors, broader numeric types,
|
|
ownership, or layout/ABI promises.
|
|
|
|
Assuming the matching Glagol v1.4 release implements this contract, v1.4
|
|
promotes:
|
|
|
|
- `match` expressions over `(option i32)` and `(result i32 i32)`
|
|
- exhaustive option arms: `some` and `none`
|
|
- exhaustive result arms: `ok` and `err`
|
|
- immutable arm payload binding for `some`, `ok`, and `err`
|
|
- one-or-more expression arm bodies whose final expression is the arm value
|
|
- common arm result typing for the whole match expression
|
|
- named diagnostics for match subject, payload, exhaustiveness, duplicate arm,
|
|
malformed pattern, arm type, binding collision, mutation, and container
|
|
boundaries
|
|
|
|
Existing `is_some`, `is_none`, `is_ok`, `is_err`, `unwrap_some`, `unwrap_ok`,
|
|
and `unwrap_err` remain supported. New examples prefer `match` when control
|
|
flow depends on the payload.
|
|
|
|
## Match Syntax
|
|
|
|
Option matches use:
|
|
|
|
```slo
|
|
(match value
|
|
((some payload)
|
|
payload)
|
|
((none)
|
|
0))
|
|
```
|
|
|
|
Result matches use:
|
|
|
|
```slo
|
|
(match value
|
|
((ok payload)
|
|
payload)
|
|
((err code)
|
|
code))
|
|
```
|
|
|
|
Payload bindings are immutable and scoped only to the selected arm. Arm bodies
|
|
may contain one or more expressions. The final expression is the arm value, and
|
|
all arms must produce the same result type.
|
|
|
|
## Supported Fixture Additions
|
|
|
|
v1.4 adds these Slovo fixtures:
|
|
|
|
```text
|
|
examples/supported/option-result-match.slo
|
|
examples/formatter/option-result-match.slo
|
|
```
|
|
|
|
## v1.4 Deferrals
|
|
|
|
Slovo v1.4 does not support user-defined enums or algebraic data types,
|
|
generic option/result payloads, non-`i32` payload matching, nested
|
|
option/result payloads beyond current v1 limits, options/results in arrays or
|
|
structs, option/result mutation, vectors, struct mutation, `i64`, general
|
|
`(block ...)` expressions outside match arms, pattern guards, wildcard/rest
|
|
patterns, destructuring structs/arrays/strings, standard-library error
|
|
conventions, user-catchable exceptions, ownership promises, stable layout, or
|
|
stable ABI.
|
|
|
|
## v1.3
|
|
|
|
Release tag: `v1.3`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.3 is a project-mode and local-modules release over the v1.2 language
|
|
and toolchain contract. It does not add packages, dependencies, remote
|
|
registries, version solving, workspaces, macros, public ABI, cross-package
|
|
visibility, incremental builds, watch/LSP, path escapes, or generated code.
|
|
|
|
Assuming the matching Glagol v1.3 release implements this contract, v1.3
|
|
promotes:
|
|
|
|
- a project manifest named `slovo.toml`
|
|
- a flat local source-root convention, defaulting to `src`
|
|
- project mode for `glagol check`, `glagol test`, and `glagol build`
|
|
- explicit imports between local project modules
|
|
- explicit exports of top-level `fn` and `struct` names
|
|
- deterministic project/module ordering
|
|
- duplicate-name, missing-import, import-cycle, ambiguous-name, and visibility
|
|
diagnostics
|
|
- multi-file source spans and project artifact-manifest fields
|
|
|
|
Single-file mode remains unchanged when a command receives one `.slo` file.
|
|
|
|
## Project Manifest
|
|
|
|
The v1.3 manifest is exactly `slovo.toml`:
|
|
|
|
```toml
|
|
[project]
|
|
name = "example"
|
|
source_root = "src"
|
|
entry = "main"
|
|
```
|
|
|
|
`name` is required and must be a lowercase package-shaped identifier.
|
|
`source_root` defaults to `src` and must stay under the project root. `entry`
|
|
defaults to `main` and must be a flat module identifier. Unknown manifest
|
|
sections or keys are diagnostics in v1.3.
|
|
|
|
## Project Layout And Modules
|
|
|
|
Project module files are immediate `.slo` children of the source root:
|
|
|
|
```text
|
|
.
|
|
├── slovo.toml
|
|
└── src
|
|
├── main.slo
|
|
└── math.slo
|
|
```
|
|
|
|
Each file declares one flat module whose name matches the file stem. A module
|
|
with exports uses:
|
|
|
|
```slo
|
|
(module math (export add_one))
|
|
```
|
|
|
|
The only import form is:
|
|
|
|
```slo
|
|
(import math (add_one))
|
|
```
|
|
|
|
Only exported top-level `fn` and `struct` declarations are importable. Tests,
|
|
locals, parameters, fields, builtins, intrinsics, generated declarations, and
|
|
imported names are not exportable or importable.
|
|
|
|
## Project Commands
|
|
|
|
Project mode is selected only when the input is a directory containing
|
|
`slovo.toml` or the `slovo.toml` file itself:
|
|
|
|
```text
|
|
glagol check <project-root>
|
|
glagol test <project-root>
|
|
glagol build <project-root> -o <binary>
|
|
```
|
|
|
|
`check` validates every project module. `test` checks the project and runs
|
|
top-level tests in deterministic module and source order. `build` checks the
|
|
project, requires the entry module and supported `main` function, and produces
|
|
one hosted native executable through the existing LLVM IR plus Glagol runtime C
|
|
plus Clang path.
|
|
|
|
## Supported Fixture Additions
|
|
|
|
v1.3 adds this Slovo project fixture:
|
|
|
|
```text
|
|
examples/projects/basic/slovo.toml
|
|
examples/projects/basic/src/main.slo
|
|
examples/projects/basic/src/math.slo
|
|
```
|
|
|
|
exp-17 later adds this project enum-import fixture:
|
|
|
|
```text
|
|
examples/projects/enum-imports/slovo.toml
|
|
examples/projects/enum-imports/src/readings.slo
|
|
examples/projects/enum-imports/src/main.slo
|
|
```
|
|
|
|
## v1.3 Deferrals
|
|
|
|
Slovo v1.3 does not support packages, dependencies, remote registries, version
|
|
solving, lockfiles, workspaces, hierarchical modules, import aliases, glob
|
|
imports, qualified names, re-exports, macros, public ABI, cross-package
|
|
visibility, incremental builds, watch mode, LSP, SARIF, path escapes,
|
|
generated code, project formatting, build profiles, cross-compilation, object
|
|
output, library output, header output, stable debug metadata, DWARF, or
|
|
standalone source maps.
|
|
|
|
## v1.2
|
|
|
|
Release tag: `v1.2`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.2 is a practical runtime values release over the v1.1 single-file
|
|
toolchain contract. It does not add project mode, package management, imports,
|
|
multi-file modules, stable ABI/layout promises, or a standard runtime.
|
|
|
|
Assuming the matching Glagol v1.2 release implements this contract, v1.2
|
|
promotes:
|
|
|
|
- immutable string `let` locals
|
|
- string parameters and returns
|
|
- calls returning strings
|
|
- string equality with `=`
|
|
- string byte length with `string_len`
|
|
- top-level tests using string equality or string length comparisons
|
|
- temporary compiler/runtime intrinsic `print_bool`
|
|
- stable runtime trap messages and process exit behavior for array bounds and
|
|
option/result unwrap failures
|
|
|
|
## Supported Fixture Additions
|
|
|
|
v1.2 adds these Slovo fixtures:
|
|
|
|
```text
|
|
examples/supported/string-value-flow.slo
|
|
examples/supported/print-bool.slo
|
|
examples/formatter/string-value-flow.slo
|
|
examples/formatter/print-bool.slo
|
|
```
|
|
|
|
No `print_unit` fixture is added because unit printing remains unsupported.
|
|
|
|
## Runtime String Contract
|
|
|
|
Strings remain immutable compiler/runtime values. Every promoted string value
|
|
originates from a source string literal or from propagating such a value through
|
|
an immutable local, parameter, return, or call result.
|
|
|
|
`string_len` returns the decoded byte count before the trailing NUL byte. String
|
|
equality compares decoded bytes before the trailing NUL byte. v1.2 does not
|
|
promise Unicode normalization, grapheme counting, display width, arbitrary byte
|
|
escapes, embedded NUL bytes, allocation, ownership, deallocation, stable ABI, or
|
|
FFI behavior.
|
|
|
|
String concatenation remains deferred in v1.2 because it requires allocation,
|
|
ownership, lifetime, and deallocation semantics. exp-1 later stages only the
|
|
narrow `std.string.concat` contract.
|
|
|
|
## Printing And Unit
|
|
|
|
`print_bool` has exactly one `bool` argument, returns builtin `unit`, and writes
|
|
`true\n` or `false\n`.
|
|
|
|
`print_unit` remains unsupported. This keeps `unit` as an internal builtin
|
|
result type for supported unit-producing body forms rather than making it a
|
|
user-visible, storable, comparable, or test-final value.
|
|
|
|
## Runtime Errors
|
|
|
|
Runtime traps are process-terminating runtime errors, not user-catchable Slovo
|
|
exceptions. Required stderr messages are:
|
|
|
|
```text
|
|
slovo runtime error: array index out of bounds
|
|
slovo runtime error: unwrap_some on none
|
|
slovo runtime error: unwrap_ok on err
|
|
slovo runtime error: unwrap_err on ok
|
|
```
|
|
|
|
Each message is written with a trailing newline. The process exits with code
|
|
`1`. `glagol test` reports a top-level test that triggers one of these runtime
|
|
errors as a trapped test and exits with code `1`.
|
|
|
|
## v1.2 Deferrals
|
|
|
|
Slovo v1.2 does not support mutable string locals, string assignment, string
|
|
concatenation, string indexing or slicing, strings inside arrays/structs/
|
|
options/results, broader owned or heap strings, user-defined string runtime bindings,
|
|
stable string ABI/layout, `print_unit`, user-visible `unit` values, project
|
|
mode, imports, packages, or multi-file modules. exp-1 later stages only
|
|
`std.string.concat` as a runtime-owned string operation.
|
|
|
|
## v1.1
|
|
|
|
Release tag: `v1.1`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1.1 is a tooling release over the v1 language contract. It does not add
|
|
new source language features, broaden the supported fixture set, or relax any
|
|
v1 unsupported boundary.
|
|
|
|
Assuming the matching Glagol v1.1 release implements the Slovo v1.1 toolchain
|
|
contract, the stable user-facing tool surface is:
|
|
|
|
```text
|
|
glagol check <file.slo>
|
|
glagol fmt <file.slo>
|
|
glagol test <file.slo>
|
|
glagol build <file.slo> -o <binary>
|
|
```
|
|
|
|
These commands are single-file commands in v1.1. Project mode, package
|
|
management, multi-file modules, stdin formatting, write-in-place formatting,
|
|
test filtering, cross-compilation, optimization profiles, stable ABI promises,
|
|
object/library output, C headers, FFI, LSP, SARIF, and daemon protocols remain
|
|
deferred.
|
|
|
|
## Toolchain Contract
|
|
|
|
v1.1 productizes the existing v1 language through a predictable CLI contract:
|
|
|
|
- `check` parses, lowers, and type-checks one Slovo source file without
|
|
producing primary artifacts.
|
|
- `fmt` prints canonical formatted source for one file to stdout and does not
|
|
modify the input file.
|
|
- `test` runs top-level Slovo tests in one file and reports source failures,
|
|
failed tests, and reported runtime traps as ordinary command failures.
|
|
- `build` produces a hosted native executable for the current machine through
|
|
the Glagol LLVM IR plus runtime C plus Clang pipeline.
|
|
- `--json-diagnostics` requests newline-delimited JSON diagnostics on stderr.
|
|
- `--manifest <path>` requests a `slovo.artifact-manifest` version `1`
|
|
manifest describing the actual invocation outputs.
|
|
- `--no-color`, `--help`, and `--version` are common command flags.
|
|
|
|
Machine diagnostics remain schema `slovo.diagnostic` version `1`. Artifact
|
|
manifests remain schema `slovo.artifact-manifest` version `1`.
|
|
|
|
## Stable Exit Codes
|
|
|
|
Glagol v1.1 commands use this stable table:
|
|
|
|
```text
|
|
0 success
|
|
1 source parse, lowering, type, formatter, test failure, or unsupported form
|
|
2 command-line usage error
|
|
3 required toolchain component missing or unusable
|
|
4 internal compiler error
|
|
5 manifest or output artifact write failure
|
|
```
|
|
|
|
A failed Slovo test is exit code `1`. A missing hosted build dependency such as
|
|
Clang is exit code `3`. Panics or impossible compiler states on supported
|
|
inputs are release blockers and map to exit code `4` only as a containment
|
|
path.
|
|
|
|
## Compatibility Aliases
|
|
|
|
The canonical documented commands are `check`, `fmt`, `test`, and `build`.
|
|
|
|
Glagol may retain pre-v1.1 developer commands or flags as compatibility aliases
|
|
only when they route through the same diagnostics, manifest, and exit-code
|
|
paths as the canonical commands and do not change semantics. Slovo v1.1 does
|
|
not treat those aliases as primary user documentation, and exact alias names
|
|
remain Glagol release evidence rather than new Slovo language surface.
|
|
|
|
## Native Build Boundary
|
|
|
|
`glagol build <file.slo> -o <binary>` is a hosted native build path, not a
|
|
stable systems ABI promise. It proves that supported v1 programs can build and
|
|
run as direct executables on the current host using documented Glagol runtime C
|
|
inputs and the host Clang/linker environment.
|
|
|
|
Required v1.1 native build smoke coverage includes `add`, `while`, array value
|
|
flow, option payload flow, result payload flow, struct value flow, and string
|
|
print.
|
|
|
|
## Release Gates
|
|
|
|
Slovo-side gate:
|
|
|
|
```text
|
|
git -C slovo diff --check
|
|
```
|
|
|
|
Glagol-side gates for the matching v1.1 release include the baseline test and
|
|
format gates, CLI tests for all canonical commands, stable exit-code tests,
|
|
JSON diagnostic snapshots, artifact manifest snapshots, hosted native build
|
|
smokes, fixture-alignment checks, and release-note review for aliases and
|
|
deferrals.
|
|
|
|
No `v1.1` tag should be cut while required gates are failing, skipped, or
|
|
blocked by review.
|
|
|
|
## v1
|
|
|
|
Release tag: `v1`
|
|
|
|
Release date: 2026-05-17
|
|
|
|
## Summary
|
|
|
|
Slovo v1 extends the v0 kernel with practical value flow while preserving the
|
|
manifest rule: a feature is supported only when the language contract, fixtures,
|
|
formatter behavior, diagnostics, tests, and Glagol implementation agree.
|
|
|
|
v1 keeps native executable output, stable ABI/layout promises, broad runtime
|
|
bindings, raw memory, and FFI out of scope. The supported compiler path remains
|
|
Slovo source through Glagol to textual LLVM IR, with native execution available
|
|
through the explicit LLVM-plus-runtime Clang workflow.
|
|
|
|
## Supported Fixture Set
|
|
|
|
These examples define the promoted Slovo v1 surface:
|
|
|
|
```text
|
|
examples/supported/add.slo
|
|
examples/supported/top-level-test.slo
|
|
examples/supported/local-variables.slo
|
|
examples/supported/if.slo
|
|
examples/supported/while.slo
|
|
examples/supported/struct.slo
|
|
examples/supported/struct-value-flow.slo
|
|
examples/supported/array.slo
|
|
examples/supported/array-value-flow.slo
|
|
examples/supported/array-direct-scalars.slo
|
|
examples/supported/array-direct-scalars-value-flow.slo
|
|
examples/supported/array-string.slo
|
|
examples/supported/array-string-value-flow.slo
|
|
examples/supported/option-result.slo
|
|
examples/supported/option-result-flow.slo
|
|
examples/supported/option-result-payload.slo
|
|
examples/supported/string-print.slo
|
|
examples/supported/unsafe.slo
|
|
```
|
|
|
|
Formatter fixtures under `examples/formatter/` define canonical v1 layout,
|
|
including the promoted full-line comment stability fixture
|
|
`examples/formatter/comments.slo`.
|
|
|
|
Frozen v0 compatibility fixtures remain under `examples/compat/v0/`.
|
|
|
|
## Promoted v1 Language Surface
|
|
|
|
- Struct value flow: immutable struct locals, struct parameters, struct
|
|
returns, calls returning structs, and field access through stored values.
|
|
- Fixed array value flow: immutable positive-length arrays over the current
|
|
direct scalar families `i32`, `i64`, `f64`, `bool`, plus `string`, with
|
|
immutable array locals, parameters, returns, calls returning arrays, and
|
|
runtime-checked dynamic indexing on `i32` expressions.
|
|
- Option/result value flow for `(option i32)` and `(result i32 i32)`: immutable
|
|
locals, parameters, calls returning option/result values, tag observation, and
|
|
explicit trap-based `i32` payload extraction with `unwrap_some`, `unwrap_ok`,
|
|
and `unwrap_err`.
|
|
- Narrow string runtime slice: direct source string literals passed to
|
|
temporary compiler/runtime intrinsic `print_string`.
|
|
- Lexical `unsafe` remains the accepted unsafe boundary, without raw memory or
|
|
FFI operations.
|
|
|
|
### Runtime String Slice
|
|
|
|
- Promotes the Slovo-side contract for immutable source string literals passed
|
|
directly to temporary compiler/runtime intrinsic `(print_string value)`.
|
|
- Defines the first runtime representation as a borrowed immutable
|
|
NUL-terminated byte pointer to compiler-emitted static storage, with no user
|
|
ownership, mutation, allocation, free, stable ABI, or broader runtime binding
|
|
promise.
|
|
- Adds `examples/supported/string-print.slo` and
|
|
`examples/formatter/string-print.slo`.
|
|
|
|
Still deferred at that stage: string locals, string function parameters or
|
|
returns, string equality/comparison, strings inside arrays, structs, options,
|
|
or results, slices, concatenation, length, indexing, ownership, user-defined
|
|
string runtime bindings, and stable string ABI promises. Current exp-19 later
|
|
promotes only direct immutable `string` struct fields.
|
|
|
|
## Tooling Contracts
|
|
|
|
- Machine diagnostics use `slovo.diagnostic` version `1` with a root
|
|
`(diagnostic ...)` form.
|
|
- Artifact manifests use `slovo.artifact-manifest` version `1` for compiler
|
|
outputs and test-report side channels.
|
|
- Formatter output is stable for promoted formatter fixtures, preserves accepted
|
|
full-line comment positions, rejects unsupported comment/layout positions
|
|
with structured diagnostics, and does not promise width-based reflow.
|
|
- Glagol keeps golden diagnostic fixtures for current explicitly rejected v1
|
|
boundaries and textual lowering-inspector golden fixtures for promoted v1
|
|
feature families.
|
|
- Stable LLVM debug metadata, DWARF, standalone source-map files, JSON tooling
|
|
output, direct native output, package layout, and stable ABI/layout remain
|
|
deferred.
|
|
|
|
## Explicit Deferrals
|
|
|
|
Slovo v1 does not support:
|
|
|
|
- struct field/value mutation
|
|
- full option/result matching, mapping, equality, printing, nested values,
|
|
non-`i32` payloads, containers, or user-catchable payload traps
|
|
- bool or unit printing, user-declared/stored `unit`, or broader standard
|
|
runtime printing
|
|
- full string value flow, ownership, slicing, indexing, equality/comparison, or
|
|
user-defined runtime bindings
|
|
- array mutation, arrays of unsupported element types, zero-length arrays,
|
|
array equality, printing arrays, nested arrays, unchecked indexing, or
|
|
stable array layout
|
|
- pointer types, allocation, deallocation, load/store, pointer arithmetic,
|
|
reinterpretation, raw memory operations, or FFI
|
|
- JSON diagnostics or lowering-inspector output
|
|
- macros, generics, package management, concurrency, direct machine-code
|
|
backend, stable ABI, or stable layout
|
|
|
|
## v0
|
|
|
|
Release tag: `v0`
|
|
|
|
Release date: 2026-05-16
|
|
|
|
Release commit: `d7a60ce`
|
|
|
|
## Summary
|
|
|
|
Slovo v0 is the first released language contract. It turns the initial
|
|
manifest, design laws, and compiler experiments into a strict supported subset
|
|
with matching Glagol implementation coverage.
|
|
|
|
The purpose of v0 is not broad application development. The purpose is to
|
|
establish a clean, compiler-backed kernel that can be parsed, formatted,
|
|
checked, tested, inspected, lowered, and emitted as LLVM IR.
|
|
|
|
## Supported Fixture Set
|
|
|
|
These examples define the compiler-supported Slovo v0 surface:
|
|
|
|
```text
|
|
examples/supported/add.slo
|
|
examples/supported/top-level-test.slo
|
|
examples/supported/local-variables.slo
|
|
examples/supported/if.slo
|
|
examples/supported/while.slo
|
|
examples/supported/struct.slo
|
|
examples/supported/array.slo
|
|
examples/supported/option-result.slo
|
|
examples/supported/unsafe.slo
|
|
```
|
|
|
|
Formatter fixtures live in `examples/formatter/` and define canonical layout
|
|
for the same strict supported syntax.
|
|
|
|
Frozen copies of the v0 supported and formatter fixtures live under
|
|
`examples/compat/v0/` for post-v0 compatibility checks.
|
|
|
|
Examples under `examples/speculative/` are design targets, not supported v0
|
|
compiler fixtures.
|
|
|
|
## Supported Language Surface
|
|
|
|
Slovo v0 supports:
|
|
|
|
- `(module name)`
|
|
- top-level `(fn ...)`
|
|
- top-level `(test "name" body... final-expression)`
|
|
- top-level `(struct Name (field i32)...)`
|
|
- explicit `i32` parameters and `i32` returns
|
|
- direct `(option i32)` and `(result i32 i32)` constructor returns
|
|
- integer literals and parameter references
|
|
- binary `+`
|
|
- equality comparison `=`
|
|
- ordering comparison `<`
|
|
- user function calls
|
|
- temporary compiler intrinsic `print_i32`
|
|
- local `i32` bindings with `let` and `var`
|
|
- mutable local assignment with `set`
|
|
- value-producing `if`
|
|
- first-pass `while` as a non-final sequential body form
|
|
- first-pass struct construction and immediate field access
|
|
- first-pass fixed `i32` array construction
|
|
- immutable fixed `i32` array locals
|
|
- literal checked indexing
|
|
- first-pass option/result constructors
|
|
- lexical `unsafe` expression blocks containing otherwise supported safe forms
|
|
|
|
## Compiler Contract
|
|
|
|
The matching compiler release is Glagol v0. Its implementation-facing surface is
|
|
the `glagol` binary CLI.
|
|
|
|
Glagol can:
|
|
|
|
- emit LLVM IR for supported programs
|
|
- format supported source
|
|
- print parsed trees
|
|
- inspect surface lowering
|
|
- inspect checked lowering
|
|
- check top-level tests
|
|
- run top-level tests
|
|
- emit structured diagnostics for unsupported or invalid source-reachable forms
|
|
|
|
Native executable output is not part of the Slovo v0 language contract. v0 uses
|
|
the explicit Glagol LLVM IR plus Clang runtime-linking workflow.
|
|
|
|
## Explicit Deferrals
|
|
|
|
Slovo v0 does not support:
|
|
|
|
- runtime string values
|
|
- dynamic array indices
|
|
- runtime array bounds traps
|
|
- array parameters, returns, or mutation
|
|
- slices
|
|
- option/result locals, calls as values, matching, unwrap, equality, or printing
|
|
- struct locals, parameters, returns, field mutation, nested fields, recursive
|
|
structs, or methods
|
|
- pointer types
|
|
- raw allocation and deallocation
|
|
- pointer load/store
|
|
- pointer arithmetic
|
|
- unchecked indexing behavior
|
|
- reinterpretation
|
|
- FFI
|
|
- unsafe abstractions
|
|
- stable ABI or layout promises
|
|
- macros
|
|
- generics
|
|
- package management
|
|
- ownership or affine resources
|
|
- concurrency
|
|
- direct machine-code backend
|
|
|
|
## Post-v0 Direction
|
|
|
|
Post-v0 work starts in `SPEC-v1.md` and `.llm/V1_ROADMAP.md`.
|
|
|
|
The first recommended v1 slice is struct value flow: struct locals, parameters,
|
|
returns, and field access through stored struct values. This slice should be
|
|
specified before implementation and must preserve the v0 support rule.
|