@shd101wyy/yo 0.1.26 → 0.1.28

package/.github/skills/yo-syntax/syntax-cheatsheet.md

@@ -13,7 +13,7 @@ These are baseline syntax rules for portable Yo code.
 ## Common declaration forms
 
 ```rust
-{ println } :: import "std/fmt";
+{ println } :: import("std/fmt");
 
 app_name :: "yo-demo";
 
@@ -23,21 +23,22 @@ main :: (fn() -> unit)({
   println(message);
 });
 
-export main;
+export(main);
 ```
 
 - Top-level binding: `name :: expr;`
 - Local binding: `name := expr;`
 - Typed binding: `(name : Type) = expr;`
 - Function definition: `name :: (fn(args...) -> ReturnType)(body);`
+- Export: `export(name);`
 
 ## Blocks and expressions
 
-| Goal              | Write                      | Avoid                      |
-| ----------------- | -------------------------- | -------------------------- |
-| Single expression | `cond(...)`                | `{ cond(...) }`            |
-| Begin block       | `{ x := i32(1); x }`       | `{ x := i32(1), x }`       |
-| Struct literal    | `{ name: "yo", ok: true }` | `{ name: "yo"; ok: true }` |
+| Goal              | Write                        | Avoid                        |
+| ----------------- | ---------------------------- | ---------------------------- |
+| Single expression | `cond(...)`                  | `{ cond(...) }`              |
+| Begin block       | `{ x := i32(1); x }`         | `{ x := i32(1), x }`         |
+| Struct literal    | `{ name : "yo", ok : true }` | `{ name : "yo"; ok : true }` |
 
 ```rust
 result := cond(
@@ -53,6 +54,8 @@ total := {
 
 Remember: `{ expr }` without semicolons is a struct literal, not a block. The parser now detects this mistake and emits a clear error if the single expression is not a valid struct field.
 
+In struct literals, keep spaces around `:` and parenthesize infix field values: `{ x : (1 + 2), y : 3 }`, not `{ x: 1 + 2, y: 3 }`.
+
 ## Control flow
 
 ```rust
@@ -74,6 +77,18 @@ if(done, println("done"), println("pending"));
 - Always write `cond(...)`, never bare `cond ...`
 - Always write `match(...)`, never bare `match ...`
 - `if(a, b)` and `if(a, b, c)` are macro forms over `cond`
+- Write `return(value)` or `return()`; `return value` is invalid.
+- Write `escape(value)` or `escape()`; `escape value` is invalid.
+- If a `match`/`cond` branch returns an enum variant and inference fails, qualify
+  the variant with its enum type: `TypeValue.Unit` instead of `.Unit`.
+- Do not match enum payload literals directly, e.g. avoid `.Some(false)` and
+  `.Some(true)` as sibling branches. Match `.Some(value)` once, then branch with
+  `if(value, ...)` or `cond(...)` inside the arm; otherwise generated C can
+  contain duplicate enum `case` labels.
+- In large enum matches, avoid binding a pattern variable with the same name as a
+  variant field (for example, prefer `struct_field_types` over `field_types`).
+  This can currently produce invalid generated C in some self-hosted codegen
+  paths.
 
 ## String types
 
@@ -101,10 +116,18 @@ flag := ((a > b) && (b > c));
 masked := ((A | B) | C);
 ```
 
-- Prefer parenthesized calls: `func(arg1, arg2)`
-- `func (a, b)` is a different parse shape than `func(a, b)`
+- Calls require immediate parentheses: `func(arg1, arg2)`
+- `func arg1, arg2` and `func (arg1, arg2)` are invalid
 - Yo has no operator precedence; fully parenthesize binary expressions
-- **All unary operators (`!`, `&`, `-`, `~`) greedily consume everything that follows, including comma-separated args.** `func(&s, a, b)` is parsed as `func(&(s, a, b))` — ONE tuple argument! Preferred fix: parenthesize the operand: `func(&(s), a, b)`. The outer-parens form `func((&s), a, b)` also works. Either is fine; the operand-parens form `&(x)` matches how the parser thinks about it.
+- Preserve grouping around infix expressions on operator RHS positions: `true => (x / y)`, `value := (x + y)`, `(ptr &+ 1).*`
+- Line breaks can disambiguate operator chains; keep line-leading operators like `(4\n| 5\n| 6)` and newlines after `:` before a lambda unless you add equivalent grouping
+- When an operator ends a line, indent its RHS one level as a continuation: `(given(x) : T) =\n  (v) -> { ... }`
+- Prefix operators (`!`, `&`, `-`, `~`) require parenthesized operands: `func(&(s), a, b)`, `!(ready)`, `-(value)`.
+- Tight special forms also require immediate parentheses: `#(expr)`, `?*(u8)`, `T <: !(Runtime)`
+- Dynamic field access with unquote must keep grouping after the dot: `value.(#(field_expr))`, not `value.#(field_expr)`.
+- Unquote splicing is the tight operator `...#(exprs)`; do not insert a space between `...` and `#`.
+- Canonical pointer dereference is `ptr.*`; formatter should canonicalize legacy `ptr.(*)` to `ptr.*`.
+- Keep single-line array and tuple literals compact during formatting: `[1, 2, 3]`, `(1, 2, 3)`.
 - Parenthesize other unary operands too: `!(ready)`, `-(value)`
 - **`!x && y` is parsed as `!(x && y)`**, not `(!x) && y`. Prefix `!` greedily consumes the full right-hand expression. To get `(!x) && y`, write `((!x) && y)` with explicit inner parens.
 - **Nested `&&` / `||` in a single compound condition causes "Ambiguous operator precedence"** even with explicit parentheses: `((A && B) && (C && D))` on one line triggers the error. Fix: extract sub-conditions into named booleans first: `_c1 := (A && B); _c2 := (C && D); if((_c1 && _c2), ...)`.
@@ -127,6 +150,8 @@ impl(Counter,
 ```
 
 - No space between a function type and its body: `(fn(...) -> T)(...)`
+- Top-level aliases for function types need parentheses too:
+  `Callback :: (fn(x : i32) -> i32);`, not `Callback :: fn(x : i32) -> i32;`
 - Use `Self` in method signatures and in type definitions for recursive references (the type name is not available during its own definition)
 - `Self` also works inside generic type constructors — it refers to the current instantiation (e.g., `Tree(T)` inside `Tree`). Use `recur(args)` only when type arguments differ from the current instantiation.
 - Use `struct(...)` for record and effect-record types. The legacy `module(...)`,
@@ -169,7 +194,7 @@ safe_divide :: (fn(x : i32, y : i32, using(raise : Raise)) -> i32)(
 
 caller :: (fn() -> i32)({
   (given(raise) : Raise) = (fn(msg : String) -> i32)({
-    return i32(0);
+    return(i32(0));
   });
 
   safe_divide(i32(10), i32(0))
@@ -189,9 +214,9 @@ caller :: (fn() -> i32)({
 result := closure(i32(5));
 
 transform :: (fn(list : ArrayList(i32), f : Impl(Fn(x : i32) -> i32)) -> unit)({
-  for list.iter(), (ptr) => {
+  for(list.iter(), (ptr) => {
     ptr.* = f(ptr.*);
-  };
+  });
 });
 ```
 
@@ -203,15 +228,15 @@ transform :: (fn(list : ArrayList(i32), f : Impl(Fn(x : i32) -> i32)) -> unit)({
 ## Imports and modules
 
 ```rust
-{ Parser } :: import "./parser.yo";
-parser_module :: import "./parser.yo";
+{ Parser } :: import("./parser.yo");
+parser_module :: import("./parser.yo");
 
-open import "std/string";
-{ ArrayList } :: import "std/collections/array_list";
+open(import("std/string"));
+{ ArrayList } :: import("std/collections/array_list");
 ```
 
 - Use relative imports for nearby `.yo` files
-- Use `open import "std/module"` for standard-library modules you want fully in scope
+- Use `open(import("std/module"))` for standard-library modules you want fully in scope
 - Do not write `import "./file.yo" as name`
 - Do not import `std/prelude`
 
@@ -237,15 +262,28 @@ text := match(value,
 Three destructuring shapes for arms (mix freely across arms):
 
 ```rust
-Shape :: enum(Circle(radius : i32), Rectangle(width : i32, height : i32));
+Shape :: enum(
+  Circle(radius : i32),
+  Rectangle(width : i32, height : i32),
+  Triangle(base : i32, height : i32, label : str)
+);
 
 match(s,
-  .Circle(r)                       => (r * r),         // positional
-  .Rectangle(width: w, height: h)  => (w * h),         // labeled
-  .Rectangle({width, height: h})   => (width * h)      // curly shorthand
+  // ✅ Preferred — curly shorthand names only the fields you use.
+  .Triangle({base, height: h})  => (base * h),
+
+  // Also OK — labeled (label : var) pairs; order-free, partial matches OK.
+  .Circle(radius: r)             => (r * r),
+
+  // ⚠️ Avoid for 2+ field variants — positional with `_` is brittle when
+  //    a field is added and harder to read (each `_` requires counting).
+  //    OK when the variant has one field, or when every field is named.
+  .Rectangle(w, h)               => (w * h)
 )
 ```
 
+**Preferred form**: `.Variant({label, label: alias})`. Names only the fields the arm binds, so adding a field to the variant later doesn't silently break every arm. `tests/match_curly.test.yo` is the spec.
+
 Curly `{a, b: c}` is sugar for `(a: a, b: c)` — order-free, supports partial matches (omit fields). Use `{label: _}` to ignore a specific field. Bare `{_}` and empty `{}` are rejected.
 
 > **Critical**: Within a single match arm, you must use **either all positional or all named** field patterns. Mixing positional and named fields in the same arm (e.g., `.Foo(x, y: z, w)`) causes C codegen to emit undeclared identifiers for the named fields. This is a parser/codegen limitation — do not mix.
@@ -273,17 +311,17 @@ show :: (fn(forall(T : Type), value : T, where(T <: ToString)) -> unit)(
 
 ```rust
 main :: (fn() -> unit)(());
-export main;
+export(main);
 
-export
+export(
   helper,
   Config
-;
+);
 ```
 
-- `export name;` exports a single binding
+- `export(name);` exports a single binding
 - Block form exports multiple bindings separated by commas
-- Every executable needs `export main;`
+- Every executable needs `export(main);`
 
 ## Static and dynamic dispatch types
 
@@ -321,15 +359,15 @@ factorial :: (fn(n : i32) -> i32)(
   )
 );
 
-// Runtime infinite loop — `while cond` is ALWAYS runtime
-while true, {
+// Runtime infinite loop — `while(cond, body)` is ALWAYS runtime
+while(true, {
   work();
-};
+});
 
 // Compile-time loop unrolling — requires comptime() modifier
-while comptime(i < 10), {
+while(comptime((i < 10)), {
   // body evaluated/unrolled at compile time
-};
+});
 
 // for loop — 2-arg prelude macro; first arg MUST be an iterator (has .next()):
 for(list.iter(), x => {    // ArrayList, array → call .iter() first
@@ -346,8 +384,8 @@ for(list.iter(), (ptr) => { // ptr is a mutable reference to each element
 ```
 
 - Use `recur(...)` for self-recursion
-- `while cond` is **always a runtime loop** — use this for open-ended loops (e.g., server accept loops, event loops)
-- `while comptime(cond)` explicitly unrolls at compile time — `cond` must be a compile-time-known value
+- `while(cond, body)` is **always a runtime loop** — use this for open-ended loops (e.g., server accept loops, event loops)
+- `while(comptime(cond), body)` explicitly unrolls at compile time — `cond` must be a compile-time-known value
 - Using a comptime-only (`::`) variable in a bare `while` condition without `comptime()` is a **compile error** (would be an infinite loop at runtime)
 - **`for(arr, item => { body })`** — correct 2-arg prelude macro form. The `item => { body }` is an anonymous closure.
 - **Do NOT use `for(x, arr, { body })`** — this older 3-arg form is an evaluator-internal representation, not valid top-level Yo syntax. (The self-hosted evaluator currently only understands the 3-arg form in its internal for-loop handler; track issue: `issues/eval-for-loop-3arg-vs-2arg.md`)
@@ -355,19 +393,19 @@ for(list.iter(), (ptr) => { // ptr is a mutable reference to each element
 ## Return and branch safety
 
 ```rust
-// WRONG — return consumes the comma, capturing the next match branch:
+// WRONG — paren-less return is invalid:
 match(opt,
-  .Some(v) => return v,    // parsed as return(v, .None => ...)
+  .Some(v) => return v,
   .None => default_value()
 );
 
-// CORRECT — begin blocks isolate return from the comma:
+// CORRECT — explicit return calls in begin blocks:
 match(opt,
   .Some(v) => {
-    return v;
+    return(v);
   },
   .None => {
-    return default_value();
+    return(default_value());
   }
 );
 
@@ -380,11 +418,11 @@ get_value :: (fn(opt : Option(i32)) -> i32)(
 );
 ```
 
-- `return expr1, expr2` parses as a single function call: `return(expr1, expr2)`
+- `return expr` is invalid; write `return(expr)` or `return()` for unit
 - In `cond` or `match` branches, **always use begin blocks** when you need `return`
-- `return` must be the **last expression** in a begin block — dead code after `return` is rejected. Do NOT write `{ return x; fallback_val }`. Write `{ return x; }` only.
+- `return(...)` must be the **last expression** in a begin block — dead code after `return(...)` is rejected. Do NOT write `{ return(x); fallback_val }`. Write `{ return(x); }` only.
 - If the whole function is one expression, prefer expression-bodied style and skip `return` entirely
-- The same trap applies to any function call without parens in match branches
+- The same rule applies to all calls in match branches: use immediate `(...)`
 
 ## String concatenation pitfall
 
@@ -406,43 +444,43 @@ content := String.from("line1\nline2\n");
 ## Iterator and for loop
 
 ```rust
-{ ArrayList } :: import "std/collections/array_list";
+{ ArrayList } :: import("std/collections/array_list");
 
 list := ArrayList(i32).new();
 list.push(i32(10));
 list.push(i32(20));
 
-for list.iter(), (ptr) => {
+for(list.iter(), (ptr) => {
   println(ptr.*);
-};
+});
 
-for list.into_iter(), (value) => {
+for(list.into_iter(), (value) => {
   println(value);
-};
+});
 ```
 
-- `for collection, (variable) => { body }` iterates via the `Iterator` trait
+- `for(collection, (variable) => { body })` iterates via the `Iterator` trait
 - `.iter()` borrows the collection and yields pointers
 - `.into_iter()` takes ownership and yields values
 
 ## Testing
 
 ```rust
-test "Addition works", {
+test("Addition works", {
   assert(((i32(1) + i32(1)) == i32(2)), "1+1 should be 2");
-};
+});
 
-test "Compile-time check", {
+test("Compile-time check", {
   comptime_assert((2 + 2) == 4);
   comptime_expect_error({ x :: (1 / 0); });
-};
+});
 
-test "Async test", {
+test("Async test", {
   io.await(yield());
-};
+});
 ```
 
-- `test "description", { body }` defines a test — `io : IO` is automatically available
+- `test("description", { body })` defines a test — `io : IO` is automatically available
 - All tests can use `io.async(...)`, `io.await(...)`, etc. without a `using` clause
 - `assert(condition, "message")` — runtime assertion (always include a message)
 - `comptime_assert(condition)` — compile-time assertion
@@ -540,6 +578,23 @@ Variable :: object(name : String, type : TypeValue);
 Variable :: object(name : String, ty : TypeValue);
 ```
 
+### 1-element array literals require a trailing comma
+
+`[expr]` without a trailing comma is **parsed as a Slice type** `Slice(expr)`, not an array literal. To create a 1-element array value, add a trailing comma:
+
+```rust
+// WRONG — parsed as Slice type, not array literal:
+arr := [i32(42)];
+
+// CORRECT — trailing comma makes it an array literal:
+arr := [i32(42),];
+
+// Multi-element arrays work fine (comma separator detected):
+arr2 := [i32(1), i32(2), i32(3)];  // ✓
+```
+
+This also applies inside source strings in proto-evaluator tests.
+
 ### ArrayList indexing uses call syntax
 
 ```rust
@@ -671,7 +726,7 @@ if((!cond), { do_thing(); });
 
 ### `escape` requires a nested-function context
 
-`escape value` exits the **enclosing function** — the nearest `fn(...)` that
+`escape(value)` exits the **enclosing function** — the nearest `fn(...)` that
 wraps the current code. It requires that the code is inside a nested function
 (e.g., a closure or `given` handler lambda), NOT at the top level of a
 standalone function definition.
@@ -679,20 +734,27 @@ standalone function definition.
 ```rust
 // CORRECT — escape inside a given handler lambda (lambda has enclosing fn):
 given(exn) := Exception(throw: ((err) -> {
-  escape result   // exits the outer function that contains this given()
+  escape(result); // exits the outer function that contains this given()
 }));
 do_something(using(exn));
 
+// CORRECT — even after process-exit helpers, satisfy the handler's resume type:
+given(exn2) := Exception(throw: ((err) -> {
+  eprintln(err.to_string());
+  exit(int(1));
+  escape(); // required because exit() returns unit, not the handler ResumeType
+}));
+
 // CORRECT — escape inside a closure passed as argument:
 result := match(opt, .Some(x) => x, .None => {
   // This is NOT a nested function — use return:
-  // WRONG: escape default_val  // ERROR: no enclosing fn
-  return default_val  // CORRECT: return exits the enclosing fn directly
+  // WRONG: escape(default_val)  // ERROR: no enclosing fn
+  return(default_val); // CORRECT: return exits the enclosing fn directly
 });
 
 // WRONG — escape inside a match arm (not a nested fn):
 match(opt,
-  .Some(x) => { escape x }  // ERROR: "can only be used inside a function that has an enclosing function"
+  .Some(x) => { escape(x); }  // ERROR: "can only be used inside a function that has an enclosing function"
 );
 ```
 
@@ -923,16 +985,16 @@ if (((is_tuple_type(ty) || is_struct_type(ty)) || is_union_type(ty)), ...)
 
 ### Duplicate imports from the same path must be merged
 
-Having two `:: import "path"` lines importing from the same file causes a compile error.
+Having two `:: import("path")` lines importing from the same file causes a compile error.
 Always merge them into a single destructuring import:
 
 ```rust
 // ❌ Two imports from the same path
-{ Foo } :: import "../../mod.yo";
-{ Bar } :: import "../../mod.yo";
+{ Foo } :: import("../../mod.yo");
+{ Bar } :: import("../../mod.yo");
 
 // ✅ Merged
-{ Foo, Bar } :: import "../../mod.yo";
+{ Foo, Bar } :: import("../../mod.yo");
 ```
 
 ### Implicit (`using`) parameters cannot be used with `:=` assignment
@@ -1023,3 +1085,102 @@ match(outer_val,
   .None => { fallback() } // ← outer .None arm
 )                          // ← closes outer match
 ```
+
+### Nested enum patterns in match are NOT supported
+
+Yo does **not** support nested enum patterns inside a single match arm.
+You cannot write `.Some(.IntLit(n))` — this is a parser error.
+
+```rust
+// ❌ WRONG — nested enum pattern, parser error:
+match(v.get(usize(0)),
+  .Some(.IntLit(n)) => assert(n.as_str() == "3", "ok"),
+  _ => assert(false, "err")
+)
+
+// ✅ CORRECT — two-level match:
+match(v.get(usize(0)),
+  .Some(x) => match(x, .IntLit(n) => assert(n.as_str() == "3", "ok"), _ => assert(false, "err")),
+  .None => assert(false, "err")
+)
+```
+
+This applies to ALL nested enum patterns: `.Some(.BoolVal(b))`, `.Some(.ArrayVal(arr))`, etc. — always use a two-level match.
+
+### `get_callee()` returns ExprVal directly, not an Option-wrapped EnumVal
+
+In the proto-evaluator source strings (`evaluate_module_body`), `ExprVal.get_callee()` on a FnCall returns the callee `ExprVal` directly — NOT wrapped in an `Option` EnumVal. Chaining `.is_some()` fails with SIGABRT because `is_some()` requires an `EnumVal` receiver.
+
+```rust
+// ❌ SIGABRT — get_callee() returns ExprVal, not Option(EnumVal)
+result := quote(foo(i64(1))).get_callee().is_some();
+
+// ✅ Chain .is_atom() or .is_fn_call() on the returned ExprVal
+result := quote(foo(i64(1))).get_callee().is_atom();   // true: callee "foo" is an atom
+result := quote(foo(i64(1))).get_callee().is_fn_call(); // false: callee "foo" is not a fn call
+```
+
+Similarly, calling `get_callee()` on an Atom causes the overall evaluation to fail — do not test the Atom case via `get_callee()` in source strings.
+
+### Source-string evaluation pitfalls (proto-evaluator tests)
+
+When writing source strings passed to `evaluate_module_body` in proto-evaluator tests:
+
+**`cond` form**: Always use the `cond(condition => value, true => fallback)` form, NOT `cond(condition, value, fallback)`. The 3-arg form does NOT work inside lambdas or recursive functions in source strings.
+
+```
+// ❌ WRONG — crashes inside lambdas and recursive functions
+cond((n <= i32(1)), i32(1), (n * recur((n - i32(1)))))
+
+// ✅ CORRECT
+cond((n <= i32(1)) => i32(1), true => (n * recur((n - i32(1)))))
+```
+
+**Recursive functions**: Use `recur(...)` for self-recursion inside named `::` functions. Never call the function by name from inside its own body.
+
+**Chaining function calls with operators**: `f(a) + f(b) + f(c)` throws an exception. Use fold over an array instead:
+
+```
+// ❌ WRONG — exception in source strings
+result := abs_val(i32(3)) + abs_val(i32(1)) + abs_val(i32(4));
+
+// ✅ CORRECT
+arr := [i32(3), i32(1), i32(4)];
+result := arr.fold(i32(0), (fn(acc : i32, x : i32) -> i32)((acc + abs_val(x))));
+```
+
+**Empty array `[]` in cond branches**: `cond(condition => [x], true => [])` crashes because the empty array type is unknown. Avoid empty array literals in conditional branches inside `flat_map` lambdas.
+
+**Option types**: Must use `Option(T).Some(val)` not `Option.Some(val)`. `Option(T).None` with a type annotation crashes — use `r := Option(i32).None` without annotation. `.is_none()` is not supported; use `!(r.is_some())`. `and_then(f)` returns the raw value (not wrapped in Option), so calling `.unwrap_or()` on the result crashes.
+
+**Number literals**: `i32(-3)` crashes — use `(i32(0) - i32(3))`. `i32.as_usize()` / `usize.as_i32()` not supported.
+
+**Fibonacci without tmp variable**: `b = (a + b); a = (b - a)` computes fib correctly without a temp variable. After N iterations, `a` holds fib(N) and `b` holds fib(N+1).
+
+**3-term multiplication in source strings**: `(x * x * x)` causes an exception in evaluated source strings. Break it into a block:
+
+```
+// ❌ WRONG — causes exception
+cubes := arr.map((fn(x : i32) -> i32)((x * x * x)));
+
+// ✅ CORRECT — use a block with a local binding
+cubes := arr.map((fn(x : i32) -> i32)({
+  sq := (x * x);
+  (sq * x)
+}));
+```
+
+**3-term sum in fold on tuples**: `(acc + p.0 + p.1)` inside a fold lambda on tuple pairs crashes. Always map pairs to scalars first, then fold:
+
+```
+// ❌ WRONG — crashes in fold on (i32, i32) tuples
+total := pairs.fold(i32(0), (fn(acc : i32, p : (i32, i32)) -> i32)((acc + p.0 + p.1)));
+
+// ✅ CORRECT — map to scalars first, then fold
+sums := pairs.map((fn(p : (i32, i32)) -> i32)((p.0 + p.1)));
+total := sums.fold(i32(0), (fn(acc : i32, x : i32) -> i32)((acc + x)));
+```
+
+**`&&` in `cond` conditions inside `while` body**: Crashes. Avoid by restructuring (e.g., start loop at 1 instead of 0 to eliminate the `&& (i > 0)` guard).
+
+**Test API format**: Use `evaluate_module_body(exprs, &(env))` (reference syntax, returns `Option`). Match with function-style `match(result, .None => ..., .Some(m) => ...)`. Do NOT use block-style `match(result) { ... }` — it causes a parse error ("Paren-less function and operator calls are not supported").

package/.github/skills/yo-wasm-integration/wasm-integration-cheatsheet.md

@@ -16,7 +16,7 @@ Export C-compatible functions that operate on linear memory:
 
 ```rust
 // src/wasm_api.yo
-open import "std/string";
+open(import("std/string"));
 
 // Allocate WASM memory for the caller
 wasm_alloc :: (fn(size : usize) -> *(u8))(
@@ -89,7 +89,7 @@ The `Executable` struct accepts: `name`, `root`, `target`, `optimize`, `allocato
 Emscripten-specific flags go in `add_c_flags(...)` after creating the step.
 
 ```rust
-build :: import "std/build";
+build :: import("std/build");
 
 wasm_api :: build.executable({
   name: "my_lib_wasm_api",
@@ -242,7 +242,7 @@ cd npm && node -e "const m = require('.'); m.createRenderer().render('hello').th
 - **Memory leaks**: Always `_wasm_free` every `_wasm_alloc` on the JavaScript side.
 - **String encoding**: WASM only sees bytes — use `TextEncoder`/`TextDecoder` for UTF-8.
 - **Errno differences**: WASI errno values differ from POSIX. Use `std/libc/errno` constants.
-- **No `main` needed**: Library WASM modules don't need `main` or `export main;` — just export the API functions.
+- **No `main` needed**: Library WASM modules don't need `main` or `export(main);` — just export the API functions.
 - **Emscripten environment**: Set `-sENVIRONMENT='web,node'` to support both contexts, or `'node'` for Node.js only.
 - **Module initialization is async**: Emscripten's `createModule()` returns a Promise. Initialize once and reuse.
 - **WASM memory growth**: Always use `-sALLOW_MEMORY_GROWTH=1` for dynamic allocations.

package/README.md

@@ -202,14 +202,14 @@ my-project/
 
 `src/main.yo`:
 
-```typescript
-{ println } :: import "std/fmt";
+```rust
+{ println } :: import("std/fmt");
 
 main :: (fn() -> unit)({
   println("Hello, world!");
 });
 
-export main;
+export(main);
 ```
 
 Common build commands:
@@ -220,6 +220,8 @@ $ yo build run              # Build and run the executable
 $ yo build test             # Run tests
 $ yo build --list-steps     # List available build steps
 $ yo build doc              # Generate HTML documentation
+$ yo fmt                    # Format Yo source files
+$ yo fmt --check            # Check formatting without writing changes
 ```
 
 ## Prelude
@@ -254,15 +256,15 @@ Check the [./tests](./tests/) and [./std](./std/) folders for more code examples
 
 ### Hello World
 
-```typescript
+```rust
 // main.yo
-{ println } :: import "std/fmt";
+{ println } :: import("std/fmt");
 
-main :: (fn() -> unit) {
+main :: (fn() -> unit)({
   println("Hello, world!");
-};
+});
 
-export main;
+export(main);
 
 // $ yo compile main.yo --release -o main
 // $ ./main