Use tuples as closure param

Signed-off-by: Maksym Pavlenko <pavlenko.maksym@gmail.com>

Author: mxpv

README.md

@@ -138,6 +138,21 @@ pub fn main() !void {
     // Call Lua function from Zig
     const result2 = try lua.globals().call("multiply", .{6, 7}, i32);
     assert(result2 == 42);
+
+    // Closures with captured values
+    const table = lua.createTable(.{});
+    defer table.deinit();
+    
+    fn getGlobal(lua_ptr: *luaz.Lua, key: []const u8) !i32 {
+        return try lua_ptr.globals().get(key, i32) orelse 0;
+    }
+    const lua_ptr = @constCast(&lua);
+    try table.setClosure("getGlobal", .{lua_ptr}, getGlobal);
+    try lua.globals().set("funcs", table);
+    try lua.globals().set("myValue", @as(i32, 123));
+    
+    const result3 = try lua.eval("return funcs.getGlobal('myValue')", .{}, i32);
+    assert(result3 == 123);
 }
 ```
 

src/lua.zig

@@ -406,10 +406,15 @@ pub const Lua = struct {
         /// - `upvalues`: Values to be captured as upvalues (single value or tuple)
         /// - `func`: A Zig function that accepts upvalues as its first parameter
         ///
-        /// Example:
+        /// Examples:
         /// ```zig
-        /// fn scaledAdd(upvalues: struct { scale: f32, offset: f32 }, x: f32) f32 {
-        ///     return x * upvalues.scale + upvalues.offset;
+        /// // Single upvalue
+        /// fn add(increment: i32, x: i32) i32 { return x + increment; }
+        /// try table.setClosure("add5", .{5}, add);
+        ///
+        /// // Multiple upvalues (tuple)
+        /// fn scaledAdd(upvals: struct { f32, f32 }, x: f32) f32 {
+        ///     return x * upvals[0] + upvals[1];
         /// }
         /// try table.setClosure("transform", .{ 2.0, 10.0 }, scaledAdd);
         /// ```

src/stack.zig

@@ -306,11 +306,21 @@ pub fn createFunc(_: Lua, value: anytype, comptime ClosureType: ?type) State.CFu
             const arg_start_idx = if (has_upvalues) blk: {
                 // First parameter is upvalues - populate from upvalue indices
                 const CT = ClosureType.?;
-                const upvalues_fields = std.meta.fields(CT);
-                inline for (upvalues_fields, 0..) |field, i| {
-                    const idx = State.upvalueIndex(@intCast(i + 1));
-                    @field(args[0], field.name) = toValue(l, field.type, idx) orelse
-                        l.state.typeError(idx, @typeName(field.type));
+                const ct_info = @typeInfo(CT);
+
+                if (ct_info == .@"struct" and ct_info.@"struct".is_tuple) {
+                    // Multiple upvalues as tuple
+                    const upvalues_fields = std.meta.fields(CT);
+                    inline for (upvalues_fields, 0..) |field, i| {
+                        const idx = State.upvalueIndex(@intCast(i + 1));
+                        args[0][i] = toValue(l, field.type, idx) orelse
+                            l.state.typeError(idx, @typeName(field.type));
+                    }
+                } else {
+                    // Single upvalue
+                    const idx = State.upvalueIndex(1);
+                    args[0] = toValue(l, CT, idx) orelse
+                        l.state.typeError(idx, @typeName(CT));
                 }
                 break :blk 1; // Start stack args from index 1, skip upvalue parameter
             } else blk: {

src/tests.zig

@@ -1365,29 +1365,33 @@ test "table readonly" {
     try expect(try table.get("after", ?i32) == null);
 }
 
-fn closureAdd5(upv: struct { n: i32 }, x: i32) i32 {
-    return x + upv.n;
+fn closureAdd5(n: i32, x: i32) i32 {
+    return x + n;
 }
 
-fn closureTransform(upv: struct { a: f32, b: f32 }, x: f32) f32 {
-    return x * upv.a + upv.b;
+fn closureTransform(upv: struct { f32, f32 }, x: f32) f32 {
+    return x * upv[0] + upv[1];
 }
 
-fn closureOptAdd(upv: struct { thresh: i32 }, x: i32, y: ?i32) i32 {
-    return if (x > upv.thresh) x + (y orelse 0) else x;
+fn closureOptAdd(thresh: i32, x: i32, y: ?i32) i32 {
+    return if (x > thresh) x + (y orelse 0) else x;
 }
 
-fn closureMultiply(upv: struct { cfg: Lua.Table }, x: i32) !i32 {
-    const m = try upv.cfg.get("mult", i32) orelse 1;
+fn closureMultiply(cfg: Lua.Table, x: i32) !i32 {
+    const m = try cfg.get("mult", i32) orelse 1;
     return x * m;
 }
 
-fn closureConstant(upv: struct { val: i32 }) i32 {
-    return upv.val;
+fn closureConstant(val: i32) i32 {
+    return val;
 }
 
-fn closureSumAll(upv: struct { base: i32 }, a: ?i32, b: ?i32) i32 {
-    return upv.base + (a orelse 0) + (b orelse 0);
+fn closureSumAll(base: i32, a: ?i32, b: ?i32) i32 {
+    return base + (a orelse 0) + (b orelse 0);
+}
+
+fn closureSingle(increment: i32, x: i32) i32 {
+    return x + increment;
 }
 
 test "table setClosure" {
@@ -1418,6 +1422,9 @@ test "table setClosure" {
     // Multiple optionals
     try table.setClosure("sum", .{100}, closureSumAll);
 
+    // Single upvalue (not wrapped in struct)
+    try table.setClosure("single", .{42}, closureSingle);
+
     try lua.globals().set("f", table);
     try lua.globals().set("config", config);
 
@@ -1431,6 +1438,7 @@ test "table setClosure" {
     try expect(try lua.eval("return f.const()", .{}, i32) == 42);
     try expect(try lua.eval("return f.sum()", .{}, i32) == 100);
     try expect(try lua.eval("return f.sum(1, 2)", .{}, i32) == 103);
+    try expect(try lua.eval("return f.single(8)", .{}, i32) == 50);
 
     // Test config modification
     _ = try lua.eval("config.mult = 7", .{}, void);