interface.zig

const std = @import("std");
const warn = std.debug.warn;
const TypeId = @import("builtin").TypeId;

const VTable = struct {
    accelerate_fn: fn(self: usize) void,
};

fn Unwraped(comptime T: type) type {
    if (@typeId(T) == TypeId.Pointer) {
        return T.Child;
    }

    return T;
}

fn vtable_for(comptime TWrapped: type) VTable {
    const T = Unwraped(TWrapped);

    return VTable {
        .accelerate_fn = struct {
            fn accelerate(self: usize) void {
                return @intToPtr(&T, self).accelerate();
            }
        }.accelerate,
    };
}

const Car = struct {
    data: usize,
    fn accelerate(self: &Car) void {
        warn("VROOM VROOM\n");
    }
};

const Acceleratable = struct {
    vtable: &const VTable,
    obj: usize,

    fn init(obj: var) Acceleratable {
        return Acceleratable {
            .vtable = comptime &vtable_for(@typeOf(obj)),
            .obj = @ptrToInt(obj),
        };
    }

    fn accelerate(self: &Acceleratable) void {
        return self.vtable.accelerate_fn(self.obj);
    }
};

pub fn main() void {
    var car = Car { .data = 0 };

    accelerate(&Acceleratable.init(car));
}

fn accelerate(acc: &Acceleratable) void {
    acc.accelerate();
}