From 6b5edc77b4f1e60597a7588537153a217be7ec3d Mon Sep 17 00:00:00 2001
From: agra <alex@swipelab.co>
Date: Sun, 31 May 2026 10:57:21 +0300
Subject: [PATCH] lang: require ':' before a for-loop range cursor
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cursor clause now matches the collection form's ': (capture)' — 'for 0..N: (i)' instead of 'for 0..N (i)'. The colon is required when a cursor is present; the no-cursor form 'for 0..N { }' is unchanged. Updated examples/200, the pack-index doc comment, and the spec.
---
 examples/163-pack-runtime-index.sx |  2 +-
 examples/200-for-range.sx          | 10 +++++-----
 specs.md                           | 10 ++++++----
 src/parser.zig                     |  7 +++++--
 4 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/examples/163-pack-runtime-index.sx b/examples/163-pack-runtime-index.sx
index d68ec05..17b88e5 100644
--- a/examples/163-pack-runtime-index.sx
+++ b/examples/163-pack-runtime-index.sx
@@ -6,7 +6,7 @@
 // constant (a literal, or an `inline for` cursor). A runtime index (here a
 // `while`-loop counter) must produce a clear diagnostic, not the confusing
 // "unresolved 'args'" the slice-index fall-through used to give. To walk a
-// pack, use `inline for 0..args.len (i) { ... }`, which unrolls so each
+// pack, use `inline for 0..args.len: (i) { ... }`, which unrolls so each
 // `args[i]` is a comptime index.
 
 #import "modules/std.sx";
diff --git a/examples/200-for-range.sx b/examples/200-for-range.sx
index 369eeb2..e95401b 100644
--- a/examples/200-for-range.sx
+++ b/examples/200-for-range.sx
@@ -1,5 +1,5 @@
-// Range-based for loops: `for start..end (i) { }` (cursor optional, `end`
-// exclusive) is a runtime counting loop; `inline for start..end (i) { }`
+// Range-based for loops: `for start..end: (i) { }` (cursor optional, `end`
+// exclusive) is a runtime counting loop; `inline for start..end: (i) { }`
 // is comptime-unrolled — the cursor is a compile-time constant each
 // iteration, so `xs[i]` over a heterogeneous pack substitutes the concrete
 // per-position element (this is what drives pack iteration).
@@ -16,14 +16,14 @@ impl Show for B { show :: (self: *B) -> string => "B"; }
 
 // Comptime-unrolled iteration over a pack; cursor `i` indexes the pack.
 each :: (..xs: Show) -> void {
-    inline for 0..xs.len (i) {
+    inline for 0..xs.len: (i) {
         print("[{}]={}\n", i, xs[i].show());
     }
 }
 
 main :: () -> s32 {
     // Runtime range, cursor used.
-    for 0..3 (i) { print("i={}\n", i); }
+    for 0..3: (i) { print("i={}\n", i); }
 
     // Runtime range, no cursor — body runs `end - start` times.
     n := 0;
@@ -31,7 +31,7 @@ main :: () -> s32 {
     print("n={}\n", n);
 
     // Non-zero start.
-    for 2..5 (j) { print("j={}\n", j); }
+    for 2..5: (j) { print("j={}\n", j); }
 
     // Inline unroll over a heterogeneous pack.
     each(A.{ x = 1 }, B.{ s = "hi" }, A.{ x = 3 });
diff --git a/specs.md b/specs.md
index 6ad01d3..4a74148 100644
--- a/specs.md
+++ b/specs.md
@@ -1540,15 +1540,17 @@ while i < 10 {
 
 #### Range form
 ```sx
-for start..end (i) { }              // counting loop, cursor `i` (s64), `end` exclusive
+for start..end: (i) { }             // counting loop, cursor `i` (s64), `end` exclusive
 for start..end { }                  // no cursor — body runs `end - start` times
-inline for start..end (i) { }       // comptime-unrolled; `i` is a comptime constant per iteration
+inline for start..end: (i) { }      // comptime-unrolled; `i` is a comptime constant per iteration
 ```
 `start` and `end` are `s64` expressions; the loop counts `start, start+1, …, end-1`.
-The cursor parens are optional — omit them when the body doesn't need the index.
+The cursor is optional — omit `: (i)` entirely when the body doesn't need the index
+(`for 0..n { … }`). When present it is introduced by `:`, matching the collection
+form (`for xs: (x)`).
 The `inline` variant requires comptime-known bounds and unrolls the body once per
 value, binding the cursor as a compile-time constant (so it can index a pack:
-`inline for 0..xs.len (i) { xs[i].m() }`). `break;` / `continue;` work in the
+`inline for 0..xs.len: (i) { xs[i].m() }`). `break;` / `continue;` work in the
 runtime form.
 
 #### Collection form
diff --git a/src/parser.zig b/src/parser.zig
index 41614b4..98853df 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -2867,9 +2867,12 @@ pub const Parser = struct {
         var capture_by_ref = false;
 
         if (range_end != null) {
-            // Range capture is the optional cursor: `(i)` or nothing.
-            if (self.current.tag == .l_paren) {
+            // Optional cursor, introduced by `:` for symmetry with the
+            // collection form: `for 0..N: (i)` (or `for 0..N` with no cursor).
+            // The colon is required when a cursor is present.
+            if (self.current.tag == .colon) {
                 self.advance();
+                try self.expect(.l_paren);
                 if (self.current.tag != .identifier) return self.fail("expected cursor variable name");
                 capture_name = self.tokenSlice(self.current);
                 self.advance();