Merge pull request #198 from ryanbreen/feat/breenish-phase5-editing

feat: add array HOF methods, line editing, and history

Author: ryanbreen

docs/planning/BREENISH_SHELL_PLAN.md

@@ -48,7 +48,13 @@
   - env() native function: get/set/enumerate environment variables
   - source command: load and evaluate script files in current context
   - .bshrc startup script: auto-loads /etc/bshrc on REPL start
-  - 134 passing tests, bsh v0.5.0 with full shell builtins
+  - Array HOF methods: map, filter, reduce, forEach, find, some, every, flat
+  - call_function_sync helper for synchronous callback invocation
+  - Single-parameter arrow functions without parens: `x => expr`
+  - Interactive line editing: cursor movement, Home/End, Ctrl+A/E/U/K/W/C/D
+  - Command history with Up/Down arrow navigation
+  - Raw mode terminal handling via libbreenix termios
+  - 149 passing tests, bsh v0.5.0 with full shell builtins
 - **Phase 6**: PLANNED -- Advanced features (class, Proxy, JIT)
 
 ## Architecture

libs/breenish-js/src/compiler.rs

@@ -1274,9 +1274,13 @@ impl<'a> Compiler<'a> {
 
         if let TokenKind::Identifier(name) = &tok.kind {
             let name = name.clone();
-            // Look ahead for assignment operator
+            // Look ahead for assignment operator or arrow function
             let next = self.lexer.peek_ahead(1);
             match &next.kind {
+                TokenKind::Arrow => {
+                    // Single-param arrow function without parens: x => expr
+                    return self.compile_arrow_function_single_param();
+                }
                 TokenKind::Assign => {
                     self.lexer.next_token(); // consume identifier
                     self.lexer.next_token(); // consume '='
@@ -2253,6 +2257,88 @@ impl<'a> Compiler<'a> {
         Ok(())
     }
 
+    /// Compile an arrow function with a single parameter and no parens: x => expr
+    fn compile_arrow_function_single_param(&mut self) -> JsResult<()> {
+        // Current token is the identifier (param name)
+        let tok = self.lexer.next_token().clone();
+        let param_name = match &tok.kind {
+            TokenKind::Identifier(n) => n.clone(),
+            _ => {
+                return Err(JsError::syntax(
+                    "expected parameter name",
+                    tok.span.line,
+                    tok.span.column,
+                ));
+            }
+        };
+        self.lexer.expect(&TokenKind::Arrow)?;
+
+        // Push current context onto the function stack
+        let parent_ctx = FunctionContext {
+            code: core::mem::replace(&mut self.code, CodeBlock::new("<arrow>")),
+            scopes: core::mem::replace(
+                &mut self.scopes,
+                vec![Scope {
+                    locals: Vec::new(),
+                    base_slot: 0,
+                }],
+            ),
+            next_slot: self.next_slot,
+            loop_stack: core::mem::take(&mut self.loop_stack),
+            upvalues: core::mem::take(&mut self.upvalues),
+            is_async: self.is_async,
+        };
+        self.function_stack.push(parent_ctx);
+        self.next_slot = 0;
+
+        // Declare the single parameter as a local
+        self.declare_local(param_name, false);
+
+        // Compile body: either a block or a single expression
+        if self.lexer.peek().kind == TokenKind::LeftBrace {
+            // Block body: { statements }
+            self.lexer.next_token(); // consume '{'
+            while self.lexer.peek().kind != TokenKind::RightBrace
+                && self.lexer.peek().kind != TokenKind::Eof
+            {
+                self.compile_statement()?;
+            }
+            self.lexer.expect(&TokenKind::RightBrace)?;
+            // Implicit undefined return if no explicit return
+            self.emit_undefined();
+            self.code.emit_op(Op::Return);
+        } else {
+            // Expression body: the expression result is the return value
+            self.compile_assignment()?;
+            self.code.emit_op(Op::Return);
+        }
+
+        self.code.local_count = self.next_slot;
+
+        // Collect upvalues
+        let func_upvalues = core::mem::take(&mut self.upvalues);
+
+        // Restore parent context
+        let parent_ctx = self.function_stack.pop().unwrap();
+        let func_code = core::mem::replace(&mut self.code, parent_ctx.code);
+        self.scopes = parent_ctx.scopes;
+        self.next_slot = parent_ctx.next_slot;
+        self.loop_stack = parent_ctx.loop_stack;
+        self.upvalues = parent_ctx.upvalues;
+        self.is_async = parent_ctx.is_async;
+
+        let func_index = self.functions.len();
+        self.functions.push(func_code);
+
+        if func_upvalues.is_empty() {
+            let const_idx = self.code.add_constant(Constant::Function(func_index as u32));
+            self.code.emit_op_u16(Op::LoadConst, const_idx);
+        } else {
+            self.emit_create_closure(func_index, &func_upvalues);
+        }
+        Ok(())
+    }
+
     /// Compile an async arrow function: async (params) => expr  or  async (params) => { body }
     /// The 'async' token has already been consumed.
     fn compile_async_arrow_function(&mut self) -> JsResult<()> {

libs/breenish-js/src/lib.rs

@@ -1390,6 +1390,129 @@ mod tests {
         );
     }
 
+    // --- Higher-order array method tests ---
+
+    #[test]
+    fn test_array_map() {
+        assert_eq!(
+            eval_and_capture("let a = [1, 2, 3].map(x => x * 2); print(a);"),
+            "2,4,6\n"
+        );
+    }
+
+    #[test]
+    fn test_array_map_with_index() {
+        assert_eq!(
+            eval_and_capture("let a = [10, 20, 30].map((x, i) => x + i); print(a);"),
+            "10,21,32\n"
+        );
+    }
+
+    #[test]
+    fn test_array_filter() {
+        assert_eq!(
+            eval_and_capture("let a = [1, 2, 3, 4, 5].filter(x => x > 3); print(a);"),
+            "4,5\n"
+        );
+    }
+
+    #[test]
+    fn test_array_reduce() {
+        assert_eq!(
+            eval_and_capture("let r = [1, 2, 3].reduce((acc, x) => acc + x, 0); print(r);"),
+            "6\n"
+        );
+    }
+
+    #[test]
+    fn test_array_reduce_no_initial() {
+        assert_eq!(
+            eval_and_capture("let r = [1, 2, 3, 4].reduce((acc, x) => acc + x); print(r);"),
+            "10\n"
+        );
+    }
+
+    #[test]
+    fn test_array_foreach() {
+        // Use an array to accumulate results since closures capture by value
+        assert_eq!(
+            eval_and_capture("let result = []; [1, 2, 3].forEach(x => { result.push(x * 10); }); print(result);"),
+            "10,20,30\n"
+        );
+    }
+
+    #[test]
+    fn test_array_find() {
+        assert_eq!(
+            eval_and_capture("let r = [1, 2, 3, 4].find(x => x > 2); print(r);"),
+            "3\n"
+        );
+    }
+
+    #[test]
+    fn test_array_find_not_found() {
+        assert_eq!(
+            eval_and_capture("let r = [1, 2, 3].find(x => x > 10); print(r);"),
+            "undefined\n"
+        );
+    }
+
+    #[test]
+    fn test_array_some() {
+        assert_eq!(
+            eval_and_capture("print([1, 2, 3].some(x => x > 2));"),
+            "1\n"
+        );
+    }
+
+    #[test]
+    fn test_array_some_false() {
+        assert_eq!(
+            eval_and_capture("print([1, 2, 3].some(x => x > 10));"),
+            "0\n"
+        );
+    }
+
+    #[test]
+    fn test_array_every() {
+        assert_eq!(
+            eval_and_capture("print([1, 2, 3].every(x => x > 0));"),
+            "1\n"
+        );
+    }
+
+    #[test]
+    fn test_array_every_false() {
+        assert_eq!(
+            eval_and_capture("print([1, 2, 3].every(x => x > 2));"),
+            "0\n"
+        );
+    }
+
+    #[test]
+    fn test_array_flat() {
+        assert_eq!(
+            eval_and_capture("let a = [1, [2, 3], [4, 5]].flat(); print(a);"),
+            "1,2,3,4,5\n"
+        );
+    }
+
+    #[test]
+    fn test_array_flat_deep() {
+        assert_eq!(
+            eval_and_capture("let a = [1, [2, [3, [4]]]].flat(2); print(a);"),
+            "1,2,3,4\n"
+        );
+    }
+
+    #[test]
+    fn test_array_method_chaining() {
+        assert_eq!(
+            eval_and_capture("let r = [1, 2, 3, 4, 5].filter(x => x > 2).map(x => x * 10); print(r);"),
+            "30,40,50\n"
+        );
+    }
+
     // --- String method tests ---
 
     #[test]