✓
Passing This code compiles and runs correctly.
Code
// Test 170: Module-Level Event Globbing with Taps
//
// Tests that taps can use wildcards to match ALL events from a module.
// Pattern: ~input:* -> * matches ANY event in the main module.
//
// This demonstrates powerful observability - a single tap pattern can
// intercept every event in a module, perfect for profiling or logging.
//
// Structure:
// test_lib/
// logger.kz → Defines ~input:* -> * to intercept ALL main module events
//
// Expected: The logger's tap fires for ALL events (compute, format, display)
// even though the pattern only specifies ~input:* once.
const std = @import("std");
// Import the logger module (which defines module-level globbing tap)
~import "$app/test_lib/logger"
// Define multiple events to test with
~event compute { x: i32 }
| result { value: i32 }
~event format { value: i32 }
| formatted { text: []const u8 }
~event display { text: []const u8 }
| done {}
~proc compute {
std.debug.print("compute({d})\n", .{x});
return .{ .result = .{ .value = x * 2 } };
}
~proc format {
std.debug.print("format({d})\n", .{value});
const text = "formatted";
return .{ .formatted = .{ .text = text } };
}
~proc display {
std.debug.print("Final: {s}\n", .{text});
return .{ .done = .{} };
}
// Call all three events - the logger's ~input:* tap should intercept ALL of them!
~compute(x: 42)
| result r |> format(value: r.value)
| formatted f |> display(text: f.text)
| done |> _
Expected Output
compute(42)
[TAP] Intercepted: compute
format(84)
[TAP] Intercepted: format
Final: formatted
[TAP] Intercepted: display
Imported Files
// Universal logger using module-level event globbing
// Demonstrates the power of wildcard patterns in taps
~import "$std/taps"
const std = @import("std");
// Define a logging event
~pub event log { event_name: []const u8 }
| done {}
~proc log {
std.debug.print("[TAP] Intercepted: {s}\n", .{event_name});
return .{ .done = .{} };
}
// Module-level glob: Intercept ALL events from main module
// This single pattern matches input:compute, input:format, input:display, etc.
// Perfect for module-wide profiling or logging!
// Tap for compute event (.result branch)
// Note: Tap flows must end with void - they're observers, not transformers
~tap(input:* -> *)
| result |> log(event_name: "compute")
| done |> _
// Tap for format event (.formatted branch)
~tap(input:* -> *)
| formatted |> log(event_name: "format")
| done |> _
// Tap for display event (.done branch)
~tap(input:* -> *)
| done |> log(event_name: "display")
| done |> _
Test Configuration
MUST_RUN