slovo/docs/language/examples/formatter

Slovo Formatter Fixtures

Formatter fixtures define canonical layout for the current strict supported syntax. They are not additional compiler-supported programs unless mirrored under examples/supported/.

The formatter fixture set now includes the final exp-125 unsigned fixtures absorbed into 1.0.0-beta.

Promoted formatter fixtures may use only:

• (module name)
• top-level (fn ...)
• explicit i32 parameters and i32 returns, plus promoted string parameters and returns
• direct (option i32), (option i64), and (result i32 i32) returns only for first-pass option/result constructor fixtures
• integer literals
• parameter references
• binary +
• user-defined function calls
• legacy compiler/runtime compatibility alias (print_i32 value)
• local i32 bindings with (let name i32 value) and (var name i32 value)
• immutable array locals with (let name (array T N) array-expression) when T is i32, i64, f64, or bool and the initializer has the exact declared fixed array type
• assignment to mutable local i32 bindings with (set name value)
• value-producing (if condition then-expression else-expression)
• first-pass (while condition body...) as a non-final sequential body form
• top-level (struct Name (field i32)...)
• first-pass struct construction and immediate field access
• first v1 struct value flow through immutable locals, parameters, returns, calls returning structs, and stored field access
• fixed direct scalar array constructors and literal (index array index)
• fixed direct scalar array value flow through immutable array locals initialized from matching array-valued expressions, fixed array parameters, returns, calls returning arrays, and dynamic (index array index) with i32 index expressions
• first-pass (some i32 value), (none i32), (some i64 value), (none i64), (ok i32 i32 value), and (err i32 i32 value) constructors as direct function returns
• first v1 option/result value flow through immutable locals, parameters, calls returning option/result values, and is_some / is_none / is_ok / is_err tag observation
• first v1 option/result payload access with unwrap_some, unwrap_ok, and unwrap_err
• v1.4 source-level match for (option i32), (option i64), and (result i32 i32) values, with exhaustive arms, immutable arm-scoped payload bindings, one-or-more expression arm bodies, and common arm result types
• source string literals used directly as print_string or std.io.print_string arguments
• legacy compiler/runtime compatibility alias (print_string value)
• immutable string locals with (let name string value)
• string parameters and string returns
• calls returning strings
• string equality with =
• string byte length with (string_len value)
• legacy compiler/runtime compatibility alias (print_bool value)
• compiler-known standard-runtime calls (std.io.print_i32 value), (std.io.print_string value), (std.io.print_bool value), and (std.string.len value)
• exp-112 direct immutable bool locals with (let name bool value) over the already promoted bool-expression surface
• exp-20 direct f64 parameters, returns, immutable locals, decimal literals, same-type f64 arithmetic/comparison, and (std.io.print_f64 value)
• exp-21 direct i64 parameters, returns, immutable locals, explicit signed decimal i64 literal atoms, same-type i64 arithmetic/comparison, and (std.io.print_i64 value)
• exp-22 explicit numeric widening calls std.num.i32_to_i64 : (i32) -> i64, std.num.i32_to_f64 : (i32) -> f64, and std.num.i64_to_f64 : (i64) -> f64
• exp-23 checked numeric narrowing call std.num.i64_to_i32_result : (i64) -> (result i32 i32)
• exp-24 integer to string calls std.num.i32_to_string : (i32) -> string and std.num.i64_to_string : (i64) -> string
• exp-25 string parse i64 result call std.string.parse_i64_result : (string) -> (result i64 i32)
• exp-26 f64 to string call std.num.f64_to_string : (f64) -> string
• exp-27 checked f64 to i32 result call std.num.f64_to_i32_result : (f64) -> (result i32 i32)
• exp-28 string parse f64 result call std.string.parse_f64_result : (string) -> (result f64 i32)
• exp-29 direct immutable i64 and finite f64 struct fields, using existing struct construction, immutable struct flow, field access, same-type numeric arithmetic/comparison, and numeric print/format helpers
• exp-30 conservative source-layout helper shape in std-source-layout-alpha.slo, without repo-root std import/search support or source replacement of compiler-known std.* calls
• exp-31 checked f64 to i64 result call std.num.f64_to_i64_result : (f64) -> (result i64 i32)
• exp-1 compiler-known call (std.string.concat left right)
• exp-2 (vec i32) type forms and compiler-known calls (std.vec.i32.empty), (std.vec.i32.append values value), (std.vec.i32.len values), and (std.vec.i32.index values index)
• exp-3 compiler-known calls (std.io.eprint value), (std.process.argc), (std.process.arg index), (std.env.get name), (std.fs.read_text path), and (std.fs.write_text path text)
• exp-4 payloadless enum declarations (enum Name VariantA VariantB), zero-argument qualified constructors (Name.VariantA), enum locals, parameters, returns, calls, equality, and exhaustive enum match
• exp-16 unary i32 enum payload variants such as (Value i32), qualified unary constructors such as (Reading.Value value), immutable arm-local payload bindings in enum match, and same-enum tag-plus-payload equality
• exp-18 direct enum struct fields and exp-19 direct bool and immutable string struct fields, using existing struct construction, immutable struct flow, field access, equality, enum match, bool predicate, and std.string.len forms
• exp-8 compiler-known calls (std.time.monotonic_ms) and (std.time.sleep_ms 0) for structural/non-negative conformance checks only
• exp-11 compiler-known call (std.random.i32) and non-negative structural checks using existing < and if forms
• exp-12 compiler-known call (std.io.read_stdin_result) using existing (result string i32) observers, unwrap, and match
• exp-13 compiler-known call (std.string.parse_i32_result text) using existing (result i32 i32) observers, unwrap, and match
• exp-15 compiler-known result helper calls (std.result.is_ok value), (std.result.is_err value), (std.result.unwrap_ok value), and (std.result.unwrap_err value) for only (result i32 i32), (result i64 i32), and (result string i32)
• lexical (unsafe body... final-expression) expression blocks containing only otherwise supported safe v0 forms
• final-expression returns
• top-level (test "name" body... final-expression)
• equality comparison = when used as a bool-producing test expression
• ordering comparison < when used as a bool-producing condition
• line comments

Promoted formatter fixtures are canonical output. Formatting one of these fixtures must reproduce the same source bytes, including accepted full-line comments and final newline, and formatting formatter output must be idempotent. The v1 formatter is not a width-based pretty printer and does not promise column reflow for long inline calls or forms.

Line comments are stable only as full-line comments before top-level forms, inside function/test bodies before body expressions, after the final function/test body expression before the closing paren, and after the last top-level form. Comments inside module forms, struct forms, function/test headers, type forms, or inline expression forms are unsupported formatter positions and must produce structured diagnostics instead of being silently dropped.

Nested if, while, unsafe, and match forms keep their canonical multiline shapes. Calls, field access, arrays, struct constructors, option/result constructors, option/result observers, option/result unwraps, legacy print aliases, std.io.print_* calls, exp-1 std.string.concat calls, exp-2 std.vec.i32.* calls, exp-3 host calls, exp-4 qualified enum constructors, exp-16 unary enum payload constructors, exp-8 std.time.* calls, and exp-13 std.string.parse_i32_result calls, and exp-15 std.result.* helper calls and exp-20 std.io.print_f64 calls remain inline when used as expressions. exp-21 std.io.print_i64, exp-22 std.num.* conversion calls, exp-23 std.num.i64_to_i32_result, exp-24 integer-to-string calls, and exp-25 std.string.parse_i64_result calls, and exp-26 std.num.f64_to_string calls and exp-27 std.num.f64_to_i32_result calls remain inline when used as expressions. exp-28 std.string.parse_f64_result calls and exp-31 std.num.f64_to_i64_result calls remain inline when used as expressions. string_len and std.string.len remain inline when used as expressions.

Current Slovo-side target formatter fixtures:

• u32-numeric-primitive.slo
• u64-numeric-primitive.slo
• unsigned-integer-to-string.slo
• string-parse-u32-result.slo
• string-parse-u64-result.slo

These formatter fixtures describe the final exp-125 unsigned contract shape now absorbed into 1.0.0-beta. Execution claims still come from the paired supported/project fixtures and Glagol gates, not from formatter fixtures alone.

Design-target forms such as mutable string locals, string assignment, string ordering, strings inside arrays, options, or results, string containers beyond exp-19 direct struct fields, string slices, concatenation beyond exp-1 std.string.concat, indexing, ownership annotations, user-defined string runtime bindings, print_unit, std.io.print_unit, host IO beyond the exp-3 slice and exp-12 stdin-result slice, networking, async IO, binary file APIs, directory traversal, terminal control, platform abstraction, general host error ADTs beyond exp-10, result string Error, package interaction, stdin APIs beyond the exp-12 result slice, parsing beyond exp-13 std.string.parse_i32_result, exp-25 std.string.parse_i64_result, and exp-28 std.string.parse_f64_result, result helper payload families beyond the explicitly listed (result i32 i32), (result i64 i32), (result string i32), and exp-28 returned (result f64 i32) families, tokenizer/scanner APIs, parsing bools/strings/bytes, numeric casts or conversions beyond exp-22 explicit widening calls and the exp-23 checked i64 -> i32 result call, exp-27 checked f64 -> i32 result call, and exp-31 checked f64 -> i64 result call, f64 formatting beyond exp-26 finite decimal text, locale/base/radix/grouping/padding formatting controls, generic format/display traits, stable integer-formatting ABI/layout/ownership, implicit promotion, mixed numeric arithmetic, f32, unsigned integers, narrower integer widths beyond the existing i32, char/bytes/decimal, whitespace/locale/base-prefix/underscore/plus-sign parsing beyond the exact exp-13, exp-25, and exp-28 parse calls, Unicode digit parsing, parse error messages or richer codes, randomness beyond the exp-11 slice, time beyond the exp-8 host time/sleep slice, generic vectors, vector element types other than i32, vector mutation, vector var or set, vector literals beyond empty/append construction, push, nested vectors, vectors in arrays, structs, options, or results, iterators, slices, maps, sets, user-visible vector deallocation, stable vector ABI/layout/helper symbols, allocation, user-defined standard modules, imports/packages, overloading, generic APIs, Unicode length semantics, general slices, pointer types, raw memory operations, array mutation, array element types beyond direct scalar i32, i64, f64, bool, and string, zero-length arrays, nested arrays, array equality, printing arrays, option/result mapping, equality, printing, non-i32 payload extraction, nested option/result values, arrays or structs containing option/results, generic payloads, enum payloads beyond exp-16 unary i32 variants, generic enums, generic functions, type aliases, traits/interfaces/protocols, methods, derives, wildcard/rest enum patterns, enum guards, nested enum patterns, enum values in arrays/structs/options/results/vectors, enum mutation, enum printing/ordering/hash, enum reflection, explicit enum discriminants, enum constructors with multiple arguments, unqualified variant constructors, stable enum ABI/layout, moving option/result to ordinary standard-library types, user-catchable exceptions, struct mutation, unsafe abstractions, and user-declared unit returns must stay out of this directory until they meet the strict support rule.

canonical.slo is the canonical formatted shape for the current supported function fixture surface. top-level-test.slo is the canonical formatted shape for the promoted top-level test fixture surface. local-variables.slo is the canonical formatted shape for promoted local let / var / set forms, including the later exp-112 immutable bool-local broadening. if.slo is the canonical formatted shape for promoted value-producing conditionals. while.slo is the canonical formatted shape for promoted first-pass loops. struct.slo is the canonical formatted shape for promoted first-pass structs. struct-value-flow.slo is the canonical formatted shape for the first v1 struct value-flow slice. array.slo is the canonical formatted shape for promoted first-pass array constructors, immutable array locals, and literal indexing. array-direct-scalars.slo is the canonical formatted shape for the widened direct scalar fixed-array constructor and literal-indexing slice. array-value-flow.slo is the canonical formatted shape for the first v1 array value-flow and dynamic-indexing slice. array-direct-scalars-value-flow.slo is the canonical formatted shape for the widened direct scalar fixed-array value-flow and dynamic-indexing slice. array-string.slo is the canonical formatted shape for the widened fixed string-array constructor and literal-indexing slice. array-string-value-flow.slo is the canonical formatted shape for the widened fixed string-array value-flow and dynamic-indexing slice. option-result.slo is the canonical formatted shape for promoted first-pass option/result constructors. option-result-flow.slo is the canonical formatted shape for the first v1 option/result value-flow slice. option-result-payload.slo is the canonical formatted shape for the first v1 option/result payload-access slice. option-result-match.slo is the canonical formatted shape for the v1.4 option/result match slice. string-print.slo is the canonical formatted shape for the first runtime string-printing slice. string-value-flow.slo is the canonical formatted shape for the v1.2 immutable string value-flow, equality, and length slice. print-bool.slo is the canonical formatted shape for the v1.2 bool-printing slice. standard-runtime.slo is the canonical formatted shape for the v1.5 standard-runtime alpha names. owned-string-concat.slo is the canonical formatted shape for the exp-1 owned-runtime-string concat fixture. vec-i32.slo is the canonical formatted shape for the exp-2 (vec i32) fixture. vec-i64.slo is the canonical formatted shape for the exp-94 (vec i64) fixture. host-io.slo is the canonical formatted shape for the exp-3 standard IO and host environment fixture. time-sleep.slo is the canonical formatted shape for the exp-8 host time and sleep fixture aligned by the exp-14 release. random.slo is the canonical formatted shape for the exp-11 basic randomness alpha release fixture. stdin-result.slo is the canonical formatted shape for the exp-12 standard input result alpha release fixture. string-parse-i32-result.slo is the canonical formatted shape for the exp-13 string parse i32 result alpha fixture. result-helpers.slo is the canonical formatted shape for the exp-15 result helper standard names alpha fixture. enum-basic.slo is the canonical formatted shape for the exp-4 payloadless user enum fixture. enum-payload-i32.slo is the canonical formatted shape for the exp-16 unary i32 enum payload fixture. primitive-struct-fields.slo is the canonical formatted shape for the exp-19 primitive struct field fixture. local-variables.slo is the canonical formatted shape for the exp-112 immutable bool locals fixture. f64-numeric-primitive.slo is the canonical formatted shape for the exp-20 f64 numeric primitive fixture. i64-numeric-primitive.slo is the canonical formatted shape for the exp-21 i64 numeric primitive fixture. numeric-widening-conversions.slo is the canonical formatted shape for the exp-22 numeric widening conversions fixture. checked-i64-to-i32-conversion.slo is the canonical formatted shape for the exp-23 checked i64-to-i32 conversion fixture. integer-to-string.slo is the canonical formatted shape for the exp-24 integer to string fixture. string-parse-i64-result.slo is the canonical formatted shape for the exp-25 string parse i64 result fixture. f64-to-string.slo is the canonical formatted shape for the exp-26 f64 to string fixture. f64-to-i32-result.slo is the canonical formatted shape for the exp-27 checked f64-to-i32 result fixture. string-parse-f64-result.slo is the canonical formatted shape for the exp-28 string parse f64 result fixture. numeric-struct-fields.slo is the canonical formatted shape for the exp-29 numeric struct fields fixture. std-source-layout-alpha.slo is the canonical formatted shape for the exp-30 standard library source layout alpha fixture. f64-to-i64-result.slo is the canonical formatted shape for the exp-31 checked f64-to-i64 result fixture. unsafe.slo is the canonical formatted shape for promoted lexical unsafe blocks. comments.slo is the canonical formatted shape for the promoted v1 full-line comment stability positions.