- remove custom equal function abstraction (it either was going to be too complicated, or was going to have limitations that made it equivalent to a runtime staticStringMap)

- remove staticArrayMap (and withEql) - YAGNI
- keep only StaticStringMap and StaticStringMapIgnoreCase

Author: RetroDev256

CMakeLists.txt

@@ -479,7 +479,7 @@ set(ZIG_STAGE2_SOURCES
     lib/std/process/Child.zig
     lib/std/sort.zig
     lib/std/start.zig
-    lib/std/static_array_map.zig
+    lib/std/static_string_map.zig
     lib/std/std.zig
     lib/std/time.zig
     lib/std/treap.zig

lib/std/static_array_map.zig renamed to lib/std/static_string_map.zig

@@ -3,50 +3,34 @@ const assert = std.debug.assert;
 
 /// 'comptime' optimized mapping between string keys and associated `V` values.
 pub fn StaticStringMap(comptime V: type) type {
-    return StaticArrayMapWithEql(V, u8, defaultEql);
+    return StaticStringMapWithEql(V, defaultEql);
 }
 
 /// Same as StaticStringMap, except keys are compared case-insensitively.
 pub fn StaticStringMapIgnoreCase(comptime V: type) type {
-    return StaticArrayMapWithEql(V, u8, ignoreCaseEql);
+    return StaticStringMapWithEql(V, ignoreCaseEql);
 }
 
-/// Same as StaticStringMap, but allows you to provide the `eql` function yourself.
-pub fn StaticStringMapWithEql(
-    comptime V: type,
-    comptime eql: fn (comptime anytype, anytype) bool,
-) type {
-    return StaticArrayMapWithEql(V, u8, eql);
-}
-
-/// 'comptime' optimized mapping between `[]const T` keys and associated `V` values.
-pub fn StaticArrayMap(comptime T: type, comptime V: type) type {
-    return StaticArrayMapWithEql(V, T, defaultEql);
-}
-
-pub fn defaultEql(comptime expected: anytype, actual: anytype) bool {
-    const Array = @TypeOf(expected, actual);
-    const T = @typeInfo(Array).array.child;
-    const child_bits = @sizeOf(T) * std.mem.byte_size_in_bits;
+fn defaultEql(comptime expected: anytype, actual: anytype) bool {
+    comptime assert(expected.len == actual.len);
+    const child_bits = expected.len * std.mem.byte_size_in_bits;
 
-    // Directly comparing sections of memory as integer types
-    // does not work for padded array fields, nor does it work for arrays
-    // which exceed 65535 bits (there are no integer types that large).
-    const unique = std.meta.hasUniqueRepresentation(Array);
+    // Integers are limited to 65535 bits; default to a for loop
+    // if the strings to compare are too long
     const too_many_bits = child_bits > 65535;
 
     // TODO: riscv64 backend can't airBitCast [7]u8 to u56
     const limited_backend = @import("builtin").zig_backend == .stage2_riscv64;
 
-    if (!unique or too_many_bits or limited_backend) {
+    if (too_many_bits or limited_backend) {
         var match: bool = true;
         for (expected, actual) |a, b| {
             match = match and a == b;
         }
         return match;
     }
 
-    const Compare = std.meta.Int(.unsigned, @bitSizeOf(Array));
+    const Compare = std.meta.Int(.unsigned, child_bits);
     const a: Compare = @bitCast(expected);
     const b: Compare = @bitCast(actual);
     return a == b;
@@ -67,6 +51,7 @@ fn ignoreCaseEql(comptime expected: anytype, actual: anytype) bool {
     return defaultEql(lower_expected, lower_actual);
 }
 
+// For backends that cannot handle integer vectors
 fn toLowerSimple(comptime len: usize, input: anytype) [len]u8 {
     var output: [len]u8 = undefined;
     for (input, &output) |in_byte, *out_byte| {
@@ -93,25 +78,23 @@ fn toLowerSimd(input: anytype) [@typeInfo(@TypeOf(input)).array.len]u8 {
 
 /// Static string map constructed at compile time for additional optimizations.
 /// First branches on the key length, then compares the possible matching keys.
-pub fn StaticArrayMapWithEql(
+fn StaticStringMapWithEql(
     /// The type of the value
     comptime V: type,
-    /// The type of the element in the array, eg. []const T - would be u8 for a string
-    comptime T: type,
     /// The equal function that is used to compare the keys
     comptime eql: fn (comptime anytype, anytype) bool,
 ) type {
     return struct {
         const Self = @This();
 
         pub const Kv = struct {
-            key: []const T,
+            key: []const u8,
             value: V,
         };
 
         kvs: []const Kv,
 
-        /// Initializes the map at comptime
+        /// Initializes the map at comptime with a list of key / value pairs
         pub inline fn initComptime(comptime kvs_list: anytype) Self {
             const list = comptime blk: {
                 var list: [kvs_list.len]Kv = undefined;
@@ -126,23 +109,23 @@ pub fn StaticArrayMapWithEql(
             return comptime .{ .kvs = &list };
         }
 
-        /// Checks if the map has a value for the key.
-        pub fn has(comptime self: Self, key: []const T) bool {
+        /// Checks if the map contains the key.
+        pub fn has(comptime self: Self, key: []const u8) bool {
             return self.get(key) != null;
         }
 
-        /// Returns the value for the key if any, else null.
-        pub fn get(comptime self: Self, key: []const T) ?V {
+        /// Returns the value for the key if any.
+        pub fn get(comptime self: Self, key: []const u8) ?V {
             switch (self.kvs.len) {
                 0 => return null,
                 else => return self.filterLength(key),
             }
         }
 
-        /// The list of all the keys in the map.
-        pub fn keys(comptime self: Self) []const []const T {
+        /// Returns the list of all the keys in the map.
+        pub fn keys(comptime self: Self) []const []const u8 {
             const list = comptime blk: {
-                var list: [self.kvs.len][]const T = undefined;
+                var list: [self.kvs.len][]const u8 = undefined;
                 for (&list, self.kvs) |*key, kv| {
                     key.* = kv.key;
                 }
@@ -151,7 +134,7 @@ pub fn StaticArrayMapWithEql(
             return &list;
         }
 
-        /// The list of all the values in the map.
+        /// Returns the list of all the values in the map.
         pub fn values(comptime self: Self) []const V {
             const list = comptime blk: {
                 var list: [self.kvs.len]V = undefined;
@@ -165,7 +148,7 @@ pub fn StaticArrayMapWithEql(
 
         /// Filters the input key by length, then compares it to the possible matches.
         /// Because we know the length at comptime, we can compare the strings faster.
-        fn filterLength(comptime self: Self, key: []const T) ?V {
+        fn filterLength(comptime self: Self, key: []const u8) ?V {
             // separateLength is hungry - provide 2000 branches per key/value pair
             @setEvalBranchQuota(2000 * self.kvs.len);
             const kvs_by_lengths = comptime self.separateLength();
@@ -179,14 +162,7 @@ pub fn StaticArrayMapWithEql(
                         @setEvalBranchQuota(10 * len * idx);
                         comptime for (kvs_by_len.kvs[0..idx]) |prev_kv| {
                             if (eql(kv.key[0..len].*, prev_kv.key[0..len].*)) {
-                                if (T == u8 and std.unicode.utf8ValidateSlice(kv.key)) {
-                                    @compileError("duplicate key \"" ++ kv.key ++ "\"");
-                                } else {
-                                    @compileError(std.fmt.comptimePrint(
-                                        "duplicate key: {any}",
-                                        .{kv.key},
-                                    ));
-                                }
+                                @compileError("redundant key \"" ++ kv.key ++ "\"");
                             }
                         };
 
@@ -429,73 +405,12 @@ test "sorting kvs doesn't exceed eval branch quota" {
     try testing.expectEqual(1, TypeToByteSizeLUT.get("t1"));
 }
 
-test "static array map" {
-    const map = StaticArrayMap(u16, u4).initComptime(.{
-        .{ &[_]u16{ 0, 1, 2, 3 }, 0 },
-        .{ &[_]u16{ 4, 5, 6, 7, 8 }, 1 },
-        .{ &[_]u16{ 9, 10, 1 << 13, 4 }, 2 },
-        .{ &[_]u16{0}, 3 },
-        .{ &[_]u16{}, 4 },
-    });
-
-    try testing.expectEqual(0, map.get(&[_]u16{ 0, 1, 2, 3 }).?);
-    try testing.expectEqual(2, map.get(&[_]u16{ 9, 10, 1 << 13, 4 }).?);
-    try testing.expectEqual(4, map.get(&[_]u16{}).?);
-
-    try testing.expectEqual(null, map.get(&[_]u16{ 7, 7, 7 }));
-    try testing.expectEqual(null, map.get(&[_]u16{ 0, 1 }));
-
-    try testing.expectEqual(true, map.has(&[_]u16{ 4, 5, 6, 7, 8 }));
-    try testing.expectEqual(true, map.has(&[_]u16{0}));
-
-    try testing.expectEqual(false, map.has(&[_]u16{5}));
-    try testing.expectEqual(false, map.has(&[_]u16{ 0, 0 }));
-}
-
-test "array elements that are padded" {
-    const map = StaticArrayMap(u7, u4).initComptime(&.{
-        .{ &.{ 0, 1, 2, 3, 4, 5 }, 0 },
-        .{ &.{ 0, 1, 127, 3, 4, 5 }, 1 },
-        .{ &.{ 0, 1, 2, 126, 4, 5 }, 2 },
-    });
-
-    try testing.expectEqual(null, map.get(&.{0}));
-    try testing.expectEqual(0, map.get(&.{ 0, 1, 2, 3, 4, 5 }));
-    try testing.expectEqual(1, map.get(&.{ 0, 1, 127, 3, 4, 5 }));
-    try testing.expectEqual(2, map.get(&.{ 0, 1, 2, 126, 4, 5 }));
-}
-
-fn lastElementEql(comptime expected: anytype, actual: anytype) bool {
-    if (expected.len == 0) {
-        return false;
-    } else {
-        const last_idx = expected.len - 1;
-        return expected[last_idx] == actual[last_idx];
-    }
-}
-
-test "custom equal function" {
-    const map = StaticStringMapWithEql(u2, lastElementEql).initComptime(.{
-        .{ "last byte is a t", 0 },
-        .{ "last byte is a b", 1 },
-        .{ "last byte is a s", 2 },
-        .{ "last byte is a c", 3 },
-    });
-
-    // limitation: eql functions only are called on same-length inputs
-    try testing.expectEqual(false, map.has("t"));
-
-    try testing.expectEqual(1, map.get("my magic byte: b"));
-    try testing.expectEqual(0, map.get("my magic byte: t"));
-    try testing.expectEqual(2, map.get("my magic byte: s"));
-}
-
 test "single string StaticStringMap" {
-    const map = StaticStringMap(void).initComptime(.{.{"o kama pona"}});
+    const map = StaticStringMap(void).initComptime(.{.{"Hello, World!"}});
 
-    try testing.expectEqual(true, map.has("o kama pona"));
-    try testing.expectEqual(false, map.has("o kama ike"));
-    try testing.expectEqual(false, map.has("o kama pona ala"));
+    try testing.expectEqual(true, map.has("Hello, World!"));
+    try testing.expectEqual(false, map.has("Same len str!"));
+    try testing.expectEqual(false, map.has("Hello, World! (not the same)"));
 }
 
 test "empty StaticStringMap" {

lib/std/std.zig

@@ -14,11 +14,8 @@ pub const BoundedArrayAligned = @import("bounded_array.zig").BoundedArrayAligned
 pub const Build = @import("Build.zig");
 pub const BufMap = @import("buf_map.zig").BufMap;
 pub const BufSet = @import("buf_set.zig").BufSet;
-pub const StaticArrayMap = static_array_map.StaticArrayMap;
-pub const StaticArrayMapWithEql = static_array_map.StaticArrayMapWithEql;
-pub const StaticStringMap = static_array_map.StaticStringMap;
-pub const StaticStringMapIgnoreCase = static_array_map.StaticStringMapIgnoreCase;
-pub const StaticStringMapWithEql = static_array_map.StaticStringMapWithEql;
+pub const StaticStringMap = static_string_map.StaticStringMap;
+pub const StaticStringMapIgnoreCase = static_string_map.StaticStringMapIgnoreCase;
 pub const DoublyLinkedList = @import("linked_list.zig").DoublyLinkedList;
 pub const DynLib = @import("dynamic_library.zig").DynLib;
 pub const DynamicBitSet = bit_set.DynamicBitSet;
@@ -56,7 +53,7 @@ pub const builtin = @import("builtin.zig");
 pub const c = @import("c.zig");
 pub const coff = @import("coff.zig");
 pub const compress = @import("compress.zig");
-pub const static_array_map = @import("static_array_map.zig");
+pub const static_string_map = @import("static_string_map.zig");
 pub const crypto = @import("crypto.zig");
 pub const debug = @import("debug.zig");
 pub const dwarf = @import("dwarf.zig");