ring with when filter

// Test 914: Ring buffer consumer with WHEN clause filtering
//
// This demonstrates the FULL consumer pattern with all three primitives:
// - Labels for loops
// - Taps for observation
// - When clauses for filtering
//
// Only process EVEN numbers!

const std = @import("std");
~import std/taps

// Generic ring buffer (Zig function returning type)
pub fn Ring(comptime T: type, comptime size: usize) type {
    return struct {
        const Self = @This();

        data: [size]T,
        head: usize,
        tail: usize,

        pub fn init() Self {
            return .{
                .data = undefined,
                .head = 0,
                .tail = 0,
            };
        }

        pub fn tryEnqueue(self: *Self, value: T) bool {
            if ((self.tail + 1) % size == self.head) {
                return false;
            }
            self.data[self.tail] = value;
            self.tail = (self.tail + 1) % size;
            return true;
        }

        pub fn tryDequeue(self: *Self) ?T {
            if (self.head == self.tail) {
                return null;
            }
            const value = self.data[self.head];
            self.head = (self.head + 1) % size;
            return value;
        }
    };
}

const MyRing = Ring(u32, 1024);

// Ring operations
~tor ring.enqueue { ring: *Ring(u32, 1024), value: u32 }

~proc ring.enqueue|zig {
    if (ring.tryEnqueue(value)) {
    }
}

~tor ring.dequeue { ring: *Ring(u32, 1024) }
| value u32

~proc ring.dequeue|zig {
    if (ring.tryDequeue()) |data| {
        return .{ .value = data };
    }
}

// Processing event - what we do with dequeued values
~tor process { data: u32 }

~proc process|zig {
    std.debug.print("Processing: {}\n", .{data});
}

// EVENT TAP with WHEN CLAUSE: Only process EVEN numbers!
// This is the filtered consumer - observe dequeue, but only act on evens
~tap(ring.dequeue -> *)
| value v when v.data % 2 == 0 |> process(v.data)

// Producer: Fill the ring with values
~tor produce { ring: *Ring(u32, 1024), count: u32 }

~proc produce|zig {
    var i: u32 = 0;
    while (i < count) : (i += 1) {
        _ = ring.tryEnqueue(i);
    }
    std.debug.print("Produced {} values\n", .{count});
}

// Consumer loop using label + tap
// The tap fires automatically for each dequeued value!
~tor start {}

~proc start|zig {
}

var my_ring = MyRing.init();

~start() |> produce(ring: &my_ring, count: 6) |> #consume ring.dequeue(ring: &my_ring)
    | value |> @consume
    | empty |> _