@shd101wyy/yo 0.1.25 → 0.1.26

package/.github/skills/yo-async-effects/async-effects-recipes.md

@@ -186,7 +186,7 @@ process_dir :: (fn(root: Path, using(io: IO, exn: Exception)) -> Impl(Future(uni
 
 ## Exception (non-resumable)
 
-`Exception` is a built-in module effect for non-resumable error handling. When the handler calls `escape`, the continuation is discarded:
+`Exception` is a built-in struct-record effect for non-resumable error handling. When the handler calls `escape`, the continuation is discarded:
 
 ```rust
 open import "std/error";
@@ -251,7 +251,7 @@ Key: the `return` inside the handler resumes the _effect invocation site_ with t
 
 **`escape T_value` constraint**: `escape T_value` inside an `Exception` handler requires that the enclosing `io.async` closure's return type matches `T_value`. Due to forward type inference, the evaluator may not know the closure's return type at the point where `given` is declared. This causes a "Expected: unit" error when `escape non_unit` is used in a handler declared before the final return expression. Prefer `return fallback_value` (resume) when possible.
 
-`ResumableException(ResumeType)` is a module effect for resumable error handling. The handler uses `return` to resume with a recovery value:
+`ResumableException(ResumeType)` is a struct-record effect for resumable error handling. The handler uses `return` to resume with a recovery value:
 
 ```rust
 open import "std/error";
@@ -282,19 +282,19 @@ export main;
 - Handler uses `return value` to resume the continuation with the recovery value
 - The call site receives the returned value and continues normally
 
-## Module effects vs function-type effects
+## Struct-record effects vs function-type effects
 
-Effects in Yo can be plain function types or module types:
+Effects in Yo can be plain function types or struct-record types:
 
 ```rust
 Raise :: (fn(msg : String) -> i32);
 
-Logger :: module(
+Logger :: struct(
   log : (fn(level : i32, msg : String) -> unit)
 );
 ```
 
-Both kinds use `using(...)` / `given(...)` with the same semantics — they compile to evidence passing (function pointers as implicit C parameters). Module effects group related operations under a single name.
+Both kinds use `using(...)` / `given(...)` with the same semantics — they compile to evidence passing (function pointers as implicit C parameters). Struct-record effects group related operations under a single nominal type.
 
 ## Async with effects
 

package/.github/skills/yo-core-patterns/core-patterns-cheatsheet.md

@@ -190,6 +190,10 @@ TcpStream :: object(fd : i32, buffer : ArrayList(u8));
 
 - Use `newtype(...)` when the type has exactly one field
 - Use `object(...)` for types that need shared ownership
+- Source-file imports are namespace structs. The old `module(...)`, `Module`,
+  and `SelfModule` syntax is gone; use `struct(...)`, `Type`, and normal `Self`.
+- Fields written as `name :: value` or `comptime(name) : Type` are compile-time-only static fields/methods and have no runtime layout
+- A normal field with a compile-time-only type, such as `x : comptime_int`, is still a data field and makes the struct comptime-only
 
 ## Impl blocks and generics
 

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

@@ -129,6 +129,11 @@ impl(Counter,
 - No space between a function type and its body: `(fn(...) -> T)(...)`
 - 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(...)`,
+  `Module`, and `SelfModule` syntax has been removed; imported files are
+  represented as namespace structs, and recursive references use normal `Self`.
+- Bare `Module` is not a type alias. Use `Type` for comptime type values; type
+  reflection reports source-module namespaces as `TypeInfo.Struct(...)`.
 - Wrap `fn` types in parentheses when they appear after `:`
 - **Forward references between methods in the same `impl` block are supported.** A method defined later in the block can be called by a method defined earlier. Both `self.method()` and `Self.method(...)` dispatch work. Only the canonical `name : (fn(...) -> R)(body)` method shape participates; bare lambdas do not get forward-ref shells.
 - **Module-level `::` function definitions are processed in order.** A function body that calls another function declared later in the same file will fail with "Variable not found". Always define leaf helpers first (bottom-up order): `eval_identifier` → `eval_atom` → `evaluate`.