Implement fold expression approach for variadic parameters in compi_lambda

Co-Authored-By: Serg Kryvonos <[email protected]>

Author: devin-ai-integration[bot]

docs/modules/ROOT/pages/development/python_wrapper.adoc

@@ -88,7 +88,7 @@ result2 = lambda_func([2, 5])  # 2*5 + 2 = 12
 
 [NOTE]
 ====
-The `compi_lambda` method currently supports up to 3 variables due to C++ template limitations. For expressions with more variables, use `compile_into_lambda` instead.
+The `compi_lambda` method supports up to 10 variables. For expressions with more variables, use `compile_into_lambda` instead, which has no limit on the number of variables.
 ====
 
 == Implementation Details

omnn/variable/tests/test_compilambda.py

@@ -49,6 +49,22 @@ def test_single_variable_lambda(self):
 
         result = lambda_func([4])
         self.assertEqual(float(result), 17.0)  # 4*4 + 1 = 17
+    
+    def test_multiple_variables_lambda(self):
+        x = variable.Variable()
+        y = variable.Variable()
+        z = variable.Variable()
+        w = variable.Variable()
+        
+        expr = x + y * z + w
+        
+        lambda_func = expr.compi_lambda([x, y, z, w])
+        
+        result = lambda_func([2, 3, 4, 5])
+        self.assertEqual(float(result), 19.0)  # 2 + 3*4 + 5 = 19
+        
+        result = lambda_func([1, 2, 3, 4])
+        self.assertEqual(float(result), 11.0)  # 1 + 2*3 + 4 = 11
 
 if __name__ == "__main__":
     unittest.main()

omnn/variable/valuable.cpp

@@ -177,10 +177,6 @@ BOOST_PYTHON_MODULE(variable)
         "    result = lambda_func([3, 4])  # 3 + 2*4 = 11")
 
         .def("compi_lambda", +[](const Valuable& v, const boost::python::list& variables) {
-            if (len(variables) > 3) {
-                throw std::runtime_error("Currently only supports up to 3 variables due to C++ template limitations");
-            }
-            
             std::vector<Variable> vars;
             for (int i = 0; i < len(variables); ++i) {
                 vars.push_back(extract<Variable>(variables[i]));
@@ -197,29 +193,27 @@ BOOST_PYTHON_MODULE(variable)
                         values.push_back(extract<Valuable>(args[i]));
                     }
 
-                    auto lambda = [&]() {
-                        switch (vars.size()) {
-                            case 1:
-                                return v.CompiLambda(vars[0]);
-                            case 2:
-                                return v.CompiLambda(vars[0], vars[1]);
-                            case 3:
-                                return v.CompiLambda(vars[0], vars[1], vars[2]);
-                            default:
-                                throw std::runtime_error("Unsupported number of variables");
-                        }
-                    }();
+                    auto callCompiLambda = [&v](auto&&... vars) {
+                        return v.CompiLambda(std::forward<decltype(vars)>(vars)...);
+                    };
+                    
+                    auto callLambda = [](auto&& lambda, auto&&... args) {
+                        return lambda(std::forward<decltype(args)>(args)...);
+                    };
 
-                    switch (values.size()) {
-                        case 1:
-                            return lambda(values[0]);
-                        case 2:
-                            return lambda(values[0], values[1]);
-                        case 3:
-                            return lambda(values[0], values[1], values[2]);
-                        default:
-                            throw std::runtime_error("Unsupported number of arguments");
+                    if (vars.size() > 10) {
+                        throw std::runtime_error("Currently only supports up to 10 variables due to implementation constraints");
                     }
+                    
+                    auto invokeLambda = [&]() -> Valuable {
+                        return [&]<size_t... I>(std::index_sequence<I...>) {
+                            auto lambda = callCompiLambda(vars[I]...);
+                            
+                            return callLambda(lambda, values[I]...);
+                        }(std::make_index_sequence<vars.size()>{});
+                    };
+                    
+                    return invokeLambda();
                 }
             );
         },