Incan v0.3.0

Incan 0.3

Incan 0.3 is the release where the 0.2 foundation starts to feel like a practical application platform. The 0.2 line made namespaces, library manifests, and Rust boundaries more explicit; 0.3 builds on that by adding richer source-level language features, a much broader standard library, stronger testing and formatting workflows, and a lot of hardening around generated Rust, package boundaries, decorators, aliases, vocab surfaces, and ownership planning.

The headline is not just “more syntax.” The release moves common project patterns into documented language and stdlib surfaces so users can write less Rust-shaped scaffolding, while compiler behavior increasingly flows through shared metadata and argument-planning paths instead of local special cases.

Highlights

• Richer language surface: exact numeric widths, fixed-scale decimal annotations, loop expressions, if let / while let, union narrowing, pattern alternation, value enums, enum methods, computed properties, decorators, aliases, partial callable presets, generators, iterator adapters, Result combinators, and explicit type-token overloads such as cast(expr, int).
• Broader standard library: std.collections, OrdinalMap, std.graph, std.json, std.regex, std.datetime, std.logging, std.telemetry, std.fs, std.io, std.tempfile, std.uuid, std.encoding, std.hash, std.compression, std.result, std.async, and std.testing.
• Stronger Rust interop: Rust trait adoption from Incan source, associated types, derived and inspected Rust metadata, keyword arguments for inspected Rust calls, raw identifier field access, generated-Rust lint suppression, better Rust callable alias handling, and closure context for Rust callback APIs.
• Better package and metadata behavior: public aliases, partial presets, decorator-backed metadata, facade reexports, checked API projections, public dependency-owned unions, and package-boundary call surfaces now behave much closer to ordinary local source.
• Vocab and DSL support: scoped DSL surfaces now support expression-position declarations, helper calls, leading-dot references, expression-list metadata, compound clauses, query-block-style brace forms, and dependency-provided vocab activation in tests and formatting.
• Testing and tooling improvements: incan test supports inline module tests: workflows, fixtures, parametrization, markers, resource-aware parallelism, JSON Lines, JUnit XML, shuffling, durations, and cleaner batch isolation. incan fmt, incan lock, lifecycle commands, checked API metadata, generated references, docs builds, and install actions are also more release-ready.
• Compiler hardening: ownership/coercion emission now goes through a shared argument-use plan, duckborrowing covers more real call sites, union wrapper identity is preserved more consistently, decorated defaults survive imports and reexports, and formatter/parser paths share more context across ordinary source, packages, tests, and vocab blocks.

Migration notes

Most ordinary 0.2 programs should continue to compile. The main adoption notes are:

1. Expect one intentional formatter pass. incan fmt now follows the 0.3 vertical-spacing and fluent-chain style more consistently, including vocab/query block preservation.
2. Numeric vocabulary is broader. Existing int and float code keeps working, but local names such as decimal, numeric, bigint, integer, smallint, real, or double may now collide with canonical numeric forms.
3. Testing helpers should be imported explicitly from std.testing; the language assert statement remains always available.
4. Lockfiles are less noisy. Routine build / test runs reuse stale lock payloads instead of rewriting committed lockfiles; run incan lock when you intentionally refresh the lock.
5. Most new language features are additive. Existing match, while True, helper-function, and nested-match code does not need to be rewritten immediately.

Known limitations

• Decimal arithmetic is not yet general language behavior. The 0.3 decimal surface covers typed annotations, literal validation, formatting, generated Rust representation, and display.
• incan fmt is much more capable, but still conservative rather than a complete pretty-printer overhaul for every nested expression shape.
• std.regex is a safe-default regular-expression surface, not a Python/PCRE compatibility layer. Lookaround, pattern backreferences, and other backtracking-only features are tracked separately for a future std.re surface.
• Native Windows filesystem behavior is not part of the 0.3 contract. std.fs documents Unix-like host behavior until the stdlib has an explicit platform split.

Docs

Start here for the full release notes and migration detail:

• https://incan.io/v0.3/release_notes/0_3/

Useful entry points:

• Control flow: https://incan.io/v0.3/language/explanation/control_flow/
• Numeric types: https://incan.io/v0.3/language/how-to/choosing_numeric_types/
• Testing in Incan: https://incan.io/v0.3/language/how-to/testing_stdlib/
• Standard library reference: https://incan.io/v0.3/language/reference/stdlib/
• Rust interop: https://incan.io/v0.3/language/how-to/rust_interop/

Incan v0.2.0

Incan 0.2

Incan 0.2 is the release where the language becomes more explicit, more modular, and much more serious about Rust interop.

The biggest user-facing shift is that stdlib imports and decorators now live under the std.* namespace. This release also introduces the first experimental Incan library workflow, module-level static storage, explicit call-site generic arguments, and a much stronger Rust boundary around crates, rust:: imports, rusttype, and interop authoring.

Highlights

• Namespaced stdlib surface under std.*
• Clear separation between Incan dependencies and Rust dependencies in incan.toml
• Experimental Incan Libraries with pub:: consumption
• New static / pub static module storage
• Explicit call-site generic arguments like id[int](1)
• Stronger Rust interop and better docs around rust::, rusttype, and interop adapters
• Major stabilization across ownership/codegen, tuple-unpack iteration, test harness cwd handling, and real downstream RC regressions

Migration notes

If you are upgrading from 0.1, the main changes are:

1. Move stdlib imports and decorators to std.*
2. Move Rust crates out of [dependencies] into [rust-dependencies] / [rust-dev-dependencies]
3. Add explicit std.async / std.testing imports in files that use those surfaces

Notable fixes from the 0.2 RC cycle

• Ownership/materialization fixes across comprehensions, Result[str, E], struct cloning, enum loops, shared list[str] helper calls, and list[str].append("...")
• Stronger Python-shaped iteration and pattern handling, including for idx, name in enumerate(xs):
• Builtin shadowing fixes for imported/user helpers such as sum
• Correct project-root cwd behavior in generated incan test harnesses
• Parse-safe len(...) lowering in generated Rust comparisons

Known limitations

• Ownership/borrow lowering is still heuristic in some edge cases; the broader planner work is tracked for 0.3
• incan fmt is still intentionally conservative on some line-length and layout cases
• Rust macro syntax such as serde_json::json!(...) is still not supported directly in Incan source

Docs

Start here if you want the full release write-up and migration guide:

• workspaces/docs-site/docs/release_notes/0_2.md

Incan v0.1.0

See the docs site for comprehensive language guides, tooling reference, and examples.

What's included

60+ features and fixes spanning the compiler, codegen, tooling, and documentation. Highlights:

• Automatic Serialize/Deserialize propagation to enums and newtypes (#103, #115)
• @derive(...) on enums parsed and used during lowering (#101)
• Cross-module enum variant access, associated function calls, and newtype construction (#104, #110, #112)
• Dependency module typechecking with private-import support (#111)
• Targeted parser diagnostics for common enum mistakes (#113)
• incan run executes from project root so relative paths work (#109)
• while True optimized to loop in emitted Rust (#8)

For the full changelog, see the release notes.

Known limitations

• Some RFC-described features may be partially implemented.
• Rust interop is gated by a known-good crate list.
• Web route handlers and request models must be pub for cross-module wrapper generation (#117).
• Multi-line parenthesized imports are not yet supported (#116).

RFCs implemented

• Incan Core Language (Phase 1) — RFC 000
• Const Bindings — RFC 008
• Model Field Metadata and Aliases — RFC 021