fn range(comptime N: type) type {
    return struct {
        start: N,
        stepsz: N,
        end: N,

        fn init(start_: N, stepsz_: N, end_: N) @This() {
            return @This() {
                .start = start_,
                .stepsz = stepsz_,
                .end = end_
            };
        }

        fn next(self: *@This()) ?N {
            if (self.start + self.stepsz <= self.end) {
                var ret = self.start;
                self.start += self.stepsz;
                return ret;
            }
            return null;
        }

        fn size(self: *@This()) N {
            return (self.end - self.start) / self.stepsz;
        }
    };
}

pub fn main() void {
    var sum: usize = 0;
    comptime var r = comptime range(usize).init(0, 10, 100);

    comptime var buff: [comptime r.size()] usize = undefined;

    comptime {
        for (buff) |*elem| {
            elem.* = r.next() orelse unreachable;
        }
    }

    for(buff) |elem| {
        @import("std").debug.warn("elem: {}\n", elem);
    }

}