015 abstract impl

// ============================================================================
// Test 064: Abstract Events and Implementation
// ============================================================================
// Abstract events allow declaring event signatures that can be implemented
// elsewhere in the program. This enables:
// - Library interfaces with user-provided implementations
// - Customizable coordination (e.g., compiler.coordinate)
// - Dependency inversion without runtime overhead
//
// Key properties:
// - ~[abstract] event declares the signature
// - ~proc in same file provides optional default implementation
// - ~module:event = ... provides THE implementation (module qualifier required)
// - Within implementation, event name delegates to default
// - Compile-time resolution, no runtime dispatch
//
// Design rationale:
// - Removes special-case hack for compiler.coordinate
// - Explicit via module qualifier (: indicates impl)
// - No inheritance hierarchies or virtual dispatch
// - Single implementation enforced at compile time
// - Delegation is explicit (not hidden like OOP super())
// ============================================================================

const std = @import("std");

// Example 1: Abstract event WITH default implementation
// The default can be called from within implementation via delegation
~[abstract] event coordinate { ctx: i32 }
| finished i32

~proc coordinate|zig {
    std.debug.print("Default coordination: {}\n", .{ctx});
    return .{ .finished = ctx };
}

// Example 2: Abstract event WITHOUT default implementation
// User MUST provide implementation or compile error
~[abstract] event process { data: i32 }
| done i32

// Helper proc for Example 4
~event double { value: i32 }
| result i32

~proc double|zig {
    return .{ .result = value * 2 };
}

// Example 3: Implementation that delegates to default and extends
// The module qualifier (input:) marks this as an impl override
// Module name is derived from filename: input.kz -> "input"
~input:coordinate =
    coordinate(ctx: 42)  // Delegates to default
    | finished f => finished f + 1

// Example 4: Implementation that provides complete logic
// No delegation to default (there isn't one for 'process')
~input:process =
    double(value: data)
    | result r => done r

// Use the implemented events
~coordinate(ctx: 10)
| finished _ |> _

~process(data: 5)
| done _ |> _