1eb2843365
Round 2 of the persistent-collections work. Add a real 32-way branching-trie persistent vector (src/jolt/pv.janet) with a tail buffer: O(log32 n) conj/assoc/nth/pop, with unchanged subtrees shared by identity. Vector literals and vec/vector/conj/assoc/subvec/etc. now produce and maintain these in the default (immutable) build, replacing the old tuple-based vectors. Every core seq op, the destructurer, IFn application, the printers, =, and the evaluator's literal/splice paths were taught to handle the pvec type. Define several Clojure seq fns that were silently leaking to Janet builtins (some, keep, interleave, flatten, mapcat, interpose) and broke once vectors became tables; normalize collections through realize-for-iteration everywhere. Build-time JOLT_MUTABLE flag now selects fast Janet-native mutable collections: in that mode vectors are arrays (conj appends in place, vector? true, print []), sharing one representation with lists. Default build is immutable. Tests: conformance 206/206, features 71/71, jank 119 (baseline). Test helpers normalized so Janet-level = compares against tuple literals regardless of repr. The 2 test-load-sci failures (bit-clear/get-method) pre-date this work.
56 lines
2.4 KiB
Text
56 lines
2.4 KiB
Text
(use ../src/jolt/api)
|
|
(defn ct-eval [ctx s] (normalize-pvecs (eval-string ctx s)))
|
|
(print "LazySeq Tests")
|
|
|
|
(print "1: lazy-seq from list...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= [1 2 3] (take 10 (lazy-seq [1 2 3])))")) "lazy-seq list")
|
|
(assert (= true (ct-eval ctx "(= 3 (count (lazy-seq [1 2 3])))")) "count lazy-seq"))
|
|
(print " ok")
|
|
|
|
(print "2: lazy-cat concatenation...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= [1 2 3 4] (take 10 (lazy-cat [1 2] [3 4])))")) "lazy-cat concat")
|
|
(assert (= true (ct-eval ctx "(= 4 (count (lazy-cat [1 2] [3 4])))")) "lazy-cat count"))
|
|
(print " ok")
|
|
|
|
(print "3: first/rest on lazy-seqs...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= 1 (first (lazy-seq [1 2 3])))")) "first lazy")
|
|
(assert (= true (ct-eval ctx "(= 2 (first (rest (lazy-seq [1 2 3]))))")) "first rest lazy"))
|
|
(print " ok")
|
|
|
|
(print "4: drop/nth on lazy-seqs...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= [3 4 5] (take 10 (drop 2 (lazy-seq [1 2 3 4 5]))))")) "drop 2 take 10")
|
|
(assert (= true (ct-eval ctx "(= 3 (nth (lazy-seq [1 2 3 4 5]) 2))")) "nth lazy"))
|
|
(print " ok")
|
|
|
|
(print "5: concat on lazy-seqs...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= 5 (count (concat (lazy-seq [1 2]) (lazy-seq [3 4 5]))))")) "concat lazy"))
|
|
(print " ok")
|
|
|
|
(print "6: reverse/sort on lazy-seqs...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= [3 2 1] (reverse (lazy-seq [1 2 3])))")) "reverse lazy")
|
|
(assert (= true (ct-eval ctx "(= [1 2 3] (sort (lazy-seq [3 1 2])))")) "sort lazy"))
|
|
(print " ok")
|
|
|
|
(print "7: distinct on lazy-seqs...")
|
|
(let [ctx (init)]
|
|
(assert (= true (ct-eval ctx "(= [1 2 3] (distinct (lazy-seq [1 2 1 3 2])))")) "distinct lazy"))
|
|
(print " ok")
|
|
|
|
(print "8: fib-seq (deferred — eager core-map needs lazy upgrade)...")
|
|
(let [ctx (init)]
|
|
(print " The cell-by-cell lazy-seq architecture is correct. concat, take,")
|
|
(print " drop, nth, first, rest all work with self-referencing patterns.")
|
|
(print " core-map still eagerly realizes all lazy-seq arguments, which")
|
|
(print " loops on infinite sequences. Making core-map return a lazy")
|
|
(print " result would complete the self-referencing lazy-seq story.")
|
|
(print " When fixed: (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq)))")
|
|
(print " → (take 10 fib-seq) = [0 1 1 2 3 5 8 13 21 34]"))
|
|
(print " ok (deferred — core-map needs lazy upgrade)")
|
|
|
|
(print "\nAll LazySeq tests passed!")
|