007 simple loop

// Hand-written Zig baseline for label loops
// This is what Koru label loops (#/@) SHOULD compile to
//
// Tests:
// 1. Live loop (sum 0 to 1M) - should be optimized well
// 2. Dead loop (unused result) - should be eliminated entirely

const std = @import("std");

fn count_to_million() u64 {
    var sum: u64 = 0;
    var i: u64 = 0;
    while (i < 10_000_000) : (i += 1) {
        sum += i;
    }
    return sum;
}

// Dead loop - compiler should eliminate this entirely
fn dead_loop() void {
    var i: u64 = 0;
    while (i < 1_000_000) : (i += 1) {
        // Do nothing
    }
}

pub fn main() !void {
    // Live loop
    const result = count_to_million();
    std.debug.print("Sum: {}\n", .{result});

    // Dead loop - result unused
    // In -O ReleaseFast, Zig should eliminate this entirely
    dead_loop();
}

#!/bin/bash
# Benchmark: Simple loop
# Compare Koru vs hand-written Zig

set -e

echo "Building baseline (Zig)..."
zig build-exe baseline.zig -O ReleaseFast

echo "Building Koru version..."
# Assuming output_emitted.zig or output exists from test runner
if [ -f "output_emitted.zig" ]; then
    zig build-exe output_emitted.zig -O ReleaseFast -femit-bin=koru_output
elif [ -f "output" ]; then
    # Already compiled, copy it
    cp output koru_output
    chmod +x koru_output
else
    echo "ERROR: No Koru output found (output_emitted.zig or output)"
    exit 1
fi

echo ""
echo "Running benchmarks with hyperfine..."

# Check if hyperfine is installed
if ! command -v hyperfine &> /dev/null; then
    echo "ERROR: hyperfine not installed"
    echo "Install with: brew install hyperfine (macOS) or cargo install hyperfine"
    exit 1
fi

# Run benchmark
# Use --shell=none to avoid shell startup overhead (benchmarks are <5ms)
# Use more runs for better statistics on fast benchmarks
hyperfine --warmup 5 --runs 30 --shell=none \
    --export-json results.json \
    --command-name "Baseline (Zig)" './baseline' \
    --command-name "Koru" './koru_output'

echo ""
echo "Benchmark complete! Results saved to results.json"

// MINIMAL TEST: Does label loop work at all?
// Just count to 10 and print each iteration

const std = @import("std");

// Count event - loop controller
~tor count { i: u64 }
| next u64

~proc count|zig {
    if (i < 10) {
        return .{ .next = i + 1 };
    } else {
    }
}

// Print event
~tor print { i: u64 }

~proc print|zig {
    std.debug.print("i = {}\n", .{i});
}

// Loop: count and print each iteration
~#loop count(i: 0)
| next n |> print(n.i) |> @loop(n.i)

#!/bin/bash
# Inspect what code was actually generated
# Compare Koru's label loops to Zig's while loops

echo "======================================"
echo "Generated Koru Code (output_emitted.zig)"
echo "======================================"
echo ""

if [ -f "output_emitted.zig" ]; then
    echo "Looking for loop patterns..."
    echo ""

    echo "1. Label-based loop (should look like: loop_x: while (true) { ... continue :loop_x; })"
    grep -A 10 "loop_.*: while" output_emitted.zig | head -15 || echo "  (not found - may use different pattern)"

    echo ""
    echo "2. Dead loop (should be eliminated or very simple)"
    grep -B 2 -A 5 "dead_loop\|dead.*while" output_emitted.zig | head -10 || echo "  ✅ Dead loop eliminated (not found in output)"

    echo ""
    echo "3. Main function"
    grep -A 20 "pub fn main" output_emitted.zig | head -25
else
    echo "❌ output_emitted.zig not found"
    echo "   Run: koruc input.kz"
fi

echo ""
echo "======================================"
echo "Baseline Zig Code"
echo "======================================"
echo ""
cat baseline.zig