go: eval.sx — slices + index + slice expr + len/append builtins + 10 tests [nothing]

Phase 4 cont. Adds runtime support for Go's slice type.

Slice representation: (list :go-slice ELEMS) — a simple wrapper around
a list of element values. v0 deferring the full
(length, capacity, backing-vector) triple from the Go spec until
programs need it.

  go-eval-composite      → for (:composite TYPE-OR-EXPR ELEMS) where
                            TYPE is :ty-slice / :ty-array, eval each
                            element (handling :kv index-keyed
                            shorthand by taking only the value) and
                            wrap in :go-slice.
  go-eval-index          → (:index OBJ IDX). Bounds-checked; out-of-
                            range returns (:eval-error :index-out-of-range).
  go-eval-slice          → (:slice OBJ LOW HIGH MAX). Two-index slice
                            with omitted low → 0, omitted high → len.
                            Returns a new :go-slice.
  go-list-slice          → primitive list-slicing helper.

Builtins live in a new starter env go-env-builtins:
  len(slice|string)      → count
  append(slice, ...x)    → new slice with x appended
  print(...)             → no-op in v0

Builtins are bound as (:go-builtin NAME); go-eval-call recognises the
shape and routes to go-eval-builtin instead of go-eval-fn.

**Summing a slice via the canonical Go for-loop works end-to-end:**

  a := []int{1, 2, 3, 4, 5}
  sum := 0
  for i := 0; i < len(a); i++ {
    sum = sum + a[i]
  }
  // sum == 15

eval 50/50, total 427/427.

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

lib/go/tests/eval.sx

@@ -195,6 +195,73 @@
     (go-eval env (go-parse "fact(5)")))
   120)
 
+(go-eval-test
+  "slice: []int{1,2,3} → :go-slice"
+  (gtev go-env-empty "[]int{1, 2, 3}")
+  (list :go-slice (list 1 2 3)))
+
+(go-eval-test
+  "index: a[0] = 10, a[2] = 30"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30}")))))
+    (list (go-eval env (go-parse "a[0]")) (go-eval env (go-parse "a[2]"))))
+  (list 10 30))
+
+(go-eval-test
+  "index: out-of-range error"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2}")))))
+    (go-eval env (go-parse "a[5]")))
+  (list :eval-error :index-out-of-range 5 2))
+
+(go-eval-test
+  "builtin: len(slice) = 3"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3}")))))
+    (go-eval env (go-parse "len(a)")))
+  3)
+
+(go-eval-test
+  "builtin: len(string)"
+  (go-eval go-env-builtins (go-parse "len(\"hello\")"))
+  5)
+
+(go-eval-test
+  "builtin: append(a, 4, 5)"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3}")))))
+    (go-eval env (go-parse "append(a, 4, 5)")))
+  (list
+    :go-slice (list 1 2 3 4 5)))
+
+(go-eval-test
+  "slice expr: a[1:3]"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30, 40}")))))
+    (go-eval env (go-parse "a[1:3]")))
+  (list :go-slice (list 20 30)))
+
+(go-eval-test
+  "slice expr: a[:2] (omitted low)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2, 3, 4}")))))
+    (go-eval env (go-parse "a[:2]")))
+  (list :go-slice (list 1 2)))
+
+(go-eval-test
+  "slice expr: a[2:] (omitted high)"
+  (let
+    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2, 3, 4}")))))
+    (go-eval env (go-parse "a[2:]")))
+  (list :go-slice (list 3 4)))
+
+(go-eval-test
+  "fn: sum slice via for-loop with len + index"
+  (let
+    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "sum := 0") (go-parse "for i := 0; i < len(a); i++ { sum = sum + a[i] }")))))
+    (go-env-lookup env "sum"))
+  15)
+
 (define
   go-eval-test-summary
   (str "eval " go-eval-test-pass "/" go-eval-test-count))