feat: implement arrow functions and array higher-order methods

Major Features:
- Arrow function support with lambda generation
- Array methods: forEach, find, findIndex, some, every, includes
- Enhanced destructuring with object rest properties
- Spread operator for arrays with concatenation
- C++ reserved keyword escaping

Runtime Enhancements:
- Added arithmetic operators to js::any (*, /, -, %)
- Added comparison operators to js::any (>, <, >=, <=, ==, !=)
- Fixed object rest properties using lambda wrappers
- Added entries() method to js::object

Quality Improvements:
- Better array method detection in code generator
- Improved identifier mapping for reserved words
- Corrected === operator mapping to ==
- Version bump to 0.7.0

Author: danielsreichenbach

RELEASE_NOTES_v0.7.x.md

@@ -0,0 +1,99 @@
+# Release Notes - v0.7.x Series
+
+## Version 0.7.0 - Arrow Functions and Array Methods (2025-01-14)
+
+Major update introducing arrow functions and comprehensive array higher-order methods support.
+
+### Added
+
+#### Arrow Functions
+- Full arrow function support with lambda generation
+- Lexical `this` binding with capture modes
+- Single expression and block body syntax
+- Type inference for arrow function parameters
+- Proper return type deduction
+
+#### Array Higher-Order Methods
+- `forEach()` - Execute function for each element
+- `find()` - Find first element matching predicate
+- `findIndex()` - Find index of first matching element
+- `some()` - Test if at least one element matches
+- `every()` - Test if all elements match
+- `includes()` - Check if array contains value
+- Enhanced `map()`, `filter()`, `reduce()` with js::any support
+
+#### Destructuring Enhancements
+- Object rest properties (`const { a, ...rest } = obj`)
+- Array rest elements (`const [first, ...rest] = arr`)
+- Lambda-wrapped rest object generation for global scope
+- Proper entries() method for object iteration
+
+#### Spread Operator
+- Array spread in array literals (`[...arr1, ...arr2]`)
+- Concatenation support for spread operations
+- Empty array handling with explicit type specification
+
+### Fixed
+
+#### Code Generation
+- C++ reserved keywords now properly escaped with underscore suffix
+- Variable names checked against full C++ keyword list
+- Fixed object rest properties at global scope using lambda wrappers
+- Corrected === and !== operator mapping to == and !=
+
+#### Runtime Library
+- Added missing arithmetic operators to js::any (*, /, -, %)  
+- Added comparison operators to js::any (>, <, >=, <=, ==, !=)
+- Added operator overloads for js::any with js::number
+- Enhanced js::any to delegate array methods to underlying arrays
+- Added entries() method to js::object for iteration
+
+### Enhanced
+
+#### Developer Experience
+- Better array method detection in code generator
+- Improved identifier mapping for reserved words
+- More comprehensive operator support in runtime
+- Cleaner lambda generation for complex patterns
+
+### Technical Details
+
+#### Runtime Additions
+```cpp
+// New array methods in js::array<T>
+template<typename Func> void forEach(Func&& func) const;
+template<typename Func> T find(Func&& func) const;
+template<typename Func> int findIndex(Func&& func) const;
+template<typename Func> bool some(Func&& func) const;
+template<typename Func> bool every(Func&& func) const;
+bool includes(const T& value) const;
+
+// New operators in js::any
+any operator*(const number& other) const;
+any operator/(const number& other) const;
+any operator-(const number& other) const;
+any operator%(const number& other) const;
+bool operator>(const number& other) const;
+bool operator<(const number& other) const;
+bool operator>=(const number& other) const;
+bool operator<=(const number& other) const;
+bool operator==(const number& other) const;
+bool operator!=(const number& other) const;
+```
+
+#### Breaking Changes
+None - All changes are additive or bug fixes.
+
+### Known Limitations
+
+- Lambda functions cannot be directly stored as js::any (need std::function wrapper)
+- Some complex arrow function patterns may require manual adjustment
+- Object rest iteration requires C++17 structured bindings
+
+### Migration Guide
+
+No migration required. Existing code continues to work with enhanced functionality available.
+
+### Contributors
+
+This release represents significant progress in JavaScript feature parity, bringing modern array operations and arrow functions to the C++ transpilation.

TODO.md

@@ -4,7 +4,7 @@ This document tracks planned features and known issues for typescript2cxx.
 
 ## 📊 Implementation Status Summary
 
-**Current Version: v0.5.3**
+**Current Version: v0.7.0-dev**
 
 ### Overall Progress
 

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@wowemulation-dev/typescript2cxx",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "MIT OR Apache-2.0",
   "exports": {
     ".": "./src/mod.ts",

runtime/core.h

@@ -228,6 +228,68 @@ class array {
         std::vector<T> sliced(elements_.begin() + start, elements_.begin() + actualEnd);
         return array<T>(sliced);
     }
+    
+    // forEach method - executes a function for each element
+    template<typename Func>
+    void forEach(Func&& func) const {
+        for (const auto& elem : elements_) {
+            func(elem);
+        }
+    }
+    
+    // find method - returns first element that satisfies the predicate
+    template<typename Func>
+    T find(Func&& func) const {
+        for (const auto& elem : elements_) {
+            if (func(elem)) {
+                return elem;
+            }
+        }
+        return T(); // Return default value if not found
+    }
+    
+    // findIndex method - returns index of first element that satisfies the predicate
+    template<typename Func>
+    int findIndex(Func&& func) const {
+        for (size_t i = 0; i < elements_.size(); ++i) {
+            if (func(elements_[i])) {
+                return static_cast<int>(i);
+            }
+        }
+        return -1; // Return -1 if not found
+    }
+    
+    // some method - tests whether at least one element passes the test
+    template<typename Func>
+    bool some(Func&& func) const {
+        for (const auto& elem : elements_) {
+            if (func(elem)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    // every method - tests whether all elements pass the test
+    template<typename Func>
+    bool every(Func&& func) const {
+        for (const auto& elem : elements_) {
+            if (!func(elem)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    // includes method - checks if array includes a certain value
+    bool includes(const T& value) const {
+        for (const auto& elem : elements_) {
+            if (elem == value) {
+                return true;
+            }
+        }
+        return false;
+    }
 };
 
 // Object class for JavaScript objects
@@ -261,6 +323,11 @@ class object {
     bool has(const std::string& key) const {
         return properties_.find(key) != properties_.end();
     }
+    
+    // Get all entries as a range for iteration
+    const std::unordered_map<std::string, std::any>& entries() const {
+        return properties_;
+    }
 };
 
 // Console class
@@ -466,8 +533,159 @@ class any {
         return any(toString() + other);
     }
 
+    // Arithmetic operators with numbers
+    any operator*(const number& other) const {
+        if (is<number>()) {
+            return any(number(get<number>().value() * other.value()));
+        }
+        return undefined;
+    }
+    
+    any operator/(const number& other) const {
+        if (is<number>()) {
+            return any(number(get<number>().value() / other.value()));
+        }
+        return undefined;
+    }
+    
+    any operator-(const number& other) const {
+        if (is<number>()) {
+            return any(number(get<number>().value() - other.value()));
+        }
+        return undefined;
+    }
+    
+    any operator%(const number& other) const {
+        if (is<number>()) {
+            return any(number(std::fmod(get<number>().value(), other.value())));
+        }
+        return undefined;
+    }
+    
+    // Comparison operators
+    bool operator>(const number& other) const {
+        if (is<number>()) {
+            return get<number>().value() > other.value();
+        }
+        return false;
+    }
+    
+    bool operator<(const number& other) const {
+        if (is<number>()) {
+            return get<number>().value() < other.value();
+        }
+        return false;
+    }
+    
+    bool operator>=(const number& other) const {
+        if (is<number>()) {
+            return get<number>().value() >= other.value();
+        }
+        return false;
+    }
+    
+    bool operator<=(const number& other) const {
+        if (is<number>()) {
+            return get<number>().value() <= other.value();
+        }
+        return false;
+    }
+    
+    bool operator==(const number& other) const {
+        if (is<number>()) {
+            return get<number>().value() == other.value();
+        }
+        return false;
+    }
+    
+    bool operator!=(const number& other) const {
+        if (is<number>()) {
+            return get<number>().value() != other.value();
+        }
+        return true;
+    }
+    
     // Property assignment for objects - this method should not be used directly
     // Use explicit assignment through the object reference instead
+    
+    // Array methods - delegate to underlying array if this contains an array
+    template<typename Func>
+    auto map(Func&& func) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().map(std::forward<Func>(func));
+        }
+        return array<any>(); // Return empty array for non-arrays
+    }
+    
+    template<typename Func>
+    auto filter(Func&& func) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().filter(std::forward<Func>(func));
+        }
+        return array<any>(); // Return empty array for non-arrays
+    }
+    
+    template<typename Func, typename Init>
+    auto reduce(Func&& func, Init&& init) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().reduce(std::forward<Func>(func), std::forward<Init>(init));
+        }
+        return init; // Return initial value for non-arrays
+    }
+    
+    template<typename Func>
+    void forEach(Func&& func) const {
+        if (is<array<any>>()) {
+            get<array<any>>().forEach(std::forward<Func>(func));
+        }
+    }
+    
+    template<typename Func>
+    any find(Func&& func) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().find(std::forward<Func>(func));
+        }
+        return undefined; // Return undefined for non-arrays
+    }
+    
+    template<typename Func>
+    number findIndex(Func&& func) const {
+        if (is<array<any>>()) {
+            return number(get<array<any>>().findIndex(std::forward<Func>(func)));
+        }
+        return number(-1); // Return -1 for non-arrays
+    }
+    
+    template<typename Func>
+    bool some(Func&& func) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().some(std::forward<Func>(func));
+        }
+        return false; // Return false for non-arrays
+    }
+    
+    template<typename Func>
+    bool every(Func&& func) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().every(std::forward<Func>(func));
+        }
+        return true; // Return true for non-arrays (vacuous truth)
+    }
+    
+    bool includes(const any& value) const {
+        if (is<array<any>>()) {
+            return get<array<any>>().includes(value);
+        }
+        return false; // Return false for non-arrays
+    }
+    
+    // As object for iteration  
+    object as_object() const {
+        if (is<object>()) {
+            return get<object>();
+        }
+        return object(); // Return empty object for non-objects
+    }
 };
 
 // Typedef for array<any>