feat: add pushNumeric, toNumeric and checkNumeric

These functions rely (lightly) on Zig's comptime to minimize some of the
annoying overhead of writing `@intCast` and `@floatCast` all the time by
making those builtins part of the function definition. However, since
those builtins assert in builds with runtime safety enabled, these
functions will crash the program if called with bad Lua input. More
discussion is warranted about the tradeoffs of going this route before
merging.

Resolves #172.

Author: robbielyman

src/lib.zig

@@ -2035,6 +2035,18 @@ pub const Lua = opaque {
         c.lua_pushnil(@ptrCast(lua));
     }
 
+    /// Pushes a numeric type with value `n` onto the stack
+    /// The conversion from the type of `n` to `Integer` or `Number`
+    /// is performed with `@_Cast` so will assert in modes with runtime safety enabled.
+    ///
+    /// * Pops:   `0`
+    /// * Pushes: `1`
+    /// * Errors: `never`
+    pub fn pushNumeric(lua: *Lua, n: anytype) void {
+        if (@typeInfo(@TypeOf(n)) == .int) return lua.pushInteger(@intCast(n));
+        lua.pushNumber(@floatCast(n));
+    }
+
     /// Pushes a float with value `n` onto the stack
     ///
     /// * Pops:   `0`
@@ -2594,6 +2606,19 @@ pub const Lua = opaque {
         c.lua_toclose(@ptrCast(lua), index);
     }
 
+    /// Converts the Lua value at the given `index` to a numeric type;
+    /// if T is an integer type, the Lua value is converted to an integer.
+    /// The conversion from `Integer` or `Number` to T is performed with `@_Cast`,
+    /// which will assert in builds with runtime safety enabled
+    ///
+    /// * Pops:   `0`
+    /// * Pushes: `0`
+    /// * Errors: `never`
+    pub fn toNumeric(lua: *Lua, comptime T: type, index: i32) !T {
+        if (@typeInfo(T) == .int) return @intCast(try lua.toInteger(index));
+        return @floatCast(try lua.toNumber(index));
+    }
+
     /// Converts the Lua value at the given `index` to a signed integer
     /// The Lua value must be an integer, or a number, or a string convertible to an integer
     /// Returns an error if the conversion failed
@@ -3342,6 +3367,19 @@ pub const Lua = opaque {
         c.luaL_checkany(@ptrCast(lua), arg);
     }
 
+    /// Checks whether the function argument `arg` is a numeric type and converts it to type T
+    ///
+    /// The conversion is done with `@intCast` for numeric types,
+    /// so causes an assertion in modes with runtime safety enabled.
+    ///
+    /// * Pops:   `0`
+    /// * Pushes: `0`
+    /// * Errors: `explained in text / on purpose`
+    pub fn checkNumeric(lua: *Lua, comptime T: type, arg: i32) T {
+        if (@typeInfo(T) == .int) return @intCast(lua.checkInteger(arg));
+        return @floatCast(lua.checkNumber(arg));
+    }
+
     /// Checks whether the function argument `arg` is a number and returns this number cast to an i32
     ///
     /// Not available in Lua 5.3 and 5.4

src/tests.zig

@@ -3055,3 +3055,13 @@ test "error union for CFn" {
         try expectEqualStrings("MissingInteger", try lua.toString(-1));
     };
 }
+
+test "pushNumeric and toNumeric" {
+    const lua: *Lua = try .init(testing.allocator);
+    defer lua.deinit();
+
+    const num: u32 = 100;
+    lua.pushNumeric(num);
+    const pull = lua.toNumeric(u32, lua.getTop());
+    try std.testing.expectEqual(num, pull);
+}