Compiler Explorer

Source code

//// Qn to #zig: Is this the idiomatic way of writing a generic "class"?
//// Another qn: How do we write interface in zig?
////             I couldn't find resources on this, but I think I can hand-roll
////             my own interface by using comptime @asserts
fn SliceStream(comptime Elem: type) type {
    return struct {
        data: []const Elem,
        pos: usize,
    
        pub fn peek(self: SliceStream(Elem)) ?Elem {
            if (self.pos >= self.data.len) {
                return null;
            } else {
                return self.data[self.pos];
            }
        }

//// The real qn:
        //// I needed a way to construct a value of this type
        //// So are we supposed to put our "constructors" in the type itself?
        //// It seems to lead to this funny recursive syntax here
        ////                                           |
        ////                                           v
        pub fn slice_stream(data: []const Elem) SliceStream(Elem) {
            return .{.data = data, .pos = 0 };
        }
    };
}

export fn fancy_id(num: i32) i32 {
    const my_data = [_]i32{num, num, num};

// Instantiates the type for our particular data
    // Similar to vector<i32> if using C++
    const I32SliceStream = SliceStream(i32);

// calls the "constructor" which I put as a function in the class
    // I guess this would be something like vector<i32>::vector<i32>(...)
    const my_stream = I32SliceStream.slice_stream(my_data[0..3]);

// call the method.
    // obj.method() gets rewritten to @Typeof(obj).method(obj)
    // So it's like python.
    return (my_stream.peek()).?;
}

pub fn main() u8 {
    return @intCast(u8, fancy_id(5));
}