ring with multitaps

// Test 913: Ring buffer with event taps - demonstrating consumer pattern
//
// This shows the "consumer pattern" we discovered:
// - Labels for loops
// - Taps for observation
// - When clauses for filtering
//
// No special syntax needed - just composition of primitives!

~import std/taps

const std = @import("std");

// 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 x 1: {}\n", .{data});
}

~tor process-timestwo { data: u32 }

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

// EVENT TAP: Watch ring.dequeue and process each value
// This is the "consumer" - it observes dequeue events and acts on them
~tap(ring.dequeue -> *)
| value v |> process(v.data)
~tap(ring.dequeue -> *)
| value v when v.data * 2 > 2 |> process-timestwo(v.data) | done |> _

// 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 {}

~[pure]proc start|zig {
}

var my_ring = MyRing.init();

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