Fix REPL collection rendering — print values instead of memory addresses

- print-value now renders tuples as [val1 val2 ...]
- print-value now renders arrays as (val1 val2 ...)
- print-value now renders structs/tables as {key val ...}
- print-value now renders sets as #{val1 val2 ...}
- print-value renders keywords with : prefix
- Forward var declaration for mutual recursion (print-collection → print-value)
- 315 tests pass, 0 regressions

src/jolt/main.janet

@@ -12,12 +12,92 @@
   (let [line (file/read stdin :line)]
     (if line (string/trim line) nil)))
 
-(defn print-value [v]
-  (if (nil? v)
-    (print "nil")
-    (if (and (table? v) (= :jolt/var (v :jolt/type)))
-      (printf "#'%s/%s" (ctx-current-ns ctx) ((var-name v) :name))
-      (print v))))
+# Forward declaration for mutual recursion
+(var print-value nil)
+
+(defn- print-collection [v]
+  (cond
+    (tuple? v)
+    (do
+      (prin "[")
+      (var i 0)
+      (let [n (length v)]
+        (while (< i n)
+          (print-value (in v i))
+          (when (< (+ i 1) n) (prin " "))
+          (++ i)))
+      (prin "]"))
+
+    (array? v)
+    (do
+      (prin "(")
+      (var i 0)
+      (let [n (length v)]
+        (while (< i n)
+          (print-value (in v i))
+          (when (< (+ i 1) n) (prin " "))
+          (++ i)))
+      (prin ")"))
+
+    (and (table? v) (= :jolt/set (v :jolt/type)))
+    (do
+      (prin "#{")
+      (var first? true)
+      (each k (keys (v :phm))
+        (when (not= k :jolt/deftype)
+          (if first? (set first? false) (prin " "))
+          (print-value k)))
+      (prin "}"))
+
+    (and (table? v) (get v :jolt/deftype))
+    (do
+      (prin "{")
+      (var first? true)
+      (each [k val] (pairs v)
+        (when (and (not= k :jolt/deftype) (not= k :cnt) (not= k :buckets) (not= k :_meta)
+                   (not= k :jolt/type) (not= k :phm))
+          (if first? (set first? false) (prin " "))
+          (print-value k)
+          (prin " ")
+          (print-value val)))
+      (prin "}"))
+
+    (struct? v)
+    (do
+      (prin "{")
+      (var first? true)
+      (each [k val] (pairs v)
+        (if first? (set first? false) (prin " "))
+        (print-value k)
+        (prin " ")
+        (print-value val))
+      (prin "}"))
+
+    (table? v)
+    (do
+      (prin "{")
+      (var first? true)
+      (each [k val] (pairs v)
+        (when (not= k :jolt/type)
+          (if first? (set first? false) (prin " "))
+          (print-value k)
+          (prin " ")
+          (print-value val)))
+      (prin "}"))))
+
+(set print-value (fn [v]
+  (cond
+    (nil? v) (print "nil")
+    (= true v) (print "true")
+    (= false v) (print "false")
+    (number? v) (print v)
+    (string? v) (print v)
+    (keyword? v) (prin ":") (print (string v))
+    (and (table? v) (= :jolt/var (v :jolt/type)))
+    (printf "#'%s/%s" (ctx-current-ns ctx) ((var-name v) :name))
+    (or (tuple? v) (array? v) (struct? v) (table? v))
+    (print-collection v)
+    (print v))))
 
 (defn main [&]
   (print "Jolt — Clojure on Janet")