View difference between Paste ID: Zrmbxski and 1bTancwt

 
 const std = @import("std");
 
 const SlabError = error{
     OutOfRange,
     SlotOccupied,
     EmptySlot,
     RemoveEmptySlot,
 };
 
 const SlabConfig = struct {
-    dynamic: bool = true,
+
     storage: enum {
         dynamic,
         static,
     },
     size: comptime_int,
 };
 
-        data: []?T,
+
     return struct {
-        pub fn init(allocator: ?std.mem.Allocator) !Self {
+
-            if (comptime cfg.dynamic) {
+
-                if (allocator == null) @compileError("Allocator is required for dynamic slab.");
+
-                const data = try allocator.?.alloc(?T, cfg.size);
+        data: switch (cfg.storage) {
-                for (data) |*slot| slot.* = null;
+            .dynamic => []?T,
             .static => [cfg.size]?T,
-                    .allocator = allocator.?,
+        },
-                    // .data = comptime @as(&T, &[_]?T{null} ** cfg.size),
+
         fn init(allocator: ?std.mem.Allocator) !Self {
             if (cfg.storage == .dynamic) {
                 const alloc = allocator orelse @panic("Allocator is required for dynamic slab.");
                 const data = try alloc.alloc(?T, cfg.size);
-                    .data = @memset(, elem),
+                @memset(data, null);
                 return Self{
                     .allocator = alloc,
                     .data = data,
                 };
             } else {
                 return Self{
                     .allocator = undefined,
                     .data = @splat(null),
                 };
-            try checkOutOfRage(index);
+
         }
 
         pub fn deinit(self: *Self, alloc: ?std.mem.Allocator) void {
             if (cfg.storage == .dynamic) {
                 alloc.?.free(self.data);
             }
         }
 
         inline fn checkOutOfRage(self: *Self, index: usize) !void {
             if (cfg.safe and index >= self.data.len) return SlabError.OutOfRange;
-            try checkOutOfRage(index);
+
 
-            const maybe = self.data[index] orelse return SlabError.EmptySlot;
+
-            return &maybe;
+            try self.checkOutOfRage(index);
             if (self.data[index] != null) return SlabError.SlotOccupied;
             self.data[index] = value;
         }
 
-test "init" {
+
-    const Slab = createSlab(u32, .{ .dynamic = false, .size = 3000, .safe = false });
+
-    const slab = try Slab.init(null);
+
         }
-    std.debug.print("{}\n", .{slab.get(2500)});
+
         pub fn get(self: *Self, index: usize) SlabError!*T {
             try self.checkOutOfRage(index);
 
             const maybe = &(self.data[index] orelse return SlabError.EmptySlot);
             return maybe;
         }
     };
 }
 
 test "init static" {
     const Slab = createSlab(u32, .{ .storage = .static, .size = 3000, .safe = false });
     var slab = try Slab.init(null);
     try slab.insertAt(2500, 25);
     std.debug.print("{}\n", .{(try slab.get(2500)).*});
 }
 
 test "init dynamic" {
     const Slab = createSlab(u32, .{ .storage = .dynamic, .size = 3000, .safe = false });
 
     var slab = try Slab.init(std.testing.allocator);
     defer slab.deinit(std.testing.allocator);
 
     try slab.insertAt(2500, 25);
     std.debug.print("{}\n", .{(try slab.get(2500)).*});
 }