refactor: use concrete *std.Io.Reader and *std.Io.Writer types

Replace all anytype reader/writer parameters with concrete types
*std.Io.Reader and *std.Io.Writer throughout the codebase. This
leverages Zig 0.15's new IO system with buffers above vtables.

Updated all pack/unpack functions, Packer/Unpacker types, and tests
to use the new concrete types and updated API methods (takeByte,
readSliceAll, etc.).

Author: lalinsky

src/any.zig

@@ -75,7 +75,7 @@ pub fn sizeOfPackedAny(comptime T: type, value: T) usize {
     @compileError("Unsupported type '" ++ @typeName(T) ++ "'");
 }
 
-pub fn packAny(writer: anytype, value: anytype) !void {
+pub fn packAny(writer: *std.Io.Writer, value: anytype) !void {
     const T = @TypeOf(value);
     switch (@typeInfo(T)) {
         .void => return packNull(writer),
@@ -123,7 +123,7 @@ pub fn packAny(writer: anytype, value: anytype) !void {
     @compileError("Unsupported type '" ++ @typeName(T) ++ "'");
 }
 
-pub fn unpackAny(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackAny(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     switch (@typeInfo(T)) {
         .void => return unpackNull(reader),
         .bool => return unpackBool(reader, T),
@@ -156,74 +156,74 @@ pub fn unpackAny(reader: anytype, allocator: std.mem.Allocator, comptime T: type
 
 test "packAny/unpackAny: bool" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), true);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, true);
 
-    stream.reset();
-    try std.testing.expectEqual(true, try unpackAny(stream.reader(), std.testing.allocator, bool));
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    try std.testing.expectEqual(true, try unpackAny(&reader, std.testing.allocator, bool));
 }
 
 test "packAny/unpackAny: optional bool" {
     const values = [_]?bool{ true, null };
     for (values) |value| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?bool));
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?bool));
     }
 }
 
 test "packAny/unpackAny: int" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), -42);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, -42);
 
-    stream.reset();
-    try std.testing.expectEqual(-42, try unpackAny(stream.reader(), std.testing.allocator, i32));
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    try std.testing.expectEqual(-42, try unpackAny(&reader, std.testing.allocator, i32));
 }
 
 test "packAny/unpackAny: optional int" {
     const values = [_]?i32{ -42, null };
     for (values) |value| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?i32));
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?i32));
     }
 }
 
 test "packAny/unpackAny: float" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), 3.14);
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, 3.14);
 
-    stream.reset();
-    try std.testing.expectEqual(3.14, try unpackAny(stream.reader(), std.testing.allocator, f32));
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    try std.testing.expectEqual(3.14, try unpackAny(&reader, std.testing.allocator, f32));
 }
 
 test "packAny/unpackAny: optional float" {
     const values = [_]?f32{ 3.14, null };
     for (values) |value| {
         var buffer: [16]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?f32));
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?f32));
     }
 }
 
 test "packAny/unpackAny: string" {
     var buffer: [32]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packAny(stream.writer(), "hello");
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packAny(&writer, "hello");
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, []const u8);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, []const u8);
     defer std.testing.allocator.free(result);
     try std.testing.expectEqualStrings("hello", result);
 }
@@ -232,11 +232,11 @@ test "packAny/unpackAny: optional string" {
     const values = [_]?[]const u8{ "hello", null };
     for (values) |value| {
         var buffer: [32]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?[]const u8);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?[]const u8);
         defer if (result) |str| std.testing.allocator.free(str);
         if (value) |str| {
             try std.testing.expectEqualStrings(str, result.?);
@@ -248,12 +248,12 @@ test "packAny/unpackAny: optional string" {
 
 test "packAny/unpackAny: array" {
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const array = [_]i32{ 1, 2, 3, 4, 5 };
-    try packAny(stream.writer(), &array);
+    try packAny(&writer, &array);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, []const i32);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, []const i32);
     defer std.testing.allocator.free(result);
     try std.testing.expectEqualSlices(i32, &array, result);
 }
@@ -263,11 +263,11 @@ test "packAny/unpackAny: optional array" {
     const values = [_]?[]const i32{ &array, null };
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?[]const i32);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?[]const i32);
         defer if (result) |arr| std.testing.allocator.free(arr);
         if (value) |arr| {
             try std.testing.expectEqualSlices(i32, arr, result.?);
@@ -283,12 +283,12 @@ test "packAny/unpackAny: struct" {
         y: i32,
     };
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const point = Point{ .x = 10, .y = 20 };
-    try packAny(stream.writer(), point);
+    try packAny(&writer, point);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, Point);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, Point);
     try std.testing.expectEqualDeep(point, result);
 }
 
@@ -301,11 +301,11 @@ test "packAny/unpackAny: optional struct" {
     const values = [_]?Point{ point, null };
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?Point);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?Point);
         try std.testing.expectEqualDeep(value, result);
     }
 }
@@ -323,11 +323,11 @@ test "packAny/unpackAny: union" {
 
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, Value);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, Value);
         try std.testing.expectEqualDeep(value, result);
     }
 }
@@ -346,35 +346,35 @@ test "packAny/unpackAny: optional union" {
 
     for (values) |value| {
         var buffer: [64]u8 = undefined;
-        var stream = std.io.fixedBufferStream(&buffer);
-        try packAny(stream.writer(), value);
+        var writer = std.Io.Writer.fixed(&buffer);
+        try packAny(&writer, value);
 
-        stream.reset();
-        const result = try unpackAny(stream.reader(), std.testing.allocator, ?Value);
+        var reader = std.Io.Reader.fixed(writer.buffered());
+        const result = try unpackAny(&reader, std.testing.allocator, ?Value);
         try std.testing.expectEqualDeep(value, result);
     }
 }
 
 test "packAny/unpackAny: String struct" {
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const str = String{ .data = "hello" };
-    try packAny(stream.writer(), str);
+    try packAny(&writer, str);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, String);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, String);
     defer std.testing.allocator.free(result.data);
     try std.testing.expectEqualStrings("hello", result.data);
 }
 
 test "packAny/unpackAny: Binary struct" {
     var buffer: [64]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
+    var writer = std.Io.Writer.fixed(&buffer);
     const str = String{ .data = "\x01\x02\x03\x04" };
-    try packAny(stream.writer(), str);
+    try packAny(&writer, str);
 
-    stream.reset();
-    const result = try unpackAny(stream.reader(), std.testing.allocator, String);
+    var reader = std.Io.Reader.fixed(writer.buffered());
+    const result = try unpackAny(&reader, std.testing.allocator, String);
     defer std.testing.allocator.free(result.data);
     try std.testing.expectEqualStrings("\x01\x02\x03\x04", result.data);
 }

src/array.zig

@@ -31,7 +31,7 @@ pub fn sizeOfPackedArray(len: usize) !usize {
     return try sizeOfPackedArrayHeader(len) + len;
 }
 
-pub fn packArrayHeader(writer: anytype, len: usize) !void {
+pub fn packArrayHeader(writer: *std.Io.Writer, len: usize) !void {
     if (len <= hdrs.FIXARRAY_MAX - hdrs.FIXARRAY_MIN) {
         try writer.writeByte(hdrs.FIXARRAY_MIN + @as(u8, @intCast(len)));
     } else if (len <= std.math.maxInt(u16)) {
@@ -45,8 +45,8 @@ pub fn packArrayHeader(writer: anytype, len: usize) !void {
     }
 }
 
-pub fn unpackArrayHeader(reader: anytype, comptime T: type) !T {
-    const header = try reader.readByte();
+pub fn unpackArrayHeader(reader: *std.Io.Reader, comptime T: type) !T {
+    const header = try reader.takeByte();
     switch (header) {
         hdrs.FIXARRAY_MIN...hdrs.FIXARRAY_MAX => {
             return header - hdrs.FIXARRAY_MIN;
@@ -63,7 +63,7 @@ pub fn unpackArrayHeader(reader: anytype, comptime T: type) !T {
     }
 }
 
-pub fn packArray(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
+pub fn packArray(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
     const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
     try packArrayHeader(writer, value.len);
 
@@ -72,7 +72,7 @@ pub fn packArray(writer: anytype, comptime T: type, value_or_maybe_null: T) !voi
     }
 }
 
-pub fn unpackArray(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
+pub fn unpackArray(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
     const len = if (isOptional(T))
         try unpackArrayHeader(reader, ?u32) orelse return null
     else
@@ -90,7 +90,7 @@ pub fn unpackArray(reader: anytype, allocator: std.mem.Allocator, comptime T: ty
     return data;
 }
 
-pub fn unpackArrayInto(reader: anytype, allocator: std.mem.Allocator, comptime Item: type, buffer: []Item) ![]Item {
+pub fn unpackArrayInto(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime Item: type, buffer: []Item) ![]Item {
     const len = try unpackArrayHeader(reader, u32);
 
     if (buffer.len < len) {
@@ -126,16 +126,16 @@ const packed_abc = [_]u8{ 0x93, 0x61, 0x62, 0x63 };
 
 test "packArray: abc" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packArray(stream.writer(), []const u8, "abc");
-    try std.testing.expectEqualSlices(u8, &packed_abc, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packArray(&writer, []const u8, "abc");
+    try std.testing.expectEqualSlices(u8, &packed_abc, writer.buffered());
 }
 
 test "packArray: null" {
     var buffer: [16]u8 = undefined;
-    var stream = std.io.fixedBufferStream(&buffer);
-    try packArray(stream.writer(), ?[]const u8, null);
-    try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
+    var writer = std.Io.Writer.fixed(&buffer);
+    try packArray(&writer, ?[]const u8, null);
+    try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
 }
 
 test "sizeOfPackedArray" {