Unify ConditionalFormula evaluation and add algebraic fusion for chained NaturalArray transforms

src/main/cod/demo/src/main/test/broadcast/Broadcast.cod

@@ -40,6 +40,24 @@ Broadcaster {
         out("reduced = " + reduced + " (expect 10)")
         out("reducedNamed = " + reducedNamed + " (expect 10)")
         out("reduceResult = " + reduceResult + " (expect 10)")
+
+        scanned := [4, 5, 6].scan()
+        out("scanned[1] = " + scanned[1] + " (expect 5)")
+
+        zipped := [1, 2, 3].zip([10, 20, 30])
+        out("zipped[0][0] = " + zipped[0][0] + " (expect 1)")
+        out("zipped[0][1] = " + zipped[0][1] + " (expect 10)")
+        out("zipped[2][0] = " + zipped[2][0] + " (expect 3)")
+        out("zipped[2][1] = " + zipped[2][1] + " (expect 30)")
+
+        zippedCombined := [1, 2, 3].zip([10, 20, 30], \(left, right) left + right)
+        out("zippedCombined[0] = " + zippedCombined[0] + " (expect 11)")
+        out("zippedCombined[2] = " + zippedCombined[2] + " (expect 33)")
+
+        emptyArr := []
+        nonEmptyArr := [1]
+        out("emptyArr.isEmpty() = " + emptyArr.isEmpty() + " (expect true)")
+        out("nonEmptyArr.isEmpty() = " + nonEmptyArr.isEmpty() + " (expect false)")
     }
 
 }

src/main/cod/demo/src/main/test/multiarray/ConditionalFormulaOptimization.cod

@@ -0,0 +1,68 @@
+unit test.multiarray
+
+local isUnderThreshold(value: int, threshold: int) :: ok: bool {
+    ~> (ok: value < threshold)
+}
+
+share main() {
+    out("=== Conditional formula optimization ===")
+
+    optimized := [0 to 60]
+    for i of [0 to 60] {
+        if i % 2 == 0 {
+            base := i * 3
+            optimized[i] = base + 1
+        } elif i % 5 == 0 {
+            shifted := i + 7
+            optimized[i] = shifted * 2
+        } else {
+            optimized[i] = i - 1
+        }
+    }
+
+    out("optimized[10]=" + optimized[10] + " expected=31")
+    out("optimized[25]=" + optimized[25] + " expected=64")
+    out("optimized[7]=" + optimized[7] + " expected=6")
+
+    fallback := [0 to 40]
+    for i of [0 to 40] {
+        if isUnderThreshold(i, 12) {
+            fallback[i] = i + 100
+        } else {
+            fallback[i] = i - 100
+        }
+    }
+
+    out("fallback[5]=" + fallback[5] + " expected=105")
+    out("fallback[20]=" + fallback[20] + " expected=-80")
+
+    constantTrue := [0 to 12]
+    for i of [0 to 12] {
+        if true {
+            constantTrue[i] = i + 9
+        } else {
+            constantTrue[i] = i - 9
+        }
+    }
+    out("constantTrue[3]=" + constantTrue[3] + " expected=12")
+
+    constantFalse := [0 to 12]
+    for i of [0 to 12] {
+        if false {
+            constantFalse[i] = i + 9
+        } else {
+            constantFalse[i] = i - 9
+        }
+    }
+    out("constantFalse[3]=" + constantFalse[3] + " expected=-6")
+
+    fusedMapped := optimized.map(\(x) x + 3).map(\(x) x * 2)
+    fusedFiltered := fusedMapped.filter(">=", 40).filter("<=", 150)
+    out("fusedMapped[0]=" + fusedMapped[0] + " expected=8")
+    out("fusedMapped[1]=" + fusedMapped[1] + " expected=6")
+    out("fusedFiltered[0]=" + fusedFiltered[0] + " expected=54")
+
+    zippedFused := optimized.map(\(x) x + 1).zip(optimized.map(\(x) x + 2), \(left, right) left + right)
+    out("zippedFused[0]=" + zippedFused[0] + " expected=5")
+    out("zippedFused[1]=" + zippedFused[1] + " expected=3")
+}