go: eval.sx — for / break / continue / inc-dec + 7 tests [nothing]

Phase 4 cont. go-eval-for handles all three for-header shapes:

  for { ... }                          — infinite (cond defaults to true)
  for cond { ... }                     — while-like (init=nil, post=nil)
  for init ; cond ; post { ... }       — C-style

Implementation:
  * Run INIT (if any), extending env.
  * Loop: eval COND. If false, exit with current env.
    Eval body (a :block). Catch sentinels:
      :return-value → propagate up
      :break        → exit loop with pre-break env
      :continue     → still runs POST, then re-loops
    Otherwise: run POST, re-loop.

:break and :continue propagate as keyword sentinels through
go-eval-block alongside the existing :return-value sentinel. The
block returns whichever sentinel hit first; control-flow constructs
(for, switch, select) catch them.

inc-dec (x++ / x--) updates env via the same shadowing model used by
assign — `(go-env-extend env name (+ current 1))`.

**Iterative fact(5) = 120 and the classic sum-to-9 = 45 both
evaluate.** Demonstrates the for-loop machinery is solid enough for
real programs.

eval 40/40, total 417/417.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

lib/go/eval.sx

@@ -348,6 +348,78 @@
           (body (nth stmt 4)))
       (go-env-extend env name (list :go-fn params body)))))
 
+(define
+  go-eval-inc-dec
+  ;; (:inc-dec OP EXPR) where OP is "++" or "--". EXPR should be (:var NAME).
+  (fn (env stmt)
+    (let ((op (nth stmt 1)) (operand (nth stmt 2)))
+      (cond
+        (not (and (list? operand) (= (first operand) :var)))
+        (list :eval-error :unsupported-lhs operand)
+        :else
+        (let ((current (go-eval env operand)))
+          (cond
+            (go-eval-error? current) current
+            :else
+            (let ((new-val
+                    (cond
+                      (= op "++") (+ current 1)
+                      (= op "--") (- current 1)
+                      :else current)))
+              (go-env-extend env (nth operand 1) new-val))))))))
+
+(define
+  go-eval-for
+  ;; (:for INIT COND POST BODY). Any may be nil.
+  (fn (env stmt)
+    (let ((init (nth stmt 1)) (cnd (nth stmt 2))
+          (post (nth stmt 3)) (body (nth stmt 4)))
+      (let ((env0
+              (cond
+                (= init nil) env
+                :else (go-eval-stmt env init))))
+        (cond
+          (go-eval-error? env0) env0
+          :else (go-for-loop env0 cnd post body))))))
+
+(define
+  go-for-loop
+  (fn (env cnd post body)
+    (let ((c
+            (cond
+              (= cnd nil) true
+              :else (go-eval env cnd))))
+      (cond
+        (go-eval-error? c) c
+        (not c) env
+        :else
+        (let ((r
+                (cond
+                  (= body nil) env
+                  (and (list? body) (= (first body) :block))
+                  (go-eval-block env (nth body 1))
+                  :else env)))
+          (cond
+            (and (list? r) (= (first r) :return-value)) r
+            (= r :break) env
+            (= r :continue)
+            (let ((env1
+                    (cond
+                      (= post nil) env
+                      :else (go-eval-stmt env post))))
+              (cond
+                (go-eval-error? env1) env1
+                :else (go-for-loop env1 cnd post body)))
+            (go-eval-error? r) r
+            :else
+            (let ((env1
+                    (cond
+                      (= post nil) r
+                      :else (go-eval-stmt r post))))
+              (cond
+                (go-eval-error? env1) env1
+                :else (go-for-loop env1 cnd post body)))))))))
+
 (define
   go-eval-stmt
   (fn (env stmt)
@@ -372,6 +444,12 @@
       (go-eval-block env (nth stmt 1))
       (and (list? stmt) (= (first stmt) :if))
       (go-eval-if env stmt)
+      (and (list? stmt) (= (first stmt) :for))
+      (go-eval-for env stmt)
+      (and (list? stmt) (= (first stmt) :break))    :break
+      (and (list? stmt) (= (first stmt) :continue)) :continue
+      (and (list? stmt) (= (first stmt) :inc-dec))
+      (go-eval-inc-dec env stmt)
       (and (list? stmt) (= (first stmt) :func-decl))
       (go-eval-func-decl env stmt)
       :else
@@ -389,6 +467,8 @@
       (let ((r (go-eval-stmt env (first stmts))))
         (cond
           (and (list? r) (= (first r) :return-value)) r
+          (= r :break) r
+          (= r :continue) r
           (go-eval-error? r) r
           :else (go-eval-block r (rest stmts)))))))
 

lib/go/scoreboard.json

@@ -1,12 +1,12 @@
 {
   "language": "go",
-  "total_pass": 410,
-  "total": 410,
+  "total_pass": 417,
+  "total": 417,
   "suites": [
     {"name":"lex","pass":129,"total":129,"status":"ok"},
     {"name":"parse","pass":176,"total":176,"status":"ok"},
     {"name":"types","pass":72,"total":72,"status":"ok"},
-    {"name":"eval","pass":33,"total":33,"status":"ok"},
+    {"name":"eval","pass":40,"total":40,"status":"ok"},
     {"name":"runtime","pass":0,"total":0,"status":"pending"},
     {"name":"stdlib","pass":0,"total":0,"status":"pending"},
     {"name":"e2e","pass":0,"total":0,"status":"pending"}

lib/go/scoreboard.md

@@ -1,13 +1,13 @@
 # Go-on-SX Scoreboard
 
-**Total: 410 / 410 tests passing**
+**Total: 417 / 417 tests passing**
 
 |  | Suite | Pass | Total |
 |---|---|---|---|
 | ✅ | lex | 129 | 129 |
 | ✅ | parse | 176 | 176 |
 | ✅ | types | 72 | 72 |
-| ✅ | eval | 33 | 33 |
+| ✅ | eval | 40 | 40 |
 | ⬜ | runtime | 0 | 0 |
 | ⬜ | stdlib | 0 | 0 |
 | ⬜ | e2e | 0 | 0 |

lib/go/tests/eval.sx

@@ -146,6 +146,55 @@
     (go-eval env (go-parse "fib(5)")))
   5)
 
+(go-eval-test
+  "for: count to 10 with sum"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var sum = 0") (go-parse "for i := 0; i < 10; i++ { sum = sum + i }")))))
+    (go-env-lookup env "sum"))
+  45)
+
+(go-eval-test
+  "inc-dec: x++ updates env"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 5) (list (go-parse "x++")))))
+    (go-env-lookup env "x"))
+  6)
+
+(go-eval-test
+  "inc-dec: x-- updates env"
+  (let
+    ((env (go-eval-program (go-env-extend go-env-empty "x" 5) (list (go-parse "x--")))))
+    (go-env-lookup env "x"))
+  4)
+
+(go-eval-test
+  "for: break exits the loop"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var i = 0") (go-parse "for i < 100 { if i == 5 { break } ; i++ }")))))
+    (go-env-lookup env "i"))
+  5)
+
+(go-eval-test
+  "for: continue skips body but runs post"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var sum = 0") (go-parse "for i := 0; i < 5; i++ { if i == 2 { continue } ; sum = sum + i }")))))
+    (go-env-lookup env "sum"))
+  8)
+
+(go-eval-test
+  "for: infinite + break with sum"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "var s = 0") (go-parse "var i = 1") (go-parse "for { if i > 4 { break } ; s = s + i ; i++ }")))))
+    (go-env-lookup env "s"))
+  10)
+
+(go-eval-test
+  "fn: iterative factorial via for-loop"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "func fact(n int) int { r := 1 ; for i := 2 ; i <= n ; i++ { r = r * i } ; return r }")))))
+    (go-eval env (go-parse "fact(5)")))
+  120)
+
 (define
   go-eval-test-summary
   (str "eval " go-eval-test-pass "/" go-eval-test-count))