refactor(expressions): change parse_with_params to accept enumerable

The parse_with_params method now accepts Enumerable<Element> instead of
variadic arguments. A new expr() convenience function is added to provide
the variadic interface for creating expressions.

This separation allows for more flexible parameter passing while
maintaining a convenient API for common use cases.

BREAKING CHANGE: parse_with_params signature changed from variadic to
Enumerable<Element> parameter

src/lib/Expressions/Convenience.vala

@@ -0,0 +1,8 @@
+
+namespace Invercargill.Expressions {
+
+    public Expression expr(string expression, Element first, ...) throws ExpressionError {
+        return ExpressionParser.parse_with_params(expression, Wrap.va_list<Element>(first, va_list()));
+    }
+
+}

src/lib/Expressions/ExpressionParser.vala

@@ -65,23 +65,17 @@ namespace Invercargill.Expressions {
          * Parameters are referenced using $0, $1, $2, etc. syntax.
          *
          * @param input The expression string to parse
-         * @param ... Element values for $0, $1, $2, etc. (variadic)
+         * @param params Enumerable of Element values for $0, $1, $2, etc.
          * @return The root of the expression tree
          * @throws ExpressionError if parsing fails or parameter index is out of range
          */
-        public static Expression parse_with_params(string input, ...) throws ExpressionError {
+        public static Expression parse_with_params(string input, Enumerable<Element> params) throws ExpressionError {
             var tokenizer = new ExpressionTokenizer(input);
             var tokens = tokenizer.tokenize_all();
             var parser = new ExpressionParser(tokens);
             
-            // Extract variadic arguments
-            var va_list = va_list();
-            var params_list = new Series<Element>();
-            Element? param;
-            while ((param = va_list.arg<Element?>()) != null) {
-                params_list.add(param);
-            }
-            parser._params = params_list.to_array();
+            // Convert enumerable to array for indexed access
+            parser._params = params.to_array();
             
             return parser.parse_expression();
         }

src/lib/meson.build

@@ -144,6 +144,7 @@ sources += files('Operators/Stringify.vala')
 sources += files('Operators/Contain.vala')
 
 sources += files('Expressions/Expression.vala')
+sources += files('Expressions/Convenience.vala')
 sources += files('Expressions/ExpressionError.vala')
 sources += files('Expressions/ExpressionType.vala')
 sources += files('Expressions/ExpressionVisitor.vala')

src/tests/Integration/Expressions.vala

@@ -2174,9 +2174,9 @@ void expression_tests() {
 
     Test.add_func("/invercargill/expressions/parameter_single", () => {
         // Single parameter: $0 > 5
-        var expr = ExpressionParser.parse_with_params("$0 > 5",
-            new NativeElement<int>(10)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<int>(10));
+        var expr = ExpressionParser.parse_with_params("$0 > 5", params);
         var context = new EvaluationContext(new PropertyDictionary());
         var result = expr.evaluate(context);
         
@@ -2187,10 +2187,10 @@ void expression_tests() {
 
     Test.add_func("/invercargill/expressions/parameter_multiple", () => {
         // Multiple parameters: $0 + $1
-        var expr = ExpressionParser.parse_with_params("$0 + $1",
-            new NativeElement<int>(3),
-            new NativeElement<int>(4)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<int>(3));
+        params.add(new NativeElement<int>(4));
+        var expr = ExpressionParser.parse_with_params("$0 + $1", params);
         var context = new EvaluationContext(new PropertyDictionary());
         var result = expr.evaluate(context);
         
@@ -2201,9 +2201,9 @@ void expression_tests() {
 
     Test.add_func("/invercargill/expressions/parameter_with_variable", () => {
         // Parameter with variable: x > $0
-        var expr = ExpressionParser.parse_with_params("x > $0",
-            new NativeElement<int>(5)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<int>(5));
+        var expr = ExpressionParser.parse_with_params("x > $0", params);
         var props = new PropertyDictionary();
         props.set("x", new NativeElement<int>(10));
         var context = new EvaluationContext(props);
@@ -2216,9 +2216,9 @@ void expression_tests() {
 
     Test.add_func("/invercargill/expressions/parameter_string", () => {
         // String parameter: $0 == "hello"
-        var expr = ExpressionParser.parse_with_params("$0 == \"hello\"",
-            new NativeElement<string>("hello")
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<string>("hello"));
+        var expr = ExpressionParser.parse_with_params("$0 == \"hello\"", params);
         var context = new EvaluationContext(new PropertyDictionary());
         var result = expr.evaluate(context);
         
@@ -2230,9 +2230,9 @@ void expression_tests() {
     Test.add_func("/invercargill/expressions/parameter_complex_object", () => {
         // Complex object parameter: $0.name
         var person = new ExprTestPerson("Alice", 30);
-        var expr = ExpressionParser.parse_with_params("$0.name",
-            new NativeElement<ExprTestPerson>(person)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<ExprTestPerson>(person));
+        var expr = ExpressionParser.parse_with_params("$0.name", params);
         var context = new EvaluationContext(new PropertyDictionary());
         var result = expr.evaluate(context);
         
@@ -2243,9 +2243,9 @@ void expression_tests() {
 
     Test.add_func("/invercargill/expressions/parameter_in_ternary", () => {
         // Parameter in ternary: $0 ? "yes" : "no"
-        var expr = ExpressionParser.parse_with_params("$0 ? \"yes\" : \"no\"",
-            new NativeElement<bool>(true)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<bool>(true));
+        var expr = ExpressionParser.parse_with_params("$0 ? \"yes\" : \"no\"", params);
         var context = new EvaluationContext(new PropertyDictionary());
         var result = expr.evaluate(context);
         
@@ -2261,9 +2261,9 @@ void expression_tests() {
         persons.add(new ExprTestPerson("Bob", 25, 1));
         persons.add(new ExprTestPerson("Charlie", 35, 3));
         
-        var expr = ExpressionParser.parse_with_params("items.where(i => i.rank > $0)",
-            new NativeElement<int>(2)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<int>(2));
+        var expr = ExpressionParser.parse_with_params("items.where(i => i.rank > $0)", params);
         var props = new PropertyDictionary();
         props.set("items", new NativeElement<Enumerable<ExprTestPerson>?>(persons));
         var context = new EvaluationContext(props);
@@ -2279,10 +2279,10 @@ void expression_tests() {
 
     Test.add_func("/invercargill/expressions/parameter_range_check", () => {
         // Range check with two parameters: $0 <= x && x <= $1
-        var expr = ExpressionParser.parse_with_params("$0 <= x && x <= $1",
-            new NativeElement<int>(0),
-            new NativeElement<int>(100)
-        );
+        var params = new Series<Element>();
+        params.add(new NativeElement<int>(0));
+        params.add(new NativeElement<int>(100));
+        var expr = ExpressionParser.parse_with_params("$0 <= x && x <= $1", params);
         var props = new PropertyDictionary();
         props.set("x", new NativeElement<int>(50));
         var context = new EvaluationContext(props);