From 5ad44c14b0c1f8e55856a8f048a570dad564c231 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 1 Nov 2024 11:57:39 -0700
Subject: [PATCH] std.hash.int: use anytype instead of explicit type parameter

also
* allow signed ints, simply bitcast them to unsigned
* handle odd bit sizes by upcasting and then truncating
* naming conventions
* remove redundant code
* better use of testing API
---
 lib/std/hash.zig | 75 ++++++++++++++++++++++++++----------------------
 1 file changed, 40 insertions(+), 35 deletions(-)

diff --git a/lib/std/hash.zig b/lib/std/hash.zig
index 68adb1afdd..b768a85861 100644
--- a/lib/std/hash.zig
+++ b/lib/std/hash.zig
@@ -37,25 +37,31 @@ pub const XxHash3 = xxhash.XxHash3;
 pub const XxHash64 = xxhash.XxHash64;
 pub const XxHash32 = xxhash.XxHash32;
 
-/// Deprecated: use std.hash.int(comptime T, input T) T where T is an unsigned integer type.
-/// This is handy if you have a u32 and want a u32 and don't want to take a
-/// detour through many layers of abstraction elsewhere in the std.hash
-/// namespace.
+/// Deprecated in favor of `int`.
 pub fn uint32(input: u32) u32 {
-    return int(u32, input);
+    return int(input);
 }
 
 /// Applies a bit-mangling transformation to an unsigned integer type `T`.
 /// Optimized per type: for `u16` and `u32`, Skeeto's xorshift-multiply; for `u64`, Maiga's mx3.
-/// Falls back on an avalanche pattern for other unsigned types, ensuring high entropy.
-/// Only unsigned types are accepted; signed types will raise a compile-time error.
-pub fn int(comptime T: type, input: T) T {
-    const tInfo = @typeInfo(T).int;
-    if (tInfo.signedness != .unsigned) @compileError("type has to be unsigned integer");
+/// Falls back on an avalanche pattern for other integer types, ensuring high entropy.
+pub fn int(input: anytype) @TypeOf(input) {
+    const info = @typeInfo(@TypeOf(input)).int;
+    if (info.signedness == .signed) {
+        const Unsigned = @Type(.{ .int = .{ .signedness = .unsigned, .bits = info.bits } });
+        const casted: Unsigned = @bitCast(input);
+        return @bitCast(int(casted));
+    } else if (info.bits < 16) {
+        return @truncate(int(@as(u16, input)));
+    } else if (info.bits < 32) {
+        return @truncate(int(@as(u32, input)));
+    } else if (info.bits < 64) {
+        return @truncate(int(@as(u64, input)));
+    }
     var x = input;
-    switch (T) {
-        u16 => {
-            //https://github.com/skeeto/hash-prospector
+    switch (info.bits) {
+        16 => {
+            // https://github.com/skeeto/hash-prospector
             // 3-round xorshift-multiply (-Xn3)
             // bias = 0.0045976709018820602
             x = (x ^ (x >> 7)) *% 0x2993;
@@ -63,36 +69,34 @@ pub fn int(comptime T: type, input: T) T {
             x = (x ^ (x >> 9)) *% 0x0235;
             x = x ^ (x >> 10);
         },
-        u32 => {
+        32 => {
             // https://github.com/skeeto/hash-prospector
             x = (x ^ (x >> 17)) *% 0xed5ad4bb;
             x = (x ^ (x >> 11)) *% 0xac4c1b51;
             x = (x ^ (x >> 15)) *% 0x31848bab;
             x = x ^ (x >> 14);
         },
-        u64 => {
+        64 => {
             // https://github.com/jonmaiga/mx3
             // https://github.com/jonmaiga/mx3/blob/48924ee743d724aea2cafd2b4249ef8df57fa8b9/mx3.h#L17
-            const C = 0xbea225f9eb34556d;
-            x = (x ^ (x >> 32)) *% C;
-            x = (x ^ (x >> 29)) *% C;
-            x = (x ^ (x >> 32)) *% C;
+            const c = 0xbea225f9eb34556d;
+            x = (x ^ (x >> 32)) *% c;
+            x = (x ^ (x >> 29)) *% c;
+            x = (x ^ (x >> 32)) *% c;
             x = x ^ (x >> 29);
         },
         else => {
-            // this construction provides robust avalanche properties, but it is not optimal for any given size.
-            const Tsize = @bitSizeOf(T);
-            if (Tsize < 4) @compileError("not implemented.");
-            const hsize = Tsize >> 1;
-            const C = comptime blk: {
-                const max = (1 << Tsize) - 1;
+            // This construction provides robust avalanche properties, but it is not optimal for any given size.
+            const hsize = info.bits >> 1;
+            const c = comptime blk: {
+                const max = (1 << info.bits) - 1;
                 var mul = 1;
                 while (mul * 3 < max) mul *= 3;
                 break :blk ((mul ^ (mul >> hsize)) | 1);
             };
             inline for (0..2) |_| {
-                x = (x ^ (x >> hsize + 1)) *% C;
-                x = (x ^ (x >> hsize - 1)) *% C;
+                x = (x ^ (x >> hsize + 1)) *% c;
+                x = (x ^ (x >> hsize - 1)) *% c;
             }
             x ^= (x >> hsize);
         },
@@ -100,14 +104,15 @@ pub fn int(comptime T: type, input: T) T {
     return x;
 }
 
-test "bit manglers" {
-    const expect = @import("std").testing.expect;
-    try expect(int(u4, 1) == 0xC);
-    try expect(int(u8, 1) == 0x4F);
-    try expect(int(u16, 1) == 0x2880);
-    try expect(int(u32, 1) == 0x42741D6);
-    try expect(int(u64, 1) == 0x71894DE00D9981F);
-    try expect(int(u128, 1) == 0x50BC2BB18910C3DE0BAA2CE0D0C5B83E);
+test int {
+    const expectEqual = @import("std").testing.expectEqual;
+    try expectEqual(0xC, int(@as(u4, 1)));
+    try expectEqual(0x4F, int(@as(u8, 1)));
+    try expectEqual(0x4F, int(@as(i8, 1)));
+    try expectEqual(0x2880, int(@as(u16, 1)));
+    try expectEqual(0x42741D6, int(@as(u32, 1)));
+    try expectEqual(0x71894DE00D9981F, int(@as(u64, 1)));
+    try expectEqual(0x50BC2BB18910C3DE0BAA2CE0D0C5B83E, int(@as(u128, 1)));
 }
 
 test {