coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

spec: sequence protocol tests — 45 tests, all passing on JS and OCaml

Browse Source 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
giles
2026-05-01 10:18:37 +00:00
parent 06a3eee114
commit 0fe00bf7ac
5 changed files with 233 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
spec/evaluator.sx
View File

@@ -3649,7 +3649,8 @@
(fn
(s)
(cond
((or (= s nil) (list? s)) (len s))
((= s nil) 0)
((list? s) (len s))
((vector? s) (vector-length s))
((string? s) (len s))
(else (len (seq-to-list s))))))
@@ -3674,6 +3675,15 @@
((and (string? s1) (string? s2)) (str s1 s2))
(else (concat (seq-to-list s1) (seq-to-list s2))))))
(define
build-range
(fn
(i end step acc)
(if
(if (> step 0) (>= i end) (<= i end))
(reverse acc)
(build-range (+ i step) end step (cons i acc)))))
(define
in-range
(fn
@@ -3686,16 +3696,7 @@
(if
(= step 0)
(error "in-range: step cannot be zero")
(do
(define
build
(fn
(i acc)
(if
(if (> step 0) (>= i end) (<= i end))
(reverse acc)
(build (+ i step) (cons i acc)))))
(build real-start (list)))))))
(build-range real-start end step (list))))))
(define
step-ho-map

202
spec/tests/test-sequences.sx Normal file
View File

@@ -0,0 +1,202 @@
;; test-sequences.sx — Phase 11: sequence protocol tests
(defsuite
"sequences"
(deftest
"seq-to-list nil is empty list"
(assert-equal (list) (seq-to-list nil)))
(deftest
"seq-to-list list is identity"
(assert-equal
(list 1 2 3)
(seq-to-list (list 1 2 3))))
(deftest
"seq-to-list vector to list"
(assert-equal
(list 10 20 30)
(seq-to-list (vector 10 20 30))))
(deftest
"seq-to-list string to char list"
(assert-equal (list "a" "b" "c") (seq-to-list "abc")))
(deftest
"seq-to-list empty string to empty list"
(assert-equal (list) (seq-to-list "")))
(deftest
"sequence-to-list nil is empty list"
(assert-equal (list) (sequence-to-list nil)))
(deftest
"sequence-to-list list is identity"
(assert-equal
(list 1 2 3)
(sequence-to-list (list 1 2 3))))
(deftest
"sequence-to-list vector to list"
(assert-equal (list "x" "y") (sequence-to-list (vector "x" "y"))))
(deftest
"sequence-to-list string to char list"
(assert-equal (list "h" "i") (sequence-to-list "hi")))
(deftest
"sequence-to-vector nil is empty vector"
(let
((v (sequence-to-vector nil)))
(do (assert (vector? v)) (assert= 0 (vector-length v)))))
(deftest
"sequence-to-vector list to vector"
(let
((v (sequence-to-vector (list 1 2 3))))
(do
(assert (vector? v))
(assert= 3 (vector-length v))
(assert= 1 (vector-ref v 0))
(assert= 3 (vector-ref v 2)))))
(deftest
"sequence-to-vector string to vector of chars"
(let
((v (sequence-to-vector "abc")))
(do
(assert (vector? v))
(assert= 3 (vector-length v))
(assert= "a" (vector-ref v 0))
(assert= "c" (vector-ref v 2)))))
(deftest
"sequence-length nil is 0"
(assert= 0 (sequence-length nil)))
(deftest
"sequence-length empty list is 0"
(assert= 0 (sequence-length (list))))
(deftest
"sequence-length list of 3"
(assert=
3
(sequence-length (list 1 2 3))))
(deftest
"sequence-length empty vector is 0"
(assert= 0 (sequence-length (vector))))
(deftest
"sequence-length vector of 4"
(assert=
4
(sequence-length (vector 10 20 30 40))))
(deftest
"sequence-length empty string is 0"
(assert= 0 (sequence-length "")))
(deftest
"sequence-length string hello"
(assert= 5 (sequence-length "hello")))
(deftest
"sequence-ref list first"
(assert=
10
(sequence-ref (list 10 20 30) 0)))
(deftest
"sequence-ref list last"
(assert=
30
(sequence-ref (list 10 20 30) 2)))
(deftest
"sequence-ref vector middle"
(assert=
20
(sequence-ref (vector 10 20 30) 1)))
(deftest
"sequence-ref string first char"
(assert= "h" (sequence-ref "hello" 0)))
(deftest
"sequence-ref string last char"
(assert= "o" (sequence-ref "hello" 4)))
(deftest
"sequence-append two lists"
(assert-equal
(list 1 2 3 4)
(sequence-append
(list 1 2)
(list 3 4))))
(deftest
"sequence-append list with empty"
(assert-equal
(list 1 2)
(sequence-append (list 1 2) (list))))
(deftest
"sequence-append two strings"
(assert= "hello world" (sequence-append "hello " "world")))
(deftest
"sequence-append empty strings"
(assert= "abc" (sequence-append "" "abc")))
(deftest
"in-range 1-arg gives 0..n-1"
(assert-equal
(list 0 1 2 3 4)
(in-range 5)))
(deftest
"in-range 1-arg zero is empty"
(assert-equal (list) (in-range 0)))
(deftest
"in-range 2-arg start and end"
(assert-equal
(list 1 2 3)
(in-range 1 4)))
(deftest
"in-range 2-arg same start end is empty"
(assert-equal (list) (in-range 3 3)))
(deftest
"in-range 3-arg with step 2"
(assert-equal
(list 0 2 4)
(in-range 0 6 2)))
(deftest
"in-range result is a list"
(assert (list? (in-range 5))))
(deftest
"in-range length is correct"
(assert= 10 (len (in-range 10))))
(deftest
"map over vector"
(assert-equal
(list 2 4 6)
(map
(fn (x) (* x 2))
(vector 1 2 3))))
(deftest
"filter over vector keeps odds"
(assert-equal
(list 1 3 5)
(filter
odd?
(vector 1 2 3 4 5))))
(deftest
"reduce over vector sums"
(assert=
10
(reduce
+
0
(vector 1 2 3 4))))
(deftest
"some over vector finds odd"
(assert (some odd? (vector 2 4 3 6))))
(deftest
"every? over vector all even"
(assert
(every? even? (vector 2 4 6 8))))
(deftest
"every? over vector fails with odd"
(assert= false (every? even? (vector 2 3 6))))
(deftest
"map over in-range squares"
(assert-equal
(list 0 1 4 9 16)
(map (fn (x) (* x x)) (in-range 5))))
(deftest
"filter over in-range keeps evens"
(assert-equal
(list 0 2 4 6)
(filter even? (in-range 7))))
(deftest
"reduce over in-range sums"
(assert= 15 (reduce + 0 (in-range 6))))
(deftest
"map over string returns char list"
(assert-equal (list "a" "b" "c") (map (fn (c) c) "abc")))
(deftest
"filter over string keeps matching chars"
(assert-equal (list "p" "p") (filter (fn (c) (= c "p")) "apple"))))