plans: tick quicksort.hs, progress log 2026-04-25

lib/haskell/tests/program-quicksort.sx

@@ -0,0 +1,65 @@
+;; quicksort.hs — naive functional quicksort.
+
+(define
+  hk-as-list
+  (fn (xs)
+    (cond
+      ((and (list? xs) (= (first xs) "[]")) (list))
+      ((and (list? xs) (= (first xs) ":"))
+        (cons (nth xs 1) (hk-as-list (nth xs 2))))
+      (:else xs))))
+
+(define
+  hk-prog-val
+  (fn
+    (src name)
+    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
+
+(define
+  hk-qs-source
+  "qsort [] = []
+qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
+  where
+    smaller = filter (< x) xs
+    larger  = filter (>= x) xs
+result = qsort [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
+")
+
+(hk-test
+  "quicksort.hs — sort a list of ints"
+  (hk-as-list (hk-prog-val hk-qs-source "result"))
+  (list 1 1 2 3 3 4 5 5 5 6 9))
+
+(hk-test
+  "quicksort.hs — empty list"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "e = qsort []\n")
+      "e"))
+  (list))
+
+(hk-test
+  "quicksort.hs — singleton"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "s = qsort [42]\n")
+      "s"))
+  (list 42))
+
+(hk-test
+  "quicksort.hs — already sorted"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "asc = qsort [1, 2, 3, 4, 5]\n")
+      "asc"))
+  (list 1 2 3 4 5))
+
+(hk-test
+  "quicksort.hs — reverse sorted"
+  (hk-as-list
+    (hk-prog-val
+      (str hk-qs-source "desc = qsort [5, 4, 3, 2, 1]\n")
+      "desc"))
+  (list 1 2 3 4 5))
+
+{:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}

lib/haskell/tests/programs/quicksort.hs

@@ -0,0 +1,12 @@
+-- quicksort.hs — naive functional quicksort.
+--
+-- Partition by pivot, recurse on each half, concatenate.
+-- Uses right sections `(< x)` and `(>= x)` with filter.
+
+qsort [] = []
+qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
+  where
+    smaller = filter (< x) xs
+    larger  = filter (>= x) xs
+
+result = qsort [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

plans/haskell-on-sx.md

@@ -84,7 +84,7 @@ Key mappings:
 - [ ] Classic programs in `lib/haskell/tests/programs/`:
   - [x] `fib.hs` — infinite Fibonacci stream
   - [x] `sieve.hs` — lazy sieve of Eratosthenes
-  - [ ] `quicksort.hs` — naive QS
+  - [x] `quicksort.hs` — naive QS
   - [ ] `nqueens.hs`
   - [ ] `calculator.hs` — parser combinator style expression evaluator
 - [ ] `lib/haskell/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
@@ -114,6 +114,11 @@ Key mappings:
 
 _Newest first._
 
+- **2026-04-25** — Classic program `quicksort.hs`: naive functional quicksort.
+  `qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger where smaller = filter (< x) xs; larger = filter (>= x) xs`.
+  No new runtime additions needed — right sections, `filter`, `++` all worked out of the box.
+  5 tests (general sort, empty, singleton, already-sorted, reverse-sorted). 395/395 green.
+
 - **2026-04-25** — Classic program `sieve.hs`: lazy sieve of Eratosthenes.
   Added `mod`, `div`, `rem`, `quot` to `hk-binop` (and as first-class
   values in `hk-init-env`), enabling backtick operator use. The filter-based