haskell: Phase 15 — IORef (5 ops + module wiring + ioref.sx 13/13 + counter.hs 7/7 + accumulate.hs 8/8)

hk-bind-data-ioref! registers newIORef / readIORef / writeIORef /
modifyIORef / modifyIORef' under the import alias (default IORef).
Representation: dict {"hk-ioref" true "hk-value" v} allocated inside IO.
modifyIORef' uses hk-deep-force on the new value before write.

Side-effect: fixed pre-existing bug in import handler — modname was
reading (nth d 1) (the qualified flag) instead of (nth d 2). All
'import qualified … as Foo' paths were silently no-ops; map.sx unit
suite jumps from 22→26 passing.

Conformance now 33/34 programs, 266/269 tests (only pre-existing
palindrome.hs 9/12 still failing on string-as-list reversal, present
on prior commit).

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

lib/haskell/tests/ioref.sx

@@ -0,0 +1,94 @@
+;; Phase 15 — IORef unit tests.
+
+(hk-test
+  "newIORef + readIORef returns initial value"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 42; v <- IORef.readIORef r; return v }"))
+  (list "IO" 42))
+
+(hk-test
+  "writeIORef updates the cell"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 0; IORef.writeIORef r 99; v <- IORef.readIORef r; return v }"))
+  (list "IO" 99))
+
+(hk-test
+  "writeIORef returns IO ()"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 0; IORef.writeIORef r 1 }"))
+  (list "IO" (list "Tuple")))
+
+(hk-test
+  "modifyIORef applies a function"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 5; IORef.modifyIORef r (\\x -> x * 2); v <- IORef.readIORef r; return v }"))
+  (list "IO" 10))
+
+(hk-test
+  "modifyIORef' (strict) applies a function"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 7; IORef.modifyIORef' r (\\x -> x + 3); v <- IORef.readIORef r; return v }"))
+  (list "IO" 10))
+
+(hk-test
+  "two reads return the same value"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 11; a <- IORef.readIORef r; b <- IORef.readIORef r; return (a + b) }"))
+  (list "IO" 22))
+
+(hk-test
+  "shared ref across do-steps: write then read"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef 1; IORef.writeIORef r 2; IORef.writeIORef r 3; v <- IORef.readIORef r; return v }"))
+  (list "IO" 3))
+
+(hk-test
+  "two refs are independent"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r1 <- IORef.newIORef 1; r2 <- IORef.newIORef 2; IORef.writeIORef r1 10; a <- IORef.readIORef r1; b <- IORef.readIORef r2; return (a + b) }"))
+  (list "IO" 12))
+
+(hk-test
+  "string-valued IORef"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef \"hi\"; IORef.writeIORef r \"bye\"; v <- IORef.readIORef r; return v }"))
+  (list "IO" "bye"))
+
+(hk-test
+  "list-valued IORef + cons"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nmain = do { r <- IORef.newIORef [1,2,3]; IORef.modifyIORef r (\\xs -> 0 : xs); v <- IORef.readIORef r; return v }"))
+  (list
+    "IO"
+    (list ":" 0 (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))))
+
+(hk-test
+  "counter loop: increment N times"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nloop r 0 = return ()\nloop r n = do { IORef.modifyIORef r (\\x -> x + 1); loop r (n - 1) }\nmain = do { r <- IORef.newIORef 0; loop r 10; v <- IORef.readIORef r; return v }"))
+  (list "IO" 10))
+
+(hk-test
+  "modifyIORef' inside a loop"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\ngo r 0 = return ()\ngo r n = do { IORef.modifyIORef' r (\\x -> x + n); go r (n - 1) }\nmain = do { r <- IORef.newIORef 0; go r 5; v <- IORef.readIORef r; return v }"))
+  (list "IO" 15))
+
+(hk-test
+  "newIORef inside a function passed via parameter"
+  (hk-deep-force
+    (hk-run
+      "import qualified Data.IORef as IORef\nbump r = IORef.modifyIORef r (\\x -> x + 100)\nmain = do { r <- IORef.newIORef 1; bump r; v <- IORef.readIORef r; return v }"))
+  (list "IO" 101))

lib/haskell/tests/program-accumulate.sx

@@ -0,0 +1,81 @@
+;; accumulate.hs — accumulate results into an IORef [Int] (Phase 15 conformance).
+
+(define
+  hk-accumulate-source
+  "import qualified Data.IORef as IORef\n\npush :: IORef [Int] -> Int -> IO ()\npush r x = IORef.modifyIORef r (\\xs -> x : xs)\n\npushAll :: IORef [Int] -> [Int] -> IO ()\npushAll r [] = return ()\npushAll r (x:xs) = do\n  push r x\n  pushAll r xs\n\nreadReversed :: IORef [Int] -> IO [Int]\nreadReversed r = do\n  xs <- IORef.readIORef r\n  return (reverse xs)\n\ndoubleEach :: IORef [Int] -> [Int] -> IO ()\ndoubleEach r [] = return ()\ndoubleEach r (x:xs) = do\n  push r (x * 2)\n  doubleEach r xs\n\nsumIntoRef :: IORef Int -> [Int] -> IO ()\nsumIntoRef r [] = return ()\nsumIntoRef r (x:xs) = do\n  IORef.modifyIORef r (\\acc -> acc + x)\n  sumIntoRef r xs\n\n")
+
+(hk-test
+  "accumulate.hs — push three then read length"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef []; push r 1; push r 2; push r 3; xs <- IORef.readIORef r; return (length xs) }")))
+  (list "IO" 3))
+
+(hk-test
+  "accumulate.hs — pushAll preserves reverse order"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef []; pushAll r [1,2,3,4]; xs <- IORef.readIORef r; return xs }")))
+  (list
+    "IO"
+    (list ":" 4 (list ":" 3 (list ":" 2 (list ":" 1 (list "[]")))))))
+
+(hk-test
+  "accumulate.hs — readReversed gives original order"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef []; pushAll r [10,20,30]; readReversed r }")))
+  (list "IO" (list ":" 10 (list ":" 20 (list ":" 30 (list "[]"))))))
+
+(hk-test
+  "accumulate.hs — doubleEach maps then accumulates"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef []; doubleEach r [1,2,3]; readReversed r }")))
+  (list "IO" (list ":" 2 (list ":" 4 (list ":" 6 (list "[]"))))))
+
+(hk-test
+  "accumulate.hs — sum into Int IORef"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef 0; sumIntoRef r [1,2,3,4,5]; v <- IORef.readIORef r; return v }")))
+  (list "IO" 15))
+
+(hk-test
+  "accumulate.hs — empty list leaves ref untouched"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef [99]; pushAll r []; xs <- IORef.readIORef r; return xs }")))
+  (list "IO" (list ":" 99 (list "[]"))))
+
+(hk-test
+  "accumulate.hs — pushAll then sumIntoRef on the same input"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "main = do { r <- IORef.newIORef 0; sumIntoRef r [10,20,30,40]; v <- IORef.readIORef r; return v }")))
+  (list "IO" 100))
+
+(hk-test
+  "accumulate.hs — accumulate results from a recursive helper"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-accumulate-source
+        "squaresUpTo r 0 = return ()\nsquaresUpTo r n = do { push r (n * n); squaresUpTo r (n - 1) }\nmain = do { r <- IORef.newIORef []; squaresUpTo r 4; readReversed r }")))
+  (list
+    "IO"
+    (list ":" 16 (list ":" 9 (list ":" 4 (list ":" 1 (list "[]")))))))

lib/haskell/tests/program-counter.sx

@@ -0,0 +1,66 @@
+;; counter.hs — IORef-backed mutable counter (Phase 15 conformance).
+
+(define
+  hk-counter-source
+  "import qualified Data.IORef as IORef\n\ncount :: IORef Int -> Int -> IO ()\ncount r 0 = return ()\ncount r n = do\n  IORef.modifyIORef r (\\x -> x + 1)\n  count r (n - 1)\n\ncountBy :: IORef Int -> Int -> Int -> IO ()\ncountBy r step 0 = return ()\ncountBy r step n = do\n  IORef.modifyIORef r (\\x -> x + step)\n  countBy r step (n - 1)\n\nnewCounter :: Int -> IO (IORef Int)\nnewCounter v = IORef.newIORef v\n\nbumpAndRead :: IORef Int -> IO Int\nbumpAndRead r = do\n  IORef.modifyIORef r (\\x -> x + 1)\n  IORef.readIORef r\n\n")
+
+(hk-test
+  "counter.hs — start at 0, count 5 ⇒ 5"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-counter-source
+        "main = do { r <- newCounter 0; count r 5; v <- IORef.readIORef r; return v }")))
+  (list "IO" 5))
+
+(hk-test
+  "counter.hs — start at 100, count 10 ⇒ 110"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-counter-source
+        "main = do { r <- newCounter 100; count r 10; v <- IORef.readIORef r; return v }")))
+  (list "IO" 110))
+
+(hk-test
+  "counter.hs — countBy step 5, n 4 ⇒ 20"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-counter-source
+        "main = do { r <- newCounter 0; countBy r 5 4; v <- IORef.readIORef r; return v }")))
+  (list "IO" 20))
+
+(hk-test
+  "counter.hs — bumpAndRead returns updated value"
+  (hk-deep-force
+    (hk-run
+      (str hk-counter-source "main = do { r <- newCounter 41; bumpAndRead r }")))
+  (list "IO" 42))
+
+(hk-test
+  "counter.hs — count then countBy compose"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-counter-source
+        "main = do { r <- newCounter 0; count r 3; countBy r 10 2; v <- IORef.readIORef r; return v }")))
+  (list "IO" 23))
+
+(hk-test
+  "counter.hs — two independent counters"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-counter-source
+        "main = do { a <- newCounter 0; b <- newCounter 0; count a 7; countBy b 100 2; va <- IORef.readIORef a; vb <- IORef.readIORef b; return (va + vb) }")))
+  (list "IO" 207))
+
+(hk-test
+  "counter.hs — modifyIORef' (strict) variant"
+  (hk-deep-force
+    (hk-run
+      (str
+        hk-counter-source
+        "tick r 0 = return ()\ntick r n = do { IORef.modifyIORef' r (\\x -> x + 1); tick r (n - 1) }\nmain = do { r <- newCounter 0; tick r 50; v <- IORef.readIORef r; return v }")))
+  (list "IO" 50))