Perfecting WebGPU/Dawn native graphics for Zig

That has nothing to do with what I said. I said the Allocator is not part of the type. An ArrayList(u8) is the same as another ArrayList(u8) regardless of what allocator they use.

>How is that more busywork?

Write a function that operates on any ArrayList(u8). It doesn't need to be generic itself. If the Allocator was part of the type it would also need to be generic. And its caller would need to be generic, and so on.

>Rust's issue is not really related. They added the generic after 1.0 and so it needed to have a default for backwards compatibility.

False. std::io::Read::read_to_end takes a Vec<u8>. It cannot be changed to take a Vec<u8, A> because that would require read_to_end to be generic on A, which cannot be done because that would make std::io::Read no longer be object-safe.

And to be clear, the point is not that std::io::Read can't change without being backward-compatible. The point is about needing to be generic on the allocator causes all sorts of problems, eg the infectious genericity (which also affects Zig) and the lack of object-safe-ness.

    {
        var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
        defer arena.deinit(); // All allocations made by the above allocator will be freed at the end of scope
        const allocator = arena.allocator();

        var i = 0;
        while (i < 1000000) : (i += 1) {
            _ = try allocator.create(i32);
        }
        // all allocations are freed
    }

    var buffer: [1000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    const allocator = fba.allocator();
    
    // the allocator will return an address inside of `buffer`
    _ = try allocator.create([512]u8);

    fn reticulate(splines: std.ArrayList(u8)) void {}

    fn ArrayList2(comptime T: type, comptime A: type) type {
        _ = T;
        _ = A;
        return struct {};
    }

    fn reticulate2(???) {}