Hermeticum/slovo
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4f52a54bea
slovo/docs/compiler/ROADMAP.md

1827 lines
100 KiB
Markdown
Raw Blame History

# Glagol Roadmap
Glagol is the first compiler for Slovo. Slovo language design lives in
`docs/language/` inside the same monorepo.
Compiler rule: make the tree visible. The pipeline should remain:
```text
.slo source -> tokens -> S-expression tree -> AST -> typed AST -> LLVM IR text -> hosted Clang/runtime executable step
```
Long-horizon compiler planning lives in
`.llm/GENERAL_PURPOSE_LANGUAGE_ROADMAP.md`. It mirrors Slovo's experimental
release train from the historical `v2.0.0-beta.1` tag toward and beyond the
first real general-purpose beta toolchain.
Release maturity policy lives in `.llm/RELEASE_MATURITY_POLICY.md`. Historical
`exp-*` releases remain experimental maturity. `1.0.0-beta` is the first real
general-purpose beta release.
## Definition Of Done For A Compiler Feature
A Glagol feature is done only when it has parser/lowerer support, checker behavior, diagnostics for invalid forms, backend behavior or explicit unsupported diagnostics, and tests.
Current stage: `1.0.0-beta.8`, released on 2026-05-22 as the first post-beta
concrete type alias foundation update. It keeps the `1.0.0-beta` language/compiler
support baseline and includes the `1.0.0-beta.1` tooling hardening release, the
`1.0.0-beta.2` runtime/resource foundation release, the `1.0.0-beta.3`
standard-library stabilization release, the `1.0.0-beta.4`
language-usability diagnostics release, the `1.0.0-beta.5` package/workspace
discipline release, and the `1.0.0-beta.6` compiler-known `std.net` loopback
TCP runtime family with focused lowering, interpreter, diagnostics,
source-facade, promotion, and hosted smoke coverage, plus the `1.0.0-beta.7`
compiler-known `std.json.quote_string` runtime family with matching
source-facade, test-runner, hosted smoke, and benchmark-scaffold coverage, plus
top-level `(type Alias TargetType)` parsing, checking, formatting, lowering
inspection, project import normalization, and diagnostics coverage for concrete
aliases.
Next stage target: `1.0.0-beta.9`, likely generics and collection
unification. The exact compiler-side contract must be frozen from the manifest
and roadmap before implementation.
The final experimental precursor scope is `exp-125`. Its unsigned direct-value
flow, parse/format runtime lanes, and matching staged stdlib helper breadth
are now absorbed into `1.0.0-beta`.
Phases 9 through 84 and exp-1 through exp-124 remain historical experimental
release milestones. `exp-124` Fixed Array Enum And Struct Elements Alpha is
the last tagged experimental compiler slice before beta. exp-123 Owned Vector
Benchmark Suite Extension And Whitepaper Refresh Alpha is the previous tagged
experimental benchmark/publication slice. exp-122 Composite Data Benchmark
Suite Extension And Whitepaper Refresh Alpha is the earlier tagged
experimental benchmark/publication slice. exp-121 Non-Recursive Struct Enum
Payloads Alpha and exp-120 Fixed Array Struct Fields Alpha remain earlier
historical compiler broadening steps in the path to beta.
exp-115 Composite Struct Fields And
Nested Structs Alpha is the previous gated experimental compiler slice. It
broadens direct struct field declarations by allowing the current concrete vec
families, current concrete option/result families, and current non-recursive
struct types alongside the already promoted direct scalar, string, and enum
field families in the checker, formatter, diagnostics, promoted
composite-struct fixtures, and focused Glagol tests, while keeping arrays out
of struct fields and excluding recursive layouts, field mutation, and payload
mutation. exp-114 Mutable Composite Locals Alpha is the previous gated
experimental compiler slice. It broadened the current local-mutation lane by
allowing same-type mutable local reassignment through `var`/`set` for
`string`, the current concrete vec families, the current concrete
option/result families, known struct values, and current enum values in the
checker, formatter local rendering, LLVM emission, diagnostics coverage,
promoted composite-local fixtures, and focused Glagol tests, while keeping
arrays immutable-only and excluding field, element, and payload mutation.
exp-113 Mutable Scalar Locals Alpha is the previous gated
experimental compiler slice. It broadened the current local-mutation lane by
allowing mutable `bool`, `i64`, and `f64` locals through `var`/`set` in the
checker, formatter messaging, LLVM emission, diagnostics coverage, promoted
local-variable fixtures, and focused Glagol tests, while keeping mutable
strings, vectors, option/results, structs, and enums unsupported. exp-112
Immutable Bool Locals Alpha is the previous gated experimental compiler
slice. It broadened only the immutable local-value lane by allowing
`let`-bound `bool` locals in the checker, LLVM emission, diagnostics
coverage, and focused Glagol tests, while keeping mutable `bool` locals
unsupported. exp-111 Standard IO Stdin Source Helpers Alpha is the previous
gated experimental stdlib/source slice. It
broadens the existing Glagol-owned local and explicit-source `std.io`
helper fixtures with `read_stdin_result`, `read_stdin_option`,
`read_stdin_or`, `read_stdin_i32_result`, `read_stdin_i32_option`,
`read_stdin_i32_or_zero`, `read_stdin_i32_or`, `read_stdin_i64_result`,
`read_stdin_i64_option`, `read_stdin_i64_or_zero`, `read_stdin_i64_or`,
`read_stdin_f64_result`, `read_stdin_f64_option`,
`read_stdin_f64_or_zero`, `read_stdin_f64_or`,
`read_stdin_bool_result`, `read_stdin_bool_option`,
`read_stdin_bool_or_false`, and `read_stdin_bool_or`, while keeping the
slice source-authored over the already promoted `std.io.read_stdin_result`,
`std.string.parse_*_result`, and exp-109 `ok_or_none_*` bridge helpers only.
exp-110 Standard String, Env, Fs, Process, And Cli Option Helpers Alpha is
the previous gated experimental stdlib/source slice. It broadens the
existing Glagol-owned local and explicit-source `std.string`, `std.env`,
`std.fs`, `std.process`, and `std.cli` helper fixtures with
`parse_i32_option`, `parse_i64_option`, `parse_f64_option`,
`parse_bool_option`, `get_option`, `get_i32_option`, `get_i64_option`,
`get_f64_option`, `get_bool_option`, `read_text_option`,
`read_i32_option`, `read_i64_option`, `read_f64_option`,
`read_bool_option`, `arg_option`, `arg_i32_option`, `arg_i64_option`,
`arg_f64_option`, `arg_bool_option`, `arg_text_option`,
`arg_i32_option`, `arg_i64_option`, `arg_f64_option`, and
`arg_bool_option`, while keeping the slice source-authored over the already
promoted result families and the exp-109 `ok_or_none_*` bridge helpers only.
exp-109 Standard Option And Result Bridge Helpers Alpha is the previous
gated experimental stdlib/source slice. It broadens the Glagol-owned local,
explicit-source, and workspace-source `std.option` and `std.result` helper
fixtures with `some_or_err_i32`, `some_or_err_i64`, `some_or_err_f64`,
`some_or_err_bool`, `some_or_err_string`, `ok_or_none_i32`,
`ok_or_none_i64`, `ok_or_none_string`, `ok_or_none_f64`, and
`ok_or_none_bool`, while keeping the slice concrete and source-authored over
the already promoted option/result forms only. exp-108 Standard Vec String,
F64, And Bool Prefix And Suffix Helpers Alpha is the earlier gated
experimental stdlib/source slice. It broadens the Glagol-owned local and
explicit-source `std.vec_string`, `std.vec_f64`, and `std.vec_bool` helper
fixtures with `starts_with`, `without_prefix`, `ends_with`, and
`without_suffix`, while keeping all three lanes recursive, immutable, and
limited to the already promoted vec-string, vec-f64, and vec-bool runtime
names. exp-107 Standard Vec String, F64, And Bool Edit Helpers Alpha is the
earlier gated experimental stdlib/source slice. It broadens the same helper
fixtures with `insert_at`, `insert_range`, `replace_at`, `replace_range`,
`remove_at`, and `remove_range` while keeping all three lanes recursive,
immutable, and limited to the already promoted vec-string, vec-f64, and
vec-bool runtime names. exp-106 Standard Vec F64 And Bool Option Query
Helpers Alpha is the earlier gated experimental stdlib/source slice. It
broadens the `std.vec_f64` and `std.vec_bool` helper fixtures with
`index_option`, `first_option`, `last_option`, `index_of_option`, and
`last_index_of_option` while keeping both lanes recursive, immutable, and
limited to the already promoted vec-f64 and vec-bool runtime names plus the
already promoted concrete option families they return. exp-105 Standard Vec
F64 And Bool Transform Helpers Alpha is the earlier gated experimental
stdlib/source slice. It broadens the same helper fixtures with `concat`,
`take`, `drop`, `reverse`, and `subvec` while keeping both lanes recursive,
immutable, and limited to the already promoted vec-f64 and vec-bool runtime
names. exp-104 Standard Vec Bool Baseline Alpha is the previous gated
experimental compiler/runtime plus stdlib/source slice. It adds concrete
`(vec bool)` support for immutable params, returns, locals, direct
`std.vec.bool.empty/append/len/index` calls, same-family vector equality,
and the scalar bool-equality enablement needed by the source helper lane in
the checker, formatter, backend, runtime, std runtime inventory, and test
runner, plus the matching Glagol-owned local and explicit-source
`std.vec_bool` helper fixtures for `empty`, `append`, `len`, `at`,
`singleton`, `append2`, `append3`, `pair`, `triple`, `is_empty`, `index_or`,
`first_or`, `last_or`, `contains`, and `count_of`. exp-103 Standard Vec F64
Baseline Alpha is the earlier gated experimental compiler/runtime plus
stdlib/source slice. It adds concrete `(vec f64)` support for immutable
params, returns, locals, direct `std.vec.f64.empty/append/len/index` calls,
and same-family vector equality in the checker, formatter, backend, runtime,
std runtime inventory, and test runner, plus the matching Glagol-owned local
and explicit-source `std.vec_f64` helper fixtures for `empty`, `append`,
`len`, `at`, `singleton`, `append2`, `append3`, `pair`, `triple`,
`is_empty`, `index_or`, `first_or`, `last_or`, `contains`, and `sum`. exp-102 Standard
Option Bool And F64 Baseline Alpha is the earlier gated
experimental compiler/runtime plus stdlib/source slice. It adds concrete
`(option f64)` and `(option bool)` support for immutable params, returns,
locals, `some`/`none`, `is_some`/`is_none`, `unwrap_some`, and source-level
`match` payload binding in the checker, formatter, backend, and test runner,
plus the matching Glagol-owned local, explicit-source, and workspace-source
`std.option` helper fixtures for `some_f64`, `none_f64`, `is_some_f64`,
`is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64`, `some_bool`,
`none_bool`, `is_some_bool`, `is_none_bool`, `unwrap_some_bool`, and
`unwrap_or_bool`. exp-101 Standard Vec String Option And Transform Helpers
Alpha is the earlier gated
experimental stdlib/source slice. It broadens the existing Glagol-owned local
and explicit-source `std.vec_string` helper fixtures with the option-query
helpers `index_option`, `first_option`, `last_option`, `index_of_option`,
and `last_index_of_option`, plus the transform helpers `concat`, `take`,
`drop`, `reverse`, and `subvec`, while staying concrete to `(vec string)`
plus raw current `(option string)` / `(option i32)` forms, recursive,
immutable, and limited to the existing `std.vec.string.*` runtime names.
exp-100 Standard Option String Baseline Alpha is the earlier gated
experimental compiler/runtime plus stdlib/source slice. It adds concrete
`(option string)` support for immutable params, returns, locals,
`some`/`none`, `is_some`/`is_none`, `unwrap_some`, and source-level `match`
payload binding in the checker, formatter, backend, and test runner, plus
the matching Glagol-owned local, explicit-source, and workspace-source
`std.option` helper fixtures for `some_string`, `none_string`,
`is_some_string`, `is_none_string`, `unwrap_some_string`, and
`unwrap_or_string`. exp-99 Standard Vec String Baseline Alpha is the earlier
compiler/runtime plus stdlib/source slice. It adds concrete `(vec string)`
support for immutable params, returns, locals, direct
`std.vec.string.empty/append/len/index` calls, and concrete vec-string
equality in the checker, formatter, backend, runtime, std runtime
inventory, and test runner, plus the matching Glagol-owned local and
explicit-source `std.vec_string` helper fixtures for `empty`, `append`,
`len`, `at`, `singleton`, `append2`, `append3`, `pair`, `triple`,
`is_empty`, `index_or`, `first_or`, `last_or`, `contains`, and `count_of`.
exp-98 Standard Vec I64 Edit Helpers Alpha is the previous
stdlib/source slice. It extends the staged `std.vec_i64` helper surface
through the Glagol-owned local fixture and explicit-source import fixture
with `insert_at`, `insert_range`, `replace_at`, `replace_range`,
`remove_at`, and `remove_range`, while keeping the local lane recursive and
immutable and reusing only the existing `(vec i64)` runtime names plus
existing option support. exp-97 Standard Vec I64 Transform Helpers Alpha is
the previous stdlib/source slice. It extends the same staged helper surface
with `concat`, `take`, `drop`, `reverse`, and `subvec` while keeping the
local lane recursive and immutable and reusing only the existing `(vec i64)`
runtime names plus existing option support. exp-96 Standard Vec I64 Option
Query Helpers Alpha is the earlier stdlib/source slice. It extends the same
staged helper surface with `index_option`, `first_option`, `last_option`,
`index_of_option`, and `last_index_of_option` while keeping the local lane
recursive and immutable and reusing only the existing `(vec i64)` runtime
names plus existing option support. exp-95 Standard Option I64 Baseline Alpha
is the previous compiler/runtime plus stdlib/source slice. It adds concrete
`(option i64)` support for immutable params, returns, locals, `some`,
`none`, `is_some`, `is_none`, `unwrap_some`, and source-level `match`, plus
the matching local and explicit-source `std.option` i64 helper coverage
through `std-layout-local-option/` and `std-import-option/`. exp-94 Standard
Vec I64 Baseline Alpha is the earlier compiler/runtime plus stdlib/source
slice.
exp-93 Standard Vec I32 Count-Of Helper Alpha is the earlier stdlib/source
gate. It extended the staged `std.vec_i32` concrete helper surface with the
source-authored `count_of(values,target)` helper while reusing the existing
`std.vec.i32` runtime names only and staying within the already staged
`len`, `at`, equality, and `while` surface.
exp-92 Standard Vec I32 Without-Prefix Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`without_prefix(values,prefix)`.
exp-91 Standard Vec I32 Without-Suffix Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`without_suffix(values,suffix)`.
exp-90 Standard Vec I32 Ends-With Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`ends_with(values,suffix)`.
exp-89 Standard Vec I32 Starts-With Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`starts_with(values,prefix)`.
exp-88 Standard Vec I32 Replace Range Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`replace_range(values,start,end_exclusive,replacement)`.
exp-87 Standard Vec I32 Insert Range Helper Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`insert_range(values,position,inserted)`.
exp-86 Standard Vec I32 Remove Range Helper Alpha is an earlier stdlib/source
gate. It extended the same staged facade with source-authored
`remove_range(values,start,end_exclusive)`.
exp-85 Standard Vec I32 Subvec Helper Alpha is an earlier stdlib/source gate.
It extended the same staged facade with source-authored
`subvec(values,start,end_exclusive)`.
exp-84 Standard Vec I32 Insert Helper Alpha is an earlier stdlib/source gate.
It extended the same staged facade with source-authored
`insert_at(values,position,value)`.
exp-83 Standard Vec I32 Remove Helper Alpha is an earlier stdlib/source gate.
It extended the same staged facade with source-authored
`remove_at(values,position)`.
exp-82 Standard Vec I32 Replace Helper Alpha is an earlier stdlib/source
gate. It extended the same staged facade with source-authored
`replace_at(values,position,replacement)`.
exp-80 Standard Vec I32 Generated Constructor Helpers Alpha is an earlier
stdlib/source gate. It extended the same staged facade with source-authored
`repeat` and `range_from_zero` helpers.
exp-79 Standard Vec I32 Transform Helpers Alpha is an earlier stdlib/source
gate. It extended the same staged facade with source-authored `concat`,
`take`, `drop`, and `reverse` helpers.
exp-78 Standard CLI Local Source Facade Alpha is an earlier stdlib/source
gate. It keeps the staged `std.cli` helper surface unchanged while adding the
Glagol local `cli/process/string` fixture and alignment coverage for that same
source-authored facade shape.
exp-77 Standard Vec I32 Option Query Helpers Alpha is an earlier stdlib/source
gate. exp-76 Standard Vec I32 Source Helpers Alpha is an earlier stdlib/source
gate. exp-75 Standard Option Constructors Alpha is an earlier stdlib/source
gate. exp-74 Standard Result Constructor Helpers Alpha is an earlier
stdlib/source gate. exp-73 Standard Io Value Helpers Alpha is an earlier
stdlib/source gate.
exp-72 Standard Cli Custom Fallback Helpers Alpha is an earlier stdlib/source
gate. exp-71 Standard Process Custom Fallback Helpers Alpha is an earlier
stdlib/source gate. exp-70 Standard Fs Custom Fallback Helpers Alpha is an
earlier stdlib/source gate. exp-69 Standard Env Custom Fallback Helpers Alpha
is an earlier stdlib/source gate. exp-68 Standard String Custom Fallback
Helpers Alpha is an earlier stdlib/source gate. exp-67 Standard Process Typed
Helpers Alpha is an earlier stdlib/source gate. exp-66 Standard Fs Typed Read
Helpers Alpha is an earlier stdlib/source gate. exp-65 Standard Env Typed
Helpers Alpha is an earlier stdlib/source gate. exp-64 Standard Num Fallback
Helpers Alpha is an earlier stdlib/source gate.
exp-63 Standard Fs Fallback Helpers Alpha is an earlier stdlib/source gate.
exp-62 Standard Env Fallback Helpers Alpha is an earlier stdlib/source gate.
exp-61 Standard Process Fallback Helpers Alpha is an earlier stdlib/source
gate. exp-60 Standard String Fallback Helpers Alpha is an earlier
stdlib/source gate. exp-59 Hosted Build Optimization And Benchmark Publication
Alpha is the previous compiler/tooling gate. exp-58 Boolean Logic Alpha is the
previous compiler gate. exp-57 Integer Bitwise Alpha is the previous
compiler/stdlib gate. exp-56 Integer Remainder Alpha is an earlier
compiler/stdlib gate. exp-55 Result F64 Bool Source Flow Alpha is an earlier
compiler gate. exp-54 Standard CLI Typed Arguments Alpha is an earlier source
facade gate.
exp-53 Standard CLI Source Facade Alpha is an earlier source facade gate.
exp-52 Standard Process Facade Source Search Alpha is an earlier source facade
gate. exp-51 Standard Library Path List Alpha is the previous toolchain
discovery gate. exp-50 Installed Standard Library Discovery Alpha is an
earlier toolchain discovery gate. exp-43 Technical Whitepapers And Skills
Alpha is an earlier released documentation/tooling gate.
exp-42 Hot Loop Benchmark Mode Alpha is the latest released experimental
benchmark tooling gate.
exp-41 Lisp Benchmark Comparison Alpha is an earlier released experimental
benchmark comparison gate.
exp-40 Benchmark Suite And License Alpha is the latest released experimental
license/governance gate.
exp-39 Standard Math Extensions And Benchmark Scaffold Alpha is the latest
released experimental source-helper gate. exp-34 String Parse Bool Result
Alpha is the latest compiler semantic/runtime-operation support slice.
## Phase 1: Make Current Compiler Trustworthy
- [x] Add Rust integration tests for `examples/add.slo`.
- [x] Wire `tests/add.expected.ll` into a snapshot or shape-based test.
- [x] Add negative tests for unknown function, arity mismatch, type mismatch, unclosed list, and unknown top-level form.
- [x] Remove source-reachable backend panics.
- [x] Add `UnsupportedBackendFeature` diagnostics or implement lowering for all checked expression variants.
- [x] Add an explicit test for checked `if` not crashing the backend.
- [x] Remove unused imports and warnings in touched files.
## Phase 2: Close Critical Semantic Gaps
- [x] Implement LLVM lowering for value-producing `if` with then/else/merge blocks and `phi`.
- [x] Preserve spans on checked expressions.
- [x] Add integer range diagnostics for i32 literals.
- [x] Add severity to diagnostics.
- [x] Add line/column ranges while preserving byte spans.
- [x] Ensure complex placeholder types cannot emit ABI-sensitive LLVM accidentally.
## Phase 3: Restore Slovo Tooling Promise
- [x] Add parsed-tree printer.
- [x] Add canonical formatter for supported syntax.
- [x] Add formatter fixtures.
- [x] Add machine-diagnostic snapshots.
- [x] Add lowering inspector from surface AST to checked/core AST.
## Phase 4: Implement Slovo v0 Core
- [x] Implement top-level `(test "name" expr)` or explicitly reject it in supported examples.
- [x] Implement `let`, `var`, and `set`.
- [x] Promote value-producing `if`.
- [x] Implement `while`.
- [x] Implement string runtime support or structured unsupported diagnostics.
- [x] Implement first-pass structs and immediate field access.
- [x] Implement arrays and checked indexing.
- [x] Implement first-pass `option` and `result` constructors.
- [x] Implement lexical `unsafe` and unsafe-required diagnostics.
## Phase 5: Close v0 Compiler Surface
- [x] Treat `glagol` as the v0 binary CLI.
- [x] Document supported CLI modes, stdout/stderr behavior, and exit codes.
- [x] Test successful help, diagnostic failures, input failures, and usage errors.
- [x] Keep direct native executable output deferred behind the explicit
LLVM-plus-Clang workflow.
## Phase 6: Start Slovo v1 Value Flow
- [x] Implement immutable struct locals, struct parameters, struct returns,
calls returning structs, and field access through stored struct values.
- [x] Keep struct field/value mutation deferred for v1.
- [x] Implement option/result value flow and first-pass tag observation.
- [x] Implement option/result payload extraction after Slovo
specifies the contract.
- [x] Keep broader option/result matching deferred until Slovo later specifies
a narrow source-level `match` slice.
- [x] Implement array value flow and runtime-checked dynamic indexing for
fixed-size `i32` arrays.
- [x] Implement the narrow string runtime slice: direct string literals stored
as borrowed static `ptr` values and passed to temporary `print_string`.
- [x] Keep full string value flow and broad runtime printing deferred for v1.
## Phase 7: Polish The Binary CLI
- [x] Add explicit `--emit=llvm` while keeping default LLVM emission compatible.
- [x] Add `-o <path>` for successful primary output.
- [x] Add `--version` from Cargo package metadata.
- [x] Keep direct executable output deferred behind the LLVM-plus-Clang workflow.
- [x] Keep stdin source input deferred until source naming and span behavior are
specified.
## Phase 8: Start Slovo v1 Tooling Contracts
- [x] Emit Slovo v1 machine diagnostics with `(schema slovo.diagnostic)`,
`(version 1)`, and a root `(diagnostic ...)` form.
- [x] Add `--manifest <path>` for Slovo v1 textual artifact manifests on
successful primary modes and source-diagnostic failures.
- [x] Reject user-visible `unit` parameter and return signatures with
structured diagnostics while keeping `unit` available to internal
compiler/runtime forms.
- [x] Preserve existing stdout, stderr, and `-o` behavior while adding
manifest output as a side channel, not as native executable output.
- [x] Expand formatter stability coverage for comments, nested promoted forms,
and long inline forms.
- [x] Expand and audit the v1 golden diagnostic matrix beyond the first schema
migration.
- [x] Add lowering-inspector golden fixtures for every promoted v1 feature
family.
- [x] Keep stable LLVM debug metadata, DWARF, source-map files, and stable
ABI/layout promises deferred for v1.
## Phase 9: Slovo v1.1 Toolchain Productization
- [x] Add canonical `check`, `fmt`, `test`, and `build` subcommands.
- [x] Preserve v1 compatibility flags and default LLVM emission.
- [x] Add `--json-diagnostics` with newline-delimited
`slovo.diagnostic` version `1` output.
- [x] Add `--no-color` across canonical commands and compatibility modes.
- [x] Implement hosted native `build` through emitted LLVM IR,
`runtime/runtime.c`, and Clang with `GLAGOL_CLANG` override.
- [x] Implement v1.1 exit codes `0`, `1`, `2`, `3`, and `5`; reserve `4`
for internal compiler errors.
- [x] Extend manifests for no-output `check`, canonical commands,
diagnostics encoding, build artifacts, and parsed failure cases.
- [x] Add focused CLI, JSON diagnostic, manifest failure, missing-Clang, and
ignored hosted-build smoke tests.
## Phase 10: Slovo v1.2 Practical Runtime Values
- [x] Implement immutable string `let` locals, parameters, returns, and calls
returning strings.
- [x] Implement string equality with `=`.
- [x] Implement string byte length through temporary intrinsic `string_len`.
- [x] Implement temporary intrinsic `print_bool`.
- [x] Add deterministic runtime trap stderr messages for array bounds and
option/result unwrap failures.
- [x] Make runtime traps exit with code `1` for `glagol test` trapped tests
and produced executables.
- [x] Keep the v1.1 CLI/toolchain surface unchanged.
- [x] Keep `print_unit`, mutable strings, string concatenation, strings in
containers, project mode, imports, and modules deferred.
- [x] Add fixture alignment, formatter idempotence, lowering-inspector,
diagnostic, runtime smoke, and process-exit gates matching the Slovo
v1.2 contract.
## Phase 11: Slovo v1.3 Project Mode And Modules
- [x] Read `slovo.toml` project manifests with `[project]`, required `name`,
optional `source_root = "src"`, and optional `entry = "main"`.
- [x] Select project mode for `glagol check`, `glagol test`, and
`glagol build` only when input is a project root or the `slovo.toml`
file itself.
- [x] Keep single-file `.slo` behavior unchanged from v1.2.
- [x] Discover only immediate `.slo` module files under the flat source root.
- [x] Accept module export lists such as
`(module math (export add_one Point))`.
- [x] Accept explicit local imports such as `(import math (add_one Point))`.
- [x] Enforce import/export visibility, module-private top-level names,
duplicate-name rules, and reserved builtin/intrinsic names.
- [x] Compile, test, diagnose, and write manifests in deterministic module
order.
- [x] Preserve source file identity and related spans for cross-file
diagnostics.
- [x] Extend `slovo.artifact-manifest` version `1` output for project roots,
manifests, source roots, module lists, import edges, test counts, and
build outputs.
- [x] Add project fixture, manifest, command, diagnostic, deterministic-order,
artifact-manifest, and single-file regression gates matching the Slovo
v1.3 contract.
- [x] Keep packages/dependencies, workspaces, aliases/globs/qualified imports,
re-exports, nested modules, project formatting, path escapes, watch/LSP,
incremental builds, generated sources, object/library/header outputs, and
ABI promises deferred.
## Phase 12: Slovo v1.4 Core Language Expansion
- [x] Implement source-level `match` for exactly `(option i32)` and
`(result i32 i32)`.
- [x] Require exhaustive two-arm forms: `some`/`none` for options and
`ok`/`err` for results.
- [x] Implement immutable payload bindings for `some`, `ok`, and `err`.
- [x] Scope payload bindings and local bindings to one arm body only.
- [x] Type each `match` expression as the common arm result type.
- [x] Add diagnostics for subject type mismatch, unsupported payload type,
non-exhaustive matches, duplicate arms, malformed patterns, arm type
mismatch, binding collisions, unsupported mutation, and unsupported
containers.
- [x] Add canonical multiline formatter support for promoted `match`.
- [x] Add lowering-inspector, LLVM/runtime smoke, fixture-alignment, formatter,
diagnostic, and regression gates matching the Slovo v1.4 contract.
- [x] Keep user-defined enums/ADTs, generics, non-`i32` payload matching,
nested option/result payloads, option/result containers, mutation,
vectors, `i64`, general block expressions, guards, wildcard/rest
patterns, destructuring, standard-library error conventions, ownership,
layout, and ABI guarantees deferred.
## Phase 13: Slovo v1.5 Standard Library Alpha
- [x] Implement compiler-known source-level standard-runtime names
`std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and
`std.string.len`.
- [x] Preserve legacy `print_i32`, `print_string`, `print_bool`, and
`string_len` as compatibility aliases.
- [x] Reject unknown or unpromoted `std.*` calls with a structured diagnostic,
suggested code `UnsupportedStandardLibraryCall`.
- [x] Reserve the exact promoted `std.*` names from user function/export
shadowing.
- [x] Keep promoted names out of user module, import, package, FFI, and stable
C ABI semantics.
- [x] Add fixture alignment for `examples/standard-runtime.slo`, formatter
idempotence for `tests/standard-runtime.slo`, lowering-inspector,
runtime-smoke, diagnostic, and regression gates matching the Slovo v1.5
contract.
- [x] Keep `std.io.print_unit`, file IO, environment variables, process
arguments, time, collections, allocation, overloading, generics, Unicode
length semantics, ABI/layout promises, and FFI deferred.
## Phase 14: Slovo v1.6 Memory And Unsafe Design Slice
- [x] Centralize compiler-known unsafe operation head metadata for `alloc`,
`dealloc`, `load`, `store`, `ptr_add`, `unchecked_index`, `reinterpret`,
and `ffi_call`.
- [x] Preserve lexical unsafe gating: outside `(unsafe ...)`, these heads
produce `UnsafeRequired` before user-function lookup; inside
`(unsafe ...)`, they produce `UnsupportedUnsafeOperation`.
- [x] Reserve compiler-known unsafe heads from user functions, project
imports/exports, parameters, locals, structs, and match payload bindings
where the current reservation architecture applies.
- [x] Add diagnostics-contract coverage for every unsafe head in both the
unsafe-required and unsupported-inside-unsafe gates.
- [x] Keep raw memory, pointers, allocation/free, unchecked indexing,
reinterpretation, FFI execution, stable ABI/layout promises, and runtime
C symbols deferred.
## Phase 15: Glagol v1.7 Developer Experience Hardening
- [x] Add `glagol new <project-dir> [--name <name>]` for minimal local project
scaffolding with structured diagnostics for blocked targets and invalid
arguments.
- [x] Add `glagol fmt --check` and `glagol fmt --write` for files and project
inputs while preserving plain `glagol fmt <file>` stdout formatting.
- [x] Extend formatter coverage only for already-supported project module
declarations, exports, imports, and imported calls.
- [x] Add `glagol doc <file-or-project> -o <dir>` for deterministic Markdown
summaries of modules, imports, exports, structs, functions, and tests
from current parser/lowerer/source forms.
- [x] Add `scripts/release-gate.sh` for the local release gate from either the
repository root or compiler directory context.
- [x] Keep Slovo language syntax and semantics unchanged.
## Phase 16: Glagol v2.0.0-beta.1 Experimental Gate
- [x] Treat the release as an experimental gate/readiness release based on
v1.7, not as a new language expansion.
- [x] Document the experimental-supported CLI, project workflow, language
surface, and explicit deferrals in `.llm/V2_0_0_BETA_1_RELEASE_GATE.md`.
- [x] Verify a scaffolded experimental project can run through `new`,
`fmt --check`, `test`, `doc`, and hosted `build` when the toolchain is
available.
- [x] Keep the standard-runtime alpha scoped to basic IO/string names:
`std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and
`std.string.len`.
- [x] Keep fixed-size immutable `i32` arrays as the current collection subset.
- [x] Defer vectors, growable collections, package registries, stable
ABI/layout, FFI, raw-memory execution, LSP, debug metadata, and
source-map files until future beta work.
## Phase 17: exp-1 Owned String Concat Slice
- [x] Implement compiler-known `std.string.concat(left right)` without adding
new syntax.
- [x] Keep concat strict to the standard-runtime name; no legacy
`string_concat` alias is promoted.
- [x] Lower concat through an explicit private runtime helper without claiming
stable ABI, layout, allocator, or lifetime semantics.
- [x] Keep string mutation, string containers, user deallocation, and `+`
string concatenation deferred behind existing diagnostics.
- [x] Add checker, formatter, lowering-inspector, test-runner, LLVM-shape, and
hosted-runtime coverage for the narrow slice.
## Phase 18: exp-2 Collections Alpha Slice
- [x] Implement the initial growable collection type: `(vec i32)`.
- [x] Extend the concrete vector family with `(vec i64)` in exp-94.
- [x] Promote compiler-known `std.vec.i32.empty`, `std.vec.i32.append`,
`std.vec.i32.len`, and `std.vec.i32.index`.
- [x] Promote compiler-known `std.vec.i64.empty`, `std.vec.i64.append`,
`std.vec.i64.len`, and `std.vec.i64.index`.
- [x] Keep vector values immutable from source; `append` returns a new
runtime-owned vector instead of mutating the input.
- [x] Implement same-family `(vec i32)` and `(vec i64)` equality with `=`.
- [x] Lower vector operations through private runtime helpers and reserve
helper symbols from source/project names.
- [x] Add runtime traps for vector allocation failure and vector index
out-of-bounds.
- [x] Add formatter, lowering-inspector, test-runner, LLVM/runtime, diagnostic
snapshot, fixture-inventory, and hosted-runtime coverage for the slice.
- [x] Keep generic vectors, element families beyond `i32` and `i64`, vector
mutation, push aliases, nested vectors, vectors inside other containers,
stable layout, ABI, FFI, and deallocation deferred behind diagnostics.
## Phase 19: exp-3 Standard IO And Host Environment Slice
- [x] Implement the conservative exp-3 host IO standard-runtime calls.
- [x] Keep networking, async IO, binary IO, directory traversal, terminal
control, stdin iteration, time, randomness, and stable host ABI deferred.
## Phase 20: exp-4 User ADTs Alpha Slice
- [x] Implement payloadless user-defined enums, qualified constructors,
equality, value flow, top-level tests, and exhaustive variant matches.
- [x] Keep payload variants, generic ADTs, type aliases, traits, methods,
unqualified variants, enum mutation, enum printing, enum ordering, enum
containers, stable layout, and stable ABI deferred.
## Phase 21: exp-5 Local Packages And Workspaces Alpha
- [x] Read workspace `[workspace] members` manifests and member package
`[package]` manifests with `name`, `version`, `source_root`, and `entry`.
- [x] Support local `[dependencies]` path records such as
`mathlib = { path = "../mathlib" }`.
- [x] Build a deterministic closed local package graph.
- [x] Accept package-qualified imports such as
`(import mathlib.math (add_one))`.
- [x] Enforce package boundaries through existing module export lists.
- [x] Extend artifact manifests with workspace and package graph information.
- [x] Diagnose missing packages, duplicate package names, dependency cycles,
path escapes, invalid package names, invalid package versions, private
visibility, and dependency key mismatches.
- [x] Keep registries, lockfiles, semver solving, aliases/globs/re-exports,
generated code, build scripts, publishing, optional/dev/target
dependencies, stable package ABI, and remote dependencies deferred.
## Phase 22: exp-6 C FFI Scalar Imports Alpha
- [x] Accept top-level imported C declarations such as
`(import_c c_add ((lhs i32) (rhs i32)) -> i32)`.
- [x] Restrict imported C signatures to `i32` parameters and `i32` or builtin
`unit` returns.
- [x] Require conservative C symbol names shared with the source import name.
- [x] Require calls to imported C functions to appear inside lexical
`(unsafe ...)`.
- [x] Preserve raw unsafe head diagnostics; `ffi_call` and the other v1.6 raw
unsafe heads remain unsupported even inside unsafe blocks.
- [x] Lower accepted imports to LLVM external declarations and direct calls.
- [x] Support explicit local C source linking through
`glagol build --link-c <path>`.
- [x] Report `UnsupportedTestExpression` when the interpreter-style test
runner reaches an imported C call.
- [x] Extend artifact manifests with `foreign_imports` and `c_link_inputs`.
- [x] Keep pointers, raw allocation/deallocation, raw unsafe head execution,
ownership/lifetime rules, C exports, callbacks, headers/libraries,
broad linker configuration, and stable ABI/layout deferred.
## Phase 23: exp-7 Test Selection Alpha
- [x] Add `--filter <substring>` for `glagol test` and the legacy
single-file `--run-tests` mode.
- [x] Count skipped tests before evaluation and record selected/skipped
metadata in artifact manifests.
- [x] Keep tags, groups, retries, parallelism, benchmark behavior, and watch
mode deferred.
## Phase 24: exp-8 Host Time And Sleep Alpha
- [x] Promote compiler-known `std.time.monotonic_ms: () -> i32` and
`std.time.sleep_ms: (i32) -> unit`.
- [x] Lower native calls through private runtime helpers and implement
process-relative monotonic milliseconds plus `nanosleep`.
- [x] Support deterministic `sleep_ms 0` and non-negative monotonic execution
in the test runner; trap negative sleeps with the exact runtime message.
- [x] Keep threads, channels, async, timers, wall-clock time, time zones,
scheduling guarantees, cancellation, high-resolution timing, and stable
runtime ABI deferred.
- [x] Review artifact manifests: no current standard-runtime usage structure
exists, so exp-8 defers time-specific metadata.
## Phase 25: exp-9 Reliability Performance And Ecosystem Hardening
- [x] Add Glagol exp-9 documentation/audit state aligned with the Slovo
hardening target.
- [x] Record compatibility inventory for `v2.0.0-beta.1` and exp-1 through
exp-8.
- [x] Record migration guidance that requires no source syntax, standard
runtime, or manifest schema migration by default.
- [x] Record source-reachable panic audit classifications for current source
markers.
- [x] Record benchmark smoke commands and known limits without public numeric
thresholds.
- [x] Add parser, formatter, diagnostic, project graph, runtime API,
test-runner, backend-precondition, and artifact-manifest hardening tests.
- [x] Add exp-9 corpus coverage and panic-audit classifications proving the
current source-reachable panic markers are diagnostic/trap boundaries or
non-source-reachable invariants.
- [x] Run the exp-9 release gate and benchmark smoke evidence.
- [x] Write exp-9 release review evidence.
- [x] Keep exp-9 hardening-only: no source syntax, no new standard-runtime
names, no runtime capability expansion, no manifest schema bump, no ABI
or performance stability claim, and no beta maturity claim.
## Phase 26: exp-10 Result-Based Host Errors Alpha
- [x] Implement concrete `(result string i32)` value flow, observers, unwraps,
and exact two-arm `match` without broadening arbitrary result payloads.
- [x] Promote `std.process.arg_result`, `std.env.get_result`,
`std.fs.read_text_result`, and `std.fs.write_text_result`.
- [x] Return ordinary host failures as exactly `err 1`.
- [x] Preserve exp-3 host call behavior unchanged for traps, missing
environment variables, and write status values.
- [x] Add formatter, lowering-inspector, diagnostics, deterministic
test-runner, LLVM/runtime, and fixture-alignment gates for the target
fixture `host-io-result.slo`.
- [x] Keep exp-10 experimental only: no generic results, typed host error ADTs,
error messages, errno domains, result equality/printing/mapping,
manifest schema bump, stable ABI/layout, or beta maturity.
## Phase 27: exp-11 Basic Randomness Alpha
- [x] Promote exactly `std.random.i32 : () -> i32`.
- [x] Return a non-negative implementation-owned `i32` in runtime and
deterministic-enough test-runner paths.
- [x] Trap runtime unavailability with exactly
`slovo runtime error: random i32 unavailable`.
- [x] Add fixture alignment, formatter, lowering-inspector, diagnostic,
test-runner, LLVM/runtime, and promotion-gate coverage for
`random.slo`.
- [x] Keep exp-11 experimental only: no seed APIs, crypto suitability, range
arguments, bytes, strings, UUIDs, stable sequences, manifest schema bump,
stable helper ABI, runtime headers/libraries, or beta maturity.
## Phase 28: exp-12 Standard Input Result Alpha
- [x] Promote exactly `std.io.read_stdin_result : () -> (result string i32)`.
- [x] Return `ok` with remaining stdin text, including EOF as `ok ""`, and
ordinary host/input failure as `err 1`.
- [x] Align Slovo supported and formatter fixtures with `stdin-result.slo`.
- [x] Cover formatter and lowering-inspector visibility for
`(std.io.read_stdin_result)`.
- [x] Cover diagnostics for arity mismatch, bool-context/type misuse,
source-name shadowing, helper-symbol shadowing, unsupported trap-based
`std.io.read_stdin`, line/read-line APIs, prompt APIs, terminal mode,
binary stdin, streaming, async stdin, and unknown deferred stdin
boundaries named by Slovo.
- [x] Keep exp-12 experimental only: no trap-based stdin, line iteration,
prompt APIs, terminal mode, binary stdin, streaming, async IO, encoding
or Unicode promise, stable helper ABI/layout, manifest schema change,
or beta maturity.
## Phase 29: exp-13 String Parse I32 Result Alpha
- [x] Promote exactly
`std.string.parse_i32_result : (string) -> (result i32 i32)`.
- [x] Parse an entire ASCII decimal signed `i32`, returning `ok value` on
success and ordinary parse failure as `err 1`.
- [x] Align Slovo supported and formatter fixtures with
`string-parse-i32-result.slo`.
- [x] Cover formatter and lowering-inspector visibility for
`(std.string.parse_i32_result text)`.
- [x] Cover diagnostics for arity mismatch, invalid argument type,
result/bool-context misuse, source-name shadowing, helper-symbol
shadowing, trap-based `std.string.parse_i32`, unsupported parse
families, string indexing/slicing, tokenizer/scanner APIs, and named
deferred parse boundaries.
- [x] Keep exp-13 experimental only: no trap-based parse,
float/bool/string/bytes parsing, whitespace/locale/base-prefix/
underscore/plus-sign parsing, generic parse API, richer parse errors,
Unicode digit parsing, string indexing/slicing, tokenizer/scanner APIs,
stdin line APIs, stable helper ABI/layout, runtime headers/libraries,
manifest schema changes, or beta maturity.
## Phase 30: exp-14 Standard Runtime Conformance Alignment
- [x] Add Glagol `time-sleep.slo` supported and formatter fixtures over the
released exp-8 `std.time.monotonic_ms` and `std.time.sleep_ms 0`
surface.
- [x] Add lowering-inspector snapshots, promotion-gate inventory, formatter
checks, compile-shape checks, and test-runner checks for the time/sleep
fixture.
- [x] Add a focused conformance gate script separate from
`scripts/release-gate.sh`.
- [x] Add focused integration coverage for projects/imports, tests, docs,
`fmt --check`, `check`, `test`, hosted build/run when available, and
the released standard-runtime surface through exp-13 plus exp-8
time/sleep.
- [x] Release exp-14 only after focused conformance, full release gate, and
Slovo/Glagol review pass together.
- [x] Keep exp-14 experimental only: no source syntax, type forms,
standard-library operation names, runtime APIs, ABI/layout promises,
manifest schema changes, or beta maturity.
## Phase 31: exp-15 Result Helper Standard Names Alpha
- [x] Accept exactly `std.result.is_ok`, `std.result.is_err`,
`std.result.unwrap_ok`, and `std.result.unwrap_err`.
- [x] Map those names to existing result observer/unwrap behavior for exactly
`(result i32 i32)` and `(result string i32)`.
- [x] Preserve source helper spelling in surface and checked lowering output.
- [x] Keep legacy `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` working.
- [x] Add `result-helpers.slo` examples/tests, lowering snapshots,
promotion-gate inventory, formatter coverage, compile-shape coverage,
test-runner coverage, and focused negative tests for deferred/misused
names.
- [x] Keep exp-15 experimental only: no `std.result.map`,
`std.result.unwrap_or`, `std.result.and_then`, option standard names,
generic results, new result payload families, runtime/runtime.c changes,
LLVM runtime declarations, manifest schema changes, or beta maturity.
## Phase 32: exp-16 Unary I32 Enum Payloads Alpha
- [x] Support user enum declarations with payloadless variants and unary `i32`
payload variants.
- [x] Support qualified payload and payloadless constructors, immutable enum
locals/params/returns/calls/tests/main flow, and same-enum equality.
- [x] Require exhaustive enum matches with no binding on payloadless variants
and one immutable arm-local `i32` binding on payload variants.
- [x] Lower payload enums as compiler-owned tag-plus-`i32` aggregates in LLVM
and the test runner, without runtime/runtime.c changes or ABI/layout
claims.
- [x] Add `enum-payload-i32.slo` examples/tests, surface and checked lowering
snapshots, formatter coverage, focused Rust integration tests,
promotion-gate inventory, and diagnostics for payload boundary cases.
- [x] Keep exp-16 experimental only: no non-`i32` payload types, multiple
payloads, record variants, generic enums/functions, wildcard/rest/nested
enum patterns, guards, enum containers, enum mutation, enum printing,
enum ordering/hash/reflection/discriminants, runtime ABI/layout claims,
manifest schema changes, or beta maturity.
## Future Beta Next
- [x] Complete exp-9 hardening gates before adding source semantics.
- [x] Completed exp-10 gates; result-based host errors are released as
experimental compiler support.
- [x] Completed exp-11 gates; basic randomness is released as experimental
compiler support.
- [x] Completed exp-12 gates; standard input result is released as
experimental compiler support.
- [x] Completed exp-13 gates; string parse i32 result is released as
experimental compiler support.
- [x] Complete exp-14 Standard Runtime Conformance Alignment gates before
treating the conformance fixture/gate set as released experimental
support.
- [x] Completed exp-15 gates; result helper standard names are released as
experimental compiler support.
- [x] Completed exp-16 gates; unary `i32` enum payloads are released as
experimental compiler support.
- [x] Completed exp-17 gates; project/workspace enum imports are released as
experimental compiler support.
- [x] Completed exp-18 gates; direct enum struct fields are released as
experimental compiler support.
## Phase 33: exp-17 Project/Workspace Enum Imports Alpha
- [x] Treat top-level enum declarations as project/workspace local declarations
that can be exported and imported alongside functions and structs.
- [x] Preserve payloadless and unary `i32` payload variant metadata for imported
enum types in signatures, immutable locals, calls/returns, constructors,
equality, exhaustive matches, `main`, and tests.
- [x] Keep project/workspace symbol rewriting aligned for enum declarations,
enum types, qualified constructors, enum match patterns, and imported enum
symbols.
- [x] Add project and workspace/package tests plus the
`examples/projects/enum-imports/` fixture.
- [x] Keep exp-17 experimental only: no non-`i32` payloads, multi-payloads,
record variants, enum containers, mutation, printing, ordering, generics,
stable ABI/layout, manifest schema changes, registry/package-manager
behavior, or beta maturity.
- [ ] If collections expand later, specify generic vectors/growable
collections in Slovo first, then add Glagol parser/checker/formatter/
diagnostic/backend/runtime gates.
- [ ] If editor tooling is promoted later, specify LSP/watch/debug/source-map
behavior before claiming support.
## Phase 34: exp-18 Enum Struct Fields Alpha
- [x] Allow direct known enum types as struct fields for current payloadless
and unary `i32` payload enums.
- [x] Preserve `UnsupportedEnumContainer` for arrays, vectors, options, and
results containing enum values in struct fields.
- [x] Keep other unsupported struct field types on the existing
`UnsupportedStructFieldType` path.
- [x] Add `enum-struct-fields.slo` examples/tests, surface and checked lowering
snapshots, focused Rust integration tests, promotion-gate inventory, and
diagnostics for enum container fields.
- [x] Keep exp-18 experimental only: no enum containers, nested structs,
mutation, printing, ordering/hash/reflection, broader payloads, generics,
stable ABI/layout, manifest schema changes, package registry behavior,
import aliases/globs/re-exports, or beta maturity.
## Phase 35: exp-19 Primitive Struct Fields Alpha
- [x] Allow direct `bool` and immutable `string` field types in top-level
structs, alongside existing direct `i32` fields and exp-18 direct enum
fields.
- [x] Preserve unsupported diagnostics for arrays, vectors, options, and
results containing these field types, nested structs, and unknown named
field types.
- [x] Add `primitive-struct-fields.slo` examples/tests, surface and checked
lowering snapshots, focused Rust integration tests, promotion-gate
inventory, diagnostics, formatter coverage, test-runner coverage, LLVM
shape coverage, and Slovo alignment hooks.
- [x] Keep exp-19 experimental only: no primitive containers as struct fields,
nested structs, mutation, broader string ownership/cleanup promises,
generics, methods/traits, stable ABI/layout, manifest schema changes,
import/package widening, or beta maturity.
## Phase 36: exp-20 F64 Numeric Primitive Alpha
- [x] Add direct `f64` type/literal value flow for locals, parameters,
returns, calls, top-level tests, and `main`-reachable helper calls.
- [x] Lower `f64` to LLVM `double`, including constants, function
parameters/returns, arithmetic `+ - * /`, equality, and ordered
comparisons.
- [x] Promote exactly `std.io.print_f64 : (f64) -> unit` with runtime
`%.17g\n` formatting and test-runner coverage.
- [x] Add `f64-numeric-primitive.slo` examples/tests, surface and checked
lowering snapshots, formatter coverage, focused Rust integration tests,
LLVM shape coverage, runtime smoke, and mixed i32/f64 diagnostics.
- [x] Keep exp-20 experimental only: no f32, wider integer families,
characters/bytes/decimal, casts, mixed i32/f64 arithmetic, f64
arrays/vectors/options/results/enum payloads/struct fields, parse_f64,
random floats, stable ABI/layout, or beta maturity.
## Phase 37: exp-21 I64 Numeric Primitive Alpha
- [x] Add direct `i64` type/literal value flow for immutable locals,
parameters, returns, calls, top-level tests, and `main`-reachable helper
calls.
- [x] Require explicit signed decimal `i64` suffix atoms and reject malformed
or out-of-range `i64` literals with structured diagnostics.
- [x] Lower `i64` to LLVM `i64`, including constants, function
parameters/returns, arithmetic `+ - * /`, equality, and ordered
comparisons.
- [x] Promote exactly `std.io.print_i64 : (i64) -> unit` with runtime decimal
output and test-runner coverage.
- [x] Add `i64-numeric-primitive.slo` examples/tests, surface and checked
lowering snapshots, formatter coverage, focused Rust integration tests,
LLVM shape coverage, runtime smoke, fixture alignment hooks, and
diagnostics for mutable i64 locals and mixed numeric operands.
- [x] Keep exp-21 experimental only: no f32, unsigned integers, narrower
signed integers, characters/bytes/decimal, casts, mixed
i32/i64/f64 arithmetic, i64 arrays/vectors/options/results/enum
payloads/struct fields, parse_i64, random i64, stable ABI/layout, or
beta maturity.
## Phase 38: exp-22 Numeric Widening Conversions Alpha
- [x] Promote exactly `std.num.i32_to_i64 : (i32) -> i64`,
`std.num.i32_to_f64 : (i32) -> f64`, and
`std.num.i64_to_f64 : (i64) -> f64`.
- [x] Lower the promoted conversions directly to LLVM `sext`/`sitofp`
conversion instructions without adding stable runtime helper ABI
promises.
- [x] Execute the conversions in the deterministic test runner and preserve
them in formatter and lowering-inspector fixtures.
- [x] Add diagnostics for wrong arity, wrong argument type, and explicitly
unsupported narrowing or generic cast names.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixtures for `numeric-widening-conversions.slo`.
- [x] Keep exp-22 experimental only: no implicit promotion, mixed numeric
operators, narrowing or checked conversions, cast syntax, broader
numeric families, stable ABI/layout, manifest schema changes, or beta
maturity.
## Phase 39: exp-23 Checked I64-To-I32 Conversion Alpha
- [x] Promote exactly
`std.num.i64_to_i32_result : (i64) -> (result i32 i32)`.
- [x] Return `ok value` for signed `i64` inputs in signed `i32` range and
`err 1` for out-of-range inputs, with no traps.
- [x] Lower directly to LLVM signed range checks, `trunc`, `select`, and the
existing `(result i32 i32)` aggregate representation without adding a
stable helper ABI promise.
- [x] Execute the conversion in the deterministic test runner and preserve it
in formatter and lowering-inspector fixtures.
- [x] Add diagnostics for wrong arity, wrong argument type, and explicitly
unsupported deferred checked/cast names.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixture hooks for `checked-i64-to-i32-conversion.slo`.
- [x] Keep exp-23 experimental only: no implicit promotion, unchecked
narrowing, cast syntax, additional narrowing conversions, f64
conversions, stable ABI/layout, manifest schema changes, or beta
maturity.
## Phase 40: exp-24 Integer To String Alpha
- [x] Promote exactly `std.num.i32_to_string : (i32) -> string` and
`std.num.i64_to_string : (i64) -> string`.
- [x] Return signed decimal ASCII text with a leading `-` only for negative
values and no leading `+`.
- [x] Lower to private runtime helpers with current implementation-owned
string allocation behavior and no stable helper ABI/layout promise.
- [x] Execute both calls in the deterministic test runner and preserve them
in formatter and lowering-inspector fixtures.
- [x] Add diagnostics for wrong arity, wrong argument type, and explicitly
unsupported deferred formatting names.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixture hooks for `integer-to-string.slo`.
- [x] Keep exp-24 experimental only: no f64 formatting, parse APIs,
locale/base/radix/grouping/padding, generic display/format traits,
implicit conversion, manifest schema changes, stable helper ABI/layout,
or beta maturity.
## Phase 41: exp-25 String Parse I64 Result Alpha
- [x] Promote exactly
`std.string.parse_i64_result : (string) -> (result i64 i32)`.
- [x] Accept only an entire non-empty signed decimal ASCII string with an
optional leading `-` and signed `i64` bounds.
- [x] Return `ok value` for valid inputs and `err 1` for malformed or
out-of-range inputs without ordinary traps.
- [x] Lower to a private runtime helper returning status plus an `i64`
out-parameter, and keep the result aggregate implementation-owned.
- [x] Execute the call in the deterministic test runner and preserve it in
formatter, lowering-inspector, hosted-runtime, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixture hooks for `string-parse-i64-result.slo`.
- [x] Keep exp-25 experimental only: no leading `+`, whitespace, locale,
base/radix prefixes, underscores, Unicode digits, suffix/trailing bytes,
f64 parse, generic parse, rich parse errors, manifest schema changes,
stable helper ABI/layout, or beta maturity.
## Phase 42: exp-26 F64 To String Alpha
- [x] Promote exactly `std.num.f64_to_string : (f64) -> string`.
- [x] Return finite decimal ASCII text for promoted finite `f64` fixture
values.
- [x] Lower to a private runtime helper with implementation-owned string
allocation behavior and no stable helper ABI/layout promise.
- [x] Execute the call in the deterministic test runner and preserve it in
formatter, lowering-inspector, hosted-runtime, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixture hooks for `f64-to-string.slo`.
- [x] Keep exp-26 experimental only: no `f32`, f64 parse, generic
format/display/interpolation, locale/base/radix/grouping/padding/
precision controls, stable NaN/infinity text, implicit conversion,
manifest schema changes, stable helper ABI/layout, or beta maturity.
## Phase 43: exp-27 Checked F64 To I32 Result Alpha
- [x] Promote exactly
`std.num.f64_to_i32_result : (f64) -> (result i32 i32)`.
- [x] Return `ok value` only for finite, exactly integral inputs inside the
signed `i32` range and `err 1` for non-finite, fractional, or
out-of-range input.
- [x] Lower directly to LLVM with ordered range checks before `fptosi`, so
non-finite and out-of-range values do not reach undefined conversion.
- [x] Execute the call in the deterministic test runner and preserve it in
formatter, lowering-inspector, LLVM smoke, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixture hooks for `f64-to-i32-result.slo`.
- [x] Keep exp-27 experimental only: no unchecked `f64` to `i32`, casts or
cast syntax, generic `cast_checked`, `f32`, unsigned/narrower integer
families, f64 parse, mixed numeric arithmetic, numeric containers,
manifest schema changes, stable ABI/layout, or beta maturity.
## Phase 45: exp-29 Numeric Struct Fields Alpha
- [x] Allow direct immutable struct fields whose types are exactly `i64` or
finite `f64`, alongside existing direct `i32`, `bool`, immutable
`string`, and current enum fields.
- [x] Preserve constructor, immutable local, parameter, return, call, and field
access flow for `i64`/`f64` fields.
- [x] Allow accessed numeric fields to use existing same-type arithmetic,
comparison, print, and format helper support without adding new APIs.
- [x] Preserve deferred containers, nested structs, mutation, mixed numeric
arithmetic, implicit conversions, ABI/layout claims, manifest schema
changes, and beta maturity.
## Phase 46: exp-30 Standard Library Source Layout Alpha
- [x] Recognize the repo `lib/std/` source layout as a contract artifact
with `README.md`, `io.slo`, `string.slo`, `num.slo`, `result.slo`, and
`math.slo`.
- [x] Add Glagol-local project coverage for an explicit local `math.slo`
import through `examples/projects/std-layout-local-math/`.
- [x] Add an ignored sibling Slovo gate for `std/` file inventory and
source-shape and formatter stability.
- [x] Keep exp-30 experimental only: no new source syntax, new
compiler-known standard-runtime functions, automatic std import/search
path, package registry behavior, manifest schema changes, self-hosted
replacement for compiler-known `std.*` calls, or beta maturity.
## Phase 47: exp-31 Checked F64 To I64 Result Alpha
- [x] Promote exactly
`std.num.f64_to_i64_result : (f64) -> (result i64 i32)`.
- [x] Return `ok value` only for finite, exactly integral inputs inside the
signed `i64` range and `err 1` for non-finite, fractional, or
out-of-range input.
- [x] Lower directly to LLVM with ordered range checks before `fptosi`, so
non-finite and out-of-range values do not reach undefined conversion.
- [x] Execute the call in the deterministic test runner and preserve it in
formatter, lowering-inspector, LLVM smoke, hosted-runtime, and
diagnostic fixtures.
- [x] Keep exp-31 experimental only: no unchecked `f64` to `i64`, casts or
cast syntax, generic `cast_checked`, `f32`, unsigned/narrower integer
families, additional numeric conversion families, mixed numeric
arithmetic, numeric containers, manifest schema changes, stable
ABI/layout, or beta maturity.
## Phase 48: exp-32 Standard Math Source Helpers Alpha
- [x] Gate the narrow source-authored `std/math.slo` helper set without adding
compiler-known runtime names or compiler-loaded std source.
- [x] Extend `examples/projects/std-layout-local-math/` so an ordinary project
explicitly imports local `math.slo` helpers for `i32`, `i64`, and `f64`.
- [x] Cover `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`, `square_i32`,
`abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, `square_i64`, `abs_f64`,
`min_f64`, `max_f64`, `clamp_f64`, and `square_f64`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
Slovo `lib/std/math.slo` helper alignment in the ignored monorepo gate.
- [x] Keep exp-32 experimental only: no new compiler-known `std.*` runtime
calls, runtime ABI changes, automatic std import/search, broad math
library, trigonometry/sqrt/pow, `f32`, unsigned/narrower integers,
generic math, overloads, traits, mixed numeric arithmetic, manifest
schema changes, stable ABI/layout, or beta maturity.
## Phase 49: exp-33 Standard Result Source Helpers Alpha
- [x] Gate the narrow source-authored `std/result.slo` helper-name extension
without adding compiler-known runtime names or compiler-loaded std
source.
- [x] Add `examples/projects/std-layout-local-result/` so an ordinary project
explicitly imports local `result.slo` helpers for existing concrete
result families.
- [x] Cover `is_err_i64`, `unwrap_err_i64`, `is_err_string`,
`unwrap_err_string`, `is_err_f64`, `unwrap_err_f64`, `unwrap_or_i32`,
`unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
Slovo `lib/std/result.slo` helper alignment in the ignored monorepo gate.
- [x] Keep exp-33 experimental only: no generic result helpers, no
compiler-known `std.result.unwrap_or`, no map/chaining helpers, no
option helpers, no new result payload families, no new compiler-known
`std.*` runtime calls, no runtime ABI changes, no automatic std
import/search, no manifest schema changes, no stable ABI/layout, and no
beta maturity.
## Phase 44: exp-28 String Parse F64 Result Alpha
- [x] Promote exactly
`std.string.parse_f64_result : (string) -> (result f64 i32)`.
- [x] Accept complete finite ASCII decimal text in the narrow
`-?digits.digits` shape and return `ok value`; return `err 1` for
ordinary parse failure, non-finite text, unsupported leading/trailing
characters, or out-of-domain input.
- [x] Add concrete `(result f64 i32)` compiler support for direct fixture
flow, result helpers, lowering, and LLVM payload access without making
results generic or opening source-authored `(result f64 i32)`
constructors/matches.
- [x] Lower hosted builds through private runtime helper
`__glagol_string_parse_f64_result` and execute the call in the
deterministic test runner.
- [x] Preserve formatter, lowering-inspector, LLVM smoke, hosted-runtime,
promotion-gate, and diagnostic fixtures.
- [x] Keep Glagol examples/tests byte-aligned with Slovo supported/formatter
fixture hooks for `string-parse-f64-result.slo`.
- [x] Keep exp-28 experimental only: no generic parse, trap-based
`std.string.parse_f64`, leading `+`, exponent notation, locale parsing,
Unicode digits, rich parse errors, f64 containers, mixed numeric
arithmetic, manifest schema changes, stable helper ABI/layout, or beta
maturity.
## Phase 45: exp-34 String Parse Bool Result Alpha
- [x] Promote exactly
`std.string.parse_bool_result : (string) -> (result bool i32)`.
- [x] Accept only complete lowercase ASCII `true` and `false`; return
`ok true` or `ok false`, and return `err 1` for empty text, uppercase or
mixed-case text, whitespace, numeric text, and all other text.
- [x] Add concrete `(result bool i32)` compiler support for direct fixture
flow, result helpers, formatter/lowering snapshots, test-runner
execution, and LLVM payload access without making results generic or
opening source-authored `(result bool i32)` constructors/matches.
- [x] Lower hosted builds through private runtime helper
`__glagol_string_parse_bool_result`.
- [x] Preserve diagnostics, promotion-gate, lowering-inspector, LLVM smoke,
hosted-runtime, and sibling Slovo fixture/std-string source alignment.
- [x] Keep exp-34 experimental only: no generic parse, trap-based
`std.string.parse_bool`, case-insensitive parsing, whitespace trimming,
locale/Unicode parsing, numeric bool parsing, string/bytes parsing, rich
parse errors, manifest schema changes, stable helper ABI/layout, or beta
maturity.
## Phase 50: exp-35 Standard Result Bool Source Helpers Alpha
- [x] Gate the narrow source-authored `std/result.slo` bool helper-name
extension without adding compiler-known runtime names or
compiler-loaded std source.
- [x] Extend `examples/projects/std-layout-local-result/` so an ordinary
project explicitly imports local `result.slo` helpers for values coming
from `std.string.parse_bool_result`.
- [x] Cover `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`, `unwrap_err_bool`,
and `unwrap_or_bool`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
Slovo `lib/std/result.slo` bool helper alignment in the ignored monorepo
gate.
- [x] Keep exp-35 experimental only: no source constructors for bool results,
no generic bool result match, no compiler-known `std.result.unwrap_or`,
no map/chaining helpers, no option helpers, no new compiler-known
`std.*` runtime calls, no runtime ABI changes, no automatic std
import/search, no manifest schema changes, no stable ABI/layout, and no
beta maturity.
## Phase 51: exp-36 Standard Option Source Helpers Alpha
- [x] Gate the narrow source-authored `std/option.slo` helper-name facade
without adding compiler-known runtime names or compiler-loaded std
source.
- [x] Add `examples/projects/std-layout-local-option/` so an ordinary
project explicitly imports local `option.slo` helpers for source-authored
`(option i32)` values from `some` and `none`.
- [x] Cover `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, and
`unwrap_or_i32`.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
Slovo `lib/std/option.slo` helper alignment in the ignored monorepo std
source-layout gate.
- [x] Keep exp-36 experimental only: no new compiler-known `std.*` names, no
generic option helpers, no option payload families beyond `i32`, no
automatic std imports/search, no compiler-loaded std source, no
manifest schema changes, no stable ABI/layout, and no beta maturity.
## Phase 75: exp-95 Standard Option I64 Baseline Alpha
- [x] Broaden the concrete option family from only `(option i32)` to
`(option i64)` as well.
- [x] Extend checker, formatter, backend layout, and test-runner behavior for
immutable `(option i64)` params, returns, locals, `some`, `none`,
`is_some`, `is_none`, and `unwrap_some`.
- [x] Broaden source-level `match` payload binding and fixture coverage for
`(option i64)` without widening to generic options.
- [x] Broaden the local `std-layout-local-option/` fixture and the explicit
`std-import-option/` fixture to cover both the i32 and i64 helper
families.
- [x] Broaden the staged `std.option` helper surface to `some_i64`,
`none_i64`, `is_some_i64`, `is_none_i64`, `unwrap_some_i64`, and
`unwrap_or_i64`.
- [x] Keep exp-95 experimental only: no compiler-known `std.option.*` runtime
names, no generic option helpers, no broader payload families, no nested
option containers, no stable ABI/layout guarantee, and no beta maturity.
## Phase 82: exp-102 Standard Option Bool And F64 Baseline Alpha
- [x] Broaden the concrete option family from only `(option i32)`,
`(option i64)`, and `(option string)` to `(option f64)` and
`(option bool)` as well.
- [x] Add checker, formatter, backend, and test-runner support for immutable
`(option f64)` and `(option bool)` params, returns, locals, `some`,
`none`, `is_some`, `is_none`, `unwrap_some`, and source `match`.
- [x] Broaden the local `std-layout-local-option/`, explicit
`std-import-option/`, and workspace `std-import-option/` fixtures to
cover the same concrete helper families through `some_f64`, `none_f64`,
`is_some_f64`, `is_none_f64`, `unwrap_some_f64`, `unwrap_or_f64`,
`some_bool`, `none_bool`, `is_some_bool`, `is_none_bool`,
`unwrap_some_bool`, and `unwrap_or_bool`.
- [x] Extend focused option-result coverage, diagnostics snapshots, and
promotion-gate inventory to the same concrete `(option f64)` and
`(option bool)` baseline.
- [x] Keep exp-102 experimental only: no compiler-known `std.option.*`
runtime names, no generic option helpers, no broader payload families,
no nested option containers, no stable ABI/layout guarantee, and no
beta maturity.
## Phase 81: exp-101 Standard Vec String Option And Transform Helpers Alpha
- [x] Broaden the staged local `std-layout-local-vec_string/` fixture from
the exp-99 baseline with the option-query helpers `index_option`,
`first_option`, `last_option`, `index_of_option`, and
`last_index_of_option`.
- [x] Broaden the same concrete helper lane with the transform helpers
`concat`, `take`, `drop`, `reverse`, and `subvec`.
- [x] Keep the local and explicit-source vec-string fixtures recursive and
immutable with no `var` or `set`.
- [x] Keep the lane concrete to `(vec string)` plus raw current
`(option string)` / `(option i32)` forms only, with no generic
broadening or broader result families.
- [x] Extend focused vec-string source-helper/source-search coverage and
promotion-gate inventory for the same helper package.
- [x] Keep exp-101 experimental only: no new compiler-known `std.*` runtime
names, no edit helpers, no prefix/suffix helpers, no nested vecs, no
mutating/capacity APIs, no stable ABI/layout guarantee, and no beta
maturity.
## Phase 80: exp-100 Standard Option String Baseline Alpha
- [x] Broaden the concrete option family from only `(option i32)` and
`(option i64)` to `(option string)` as well.
- [x] Add checker, formatter, backend, and test-runner support for immutable
`(option string)` params, returns, locals, `some`, `none`, `is_some`,
`is_none`, `unwrap_some`, and source `match`.
- [x] Broaden the local `std-layout-local-option/`, explicit
`std-import-option/`, and workspace `std-import-option/` fixtures to
cover the same concrete helper family through `some_string`,
`none_string`, `is_some_string`, `is_none_string`,
`unwrap_some_string`, and `unwrap_or_string`.
- [x] Extend focused option/result coverage and promotion-gate inventory to
the same concrete `(option string)` baseline.
- [x] Keep exp-100 experimental only: no compiler-known `std.option.*`
runtime names, no generic option helpers, no broader payload families,
no nested option containers, no stable ABI/layout guarantee, and no
beta maturity.
## Phase 79: exp-99 Standard Vec String Baseline Alpha
- [x] Add concrete `(vec string)` support for immutable params, returns, and
locals in the checker, formatter, and backend.
- [x] Promote the concrete runtime names `std.vec.string.empty`,
`std.vec.string.append`, `std.vec.string.len`, and
`std.vec.string.index` without widening to generics or other vec
families.
- [x] Add concrete vec-string equality and matching runtime/test-runner
behavior.
- [x] Add the Glagol-owned local `std-layout-local-vec_string/` fixture with
the frozen helper inventory `empty`, `append`, `len`, `at`,
`singleton`, `append2`, `append3`, `pair`, `triple`, `is_empty`,
`index_or`, `first_or`, `last_or`, `contains`, and `count_of`.
- [x] Add the explicit `std-import-vec_string/` fixture and focused Glagol
coverage for the same helper surface, while tolerating mixed-repo
states where sibling `lib/std/vec_string.slo` is not present yet.
- [x] Keep exp-99 experimental only: no generics, no other vec element
families, no option-query helpers, no transform/range/edit helpers, no
nested vecs or vecs inside other containers, no mutating or capacity
APIs, no stable ABI/layout guarantee, and no beta maturity.
## Phase 78: exp-98 Standard Vec I64 Edit Helpers Alpha
- [x] Extend the staged `std.vec_i64` source-authored helper surface with
`insert_at`, `insert_range`, `replace_at`, `replace_range`,
`remove_at`, and `remove_range`.
- [x] Keep the local `std-layout-local-vec_i64/` lane recursive and immutable
with no `var` or `set` in the expected source shape.
- [x] Update the explicit `std-import-vec_i64/` fixture to exercise the same
helper inventory against repo-root `lib/std/vec_i64.slo`.
- [x] Extend focused integration coverage and promotion-gate inventory without
widening parser, checker, formatter, runtime, backend, or test-runner
semantics.
- [x] Keep exp-98 experimental only: no generics, no new compiler-known
`std.*` runtime names, no mutating or capacity APIs, no iterators,
sorting, mapping, filtering, and no beta maturity.
## Phase 77: exp-97 Standard Vec I64 Transform Helpers Alpha
- [x] Extend the staged `std.vec_i64` source-authored helper surface with
`concat`, `take`, `drop`, `reverse`, and `subvec`.
- [x] Keep the local `std-layout-local-vec_i64/` lane recursive and immutable
with no `var` or `set` in the expected source shape.
- [x] Update the explicit `std-import-vec_i64/` fixture to exercise the same
helper inventory against repo-root `lib/std/vec_i64.slo`.
- [x] Extend focused integration coverage and promotion-gate inventory without
widening parser, checker, formatter, runtime, backend, or test-runner
semantics.
- [x] Keep exp-97 experimental only: no vec_i64 insert/replace/remove
helpers, no generics, no new compiler-known `std.*` runtime names, no
mutating or capacity APIs, no iterators, sorting, mapping, filtering,
and no beta maturity.
## Phase 76: exp-96 Standard Vec I64 Option Query Helpers Alpha
- [x] Extend the staged `std.vec_i64` source-authored helper surface with
`index_option`, `first_option`, `last_option`, `index_of_option`, and
`last_index_of_option`.
- [x] Keep the local `std-layout-local-vec_i64/` lane recursive and immutable
with no `var` or `set` in the expected source shape.
- [x] Update the explicit `std-import-vec_i64/` fixture to exercise the same
helper inventory against repo-root `lib/std/vec_i64.slo`.
- [x] Extend focused integration coverage and promotion-gate inventory without
widening parser, checker, formatter, runtime, backend, or test-runner
semantics.
- [x] Keep exp-96 experimental only: no vec_i64 transform/range/edit helpers,
no generics, no new compiler-known `std.*` runtime names, no mutating
or capacity APIs, no iterators, sorting, mapping, filtering, and no
beta maturity.
## Phase 52: exp-37 Standard Time Source Facade Alpha
- [x] Gate the narrow source-authored `std/time.slo` facade without adding
compiler-known runtime names or compiler-loaded std source.
- [x] Add `examples/projects/std-layout-local-time/` so an ordinary project
explicitly imports local `time.slo` facades for `monotonic_ms` and
`sleep_ms_zero`.
- [x] Keep `sleep_ms_zero` source-shaped as an `i32` facade that calls
`std.time.sleep_ms 0` and returns `0`, because source unit-return
facade functions are not promoted.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
Slovo `lib/std/time.slo` exact inventory and facade alignment in the ignored
monorepo std source-layout gate.
- [x] Keep exp-37 experimental only: no new compiler-known `std.*` names, no
automatic std imports/search, no compiler-loaded std source, no
wall-clock/calendar/timezone/high-resolution timers, no async timers,
no cancellation or scheduling guarantees, no runtime ABI changes, no
stable ABI/layout, and no beta maturity.
## Phase 53: exp-38 Standard Host Source Facades Alpha
- [x] Gate narrow source-authored `std/random.slo`, `std/env.slo`, and
`std/fs.slo` facades without adding compiler-known runtime names or
compiler-loaded std source.
- [x] Add `examples/projects/std-layout-local-random/`,
`examples/projects/std-layout-local-env/`, and
`examples/projects/std-layout-local-fs/` so ordinary projects explicitly
import local facades over already released host/runtime calls.
- [x] Add focused project-mode and promotion-gate coverage, including sibling
Slovo std-source exact inventory and facade alignment in the ignored
monorepo std source-layout gate.
- [x] Keep exp-38 experimental only: no new compiler-known `std.*` names, no
automatic std imports/search, no compiler-loaded std source, no
seed/range/bytes/float/UUID/crypto random APIs, no environment
mutation/enumeration, no binary/directory/streaming/async filesystem
APIs, no rich host error ADTs, no runtime ABI changes, no stable
ABI/layout, and no beta maturity.
## Phase 54: exp-39 Standard Math Extensions And Benchmark Scaffold Alpha
- [x] Extend the narrow source-authored `std/math.slo` helper set without
adding compiler-known runtime names or compiler-loaded std source.
- [x] Add `neg`, `cube`, `is_zero`, `is_positive`, `is_negative`, and
inclusive `in_range` helper coverage for `i32`, `i64`, and finite
`f64` in `examples/projects/std-layout-local-math/`.
- [x] Add `benchmarks/math-loop/` with Slovo, C, Rust, and Python sources plus
a runner that reports local-machine timing comparisons only.
- [x] Add focused benchmark scaffold and promotion-gate coverage, including
repo `lib/std/math.slo` helper alignment in the ignored monorepo
std source-layout gate.
- [x] Keep exp-39 experimental only: no new compiler-known `std.*` names, no
automatic std imports/search, no compiler-loaded std source, no
broad math APIs, no generic math, no mixed numeric arithmetic, no
optimizer guarantees, no benchmark thresholds, no runtime ABI changes,
no stable ABI/layout, and no beta maturity.
## Phase 55: exp-40 Benchmark Suite And License Alpha
- [x] Add a shared benchmark runner and broaden local benchmark scaffolds to
`math-loop`, `branch-loop`, and `parse-loop`.
- [x] Include Slovo, C, Rust, Python, and Clojure source slots, with missing
toolchains skipped and deterministic checksum validation kept mandatory
for implementations that run.
- [x] Add benchmark scaffold and promotion-gate coverage for benchmark
metadata, language-source inventory, format/check commands, and Python
smoke runs.
- [x] Record project licensing as `MIT OR Apache-2.0` and document alpha/beta
naming criteria.
- [x] Keep exp-40 experimental only: no new language semantics, no optimizer
guarantees, no benchmark thresholds, no cross-machine performance
claims, no runtime ABI changes, no stable ABI/layout, no package
registry behavior, and no beta maturity.
## Phase 56: exp-41 Lisp Benchmark Comparison Alpha
- [x] Add Common Lisp/SBCL source slots beside Clojure for `math-loop`,
`branch-loop`, and `parse-loop`.
- [x] Extend the shared benchmark runner to detect SBCL through `sbcl`,
`SBCL`, or `--sbcl`.
- [x] Clarify cold-process benchmark timing: Clojure includes JVM/Clojure
startup, and Common Lisp includes SBCL script startup.
- [x] Add benchmark scaffold and promotion-gate coverage for the second Lisp
source slot.
- [x] Keep exp-41 experimental only: no new language semantics, no optimizer
guarantees, no benchmark thresholds, no cross-machine performance
claims, no runtime ABI changes, no stable ABI/layout, no package
registry behavior, no hot-runtime benchmark daemon, and no beta
maturity.
## Phase 57: exp-42 Hot Loop Benchmark Mode Alpha
- [x] Add explicit `--mode cold-process` and `--mode hot-loop` runner modes.
- [x] Record hot-loop counts and hot checksums in each benchmark scaffold.
- [x] Report hot-loop total time and normalized median time for the base
`1000000` loop count.
- [x] Let Slovo benchmark fixtures receive the runner loop count through
process arguments with stdin fallback, so Slovo participates in
hot-loop mode.
- [x] Add benchmark scaffold and promotion-gate coverage for hot-loop
metadata and execution.
- [x] Keep exp-42 experimental only: no new language semantics, no optimizer
guarantees, no high-resolution Slovo timing APIs, no stable benchmark
thresholds, no cross-machine performance claims, no runtime ABI
changes, no stable ABI/layout, no package registry behavior, no
hot-runtime benchmark daemon, and no beta maturity.
## Phase 58: exp-43 Technical Whitepapers And Skills Alpha
- [x] Add Glagol technical whitepaper Markdown and generated PDF.
- [x] Add concise compiler manifest Markdown and generated PDF.
- [x] Add repository-local beta compiler-design skill.
- [x] Keep exp-43 experimental only: no parser behavior, checker behavior,
backend behavior, runtime API, compiler-known `std.*` names, optimizer
guarantee, benchmark threshold, cross-machine claim, or beta maturity.
## Phase 59: exp-44 Standard Library Source Search Alpha
- [x] Add project-mode source search for explicit `std.<module>` imports,
starting with `std.math`.
- [x] Load `std/math.slo` through `SLOVO_STD_PATH` or a `lib/std`
checkout without copying it into the project.
- [x] Add `examples/projects/std-import-math/` plus focused integration and
promotion-gate coverage.
- [x] Keep exp-44 experimental only: no automatic std imports,
workspace/package std imports, package registry, broad standard library,
stable ABI/layout, optimizer guarantee, or beta maturity.
## Phase 60: exp-45 Standard Result And Option Source Search Alpha
- [x] Add explicit project-mode `std.result` and `std.option` source-search
fixtures without local copied modules.
- [x] Gate the fixtures with focused integration tests and promotion-gate
coverage.
- [x] Keep exp-45 experimental only: no automatic std imports,
workspace/package std imports, package registry, generic result/option
helpers, broad standard library, stable ABI/layout, optimizer
guarantee, or beta maturity.
## Phase 61: exp-46 Workspace Standard Source Search Alpha
- [x] Load explicit `std.<module>` imports inside workspace packages.
- [x] Resolve loaded standard modules before normal package-qualified
dependency lookup.
- [x] Add `examples/workspaces/std-import-option/` plus focused integration
and promotion-gate coverage.
- [x] Keep exp-46 experimental only: no automatic std imports, workspace
dependency syntax for std, package registry, installed stdlib paths,
broad standard library, stable ABI/layout, optimizer guarantee, or beta
maturity.
## Phase 62: exp-47 Standard Host Facade Source Search Alpha
- [x] Gate explicit project-mode `std.time`, `std.random`, `std.env`, and
`std.fs` source imports without local copied modules.
- [x] Add focused integration coverage for format, check, and test behavior
across the host facade fixtures.
- [x] Add promotion-gate coverage for the new fixtures and sibling Slovo
fixture alignment.
- [x] Keep exp-47 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, installed stdlib paths, broad host APIs,
stable ABI/layout, optimizer guarantee, or beta maturity.
## Phase 63: exp-48 Standard Core Facade Source Search Alpha
- [x] Gate explicit project-mode `std.string` and `std.num` source imports
without local copied modules.
- [x] Add focused integration coverage for format, check, and test behavior
across the core facade fixtures.
- [x] Add promotion-gate coverage for the new fixtures and sibling Slovo
fixture alignment.
- [x] Keep exp-48 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, installed stdlib paths, generic
parse/format APIs, broad numeric casts, stable ABI/layout, optimizer
guarantee, or beta maturity.
## Phase 64: exp-49 Standard IO Facade Source Search Alpha
- [x] Gate explicit project-mode `std.io` source imports without a local
copied module.
- [x] Add focused integration coverage for format, check, and deterministic
test behavior.
- [x] Add promotion-gate coverage for the new fixture and sibling Slovo
fixture alignment.
- [x] Keep exp-49 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, installed stdlib paths, new
compiler-known IO names, broad IO APIs, stable ABI/layout, optimizer
guarantee, or beta maturity.
## Phase 65: exp-50 Installed Standard Library Discovery Alpha
- [x] Gate executable-relative installed stdlib discovery for explicit
`std.<module>` source imports.
- [x] Add focused integration coverage that copies the compiler binary and
resolves a probe module from `share/slovo/std`.
- [x] Add promotion-gate coverage for discovery candidates and diagnostics.
- [x] Keep exp-50 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, lockfiles, package std dependencies,
stable install layout guarantee, broad stdlib APIs, stable ABI/layout,
optimizer guarantee, or beta maturity.
## Phase 66: exp-51 Standard Library Path List Alpha
- [x] Treat `SLOVO_STD_PATH` as an ordered OS path list.
- [x] Add focused integration coverage for an empty first root and a second
root containing the requested standard module.
- [x] Add promotion-gate coverage for path-list handling.
- [x] Keep exp-51 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, lockfiles, package std dependencies,
semantic version solving, stable package manager behavior, broad stdlib
APIs, stable ABI/layout, optimizer guarantee, or beta maturity.
## Phase 67: exp-52 Standard Process Facade Source Search Alpha
- [x] Add source-authored `std/process.slo` facade wrappers over the already
promoted process argument runtime calls.
- [x] Gate explicit project-mode `std.process` source imports without a local
copied module.
- [x] Add focused integration coverage and promotion-gate coverage.
- [x] Keep exp-52 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, lockfiles, package std dependencies,
process spawning, exit/status control, current-directory APIs, signal
handling, stable ABI/layout, optimizer guarantee, or beta maturity.
## Phase 68: exp-53 Standard CLI Source Facade Alpha
- [x] Add source-authored `std/cli.slo` facade helpers that compose
`std.process` and `std.string`.
- [x] Gate explicit project-mode `std.cli` source imports without a local
copied module.
- [x] Add focused integration coverage and promotion-gate coverage for
transitive standard-source imports.
- [x] Keep exp-53 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, lockfiles, package std dependencies,
shell parsing, option/flag parsing, subcommands, environment-backed
configuration, stable CLI framework APIs, stable ABI/layout, optimizer
guarantee, or beta maturity.
## Phase 69: exp-54 Standard CLI Typed Arguments Alpha
- [x] Extend `std/cli.slo` with `arg_i64_result` and `arg_i64_or_zero`.
- [x] Add direct `arg_f64_result` and `arg_bool_result` parse-result wrappers
over `std.process.arg`.
- [x] Update focused integration coverage and promotion-gate coverage for the
expanded helper inventory.
- [x] Keep exp-54 experimental only: no automatic std imports, `std.slo`
aggregator, package registry, 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, optimizer guarantee, or beta maturity.
## Phase 70: exp-55 Result F64 Bool Source Flow Alpha
- [x] Promote source constructors for `(result f64 i32)` and
`(result bool i32)`.
- [x] Promote source `match` payload bindings for `(result f64 i32)` and
`(result bool i32)`.
- [x] Add focused coverage for formatter, checker, test runner, and LLVM
aggregate shape.
- [x] Update `std.cli` coverage so `f64` and `bool` missing argument indexes
are result-based.
- [x] Keep exp-55 experimental only: no generic result types, no result
payload families beyond the already promoted concrete families, no
generic result combinators, stable ABI/layout, optimizer guarantee, or
beta maturity.
## Phase 71: exp-56 Integer Remainder Alpha
- [x] Add `%` surface/lowering support for same-width `i32` and `i64`
operands.
- [x] Gate checker, formatter, test-runner, and LLVM `srem` behavior.
- [x] Reject `f64` remainder explicitly while keeping mixed numeric operand
diagnostics.
- [x] Add `examples/integer-remainder.slo` and sibling Slovo fixture
alignment.
- [x] Extend `std.math` with `rem_i32`, `is_even_i32`, `is_odd_i32`,
`rem_i64`, `is_even_i64`, and `is_odd_i64`.
- [x] Keep exp-56 experimental only: no floating-point remainder, Euclidean
modulo, unsigned arithmetic, bit operations, generic math, stable
ABI/layout, optimizer guarantee, or beta maturity.
## Phase 72: exp-57 Integer Bitwise Alpha
- [x] Add `bit_and`, `bit_or`, and `bit_xor` surface/lowering support for
same-width `i32` and `i64` operands.
- [x] Gate checker, formatter, test-runner, and LLVM `and`/`or`/`xor`
behavior.
- [x] Reject `f64` bitwise operations explicitly while keeping mixed numeric
operand diagnostics.
- [x] Add `examples/integer-bitwise.slo` and sibling Slovo fixture alignment.
- [x] Extend `std.math` with `bit_and_i32`, `bit_or_i32`, `bit_xor_i32`,
`bit_and_i64`, `bit_or_i64`, and `bit_xor_i64`.
- [x] Keep exp-57 experimental only: no shifts, bit-not, unsigned arithmetic,
bit-width-specific integer families, generic math, stable ABI/layout,
optimizer guarantee, or beta maturity.
## Phase 73: exp-58 Boolean Logic Alpha
- [x] Add `and`, `or`, and `not` formatter/lowering support.
- [x] Lower `and` and `or` through existing `if` semantics so they
short-circuit.
- [x] Add `examples/boolean-logic.slo` and sibling Slovo fixture alignment.
- [x] Gate checker, test-runner, formatter, and LLVM branch shape.
- [x] Keep exp-58 experimental only: no truthiness, variadic boolean
operators, pattern guards, macro expansion, stable ABI/layout,
optimizer guarantee, or beta maturity.
## Phase 74: exp-59 Hosted Build Optimization And Benchmark Publication Alpha
- [x] Build hosted executables through `clang -O2`.
- [x] Lower current immutable numeric locals as SSA values where no stack
storage is required.
- [x] Refresh benchmark methodology and evidence in the publication
documents.
- [x] Add repo-local PDF rendering scripts and wire them into the release
gate.
- [x] Keep exp-59 experimental only: no benchmark thresholds, no
cross-machine performance claims, no broad optimizer guarantees, no
general SSA lowering for every value family, and no beta maturity.
## Phase 75: exp-119 Benchmark Suite Extension And Whitepaper Refresh Alpha
- [x] Add `benchmarks/array-index-loop/` with Slovo, C, Rust, Python,
Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Add `benchmarks/string-eq-loop/` with Slovo, C, Rust, Python, Clojure,
and Common Lisp/SBCL scaffold implementations.
- [x] Keep the shared benchmark runner model unchanged while extending focused
benchmark scaffold and promotion-gate coverage from three kernels to
five.
- [x] Refresh the Glagol whitepaper and publication docs around the expanded
benchmark suite and the current experimental compiler surface.
- [x] Keep exp-119 experimental only: no language-surface change, no runtime
ABI claim, no benchmark thresholds, no cross-machine performance claims,
no broad optimizer guarantee, and no beta maturity.
## Phase 76: exp-120 Fixed Array Struct Fields Alpha
- [x] Allow direct struct field declarations over `(array i32 N)`,
`(array i64 N)`, `(array f64 N)`, `(array bool N)`, and
`(array string N)`.
- [x] Keep fixed arrays positive-length only, immutable only, and limited to
the already promoted direct scalar and string element families.
- [x] Add promoted `array-struct-fields` fixture coverage, formatter/lowering
snapshots, focused Glagol tests, and diagnostic snapshot updates.
- [x] Keep exp-120 experimental only: no zero-length arrays, no array or field
mutation, no nested arrays, no arrays of unsupported element kinds, no
array equality/printing, no stable ABI/layout claim, and no beta
maturity.
## Phase 77: exp-121 Non-Recursive Struct Enum Payloads Alpha
- [x] Allow unary enum payload variants whose payload type is a current known
non-recursive struct type.
- [x] Keep one payload per payload variant and the existing same-payload-type
rule when payload variants are present.
- [x] Add promoted `enum-payload-structs` fixture coverage, formatter/lowering
snapshots, focused Glagol tests, and diagnostic snapshot updates.
- [x] Keep exp-121 experimental only: no direct array/vec/option/result
payloads, no equality requirement for struct-payload enums, no mutation,
no recursion, no stable ABI/layout claim, and no beta maturity.
## Phase 78: exp-122 Composite Data Benchmark Suite Extension And Whitepaper Refresh Alpha
- [x] Add `benchmarks/array-struct-field-loop/` with Slovo, C, Rust, Python,
Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Add `benchmarks/enum-struct-payload-loop/` with Slovo, C, Rust, Python,
Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Keep the shared benchmark runner model unchanged while extending focused
benchmark scaffold and promotion-gate coverage from five kernels to
seven.
- [x] Refresh the Glagol whitepaper and publication docs around the expanded
suite and the current experimental compiler surface through `exp-121`.
- [x] Keep exp-122 experimental only: no language-surface change, no runtime
ABI claim, no benchmark thresholds, no cross-machine performance claims,
no broad optimizer guarantee, and no beta maturity.
## Phase 79: exp-123 Owned Vector Benchmark Suite Extension And Whitepaper Refresh Alpha
- [x] Add `benchmarks/vec-i32-index-loop/` with Slovo, C, Rust, Python,
Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Add `benchmarks/vec-string-eq-loop/` with Slovo, C, Rust, Python,
Clojure, and Common Lisp/SBCL scaffold implementations.
- [x] Keep the shared benchmark runner model unchanged while extending focused
benchmark scaffold and promotion-gate coverage from seven kernels to
nine.
- [x] Refresh the Glagol whitepaper and publication docs around the expanded
suite and the current experimental compiler surface through `exp-121`.
- [x] Keep exp-123 experimental only: no language-surface change, no runtime
ABI claim, no benchmark thresholds, no cross-machine performance claims,
no broad optimizer guarantee, and no beta maturity.
## Deferred
- [ ] Macros.
- [ ] Generics.
- [ ] Concurrency.
- [ ] Advanced ownership.
- [ ] Package manager.
- [ ] Direct machine-code backend.
- [ ] Direct machine-code backend; hosted native builds use emitted LLVM IR
plus Clang and `runtime/runtime.c`.
- [ ] Stdin source input until source naming and source spans are specified.
- [ ] JSON output for lowering inspection.
- [ ] User-visible `unit` values and function signatures until Slovo specifies
their source semantics.
- [ ] Pointer types, raw memory operations, unchecked indexing,
reinterpretation, raw `ffi_call`, broad FFI, and other raw unsafe
operations. Preserve lexical unsafe diagnostics meanwhile; exp-6 only
promotes explicit `i32` C scalar imports.
- [ ] Mutable arrays, array mutation, arrays of other unsupported element
types, zero-length arrays, slices, equality,
printing, nested arrays, unchecked indexing, and stable ABI/layout
promises.
- [ ] Numeric expansion beyond exp-29 direct `f64`, direct `i64`, explicit
widening conversions, the checked `i64 -> i32` result conversion, and
`i32`/`i64` decimal-to-string calls, the single strict string-to-`i64`
result parse, finite `f64` to string, checked `f64 -> i32` result, and
strict string-to-`f64` result parse, plus direct `i64`/`f64` struct
fields,
including f32,
unsigned/narrower integer
families, char/bytes/decimal, additional narrowing or checked
conversions, cast syntax, mixed numeric arithmetic, numeric containers,
broader parse/format APIs, random numeric APIs, stable ABI/layout, and
beta maturity.
- [ ] Generic vectors, non-`i32` vectors, vector mutation, nested vectors,
vectors inside other containers, and broader growable collections until a
later Slovo contract promotes their syntax, semantics, diagnostics, and
runtime behavior.
- [ ] Option/result matching outside the exact v1.4 `(option i32)`,
`(result i32 i32)`, and exp-25 `(result i64 i32)` two-arm forms, other
non-`i32` payloads, nested
option/result values, option/result printing, and stable ABI/layout
promises.
- [ ] Result helper expansion beyond exp-33 concrete source helpers, including
compiler-known `std.result.unwrap_or`, `std.result.map`,
`std.result.and_then`, generic result helpers, option standard helper
names, and new result payload families beyond the current concrete
families.
- [ ] Mutable strings, string concatenation, string indexing/slicing, strings
in containers, broad runtime printing beyond promoted legacy aliases and
v1.5 `std.io.print_*` names, ownership, allocation/free, Unicode length
semantics, and stable ABI promises.
- [ ] Parsing beyond the released exp-13
`std.string.parse_i32_result : (string) -> (result i32 i32)`, exp-25
`std.string.parse_i64_result : (string) -> (result i64 i32)`, and
exp-28 `std.string.parse_f64_result : (string) -> (result f64 i32)`,
and exp-34
`std.string.parse_bool_result : (string) -> (result bool i32)` slices,
including trap-based parse, string/bytes parse families,
whitespace/locale/base-prefix/underscore/plus-sign parsing, generic
parse APIs, rich parse errors, Unicode digit parsing, string
indexing/slicing, tokenizer/scanner APIs, stdin line APIs, stable helper
ABI/layout, runtime headers/libraries, manifest schema changes, and beta
maturity.
- [ ] `std.io.print_unit`, host IO beyond the exp-3 slice, networking, async
IO, binary file APIs, directory traversal, terminal control,
result-based host errors beyond the exp-10 slice, stdin iteration,
wall-clock time, timers, time zones, generic vectors/maps/sets or other
collections, user-defined standard modules, imports/packages for
standard-runtime names,
overloading, generic standard-library APIs, and FFI contracts.
- [ ] Package registries, lockfiles, semver solving, remote dependencies,
publishing, optional/dev/target dependencies, stable package ABI,
hierarchical modules, import aliases/globs/qualified access, re-exports,
generated sources, project formatting, watch/LSP, incremental builds,
cross-compilation, and public ABI promises beyond the exp-5 local
workspace/package contract.
- [ ] Stable LLVM debug metadata, DWARF emission, and source-map files.
Reference in New Issue View Git Blame Copy Permalink