redscript-mc 2.6.0 → 2.6.2

package/src/examples/parkour_race.mcrs

@@ -92,7 +92,7 @@ fn race_tick() {
             let time: int = scoreboard_get(p, "pk_time");
             let seconds: int = time / 20;
             let ms: int = (time % 20) * 5;
-            actionbar(p, "§e⏱ " + seconds + "." + ms + "s");
+            actionbar(p, f"§e⏱ {seconds}.{ms}s");
             
             // Check fall
             check_fall(p);
@@ -109,7 +109,7 @@ fn check_fall(player: selector) {
     execute if entity player[y=..50] run {
         let cp: int = scoreboard_get(player, "pk_checkpoint");
         respawn_at_checkpoint(player, cp);
-        tell(player, "§cFell! Returning to checkpoint " + cp);
+        tell(player, f"§cFell! Returning to checkpoint {cp}");
         angry(player);
     }
 }
@@ -157,7 +157,7 @@ fn reach_checkpoint(player: selector, cp: int) {
     scoreboard_set(player, "pk_checkpoint", cp);
     
     title(player, "");
-    subtitle(player, "§aCheckpoint " + cp + " / " + CHECKPOINT_COUNT);
+    subtitle(player, f"§aCheckpoint {cp} / {CHECKPOINT_COUNT}");
     
     happy(player);
     playsound("minecraft:entity.experience_orb.pickup", "player", player);
@@ -194,19 +194,19 @@ fn finish_race(player: selector) {
         // First completion
         scoreboard_set(player, "pk_best", time);
         title(player, "§6Finished!");
-        subtitle(player, "§e" + seconds + "." + ms + "s §7(first record)");
-        announce("§b[Parkour] §fA player finished! Time: §e" + seconds + "." + ms + "s");
+        subtitle(player, f"§e{seconds}.{ms}s §7(first record)");
+        announce(f"§b[Parkour] §fA player finished! Time: §e{seconds}.{ms}s");
     } else {
         if (time < best) {
             // New record!
             scoreboard_set(player, "pk_best", time);
             title(player, "§6New Record!");
-            subtitle(player, "§e" + seconds + "." + ms + "s");
-            announce("§b[Parkour] §6New Record! §fTime: §e" + seconds + "." + ms + "s");
+            subtitle(player, f"§e{seconds}.{ms}s");
+            announce(f"§b[Parkour] §6New Record! §fTime: §e{seconds}.{ms}s");
             totem_effect(player);
         } else {
             title(player, "§aFinished!");
-            subtitle(player, "§e" + seconds + "." + ms + "s");
+            subtitle(player, f"§e{seconds}.{ms}s");
         }
     }
     

package/src/examples/tutorial_02_variables.mcrs

@@ -91,8 +91,8 @@ fn tally() {
     let total: int = yes_count + no_count
 
     say("=== Vote Results ===")
-    announce("YES: " + yes_count)
-    announce("NO:  " + no_count)
+    announce(f"YES: {yes_count}")
+    announce(f"NO:  {no_count}")
 
     if (total == 0) {
         say("No votes cast yet!")
@@ -116,7 +116,7 @@ fn tally() {
     // Show percentage with fixed-point arithmetic
     // Multiply by 10000 first to keep precision, then divide by total
     let yes_pct: fixed = (yes_count * 10000 / total) as fixed
-    announce("YES percentage (x10000): " + yes_pct)
+    announce(f"YES percentage (x10000): {yes_pct}")
 }
 
 // ─── While loop example ──────────────────────────────────────────────────────
@@ -125,7 +125,7 @@ fn tally() {
 fn count_down() {
     let i: int = 5
     while (i > 0) {
-        tell(@s, "Countdown: " + i)
+        tell(@s, f"Countdown: {i}")
         i = i - 1
     }
     tell(@s, "Done!")
@@ -138,7 +138,7 @@ fn for_demo() {
     // for loop: start, end (exclusive), step defaults to 1
     let i: int = 0
     while (i < 5) {
-        tell(@s, "Step " + i)
+        tell(@s, f"Step {i}")
         i = i + 1
     }
 }

package/src/examples/tutorial_03_functions_structs.mcrs

@@ -113,12 +113,12 @@ fn damage_boss() {
         boss.phase = new_phase
         scoreboard_set("#boss", "boss_phase", boss.phase)
         let phase_name: string = describe_phase(boss.phase)
-        announce("Boss entered phase " + boss.phase + ": " + phase_name + "!")
-        title(@a, "Phase " + boss.phase)
+        announce(f"Boss entered phase {boss.phase}: {phase_name}!")
+        title(@a, f"Phase {boss.phase}")
     }
 
     let pct: int = hp_percentage(boss.current_hp, boss.max_hp)
-    announce("Boss HP: " + boss.current_hp + "/" + boss.max_hp + " (" + pct + "%)")
+    announce(f"Boss HP: {boss.current_hp}/{boss.max_hp} ({pct}%)")
 
     // Check for death
     if (boss.current_hp <= 0) {
@@ -156,7 +156,7 @@ fn check_status() {
     let pct: int = hp_percentage(boss.current_hp, boss.max_hp)
     let phase_name: string = describe_phase(boss.phase)
     tell(@s, "=== Boss Status ===")
-    tell(@s, "HP: " + boss.current_hp + "/" + boss.max_hp)
-    tell(@s, "Health: " + pct + "%")
-    tell(@s, "Phase: " + phase_name)
+    tell(@s, f"HP: {boss.current_hp}/{boss.max_hp}")
+    tell(@s, f"Health: {pct}%")
+    tell(@s, f"Phase: {phase_name}")
 }

package/src/examples/tutorial_04_selectors.mcrs

@@ -89,7 +89,7 @@ fn demo_selectors() {
     foreach (p in @a[distance=..10]) {
         in_zone_count = in_zone_count + 1
     }
-    tell(@s, "Players in zone: " + in_zone_count)
+    tell(@s, f"Players in zone: {in_zone_count}")
 }
 
 // ─── Tag-based selection ─────────────────────────────────────────────────────

package/src/examples/tutorial_05_decorators.mcrs

@@ -57,14 +57,14 @@ fn every_second() {
 }
 
 fn show_countdown(sec: int) {
-    tell(@a, "Countdown: " + sec)
+    tell(@a, f"Countdown: {sec}")
     // Color changes as time runs out
     if (sec <= 3) {
         subtitle(@a, "Hurry!")
-        actionbar(@a, "⏱ " + sec + " seconds!")
+        actionbar(@a, f"⏱ {sec} seconds!")
     } else {
         subtitle(@a, "Get ready...")
-        actionbar(@a, "Countdown: " + sec)
+        actionbar(@a, f"Countdown: {sec}")
     }
 }
 

package/src/examples/tutorial_06_math_particles.mcrs

@@ -24,42 +24,42 @@ fn setup() {
 fn demo_math() {
     // abs — absolute value
     let neg: int = abs(-42)             // 42
-    tell(@s, "abs(-42) = " + neg)
+    tell(@s, f"abs(-42) = {neg}")
 
     // min / max
     let lo: int = min(10, 20)           // 10
     let hi: int = max(10, 20)           // 20
-    tell(@s, "min(10,20) = " + lo + "  max(10,20) = " + hi)
+    tell(@s, f"min(10,20) = {lo}  max(10,20) = {hi}")
 
     // clamp — restrict a value to a range
     let clamped: int = clamp(150, 0, 100)   // 100
-    tell(@s, "clamp(150, 0, 100) = " + clamped)
+    tell(@s, f"clamp(150, 0, 100) = {clamped}")
 
     // isqrt — integer square root
     let root: int = isqrt(144)          // 12
-    tell(@s, "isqrt(144) = " + root)
+    tell(@s, f"isqrt(144) = {root}")
 
     // sqrt_fixed — fixed-point sqrt (scale = 1000)
     let sq2: int = sqrt_fixed(2000)     // ~1414 = sqrt(2) * 1000
-    tell(@s, "sqrt_fixed(2000) = " + sq2 + "  (sqrt(2) * 1000 = 1414)")
+    tell(@s, f"sqrt_fixed(2000) = {sq2}  (sqrt(2) * 1000 = 1414)")
 
     // sqrt_fx — fixed-point sqrt (scale = 10000)
     let sq2_hp: int = sqrt_fx(20000)    // ~14142 = sqrt(2) * 10000
-    tell(@s, "sqrt_fx(20000) = " + sq2_hp)
+    tell(@s, f"sqrt_fx(20000) = {sq2_hp}")
 
     // sin_fixed / cos_fixed — trig in degrees, result * 1000
     let sin30: int = sin_fixed(30)      // 500 = 0.5 * 1000
     let cos60: int = cos_fixed(60)      // 500
-    tell(@s, "sin_fixed(30) = " + sin30 + "  cos_fixed(60) = " + cos60)
+    tell(@s, f"sin_fixed(30) = {sin30}  cos_fixed(60) = {cos60}")
 
     // lerp — linear interpolation  lerp(a, b, t) with t in [0,1000]
     let midpoint: int = lerp(100, 200, 500)   // 150
-    tell(@s, "lerp(100, 200, 500) = " + midpoint)
+    tell(@s, f"lerp(100, 200, 500) = {midpoint}")
 
     // mulfix — multiply two fixed-point values (scale=1000)
     // mulfix(a,b) = a*b/1000
     let product: int = mulfix(sin30, cos60)   // 500*500/1000 = 250
-    tell(@s, "mulfix(500, 500) = " + product + "  (0.5 * 0.5 = 0.25 * 1000 = 250)")
+    tell(@s, f"mulfix(500, 500) = {product}  (0.5 * 0.5 = 0.25 * 1000 = 250)")
 }
 
 // ─── Draw a circle of particles ──────────────────────────────────────────────

package/src/examples/tutorial_07_random.mcrs

@@ -79,11 +79,11 @@ fn open_chest() {
     let seed3: int = advance_seed()
     let bonus: int = binomial_sample(3, 2500, seed3)   // 3 trials, 25% each → 0..3
 
-    tell(@s, "Found: " + count + "x " + name)
+    tell(@s, f"Found: {count}x {name}")
     give(@s, item, count)
 
     if (bonus > 0) {
-        tell(@s, "BONUS! +" + bonus + " extra chests!")
+        tell(@s, f"BONUS! +{bonus} extra chests!")
         let b: int = 0
         while (b < bonus) {
             let bseed: int = advance_seed()
@@ -108,7 +108,7 @@ fn terrain_demo() {
     let i: int = 0
     while (i < 5) {
         let h: int = terrain_height(i, 0, 64, 20)
-        tell(@s, "x=" + i + " → height=" + h)
+        tell(@s, f"x={i} → height={h}")
         i = i + 1
     }
 }
@@ -123,7 +123,7 @@ fn fbm_demo() {
         // x_fx in ×10000 fixed-point: i * 5000 = 0.0, 0.5, 1.0, ...
         let x_fx: int = i * 5000
         let n: int = fbm_1d(x_fx, 4, 5000)   // 4 octaves, persistence=0.5
-        tell(@s, "fbm(" + i + "/2) = " + n)
+        tell(@s, f"fbm({i}/2) = {n}")
         i = i + 1
     }
 }

package/src/examples/tutorial_08_coroutine.mcrs

@@ -81,7 +81,7 @@ fn run_scan() {
         // Progress update every 1000 blocks (every 20 ticks)
         if (scan.blocks_checked % 1000 == 0) {
             let pct: int = scan.blocks_checked * 100 / 10000
-            actionbar(@a, "Scanning: " + pct + "% (" + scan.blocks_checked + "/10000)")
+            actionbar(@a, f"Scanning: {pct}% ({scan.blocks_checked}/10000)")
         }
 
         i = i + 1
@@ -97,17 +97,17 @@ fn scan_complete() {
     scan.scan_running = 0
 
     say("=== Scan Complete! ===")
-    say("Blocks checked: " + scan.blocks_checked)
-    say("Special blocks found: " + scan.special_found)
+    say(f"Blocks checked: {scan.blocks_checked}")
+    say(f"Special blocks found: {scan.special_found}")
 
     title(@a, "Scan Done!")
     let found: int = scan.special_found
-    subtitle(@a, "Special blocks found: " + found)
+    subtitle(@a, f"Special blocks found: {found}")
 
     // Give a report item to all players
     foreach (p in @a) {
         give(p, "minecraft:paper", 1)
-        tell(p, "Your scan report: " + scan.special_found + " special blocks in 100x100 region")
+        tell(p, f"Your scan report: {scan.special_found} special blocks in 100x100 region")
     }
 }
 
@@ -116,12 +116,12 @@ fn scan_complete() {
 @on_trigger("scan_status")
 fn scan_status() {
     if (scan.scan_running == 0) {
-        tell(@s, "No scan running. Last result: " + scan.special_found + " special blocks")
+        tell(@s, f"No scan running. Last result: {scan.special_found} special blocks")
         return
     }
 
     let pct: int = scan.blocks_checked * 100 / 10000
-    tell(@s, "Scan in progress: " + pct + "% (" + scan.blocks_checked + "/10000)")
+    tell(@s, f"Scan in progress: {pct}% ({scan.blocks_checked}/10000)")
 }
 
 // ─── Chained coroutine example ───────────────────────────────────────────────

package/src/examples/tutorial_09_precision.mcrs

@@ -39,29 +39,29 @@ fn fixed_demo() {
     // Multiplying needs manual rescaling: a*b/10000
 
     let sum: int = (a as int) + (b as int)   // 40000 = 4.0
-    tell(@s, "1.5 + 2.5 = " + sum + " (×10000, real value = 4.0)")
+    tell(@s, f"1.5 + 2.5 = {sum} (×10000, real value = 4.0)")
 
     // Multiply: must divide by 10000 to stay in scale
     let product: int = mulfix(a as int, b as int)   // 15000*25000/1000 ≈ 375000? No!
     // mulfix uses scale=1000, but our fixed uses scale=10000
     // For ×10000 scale: use (a * b) / 10000
     let product_fx: int = (a as int) * (b as int) / 10000
-    tell(@s, "1.5 * 2.5 = " + product_fx + " (×10000, real value = 3.75)")
+    tell(@s, f"1.5 * 2.5 = {product_fx} (×10000, real value = 3.75)")
 
     // Percentage calculation
     let score: int = 750    // raw score
     let max_score: int = 1000
     let pct_fx: fixed = (score * 10000 / max_score) as fixed  // 7500 = 75.00%
-    tell(@s, "Score " + score + "/" + max_score + " = " + (pct_fx as int) + " (×10000 = 75.00%)")
+    tell(@s, f"Score {score}/{max_score} = {(pct_fx as int)} (×10000 = 75.00%)")
 
     // sqrt_fx: fixed-point square root (×10000 scale)
     // sqrt_fx(20000) ≈ 14142 means sqrt(2.0) ≈ 1.4142
     let sqrt2: int = sqrt_fx(20000)
-    tell(@s, "sqrt(2.0) ≈ " + sqrt2 + " (×10000)")
+    tell(@s, f"sqrt(2.0) ≈ {sqrt2} (×10000)")
 
     // sin_fixed: degrees, result ×1000 (note: math lib uses scale=1000 not 10000)
     let sin45: int = sin_fixed(45)   // ≈ 707
-    tell(@s, "sin(45°) ≈ " + sin45 + " (×1000 = 0.707)")
+    tell(@s, f"sin(45°) ≈ {sin45} (×1000 = 0.707)")
 }
 
 // ─── Compound interest with fixed-point ─────────────────────────────────────
@@ -86,7 +86,7 @@ fn compound_interest() {
         t = t + 1
     }
 
-    tell(@s, "Fixed-point result: " + amount + " (expected ~1629)")
+    tell(@s, f"Fixed-point result: {amount} (expected ~1629)")
     scoreboard_set("#result_fx", "result_display", amount)
     scoreboard_set("#result_fx", "precision_data", amount)
 
@@ -96,7 +96,7 @@ fn compound_interest() {
     let yr: int = 1
     while (yr <= 5) {
         a = a * base_fx / 10000
-        tell(@s, "Year " + yr + ": " + a)
+        tell(@s, f"Year {yr}: {a}")
         yr = yr + 1
     }
 }
@@ -119,7 +119,7 @@ fn compound_double() {
     // Convert result to int (×10000) to display
     let result_int: int = result as int
     scoreboard_set("#result_dbl", "result_display", result_int)
-    tell(@s, "Double result (×10000): " + result_int + " (expected ~16289 = 1.6289)")
+    tell(@s, f"Double result (×10000): {result_int} (expected ~16289 = 1.6289)")
 
     // Compare precision
     // Fixed:  1000 * 10500^10 / 10000^10  (integer truncation each step)
@@ -135,20 +135,20 @@ fn cast_demo() {
 
     let i: int = 42
     let f: fixed = i as fixed       // int → fixed: just stores as-is (42 as fixed)
-    tell(@s, "int 42 as fixed = " + (f as int) + " (note: fixed stores the raw int)")
+    tell(@s, f"int 42 as fixed = {(f as int)} (note: fixed stores the raw int)")
 
     // To represent 4.2 as fixed: store 42000 (4.2 × 10000)
     let four_two: fixed = 42000 as fixed
-    tell(@s, "4.2 as fixed = " + (four_two as int) + " (×10000)")
+    tell(@s, f"4.2 as fixed = {(four_two as int)} (×10000)")
 
     // fixed → int: drops the scale factor, use / 10000 for real value
     let raw: int = four_two as int
     let real: int = raw / 10000   // integer part
     let decimal: int = raw % 10000   // decimal part (×10000)
-    tell(@s, "4.2 in fixed: integer=" + real + " decimal=" + decimal)
+    tell(@s, f"4.2 in fixed: integer={real} decimal={decimal}")
 
     // double → int: reads the double as a ×10000 fixed integer
     let d: double = 3.14d
     let d_int: int = d as int
-    tell(@s, "3.14d as int = " + d_int + " (×10000 = 31400)")
+    tell(@s, f"3.14d as int = {d_int} (×10000 = 31400)")
 }

package/src/examples/tutorial_10_kill_race.mcrs

@@ -74,7 +74,7 @@ fn game_timer() {
 
 fn countdown_tick() {
     game.timer = game.timer - 1
-    actionbar(@a, "Game starting in " + game.timer + "...")
+    actionbar(@a, f"Game starting in {game.timer}...")
 
     if (game.timer <= 0) {
         begin_game()
@@ -91,11 +91,11 @@ fn playing_tick() {
     // Actionbar with time remaining
     let mins: int = game.timer / 60
     let secs: int = game.timer % 60
-    actionbar(@a, "⏱ " + mins + "m " + secs + "s remaining — get kills!")
+    actionbar(@a, f"⏱ {mins}m {secs}s remaining — get kills!")
 
     if (game.timer <= 10) {
         // Warning sound region
-        actionbar(@a, "⚠ FINAL " + game.timer + " SECONDS!")
+        actionbar(@a, f"⚠ FINAL {game.timer} SECONDS!")
     }
 
     if (game.timer <= 0) {
@@ -257,17 +257,17 @@ fn announce_winner() {
         let k: int = scoreboard_get(p, "kr_kills")
         if (k == top_kills) {
             title(p, "You Win!")
-            subtitle(p, "Top score: " + top_kills + " kills!")
+            subtitle(p, f"Top score: {top_kills} kills!")
             buff_all(p, 60)
             give(p, "minecraft:diamond", top_kills)
-            tell(p, "Winner's prize: " + top_kills + " diamonds!")
+            tell(p, f"Winner's prize: {top_kills} diamonds!")
         } else {
             title(p, "Game Over")
-            subtitle(p, "Your kills: " + k)
+            subtitle(p, f"Your kills: {k}")
         }
     }
 
-    announce("Kill Race winner had " + top_kills + " kills!")
+    announce(f"Kill Race winner had {top_kills} kills!")
 }
 
 @schedule(200)

package/src/examples/zombie_survival.mcrs

@@ -90,7 +90,7 @@ fn start_prep_phase() {
     state.prep_timer = WAVE_DELAY;
     state.wave = state.wave + 1;
     
-    announce("§4[Zombie Survival] §eWave " + state.wave + " incoming!");
+    announce(f"§4[Zombie Survival] §eWave {state.wave} incoming!");
     announce("§7Preparation time: 10 seconds...");
     
     // Shop hint
@@ -110,7 +110,7 @@ fn start_combat_phase() {
     bossbar_set_max("zs_wave", zombie_count);
     bossbar_set_value("zs_wave", zombie_count);
     
-    title(@a, "§cWave " + state.wave);
+    title(@a, f"§cWave {state.wave}");
     
     // Spawn zombies
     spawn_zombies(zombie_count);
@@ -138,7 +138,7 @@ fn spawn_zombies(count: int) {
         }
     }
     
-    announce("§c" + count + " zombies have appeared!");
+    announce(f"§c{count} zombies have appeared!");
 }
 
 // ===== Every Tick =====
@@ -200,7 +200,7 @@ fn combat_tick() {
 }
 
 fn wave_complete() {
-    announce("§4[Zombie Survival] §aWave " + state.wave + " complete!");
+    announce(f"§4[Zombie Survival] §aWave {state.wave} complete!");
     
     // Reward coins
     let reward: int = 50 + (state.wave * 25);
@@ -208,7 +208,7 @@ fn wave_complete() {
         scoreboard_add(p, "zs_coins", reward);
         happy(p);
     }
-    announce("§6+" + reward + " coins");
+    announce(f"§6+{reward} coins");
     
     // Check special wave
     if (state.wave == 10) {
@@ -291,8 +291,8 @@ fn game_over() {
     state.running = 0;
     
     title(@a, "§cGame Over");
-    subtitle(@a, "§7Survived " + state.wave + " waves");
-    announce("§4[Zombie Survival] §cAll players eliminated! Highest wave: " + state.wave);
+    subtitle(@a, f"§7Survived {state.wave} waves");
+    announce(f"§4[Zombie Survival] §cAll players eliminated! Highest wave: {state.wave}");
     
     // Clean up zombies
     kill(@e[type=zombie]);

package/src/hir/lower.ts

@@ -13,11 +13,11 @@
 
 import type {
   Program, Expr, Stmt, Block, FnDecl, Param,
-  AssignOp, ExecuteSubcommand,
+  AssignOp, ExecuteSubcommand, MatchPattern,
 } from '../ast/types'
 import type {
   HIRModule, HIRFunction, HIRParam, HIRExpr, HIRStmt, HIRBlock,
-  HIRExecuteSubcommand, HIRStruct, HIRImplBlock, HIREnum, HIRConst, HIRGlobal,
+  HIRExecuteSubcommand, HIRStruct, HIRImplBlock, HIREnum, HIRConst, HIRGlobal, HIRMatchPattern,
 } from './types'
 
 // ---------------------------------------------------------------------------
@@ -54,6 +54,20 @@ export function lowerToHIR(program: Program): HIRModule {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Pattern lowering
+// ---------------------------------------------------------------------------
+
+function lowerMatchPattern(pat: MatchPattern): HIRMatchPattern {
+  switch (pat.kind) {
+    case 'PatSome': return pat
+    case 'PatNone': return pat
+    case 'PatInt':  return pat
+    case 'PatWild': return pat
+    case 'PatExpr': return { kind: 'PatExpr', expr: lowerExpr(pat.expr) }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Functions & globals
 // ---------------------------------------------------------------------------
@@ -248,6 +262,83 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
       return [initStmt, whileStmt]
     }
 
+    // --- Desugaring: for_each → let __for_len = arr.len(); let __for_i = 0; while(__for_i < __for_len) { let item = arr[__for_i]; body; __for_i = __for_i + 1 } ---
+    case 'for_each': {
+      // Use a counter suffix to avoid collisions in nested for_each
+      const id = forEachCounter++
+      const idxName = `__foreach_i_${id}`
+      const lenName = `__foreach_len_${id}`
+      const arrExpr = lowerExpr(stmt.array)
+
+      // let __foreach_len_N = arr.len()
+      const lenInitStmt: HIRStmt = {
+        kind: 'let',
+        name: lenName,
+        type: { kind: 'named', name: 'int' },
+        init: {
+          kind: 'invoke',
+          callee: { kind: 'member', obj: arrExpr, field: 'len' },
+          args: [],
+        },
+        span: stmt.span,
+      }
+
+      // let __foreach_i_N = 0
+      const idxInitStmt: HIRStmt = {
+        kind: 'let',
+        name: idxName,
+        type: { kind: 'named', name: 'int' },
+        init: { kind: 'int_lit', value: 0 },
+        span: stmt.span,
+      }
+
+      // let item = arr[__foreach_i_N]
+      const bindingInit: HIRStmt = {
+        kind: 'let',
+        name: stmt.binding,
+        type: undefined,
+        init: {
+          kind: 'index',
+          obj: arrExpr,
+          index: { kind: 'ident', name: idxName },
+        },
+        span: stmt.span,
+      }
+
+      // __foreach_i_N = __foreach_i_N + 1
+      const stepStmt: HIRStmt = {
+        kind: 'expr',
+        expr: {
+          kind: 'assign',
+          target: idxName,
+          value: {
+            kind: 'binary',
+            op: '+',
+            left: { kind: 'ident', name: idxName },
+            right: { kind: 'int_lit', value: 1 },
+          },
+        },
+        span: stmt.span,
+      }
+
+      const body = [bindingInit, ...lowerBlock(stmt.body)]
+      const step: HIRStmt[] = [stepStmt]
+
+      const whileStmt: HIRStmt = {
+        kind: 'while',
+        cond: {
+          kind: 'binary',
+          op: '<',
+          left: { kind: 'ident', name: idxName },
+          right: { kind: 'ident', name: lenName },
+        },
+        body,
+        step,
+        span: stmt.span,
+      }
+      return [lenInitStmt, idxInitStmt, whileStmt]
+    }
+
     case 'foreach':
       return {
         kind: 'foreach',
@@ -263,7 +354,7 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
         kind: 'match',
         expr: lowerExpr(stmt.expr),
         arms: stmt.arms.map(arm => ({
-          pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+          pattern: lowerMatchPattern(arm.pattern),
           body: lowerBlock(arm.body),
         })),
         span: stmt.span,
@@ -340,6 +431,9 @@ function lowerExecuteSubcommand(sub: ExecuteSubcommand): HIRExecuteSubcommand {
 // Expressions
 // ---------------------------------------------------------------------------
 
+/** Counter to generate unique variable names for for_each desugaring */
+let forEachCounter = 0
+
 /** Map compound assignment operator to its base binary op */
 const COMPOUND_TO_BINOP: Record<string, string> = {
   '+=': '+',

package/src/hir/monomorphize.ts

@@ -21,7 +21,7 @@
 
 import type {
   HIRModule, HIRFunction, HIRParam, HIRExpr, HIRStmt, HIRBlock,
-  TypeNode,
+  TypeNode, HIRMatchPattern,
 } from './types'
 
 // ---------------------------------------------------------------------------
@@ -258,10 +258,15 @@ class Monomorphizer {
         return {
           ...stmt,
           expr: this.rewriteExpr(stmt.expr, ctx),
-          arms: stmt.arms.map(arm => ({
-            pattern: arm.pattern ? this.rewriteExpr(arm.pattern, ctx) : null,
-            body: this.rewriteBlock(arm.body, ctx),
-          })),
+          arms: stmt.arms.map(arm => {
+            let pattern: HIRMatchPattern
+            if (arm.pattern.kind === 'PatExpr') {
+              pattern = { kind: 'PatExpr', expr: this.rewriteExpr(arm.pattern.expr, ctx) }
+            } else {
+              pattern = arm.pattern
+            }
+            return { pattern, body: this.rewriteBlock(arm.body, ctx) }
+          }),
         }
       case 'execute':
         return { ...stmt, body: this.rewriteBlock(stmt.body, ctx) }

package/src/hir/types.ts

@@ -130,6 +130,17 @@ export type HIRExecuteSubcommand =
   | { kind: 'store_result'; target: string; targetObj: string }
   | { kind: 'store_success'; target: string; targetObj: string }
 
+// ---------------------------------------------------------------------------
+// HIR Match Patterns
+// ---------------------------------------------------------------------------
+
+export type HIRMatchPattern =
+  | { kind: 'PatSome'; binding: string }   // Some(x)
+  | { kind: 'PatNone' }                    // None
+  | { kind: 'PatInt'; value: number }      // 1, 2, 3
+  | { kind: 'PatWild' }                    // _
+  | { kind: 'PatExpr'; expr: HIRExpr }     // legacy: range_lit or other expr
+
 // ---------------------------------------------------------------------------
 // HIR Statements
 // ---------------------------------------------------------------------------
@@ -146,7 +157,7 @@ export type HIRStmt =
   // foreach preserved (entity iteration is MC-specific, not just sugar)
   | { kind: 'foreach'; binding: string; iterable: HIRExpr; body: HIRBlock; executeContext?: string; span?: Span }
   // match preserved (not trivially desugarable)
-  | { kind: 'match'; expr: HIRExpr; arms: { pattern: HIRExpr | null; body: HIRBlock }[]; span?: Span }
+  | { kind: 'match'; expr: HIRExpr; arms: { pattern: HIRMatchPattern; body: HIRBlock }[]; span?: Span }
   // Unified execute block (absorbs as_block, at_block, as_at, execute)
   | { kind: 'execute'; subcommands: HIRExecuteSubcommand[]; body: HIRBlock; span?: Span }
   | { kind: 'raw'; cmd: string; span?: Span }