Step 9: mutable data structures — R7RS vectors

New Vector type (value array) with 11 primitives:
- make-vector, vector — constructors
- vector-ref, vector-set! — element access/mutation
- vector-length, vector?, vector-fill! — inspection
- vector->list, list->vector — conversion
- vector-copy — independent copy
- Element-wise equality in safe_eq

10 new tests (2668/2668 pass). Follows Record pattern (value array).

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

spec/tests/test-r7rs.sx

@@ -434,3 +434,77 @@
       (assert (integer? (ceil 3.2)))
       (assert (integer? (round 3.5)))
       (assert (integer? (truncate 3.7))))))
+
+(defsuite
+  "vectors"
+  (deftest
+    "make-vector creates vector of given size"
+    (let
+      ((v (make-vector 5)))
+      (do (assert (vector? v)) (assert= 5 (vector-length v)))))
+  (deftest
+    "make-vector with fill value"
+    (let
+      ((v (make-vector 3 42)))
+      (do
+        (assert= 42 (vector-ref v 0))
+        (assert= 42 (vector-ref v 1))
+        (assert= 42 (vector-ref v 2)))))
+  (deftest
+    "vector constructor from args"
+    (let
+      ((v (vector 1 2 3)))
+      (do
+        (assert= 3 (vector-length v))
+        (assert= 1 (vector-ref v 0))
+        (assert= 2 (vector-ref v 1))
+        (assert= 3 (vector-ref v 2)))))
+  (deftest
+    "vector-set! mutates in place"
+    (let
+      ((v (make-vector 3 0)))
+      (do
+        (vector-set! v 1 99)
+        (assert= 99 (vector-ref v 1))
+        (assert= 0 (vector-ref v 0)))))
+  (deftest
+    "vector->list conversion"
+    (assert= (list 1 2 3) (vector->list (vector 1 2 3))))
+  (deftest
+    "list->vector conversion"
+    (let
+      ((v (list->vector (list 10 20 30))))
+      (do
+        (assert (vector? v))
+        (assert= 3 (vector-length v))
+        (assert= 20 (vector-ref v 1)))))
+  (deftest
+    "vector-fill! sets all elements"
+    (let
+      ((v (vector 1 2 3)))
+      (do
+        (vector-fill! v 0)
+        (assert= 0 (vector-ref v 0))
+        (assert= 0 (vector-ref v 1))
+        (assert= 0 (vector-ref v 2)))))
+  (deftest
+    "vector-copy creates independent copy"
+    (let
+      ((v1 (vector 1 2 3)))
+      (let
+        ((v2 (vector-copy v1)))
+        (do
+          (vector-set! v2 0 99)
+          (assert= 1 (vector-ref v1 0))
+          (assert= 99 (vector-ref v2 0))))))
+  (deftest
+    "vector? predicate"
+    (do
+      (assert (vector? (vector 1 2)))
+      (assert (not (vector? (list 1 2))))
+      (assert (not (vector? 42)))))
+  (deftest
+    "vector equality"
+    (do
+      (assert= (vector 1 2 3) (vector 1 2 3))
+      (assert (not (= (vector 1 2) (vector 1 3)))))))