1 files changed, 209 insertions, 0 deletions
diff --git a/js/scripting-lang/baba-yaga-c/ROADMAP.md b/js/scripting-lang/baba-yaga-c/ROADMAP.md
new file mode 100644
index 0000000..5f44ca4
--- /dev/null
+++ b/js/scripting-lang/baba-yaga-c/ROADMAP.md
@@ -0,0 +1,209 @@
+# Baba Yaga C Implementation - Focused Roadmap
+
+## Current Status
+- ✅ **Core Language**: Complete and stable (24/27 tests passing)
+- ✅ **Table Pattern Matching**: Fixed and working
+- ✅ **When Expressions**: Fixed and working
+- ✅ **Computed Table Keys**: Fixed and working (Task 1.1 complete)
+- ✅ **Memory Issues**: Fixed - reverted partial application implementation
+- ❌ **2 Remaining Issues**: Partial application, pattern matching memory
+
+## Implementation Plan
+
+### **Phase 1: Parser Extensions (High Impact)**
+
+#### **Task 1.1: Computed Table Keys** (Test 15) ✅ **COMPLETE**
+**Issue**: `{(1 + 1): "two"}` not supported
+**Solution**: Extended table key parsing with expression support
+**Implementation**: Added `TOKEN_LPAREN` detection and expression parsing logic
+**Result**: Test 15 now passes, 25/27 tests passing
+
+#### **Task 1.2: Multi-value Pattern Expressions** (Test 22) ✅ **COMPLETE**
+**Issue**: `when (x % 2) (y % 2) is` not supported
+**Current**: Multi-value pattern expressions working correctly in parser
+**Status**: Core functionality implemented - test file has minor syntax issue
+
+#### **Task 1.3: Pattern Matching Memory** (Integration Test 02) 🔄 **IN PROGRESS**
+**Issue**: Segmentation fault in complex pattern matching
+**Current**: Memory corruption in pattern matching
+**Status**: Need to add memory debugging and fix recursion
+
+
+
+### **Phase 2: Runtime Fixes (Medium Impact)**
+
+#### **Task 2.1: Table Namespace Debugging** (Test 17) ✅ **COMPLETE**
+**Issue**: `Error: Execution failed` in table operations
+**Current**: Basic `map`, `filter`, `reduce` functions now work correctly with operator lookup
+**Status**: Core functionality implemented - operator scope access fixed
+
+**Root Cause Analysis**:
+- ✅ `t.*` namespace functions (t.map, t.filter, t.reduce, t.set, t.delete, t.merge, t.length, t.has, t.get) are working correctly
+- ✅ Basic `map`, `filter`, `reduce` functions now work correctly with operator lookup
+- ✅ `each` function works but has arity issues
+- ❌ Test still fails due to partial application and arity handling issues
+
+**Solution Implemented**:
+1. **Fixed Scope Access**: Updated stdlib function signatures to accept `Scope*` parameter
+2. **Updated Function Calls**: Modified `baba_yaga_function_call` to pass current scope to user functions
+3. **Updated Function Registration**: Changed function pointer types to support scope parameter
+4. **Verified Core Functionality**: Basic higher-order functions now work with operators
+
+**Current Status**:
+- ✅ **Core Bug Fixed**: Operator lookup in higher-order functions works correctly
+- ✅ **Basic Functions Working**: `map`, `filter`, `reduce` with operators now functional
+- ❌ **Test 17 Still Fails**: Due to partial application and arity issues (see Task 2.3)
+
+#### **Task 2.2: Pattern Matching Memory** (Integration Test 02)
+**Issue**: Segmentation fault in complex patterns
+**Current**: Memory corruption in pattern matching
+**Fix**: Add memory debugging and fix recursion
+
+#### **Task 2.3: Partial Application Support** (Test 17) 🔄 **IN PROGRESS**
+**Issue**: Test 17 fails with partial application and arity errors
+**Current**: Core higher-order functions work, but partial application not supported
+**Status**: Need to implement minimal partial application support (reverted due to memory issues)
+
+**Root Cause Analysis**:
+- ✅ **Core Functions Working**: `map`, `filter`, `reduce` with operators now functional
+- ❌ **Partial Application**: Function calls with fewer arguments than required fail
+- ❌ **Arity Issues**: `each` function expects 3 args but receives 2 in some cases
+- ❌ **Variable Scope**: Some variables like `partial_result`, `scalar_2`, etc. undefined
+
+**Error Messages from Test 17**:
+- "each: expected 3 arguments, got 2"
+- "Undefined variable: partial_result", "scalar_2", "add_to_ten"
+- "Cannot call non-function value"
+- "equals: arguments must be of the same type"
+
+**Implementation Plan**:
+1. **Implement Partial Application**: When function called with fewer args than required, return new function
+2. **Fix Arity Validation**: Ensure `each` function handles variable argument counts correctly
+3. **Debug Variable Scope**: Identify why certain variables are undefined in test context
+4. **Test Partial Application**: Verify partial functions work with remaining arguments
+
+**Technical Details**:
+- **Location**: `src/function.c` - `baba_yaga_function_call` function
+- **Current Behavior**: Returns `VAL_NIL` when insufficient arguments
+- **Required Behavior**: Return new function with bound arguments
+- **Reference**: Use `stdlib_compose` as template for function composition
+
+**Implementation Steps**:
+1. Add memory debugging to `interpreter_evaluate_when_expression`
+2. Check for infinite recursion in pattern matching
+3. Fix memory allocation/deallocation in pattern evaluation
+4. Test with complex pattern matching scenarios
+
+### **Phase 3: Validation**
+- Re-run comprehensive test suite
+- Target: 27/27 tests passing
+- Verify no regressions
+
+## Technical Notes
+
+### **Parser Architecture**
+- Table parsing: `parser_parse_primary` → `TOKEN_LBRACE` case
+- Pattern parsing: `parser_parse_when_pattern` → multi-parameter detection
+- Both need expression support in parentheses
+
+### **Standard Library**
+- `t.*` functions: Already implemented in `stdlib.c` (lines ~815-1183) ✅ **WORKING**
+- Functions: `t.map`, `t.filter`, `t.reduce`, `t.set`, `t.delete`, `t.merge`, `t.length`, `t.has`, `t.get`
+- Basic functions: `map`, `filter`, `reduce` in `stdlib.c` (lines ~559-640) ❌ **PLACEHOLDERS**
+- Issue: Basic higher-order functions need full implementation
+
+### **Memory Management**
+- Pattern matching: Uses recursion for nested patterns
+- Potential: Stack overflow or memory corruption
+- Solution: Add bounds checking and memory debugging
+
+## Next Action
+**Continue with Task 1.3** (Pattern Matching Memory) - fix segmentation fault in complex pattern matching.
+
+## Implementation Guide
+
+### **Task 2.1: Basic Higher-Order Functions Implementation** ✅ **COMPLETE**
+
+#### **Function 1: `stdlib_map` Implementation**
+**Location**: `src/stdlib.c` lines ~559-580
+**Current**: Returns original table (placeholder)
+**Required**: Apply function to each value in table
+
+**Implementation Steps**:
+1. Get all keys from input table using `baba_yaga_table_get_keys`
+2. Create new result table using `baba_yaga_value_table`
+3. For each key:
+   - Get value using `baba_yaga_table_get_by_key`
+   - Call function with value using `baba_yaga_function_call`
+   - Add result to new table using `baba_yaga_table_set`
+4. Return new table
+
+**Reference**: Use `stdlib_t_map` (lines ~815-866) as template - it's already implemented correctly
+
+#### **Function 2: `stdlib_filter` Implementation**
+**Location**: `src/stdlib.c` lines ~584-610
+**Current**: Returns original table (placeholder)
+**Required**: Keep only values that satisfy predicate
+
+**Implementation Steps**:
+1. Get all keys from input table using `baba_yaga_table_get_keys`
+2. Create new result table using `baba_yaga_value_table`
+3. For each key:
+   - Get value using `baba_yaga_table_get_by_key`
+   - Call predicate function with value using `baba_yaga_function_call`
+   - If predicate returns truthy value, add original value to new table
+4. Return new table
+
+**Reference**: Use `stdlib_t_filter` (lines ~867-923) as template - it's already implemented correctly
+
+#### **Function 3: `stdlib_reduce` Implementation**
+**Location**: `src/stdlib.c` lines ~609-640
+**Current**: Returns initial value (placeholder)
+**Required**: Combine all values with function
+
+**Implementation Steps**:
+1. Start with initial value as accumulator
+2. Get all keys from input table using `baba_yaga_table_get_keys`
+3. For each key:
+   - Get value using `baba_yaga_table_get_by_key`
+   - Call function with accumulator and value using `baba_yaga_function_call`
+   - Update accumulator with result
+4. Return final accumulator value
+
+**Reference**: Use `stdlib_t_reduce` (lines ~924-976) as template - it's already implemented correctly
+
+#### **Testing Strategy**:
+1. **Unit Tests**: Create simple tests for each function individually
+2. **Integration Test**: Run Test 17 to verify all functions work together
+3. **Regression Test**: Verify `t.*` functions still work correctly
+4. **Target**: Test 17 should pass, moving from 25/27 to 26/27 tests passing
+
+### **Task 2.3: Partial Application Support Implementation** 🔄 **IN PROGRESS**
+
+#### **Problem Analysis**
+The current function call mechanism returns `VAL_NIL` when a function is called with fewer arguments than required. Test 17 expects partial application behavior where:
+- `add_to_ten : add 10;` should create a function that adds 10 to its argument
+- `each add_to_ten numbers` should work with the partially applied function
+
+#### **Implementation Steps**
+1. **Modify `baba_yaga_function_call`** in `src/function.c`:
+   - When `arg_count < func_value->required_params`, create a new function
+   - Bind the provided arguments to the new function
+   - Return the new function instead of `VAL_NIL`
+
+2. **Create Partial Function Structure**:
+   - Store original function and bound arguments
+   - When partial function is called, combine bound args with new args
+   - Call original function with complete argument set
+
+3. **Update Function Value Structure**:
+   - Add support for partial functions in `FunctionValue`
+   - Handle partial function cleanup in memory management
+
+#### **Reference Implementation**
+Use `stdlib_compose` as a template for function composition and partial application patterns.
+
+#### **Testing Strategy**
+1. **Unit Test**: Create simple partial application test
+2. **Integration Test**: Verify Test 17 passes with partial application
+3. **Regression Test**: Ensure existing functions still work correctly
\ No newline at end of file