Zig Playground

const std = @import("std");

fn fromDirect(Fooer: type, context: *anyopaque) *Fooer {
    return @alignCast(@ptrCast(context));
}

fn fromIndirect(Fooer: type, context: *const anyopaque) *Fooer {
    return @as(*const *Fooer, @alignCast(@ptrCast(context))).*;
}

fn fromHeader(context: *ErasedVariableSize) struct { *ErasedVariableSize.Header, *anyopaque } {
    return .{ @alignCast(@ptrCast(context)), @as([*]u8, @ptrCast(context)) + @sizeOf(ErasedVariableSize.Header) };
}

const ErasedDirectly = struct {
    context: *anyopaque,
    fooFn: *const fn (context: *anyopaque, bar: u32) u32,
    resetFn: *const fn (context: *anyopaque) void,

pub fn init(fooer: anytype) @This() {
        const Fooer = @typeInfo(@TypeOf(fooer)).pointer.child;
        const Fns = struct {
            pub fn typeErasedFoo(context: *anyopaque, bar: u32) u32 {
                return fromDirect(Fooer, context).foo(bar);
            }

pub fn typeErasedReset(context: *anyopaque) void {
                fromDirect(Fooer, context).reset();
            }
        };
        return .{
            .context = fooer,
            .fooFn = Fns.typeErasedFoo,
            .resetFn = Fns.typeErasedReset,
        };
    }

pub fn foo(self: @This(), bar: u32) u32 {
        return self.fooFn(self.context, bar);
    }

pub fn reset(self: @This()) void {
        self.resetFn(self.context);
    }
};

const ErasedIndirectly = struct {
    context: *const anyopaque,
    fooFn: *const fn (context: *const anyopaque, bar: u32) u32,
    resetFn: *const fn (context: *const anyopaque) void,

pub fn init(fooer: anytype) @This() {
        const FooerPtr = @typeInfo(@TypeOf(fooer)).pointer.child;
        const Fooer = @typeInfo(FooerPtr).pointer.child;
        const Fns = struct {
            pub fn typeErasedFoo(context: *const anyopaque, bar: u32) u32 {
                return fromIndirect(Fooer, context).foo(bar);
            }

pub fn typeErasedReset(context: *const anyopaque) void {
                fromIndirect(Fooer, context).reset();
            }
        };
        return .{
            .context = @ptrCast(fooer),
            .fooFn = Fns.typeErasedFoo,
            .resetFn = Fns.typeErasedReset,
        };
    }

pub fn foo(self: @This(), bar: u32) u32 {
        return self.fooFn(self.context, bar);
    }

pub fn reset(self: @This()) void {
        self.resetFn(self.context);
    }
};

const ErasedDirectlyWithVTable = struct {
    context: *anyopaque,
    v_table: *const struct {
        fooFn: *const fn (context: *anyopaque, bar: u32) u32,
        resetFn: *const fn (context: *anyopaque) void,
    },

pub fn init(fooer: anytype) ErasedDirectlyWithVTable {
        const Fooer = @typeInfo(@TypeOf(fooer)).pointer.child;
        const Fns = struct {
            pub fn typeErasedFoo(context: *anyopaque, bar: u32) u32 {
                return fromDirect(Fooer, context).foo(bar);
            }

pub fn typeErasedReset(context: *anyopaque) void {
                fromDirect(Fooer, context).reset();
            }
        };
        return .{
            .context = fooer,
            .v_table = &.{
                .fooFn = Fns.typeErasedFoo,
                .resetFn = Fns.typeErasedReset,
            },
        };
    }

pub fn foo(self: @This(), bar: u32) u32 {
        return self.v_table.fooFn(self.context, bar);
    }

pub fn reset(self: @This()) void {
        self.v_table.resetFn(self.context);
    }
};

const ErasedVariableSize = opaque {
    pub const Header = struct {
        fooFn: *const fn (context: *anyopaque, bar: u32) u32,
        resetFn: *const fn (context: *anyopaque) void,
    };

fn bufferSize(Fooer: type) usize {
        return @sizeOf(Fooer) + @sizeOf(Header);
    }

pub fn create(fooer: anytype, buffer: *align(8) [bufferSize(@TypeOf(fooer))]u8) *@This() {
        const Fooer = @TypeOf(fooer);
        const Fns = struct {
            pub fn typeErasedFoo(context: *anyopaque, bar: u32) u32 {
                return fromDirect(Fooer, context).foo(bar);
            }

pub fn typeErasedReset(context: *anyopaque) void {
                fromDirect(Fooer, context).reset();
            }
        };
        @memcpy(buffer[0..@sizeOf(Header)], @as([*]const u8, @ptrCast(&Header{
            .fooFn = Fns.typeErasedFoo,
            .resetFn = Fns.typeErasedReset,
        })));
        @memcpy(buffer[@sizeOf(Header)..], @as([*]const u8, @ptrCast(&fooer)));
        return @ptrCast(buffer);
    }

pub fn foo(self: *@This(), bar: u32) u32 {
        const header, const raw = fromHeader(self);
        return header.fooFn(raw, bar);
    }

pub fn reset(self: *@This()) void {
        const header, const raw = fromHeader(self);
        header.resetFn(raw);
    }
};

pub fn main() void {
    const Fooer = struct {
        data: u32 = 0xBEEF,

pub fn foo(self: @This(), bar: u32) u32 {
            return self.data +% bar;
        }

pub fn reset(self: *@This()) void {
            self.data = 0;
        }

pub fn testTypeErasure(fooer: *@This(), type_erased_fooer: anytype) !void {
            std.debug.print("Testing {}\n", .{@TypeOf(type_erased_fooer)});
            errdefer std.debug.print("\tfailed\n", .{});
            if (fooer.foo(42) != type_erased_fooer.foo(42)) return error.FstFoo;
            fooer.reset();
            type_erased_fooer.reset();
            if (fooer.foo(42) != type_erased_fooer.foo(42)) return error.SndFoo;
            std.debug.print("\tsuccess\n", .{});
        }
    };

{
        var fooer: Fooer = .{};
        var fooer_for_erasure: Fooer = .{};
        fooer.testTypeErasure(ErasedDirectly.init(&fooer_for_erasure)) catch {};
    }
    {
        var fooer: Fooer = .{};
        var fooer_for_erasure: Fooer = .{};
        const fooer_ptr = &fooer_for_erasure;
        fooer.testTypeErasure(ErasedIndirectly.init(&fooer_ptr)) catch {};
    }
    {
        var fooer: Fooer = .{};
        var fooer_for_erasure: Fooer = .{};
        fooer.testTypeErasure(ErasedDirectlyWithVTable.init(&fooer_for_erasure)) catch {};
    }
    {
        var fooer: Fooer = .{};
        var erased_fooer_buffer: [20]u8 align(8) = undefined;
        fooer.testTypeErasure(ErasedVariableSize.create(fooer, &erased_fooer_buffer)) catch {};
    }
}