A compiler rejection often describes a mistaken type, unavailable value or conflicting access before it becomes a runtime problem. Reduce the example until the ownership and data flow are visible, then fix the cause rather than hiding it behind a broader type or unsafe operation.
Common problems
| Symptom | Explanation and next step |
|---|---|
| Condition requires BOOLEAN | Compare explicitly, use a Boolean predicate, or use IF LET for optional presence. |
| Read before initialization | Assign a complete value on every reaching path. NONE initializes an optional, not every type. |
| Incompatible numeric types | Convert deliberately and check the target range. |
| Cannot copy a resource | Borrow for temporary use or TAKE when ownership truly transfers. |
| Value unavailable after TAKE | Reinitialize before reuse; a transfer is not a copy. |
| Conflicting argument/borrow | Split operations, snapshot copyable input, or redesign the helper to take one owner. |
| Mutation during iteration | Build a separate result or finish the protected iteration before editing. |
| Function can fall through | Return a correctly typed value on each successful path. |
| Escaping checked error | Catch locally or add the precise FAILS dependency. Discarding a success result does not discard error. |
| Generic call lacks context | Supply a typed destination or supported AS ascription. |
| Empty collection factory lacks context | Supply the concrete generic type on the destination; later insertions do not infer it. |
| Lambda cannot capture a value | Only copyable free locals can be snapshotted; pass resource context explicitly. |
| Cache clock/mode error | Match ordinary versus At operations, retain one clock domain, and use nondecreasing mutating samples. |
| Unknown package/incompatible ABI | Check the manifest alias and rebuild with the selected compiler/SDK. |
| Program hangs on Join | Complete the protocol, close the producer, or cancel and join; scope cleanup cannot invent missing messages. |
Unexpected string or index behavior
Positions start at zero. STRING positions count Unicode scalars, not UTF-8 bytes or graphemes. Slices exclude their end; DIM array bounds include it. An omitted SPLIT separator splits into scalars, not words. A dictionary lookup with a fallback evaluates the fallback eagerly. These are deliberate rules, so make boundary examples part of application tests.
Direct list indexing and array coordinate errors have fatal policies. Named APIs such as checked editing operations or packed-byte readers may report IndexError. Read the exact operation’s contract rather than assuming TRY catches every invalid index. Floating NaN/infinity are ordinary numeric results until explicitly validated; they are rejected where an operation requires a valid hash key or finite JSON.
Unexpected task behavior
Output from independent tasks can interleave. Use messages and parent-observed results when ordering matters. COMPLETED is readiness; Join observes the outcome. Cancel is a request; Join waits through acknowledgement. A timeout cannot erase an earlier operational error. Resource results transfer once, while repeated copyable joins return independent values.
Native calls and some filesystem operations can delay coordinator progress. Increasing SPAWN count does not make an unverified foreign call run on arbitrary CPU workers. General borrowed captures and shared writable parent state remain rejected even when a programmer expects a task to finish quickly.
Current implementation boundaries
Linux x86-64 is the supported target. Compiler checks include parser nesting, parameter-word limits, error tags, choice alternatives and target frame encoding. Local metadata grows with the function; older fixed-local limits in historical reports are not current language promises. Native and coroutine stacks remain finite, and stack exhaustion is fatal. Avoid huge automatic frames and unbounded recursion, especially in task entries.
Not implemented: multiple successful return values, local/anonymous records, generic record extension/errors/choices/cleanup hooks, resource or borrowed lambda captures, mutable shared capture cells, general stored references, mutable module globals, resource keys/sets, indexed partial field holes, borrowed or BYREF task arguments, YAML/general TOML/XML codecs, remote package fetching, lockfiles, general incremental semantic caching and unrestricted foreign-thread callbacks. The current checklist owns remaining work.
Historical design files often contain proposed spellings. Do not assume those examples are accepted by today’s compiler. The maintained language specification, passing tests and current implementation establish support; requirements express future intent. This book does not silently add unsupported syntax to make an example shorter.
Find an API or report a problem
basic api emits the public prelude declaration catalog. Ctrl+Space in the IDE
browses those overloads. The generated catalog appendix in this book comes from
the compiler used for its build; imported package APIs and compiler intrinsics
are not all represented by that catalog.
When reporting a problem, include a minimal source file, exact build/run command,
expected and observed behavior, and basic toolchain output. Preserve the original
diagnostic. For a runtime issue, include input that reproduces it and whether
cancellation or native libraries are involved. Do not publish credentials or
private input files just to make a report complete.