gh-12: Fix optional kwargs.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -280,7 +280,7 @@
 
 In addition to named functions, the language provides an anonymous function literal form `LAMBDA` which constructs a `FUNC` value without binding it to a function name in the global function table. The syntax is `LAMBDA(T1: arg1, T2: arg2, ..., TN: argN):R{ block }`. Parameter typing, default-value rules, call semantics, and return-type rules are the same as for `FUNC`. Evaluating a `LAMBDA` expression captures (closes over) the current lexical environment, producing a first-class `FUNC` value that can be assigned to variables, stored in tensors, passed as an argument, or returned.
 
-A user-defined function is called with the same syntax as a built-in: `callee(expr1, expr2, ..., exprN)`. The callee may be any expression that evaluates to `FUNC`, including identifiers, tensor elements, or intermediate expressions. Calls may supply zero or more positional arguments (left-to-right) followed by zero or more keyword arguments of the form `param=expr`. Keyword arguments can only appear after all positional arguments. At the call site, every positional argument is bound to the next positional parameter; keyword arguments must match the name of a parameter that declared a default value. Duplicate keyword names, supplying too many positional arguments, or providing a keyword for an unknown parameter are runtime errors. If a keyword-capable parameter is omitted from the call, its default expression is evaluated at call time in the function's lexical environment after earlier parameters have been bound. The evaluated default must match the parameter's declared type. Built-in functions do not accept keyword arguments except that `READFILE` and `WRITEFILE` allow a single optional `coding=` keyword; attempting to pass any other keyword raises a runtime error. Arguments are evaluated left-to-right. The function body executes in a new environment (activation record) that closes over the defining environment. If a `RETURN(v)` statement is executed, the function terminates immediately and yields `v`; the returned value must match the declared return type. If control reaches the end of the body without `RETURN`, the function returns a default value of the declared return type (0 for `INT`, 0.0 for `FLT`, "" for `STR`). Functions whose return type is `TNS` or `FUNC` must execute an explicit `RETURN` of the declared type; reaching the end of the body without returning is a runtime error for `TNS`- or `FUNC`-returning functions.
+A user-defined function is called with the same syntax as a built-in: `callee(expr1, expr2, ..., exprN)`. The callee may be any expression that evaluates to `FUNC`, including identifiers, tensor elements, or intermediate expressions. Calls may supply zero or more positional arguments (left-to-right) followed by zero or more keyword arguments of the form `param=expr`. Keyword arguments can only appear after all positional arguments. At the call site, every positional argument is bound to the next positional parameter; keyword arguments must match the name of a parameter that declared a default value. Duplicate keyword names, supplying too many positional arguments, or providing a keyword for an unknown parameter are runtime errors. If a keyword-capable parameter is omitted from the call, its default expression is evaluated at call time in the function's lexical environment after earlier parameters have been bound. The evaluated default must match the parameter's declared type. Arguments are evaluated left-to-right. The function body executes in a new environment (activation record) that closes over the defining environment. If a `RETURN(v)` statement is executed, the function terminates immediately and yields `v`; the returned value must match the declared return type. If control reaches the end of the body without `RETURN`, the function returns a default value of the declared return type (0 for `INT`, 0.0 for `FLT`, "" for `STR`). Functions whose return type is `TNS` or `FUNC` must execute an explicit `RETURN` of the declared type; reaching the end of the body without returning is a runtime error for `TNS`- or `FUNC`-returning functions.
 
 Because `FUNC` is a first-class type, functions can be assigned to variables, stored inside tensors, passed as arguments, or returned from other functions. Calling `alias()` invokes the function bound to `alias`, while `tns[1]()` invokes the `FUNC` stored in the first tensor slot. Equality compares identity: two `FUNC` values are equal only if they refer to the same function object.
 
@@ -810,7 +810,7 @@
 
 ### 12.14 Rounding
 
-- `ROUND(FLT: float, STR: mode="floor", INT: ndigits=0):FLT` - Round `float` to `ndigits` places right of the radix point (binary places; `ndigits` may be negative). When exactly two arguments are supplied and the second is an `INT`, it is treated as `ndigits` with the mode defaulting to `"floor"`. Modes are:
+- `ROUND(FLT: float, STR: mode = "floor", INT: ndigits = 0):FLT` - Round `float` to `ndigits` places right of the radix point (binary places; `ndigits` may be negative). When exactly two arguments are supplied and the second is an `INT`, it is treated as `ndigits` with the mode defaulting to `"floor"`. Modes are:
 
   - `"floor"` - round toward -∞
 

src/interpreter.c

@@ -795,6 +795,31 @@ Value eval_expr(Interpreter* interp, Expr* expr, Env* env) {
                 }
             }
 
+            // Count positional-only parameters (those without a default value).
+            // Per spec: "A parameter without a default is positional; a parameter
+            // with a default is keyword-capable." Positional arguments may only
+            // bind to positional parameters.
+            int num_pos_params = 0;
+            for (size_t pi = 0; pi < user_func->params.count; pi++) {
+                if (!user_func->params.items[pi].default_value) num_pos_params++;
+                else break; // positional params must precede keyword-capable ones
+            }
+
+            if (pos_argc > num_pos_params) {
+                char buf[128];
+                snprintf(buf, sizeof(buf), "Too many positional arguments for '%s'",
+                         user_func->name ? user_func->name : "<lambda>");
+                interp->error = strdup(buf);
+                interp->error_line = expr->line;
+                interp->error_col = expr->column;
+                for (int t = 0; t < pos_argc; t++) value_free(pos_vals[t]);
+                free(pos_vals);
+                for (int t = 0; t < kwc; t++) value_free(kw_vals[t]);
+                free(kw_vals);
+                if (kw_used) free(kw_used);
+                return value_null();
+            }
+
             // Create new environment for function call
             Env* call_env = env_create(user_func->closure);
 

test2.pre

@@ -605,7 +605,7 @@ FUNC GREET(STR: name, STR: prefix = "Hello"):STR{
     RETURN(JOIN(" ", prefix, name))
 }
 ASSERT(EQ(GREET("World"), "Hello World"))
-ASSERT(EQ(GREET("World", "Hi"), "Hi World"))
+ASSERT(EQ(GREET("World", prefix = "Hi"), "Hi World"))
 PRINT("Functions: PASS\n")
 
 PRINT("Testing SIGNATURE...")