Merge pull request #3 from MasterQ32/init-rework

Tries to rework the init function to normal parameters instead of tuples

Author: alexnask

examples.zig

@@ -27,7 +27,7 @@ test "Simple NonOwning interface" {
             };
 
             var f = TestFooer{ .state = 42 };
-            var fooer = try Fooer.init(.{&f});
+            var fooer = try Fooer.init(&f);
             defer fooer.deinit();
 
             expectEqual(@as(usize, 42), fooer.call("foo", .{}));
@@ -40,6 +40,7 @@ test "Simple NonOwning interface" {
 }
 
 test "Comptime only interface" {
+    // return error.SkipZigTest;
     const TestIFace = Interface(struct {
         foo: fn (*SelfType, u8) u8,
     }, interface.Storage.Comptime);
@@ -54,7 +55,7 @@ test "Comptime only interface" {
         }
     };
 
-    comptime var iface = try TestIFace.init(.{TestType{ .state = 0 }});
+    comptime var iface = try TestIFace.init(TestType{ .state = 0 });
     expectEqual(@as(u8, 42), iface.call("foo", .{42}));
 }
 
@@ -82,7 +83,7 @@ test "Owning interface with optional function" {
                 }
             };
 
-            var iface_instance = try TestOwningIface.init(.{ comptime TestStruct{ .state = 0 }, std.testing.allocator });
+            var iface_instance = try TestOwningIface.init(comptime TestStruct{ .state = 0 }, std.testing.allocator);
             defer iface_instance.deinit();
 
             try iface_instance.call("otherFn", .{100});
@@ -117,7 +118,7 @@ test "Interface with virtual async function implemented by an async function" {
     };
 
     var i = Impl{ .state = 0 };
-    var instance = try AsyncIFace.init(.{&i});
+    var instance = try AsyncIFace.init(&i);
     _ = async instance.call("foo", .{});
 
     expectEqual(@as(usize, 0), i.state);
@@ -142,7 +143,7 @@ test "Interface with virtual async function implemented by a blocking function"
         }
     };
 
-    var instance = try AsyncIFace.init(.{Impl{}});
+    var instance = try AsyncIFace.init(Impl{});
 
     var buf: [256]u8 = undefined;
     try await async instance.call("readBytes", .{buf[0..]});

interface.zig

@@ -6,7 +6,7 @@ const assert = std.debug.assert;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
-pub const SelfType = @OpaqueType();
+pub const SelfType = @Type(.Opaque);
 
 fn makeSelfPtr(ptr: anytype) *SelfType {
     if (comptime !trait.isSingleItemPtr(@TypeOf(ptr))) {
@@ -43,16 +43,21 @@ pub const Storage = struct {
         erased_ptr: *SelfType,
         ImplType: type,
 
-        pub fn init(args: anytype) !Comptime {
-            if (args.len != 1) {
-                @compileError("Comptime storage expected a 1-tuple in initialization.");
-            }
+        fn makeInit(comptime TInterface: type) type {
+            return struct {
+                fn init(obj: anytype) !TInterface {
+                    const ImplType = PtrChildOrSelf(@TypeOf(obj));
 
-            var obj = args[0];
+                    comptime var obj_holder = obj;
 
-            return Comptime{
-                .erased_ptr = makeSelfPtr(&obj),
-                .ImplType = @TypeOf(args[0]),
+                    return TInterface{
+                        .vtable_ptr = &comptime makeVTable(TInterface.VTable, ImplType),
+                        .storage = Comptime{
+                            .erased_ptr = makeSelfPtr(&obj_holder),
+                            .ImplType = @TypeOf(obj),
+                        },
+                    };
+                }
             };
         }
 
@@ -66,13 +71,16 @@ pub const Storage = struct {
     pub const NonOwning = struct {
         erased_ptr: *SelfType,
 
-        pub fn init(args: anytype) !NonOwning {
-            if (args.len != 1) {
-                @compileError("NonOwning storage expected a 1-tuple in initialization.");
-            }
-
-            return NonOwning{
-                .erased_ptr = makeSelfPtr(args[0]),
+        fn makeInit(comptime TInterface: type) type {
+            return struct {
+                fn init(ptr: anytype) !TInterface {
+                    return TInterface{
+                        .vtable_ptr = &comptime makeVTable(TInterface.VTable, PtrChildOrSelf(@TypeOf(ptr))),
+                        .storage = NonOwning{
+                            .erased_ptr = makeSelfPtr(ptr),
+                        },
+                    };
+                }
             };
         }
 
@@ -87,19 +95,22 @@ pub const Storage = struct {
         allocator: *mem.Allocator,
         mem: []u8,
 
-        pub fn init(args: anytype) !Owning {
-            if (args.len != 2) {
-                @compileError("Owning storage expected a 2-tuple in initialization.");
-            }
-
-            const AllocT = @TypeOf(args[0]);
+        fn makeInit(comptime TInterface: type) type {
+            return struct {
+                fn init(obj: anytype, allocator: *std.mem.Allocator) !TInterface {
+                    const AllocT = @TypeOf(obj);
 
-            var obj = try args[1].create(AllocT);
-            obj.* = args[0];
+                    var ptr = try allocator.create(AllocT);
+                    ptr.* = obj;
 
-            return Owning{
-                .allocator = args[1],
-                .mem = std.mem.asBytes(obj)[0..],
+                    return TInterface{
+                        .vtable_ptr = &comptime makeVTable(TInterface.VTable, PtrChildOrSelf(AllocT)),
+                        .storage = Owning{
+                            .allocator = allocator,
+                            .mem = std.mem.asBytes(ptr)[0..],
+                        },
+                    };
+                }
             };
         }
 
@@ -119,23 +130,28 @@ pub const Storage = struct {
 
             mem: [size]u8,
 
-            pub fn init(args: anytype) !Self {
-                if (args.len != 1) {
-                    @compileError("Inline storage expected a 1-tuple in initialization.");
-                }
-
-                const ImplSize = @sizeOf(@TypeOf(args[0]));
-
-                if (ImplSize > size) {
-                    @compileError("Type does not fit in inline storage.");
-                }
-
-                var self: Self = undefined;
-
-                if (ImplSize > 0) {
-                    std.mem.copy(u8, self.mem[0..], @ptrCast([*]const u8, &args[0])[0..ImplSize]);
-                }
-                return self;
+            fn makeInit(comptime TInterface: type) type {
+                return struct {
+                    fn init(value: anytype) !TInterface {
+                        const ImplSize = @sizeOf(@TypeOf(value));
+
+                        if (ImplSize > size) {
+                            @compileError("Type does not fit in inline storage.");
+                        }
+
+                        var self = Self{
+                            .mem = undefined,
+                        };
+                        if (ImplSize > 0) {
+                            std.mem.copy(u8, self.mem[0..], @ptrCast([*]const u8, &args[0])[0..ImplSize]);
+                        }
+
+                        return TInterface{
+                            .vtable_ptr = &comptime makeVTable(TInterface.VTable, PtrChildOrSelf(@TypeOf(value))),
+                            .storage = self,
+                        };
+                    }
+                };
             }
 
             pub fn getSelfPtr(self: *Self) *SelfType {
@@ -426,15 +442,10 @@ pub fn Interface(comptime VTableT: type, comptime StorageT: type) type {
         storage: StorageT,
 
         const Self = @This();
+        const VTable = VTableT;
+        const Storage = StorageT;
 
-        pub fn init(args: anytype) !Self {
-            const ImplType = PtrChildOrSelf(@TypeOf(args.@"0"));
-
-            return Self{
-                .vtable_ptr = &comptime makeVTable(VTableT, ImplType),
-                .storage = try StorageT.init(args),
-            };
-        }
+        pub const init = StorageT.makeInit(Self).init;
 
         pub fn initWithVTable(vtable_ptr: *const VTableT, args: anytype) !Self {
             return .{