async_primes.zig

const std = @import("std");

const Channel = struct {
    value: u32 = undefined,
    frame: anyframe,
};

fn generate(out_channel: **Channel) void {
    var ch = Channel{ .frame = @frame() };
    suspend out_channel.* = &ch;
    
    var i: u32 = 2;
    while (true) : (i +%= 1) {
        ch.value = i;
        suspend {}
    }
}

fn filter(out_channel: **Channel, in_channel: *Channel, prime: u32) void {
    var ch = Channel{ .frame = @frame() };
    suspend out_channel.* = &ch;
    
    while (true) {
        resume in_channel.frame;
        if (in_channel.value % prime != 0) {
            ch.value = in_channel.value;
            suspend {}
        }
    }
}

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    
    const allocator = arena.allocator();
    const stdout = std.io.getStdOut().writer();
    
    const args = try std.process.argsAlloc(allocator);
    defer allocator.free(args);
    
    const n = if (args.len > 1)
        try std.fmt.parseInt(usize, args[1], 10)
    else
        100;
    
    var ch: *Channel = undefined;
    _ = async generate(&ch);
    
    const filters = try allocator.alloc(@Frame(filter), n - 1);
    defer allocator.free(filters);
    
    var i: u32 = 0;
    while (i < n) : (i += 1) {
        resume ch.frame;
        const prime = ch.value;
        
        try stdout.print("{d}\n", .{prime});
        if (i >= n - 1) break;
        
        var ch1: *Channel = undefined;
        filters[i] = async filter(&ch1, ch, prime);
        ch = ch1;
    }
}