Claude/wokelang ebnf grammar qoe vv (#6)

* Implement WokeLang interpreter in Rust

Complete implementation of WokeLang with:

Lexer (src/lexer/):
- Token definitions for all keywords, operators, literals
- Uses logos for fast tokenization
- Handles comments, strings with escapes, numbers

Parser (src/parser/):
- Recursive descent parser
- Full expression parsing with correct precedence
- All statement types: remember, when/otherwise, repeat, attempt safely
- Pattern matching with decide based on
- Emote tags, consent blocks, gratitude declarations

AST (src/ast/):
- Complete type definitions for all language constructs
- Spanned nodes for error reporting

Interpreter (src/interpreter/):
- Tree-walking interpreter
- Scoped environments for variables
- Built-in functions: print, len, toString, toInt
- Consent system with interactive prompts
- Pattern matching evaluation
- All operators (arithmetic, comparison, logical)

CLI (src/main.rs):
- woke <file.woke> - run program
- woke --tokenize <file> - show tokens
- woke --parse <file> - show AST

Examples:
- examples/hello.woke - feature showcase
- examples/demo.woke - runnable demo

* Add REPL, WASM compilation, and Zig FFI

REPL (src/repl.rs):
- Interactive command-line interface with rustyline
- Commands: :help, :quit, :clear, :reset, :load, :ast
- Expression evaluation with automatic result printing
- Start with `woke` or `woke --repl`

WASM Compilation (src/codegen/):
- Compile WokeLang to WebAssembly binary format
- Uses wasm-encoder for proper WASM generation
- Supports functions, expressions, loops, conditionals
- Pattern matching compilation
- CLI: `woke -c input.woke` outputs input.wasm

Zig FFI (src/ffi/, zig/, include/):
- C-compatible API for embedding WokeLang
- Interpreter lifecycle: woke_interpreter_new/free
- Code execution: woke_exec, woke_eval
- Value operations: type checking, conversion, creation
- Static library (libwokelang.a) and shared library (.so)
- C header (include/wokelang.h)
- Zig bindings (zig/wokelang.zig) with idiomatic wrapper
- Example Zig program and build.zig

Other:
- examples/math.woke - math functions for WASM demo
- Cargo.toml updated for cdylib/staticlib targets

* Add comprehensive documentation and wiki

Includes:
- Project roadmap (ROADMAP.md) with version timeline through v1.0
- Wiki home page with table of contents
- Getting Started guides: Installation, Hello World, Basic Syntax, REPL
- Language Guide: Functions, Control Flow, Error Handling, Variables/Types
- Core Concepts: Consent System, Gratitude, Emote Tags
- Reference: CLI, Built-in Functions, Keywords, Operators, Language Spec
- Internals: Architecture, Lexer, Parser, Interpreter, WASM, FFI
- Tutorial: Building a CLI app

* Implement Phase 2 Language Completeness features

- Add Result types (Okay/Oops) with pattern matching support
- Implement error propagation operator (?) for Result types
- Add pattern matching destructuring with guard clauses
- Implement module system with use/share keywords
- Add new builtins: isOkay, isOops, getOkay, getOops
- Update WASM compiler and FFI for new AST variants
- Add example programs for Result types and modules

* Add static type inference with Hindley-Milner style checker

- Implement TypeChecker module with type inference
- Support for basic types: Int, Float, String, Bool, Unit
- Support for compound types: Array, Result, Maybe, Function
- Implement unification algorithm for type constraints
- Add built-in function type handling
- Include comprehensive test suite for type checking

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

examples/module_test.woke

@@ -0,0 +1,38 @@
+// Test program for WokeLang module system
+// Demonstrates use/share keywords
+
+thanks to {
+    "WokeLang" → "For module support";
+}
+
+// Import modules
+use modules.math;
+use modules.greetings renamed greet;
+
+to main() {
+    hello "Testing Module System";
+
+    // Test math module (imported with default prefix)
+    print("=== Math Module ===");
+    remember sum = math_add(5, 3);
+    print("5 + 3 = " + toString(sum));
+
+    remember diff = math_subtract(10, 4);
+    print("10 - 4 = " + toString(diff));
+
+    remember product = math_multiply(6, 7);
+    print("6 * 7 = " + toString(product));
+
+    remember sq = math_square(9);
+    print("9^2 = " + toString(sq));
+
+    // Test greetings module (imported with rename)
+    print("");
+    print("=== Greetings Module ===");
+    greet_sayHello("World");
+    greet_sayGoodbye("Friend");
+    greet_greet("Dr. Smith", true);
+    greet_greet("Bob", false);
+
+    goodbye "Module system working!";
+}

examples/modules/greetings.woke

@@ -0,0 +1,21 @@
+// Greetings module - provides greeting utilities
+
+share sayHello;
+share sayGoodbye;
+share greet;
+
+to sayHello(name: String) {
+    print("Hello, " + name + "!");
+}
+
+to sayGoodbye(name: String) {
+    print("Goodbye, " + name + "!");
+}
+
+to greet(name: String, formal: Bool) {
+    when formal {
+        print("Good day, " + name + ".");
+    } otherwise {
+        print("Hey, " + name + "!");
+    }
+}

examples/modules/math.woke

@@ -0,0 +1,28 @@
+// Math module - provides basic math utilities
+// Example of WokeLang module system
+
+share add;
+share subtract;
+share multiply;
+share square;
+
+to add(a: Int, b: Int) -> Int {
+    give back a + b;
+}
+
+to subtract(a: Int, b: Int) -> Int {
+    give back a - b;
+}
+
+to multiply(a: Int, b: Int) -> Int {
+    give back a * b;
+}
+
+to square(x: Int) -> Int {
+    give back x * x;
+}
+
+// This function is NOT exported - private to the module
+to internalHelper() {
+    print("This is private");
+}

examples/result_types.woke

@@ -0,0 +1,57 @@
+// Example: Result Types in WokeLang
+// Demonstrates Okay(value) and Oops(error) result types
+
+thanks to {
+    "Rust" → "For inspiration on Result types";
+}
+
+// Function that may fail - returns Result type
+to safeDivide(a: Int, b: Int) {
+    when b == 0 {
+        give back Oops("Division by zero");
+    }
+    give back Okay(a / b);
+}
+
+// Function using the ? operator for error propagation
+to calculate(x: Int, y: Int) {
+    remember result = safeDivide(x, y)?;
+    give back Okay(result * 2);
+}
+
+to main() {
+    hello "Testing Result Types";
+
+    // Test 1: Successful division
+    remember r1 = safeDivide(10, 2);
+    print("10 / 2 = ");
+    print(r1);
+    print("Is Okay? " + toString(isOkay(r1)));
+
+    // Test 2: Division by zero
+    remember r2 = safeDivide(10, 0);
+    print("10 / 0 = ");
+    print(r2);
+    print("Is Oops? " + toString(isOops(r2)));
+
+    // Test 3: Pattern matching on Result
+    decide based on r1 {
+        Okay(value) → {
+            print("Success with value: " + toString(value));
+        }
+        Oops(error) → {
+            print("Error: " + error);
+        }
+    }
+
+    // Test 4: Using getOkay/getOops
+    when isOkay(r1) {
+        print("Extracted value: " + toString(getOkay(r1)));
+    }
+
+    when isOops(r2) {
+        print("Extracted error: " + getOops(r2));
+    }
+
+    goodbye "Result types working!";
+}

src/codegen/wasm.rs

@@ -323,7 +323,7 @@ impl WasmCompiler {
                             break;
                         }
                     }
-                }
+                }next stage
 
                 // Close all if blocks
                 for arm in &decide.arms {

src/parser/mod.rs

@@ -234,7 +234,7 @@ impl<'src> Parser<'src> {
     // === Worker/Side Quest/Superpower ===
 
     fn parse_worker_def(&mut self) -> Result<WorkerDef, ParseError> {
-        let start = self.current_span().start;
+        let start = self.current_next stagespan().start;
         self.expect(Token::Worker)?;
         let name = self.expect_identifier()?;
         self.expect(Token::LBrace)?;