Compiler Explorer

Source code

const std = @import("std");

pub fn StateMachine(Impl: var) type {
    return struct {
        //@BUG: we should use a nullable for frame, but #5706
        frame: @Frame(Impl.func),
        args: Impl.Args,
        result: Impl.Result,
        state: enum {
            NotStarted,
            Running,
            Finished,
        },
        
        const Self = @This();
        
        pub fn init() Self {
            return Self {
                .frame = undefined,
                .args = undefined,
                .result = undefined,
                .state = .NotStarted,
            };
        }
        
        pub fn yield(self: *Self, args: var) Impl.Result {
            const fields = std.meta.fields(Impl.Args);
            if(args.len != fields.len) @compileError("incorrect number of arguments");
            inline for(fields) |f, i| {
                @field(self.args, f.name) = args[i];
            }
            
            switch(self.state) {
                .NotStarted => {
                    self.state = .Running;
                    _ = async self.funcWrapper();
                },
                .Running => resume self.frame,
                .Finished => {},
            }
            return self.result;
        }
        
        pub fn reset(self: *Self) void {
            self.state = .NotStarted;
        }
        
        fn funcWrapper(self: *Self) void {
            self.frame = async Impl.func(&self.args, &self.result);
            const auto_reset = await self.frame;
            self.state = if(auto_reset) .NotStarted else .Finished;
        }
    };
}

pub fn main() void {
    var r = Range.init();
    while(r.yield(.{5, 20, 2})) |n| {
        std.debug.warn("{}|", .{n});
    }
    std.debug.warn("\n", .{});
    //r.reset();
    while(r.yield(.{35, 95, 5})) |n| {
        std.debug.warn("{}|", .{n});
    }
    std.debug.warn("\n", .{});
}