213cedf0b5
The trailing-`!`-after-the-value-type spelling (`-> T !`, `-> Tuple(A,B) !`) was a
redundant second way to write a failable return that the parser folded into the
same AST as the parenthesized `(T, !)` / `(A, B, !)` result list. Remove it so
there is ONE canonical spelling: the error channel always rides as the last slot
of the parenthesized list.
- parser: `parseFnReturnType` no longer folds a trailing `!` after a value type —
it rejects it with a located diagnostic ("a failable return is written `(T, !)`
… not `T !`"). This one chokepoint covers fn declarations, lambdas, fn-pointer
types `(A) -> R`, and closure types `Closure(A) -> R`. The error-ONLY `-> !` /
`-> !ErrSet` form is unaffected (parsed by parseTypeExpr as an error_type_expr).
- migrated every usage to canonical form across library/ + examples/ + issues/ +
tests/: `-> T !E` → `-> (T, !E)`; the value-carrying `-> Tuple(A, B) !` (which
FLATTENED to a multi-value failable) → `-> (A, B, !)`, preserving behavior. A
genuine single-tuple-value failable stays `-> (Tuple(A,B), !)`.
- parser unit tests: the "bare form folds" tests become "bare form is rejected";
canonical-form parse tests retained.
- docs: specs.md §12 + scattered refs and readme.md updated to the `(T, !)` form.
Behavior-preserving (the bare form was sugar for the same AST). Adversarial review
confirmed: rejection complete across all positions, every canonical form works on
both success/error paths, error-only `-> !` intact, no crashes. Full suite green
(unit tests + 850 corpus examples).
vendors/sqlite — SQLite for sx programs
- Version: 3.53.2 (
SQLITE_VERSIONinc/sqlite3.h) - Source: https://sqlite.org/2026/sqlite-amalgamation-3530200.zip
- Zip sha256:
8a310d0a16c7a90cacd4c884e70faa51c902afed2a89f63aaa0126ab83558a32 - Files kept:
c/sqlite3.c,c/sqlite3.h(the amalgamation;shell.candsqlite3ext.hdropped — no shell, no loadable extensions) - License: public domain (https://sqlite.org/copyright.html)
#import "vendors/sqlite/sqlite.sx" gives any sx program SQLite with
no system dependency and no build flags. The bindings declare the
amalgamation as a named #import c unit carrying the pinned compile
options (SQLITE_DQS=0, SQLITE_THREADSAFE=0,
SQLITE_DEFAULT_MEMSTATUS=0, SQLITE_OMIT_DEPRECATED,
SQLITE_OMIT_SHARED_CACHE, SQLITE_LIKE_DOESNT_MATCH_BLOBS,
SQLITE_ENABLE_COLUMN_METADATA, -O2); sx compiles the unit through
its content-addressed object cache (.sx-cache/), so the 250k-line
source builds once per machine. sx build links the objects into the
binary; sx run loads them as a PRIORITY symbol-search target ahead
of the process images, so an OS libsqlite3 of a different version can
never shadow this copy. examples/1624-vendor-sqlite-module.sx pins
the version and a typed round trip in the sx suite.
Bound surface
sqlite.sx maps the full practical C API (~100 functions): connection
lifecycle + open_v2 flags, errors (extended codes included), statements
with the complete bind/column families, parameter and column
introspection (built with SQLITE_ENABLE_COLUMN_METADATA), incremental
blob I/O, the online backup API, serialize/deserialize, and the library
utilities. Not bound, by design: callback-taking APIs (hooks, UDFs,
collations, authorizers — they need C→sx callbacks), the
sqlite3_value_* family (UDF-coupled), varargs configuration, UTF-16
variants, and subsystems this build omits (mutex/VFS under
SQLITE_THREADSAFE=0, sessions/snapshots/vtabs, deprecated API).
To upgrade: replace c/sqlite3.c/c/sqlite3.h with a newer
amalgamation, update this file and the version pins in consuming test
suites, and rebuild (the object cache keys on the source bytes, so the
new amalgamation recompiles automatically).