Referencing generics in other structs

[vague loom]

I'm working on an OpenGL wrapper, and I have a generic buffer struct like this:

pub fn Buffer(comptime T: type) type {
    return struct {
        // fields
        // methods
        pub fn writeVertexData(self: *Self, vertices: []const T, offset: u32) !void {
            // ...
        }
    };
}

I'm trying to avoid having anytype on the Buffer methods and then having to handle reflection paths.

The issue is, when I try to reference these Buffers in other structs, I'm not able to since they don't actually exist until created with a specific type. So this doesn't work:

const BufferBinding = struct {
    buffer: *Buffer,
    // other fields
};

What I want to do is to be able to specify that the buffer field in the above BufferBinding struct is generated from my Buffer() function (the way generic base types can be referenced in other languages). I've tried working around this by creating an opaque "AnyBuffer" constant, but that didn't work either (still getting a handle on how to use opaques).

Feels like there should be a common pattern for handling this sort of thing, but I'm having trouble finding any examples. I feel like it's going to be super obvious once someone points it out to me.

Any thoughts on the best way to handle this?

[scenic marsh]

Buffer(type1) is a different type than Buffer(type2) and there's no base type that they both fit into.

I'm not sure how you're using the type field in the buffer, but making an AnyBuffer should work. how you would implement it depends on if fields are different based on the type or if only methods are different based on the type parameter

[vague loom]

Fields are the same, only the methods are different based on type parameter

And yeah I figured since there's no real base type there's no "generic type" to reference

[vestal nimbus]

Could it make sense to do something like a thicc interface similar to the new Writer? Then you can store the pointer to the interface while your concrete specialised type still exists

[scenic marsh]

if fields are the same then what you could do is make AnyBuffer contain the fields and have the Buffer struct have data: AnyBuffer, then have a method on AnyBuffer to convert it to a typed buffer to call methods on

[vague loom]

Oh wait, I think maybe I just need to make BufferBinding generic too (pub fn BufferBinding(comptime T: type) type {}), that way the buffer field can reference a specific *Buffer(T) type

[balmy otter]

Do you need to differentiate the buffer types, if not you could have generic functions instead of types.