Add map, filter, and reverse to persistent data structures

persistent.carp

@@ -201,6 +201,32 @@ This generates:
                   (Maybe.Just b-head) (%node-rc-ptr-eq &a-head &b-head)
                   (Maybe.Nothing) false)))
 
+          (doc reverse "Return a reversed copy of the list.")
+          (sig reverse (Fn [(Ref %name q)] %name))
+          (defn reverse [list-ref]
+            (reduce &(fn [acc x] (prepend x &acc)) (empty) list-ref))
+
+          (doc map
+            "Apply a function to each element, returning a new list in the same order.")
+          (sig map
+               (Fn [(Ref (Fn [%value-type] %value-type) q) (Ref %name r)] %name))
+          (defn map [f list-ref]
+            (let [rev (reduce &(fn [acc x] (prepend (~f x) &acc))
+                              (empty)
+                              list-ref)]
+              (reverse &rev)))
+
+          (doc filter
+            "Keep only elements satisfying a predicate, preserving order.")
+          (sig filter
+               (Fn [(Ref (Fn [(Ref %value-type q)] Bool) r) (Ref %name s)] %name))
+          (defn filter [pred list-ref]
+            (let [rev (reduce
+                    &(fn [acc x] (if (~pred &x) (prepend x &acc) acc))
+                    (empty)
+                    list-ref)]
+              (reverse &rev)))
+
           (doc str "Diagnostic formatting for a list.")
           (sig str (Fn [(Ref %name q)] String))
           (defn str [list-ref]
@@ -366,6 +392,23 @@ This generates:
                     ab (to-array b-ref)] (= &aa &ab))))
           (implements = %name-eq)
 
+          (doc map
+            "Apply a function to each element, returning a new queue in FIFO order.")
+          (sig map
+               (Fn [(Ref (Fn [%value-type] %value-type) q) (Ref %name r)] %name))
+          (defn map [f q-ref]
+            (reduce &(fn [acc x] (enqueue (~f x) &acc)) (empty) q-ref))
+
+          (doc filter
+            "Keep only elements satisfying a predicate, preserving FIFO order.")
+          (sig filter
+               (Fn [(Ref (Fn [(Ref %value-type q)] Bool) r) (Ref %name s)] %name))
+          (defn filter [pred q-ref]
+            (reduce
+              &(fn [acc x] (if (~pred &x) (enqueue x &acc) acc))
+              (empty)
+              q-ref))
+
           (doc str "Diagnostic formatting for a queue.")
           (sig str (Fn [(Ref %name q)] String))
           (defn str [q-ref] (fmt "(PersistentQueue length=%ld)" (length q-ref)))
@@ -1048,6 +1091,32 @@ This generates:
                 a-ref)))
           (implements = %name-eq)
 
+          (doc map-values
+            "Apply a function to each value, returning a new trie with the same keys.")
+          (sig map-values
+               (Fn [(Ref (Fn [%value-type] %value-type) q) (Ref %name r)] %name))
+          (defn map-values [f trie-ref]
+            (reduce
+              &(fn [acc p] (insert (Pair.a &p) (~f @(Pair.b &p)) &acc))
+              (empty)
+              trie-ref))
+
+          (doc filter
+            "Keep only entries whose `(Pair key value)` satisfies a predicate.")
+          (sig filter
+               (Fn
+                 [(Ref
+                    (Fn [(Ref (Pair (Array %key-part-type) %value-type) q)] Bool)
+                    r)
+                  (Ref %name s)]
+                 %name))
+          (defn filter [pred trie-ref]
+            (reduce
+              &(fn [acc p]
+                (if (~pred &p) (insert (Pair.a &p) @(Pair.b &p) &acc) acc))
+              (empty)
+              trie-ref))
+
           (doc str "Diagnostic formatting for a trie.")
           (sig str (Fn [(Ref %name q)] String))
           (defn str [trie-ref]
@@ -1261,6 +1330,23 @@ This generates:
                     ab (to-array b-ref)] (= &aa &ab))))
           (implements = %name-eq)
 
+          (doc map
+            "Apply a function to each element, returning a new deque in front-to-back order.")
+          (sig map
+               (Fn [(Ref (Fn [%value-type] %value-type) q) (Ref %name r)] %name))
+          (defn map [f dq-ref]
+            (reduce &(fn [acc x] (push-back (~f x) &acc)) (empty) dq-ref))
+
+          (doc filter
+            "Keep only elements satisfying a predicate, preserving front-to-back order.")
+          (sig filter
+               (Fn [(Ref (Fn [(Ref %value-type q)] Bool) r) (Ref %name s)] %name))
+          (defn filter [pred dq-ref]
+            (reduce
+              &(fn [acc x] (if (~pred &x) (push-back x &acc) acc))
+              (empty)
+              dq-ref))
+
           (doc str "Diagnostic formatting for a deque.")
           (sig str (Fn [(Ref %name q)] String))
           (defn str [dq-ref]
@@ -1712,6 +1798,30 @@ This generates:
                     ab (to-array b-ref)] (= &aa &ab))))
           (implements = %name-eq)
 
+          (doc map-values
+            "Apply a function to each value, returning a new map with the same keys.")
+          (sig map-values
+               (Fn [(Ref (Fn [%value-type] %value-type) q) (Ref %name r)] %name))
+          (defn map-values [f map-ref]
+            (reduce
+              &(fn [acc p] (insert @(Pair.a &p) (~f @(Pair.b &p)) &acc))
+              (empty)
+              map-ref))
+
+          (doc filter
+            "Keep only entries whose `(Pair key value)` satisfies a predicate.")
+          (sig filter
+               (Fn
+                 [(Ref (Fn [(Ref (Pair %key-type %value-type) q)] Bool) r)
+                  (Ref %name s)]
+                 %name))
+          (defn filter [pred map-ref]
+            (reduce
+              &(fn [acc p]
+                (if (~pred &p) (insert @(Pair.a &p) @(Pair.b &p) &acc) acc))
+              (empty)
+              map-ref))
+
           (doc str "Diagnostic formatting for an ordered map.")
           (sig str (Fn [(Ref %name q)] String))
           (defn str [map-ref]
@@ -2310,6 +2420,44 @@ Example:
                 a-ref)))
           (implements = %name-eq)
 
+          (doc map-values
+            "Apply a function to each value, returning a new map with the same keys.")
+          (sig map-values
+               (Fn [(Ref (Fn [%value-type] %value-type) q) (Ref %name r)] %name))
+          (defn map-values [f map-ref]
+            (%trie-reduce-values
+              &(fn [acc bucket]
+                (let-do [m acc]
+                  (for [i 0 (Array.length &bucket)]
+                    (let [pair-ref (Array.unsafe-nth &bucket i)]
+                      (set! m
+                            (insert @(Pair.a pair-ref)
+                                    (~f @(Pair.b pair-ref))
+                                    &m))))
+                  m))
+              (empty)
+              (%map-trie map-ref)))
+
+          (doc filter
+            "Keep only entries whose `(Pair key value)` satisfies a predicate.")
+          (sig filter
+               (Fn
+                 [(Ref (Fn [(Ref (Pair %key-type %value-type) q)] Bool) r)
+                  (Ref %name s)]
+                 %name))
+          (defn filter [pred map-ref]
+            (%trie-reduce-values
+              &(fn [acc bucket]
+                (let-do [m acc]
+                  (for [i 0 (Array.length &bucket)]
+                    (let [pair-ref (Array.unsafe-nth &bucket i)]
+                      (when (~pred pair-ref)
+                        (set! m
+                              (insert @(Pair.a pair-ref) @(Pair.b pair-ref) &m)))))
+                  m))
+              (empty)
+              (%map-trie map-ref)))
+
           (doc str "Diagnostic formatting for a hash map.")
           (sig str (Fn [(Ref %name q)] String))
           (defn str [map-ref]

test/persistent_deque.carp

@@ -15,8 +15,7 @@
 
 (defn build-long-back-deque [n]
   (let-do [d (IntDeque.empty)]
-    (for [i 0 n]
-      (set! d (IntDeque.push-back i &d)))
+    (for [i 0 n] (set! d (IntDeque.push-back i &d)))
     d))
 
 (defn deque-branch-lifecycle []
@@ -25,13 +24,10 @@
         d2 (IntDeque.push-back 2 &d1)
         d3 (IntDeque.push-front 0 &d2)
         d4 (IntDeque.push-back 3 &d3)]
-    (do
-      (ignore d2)
-      (ignore d4))))
+    (do (ignore d2) (ignore d4))))
 
 (defn pop-front-values [dq-ref]
-  (let [out0 []]
-    (pop-front-values-iter dq-ref &out0)))
+  (let [out0 []] (pop-front-values-iter dq-ref &out0)))
 
 (defn pop-front-values-iter [dq-ref out-ref]
   (match (IntDeque.pop-front dq-ref)
@@ -46,14 +42,12 @@
 (deftest test
   (assert-equal test
     true
-    (let [d (IntDeque.empty)]
-      (IntDeque.empty? &d))
+    (let [d (IntDeque.empty)] (IntDeque.empty? &d))
     "empty deque reports empty")
 
   (assert-equal test
     0l
-    (let [d (IntDeque.empty)]
-      (IntDeque.length &d))
+    (let [d (IntDeque.empty)] (IntDeque.length &d))
     "empty deque has length 0")
 
   (assert-equal test
@@ -62,12 +56,13 @@
           d1 (IntDeque.push-back 1 &d0)
           d2 (IntDeque.push-front 0 &d1)
           d3 (IntDeque.push-back 2 &d2)]
-      (and (match (IntDeque.peek-front &d3)
-             (Maybe.Just v) (= v 0)
-             (Maybe.Nothing) false)
-           (match (IntDeque.peek-back &d3)
-             (Maybe.Just v) (= v 2)
-             (Maybe.Nothing) false)))
+      (and
+        (match (IntDeque.peek-front &d3)
+          (Maybe.Just v) (= v 0)
+          (Maybe.Nothing) false)
+        (match (IntDeque.peek-back &d3)
+          (Maybe.Just v) (= v 2)
+          (Maybe.Nothing) false)))
     "peek-front/peek-back read both ends")
 
   (assert-equal test
@@ -119,8 +114,7 @@
         (Maybe.Just p)
           (let [v @(Pair.a &p)
                 d2 @(Pair.b &p)]
-            (and (= v 0)
-                 (= (IntDeque.length &d2) 99999l)))))
+            (and (= v 0) (= (IntDeque.length &d2) 99999l)))))
     "pop-front on 100k rear-only deque rebalances without blowing the C stack")
 
   (assert-equal test
@@ -153,5 +147,60 @@
       (and (= &a &b) (not (= &a &c))))
     "= is structural regardless of front/rear split")
 
-  (assert-memory-balance test deque-branch-lifecycle 0l "persistent deque branch lifecycle is memory-balanced")
-)
+  (assert-equal test
+    true
+    (let [d0 (IntDeque.empty)
+          d1 (IntDeque.push-back 1 &d0)
+          d2 (IntDeque.push-back 2 &d1)
+          d3 (IntDeque.push-front 0 &d2)
+          mapped (IntDeque.map &(fn [x] (+ x 10)) &d3)
+          arr (IntDeque.to-array &mapped)]
+      (and (= (Array.length &arr) 3)
+           (= @(Array.unsafe-nth &arr 0) 10)
+           (= @(Array.unsafe-nth &arr 1) 11)
+           (= @(Array.unsafe-nth &arr 2) 12)))
+    "map applies function preserving front-to-back order")
+
+  (assert-equal test
+    true
+    (let [d (IntDeque.empty)
+          m (IntDeque.map &(fn [x] (+ x 1)) &d)]
+      (IntDeque.empty? &m))
+    "map over empty deque yields empty")
+
+  (assert-equal test
+    true
+    (let [d0 (IntDeque.empty)
+          d1 (IntDeque.push-back 1 &d0)
+          d2 (IntDeque.push-back 2 &d1)
+          d3 (IntDeque.push-back 3 &d2)
+          d4 (IntDeque.push-front 0 &d3)
+          filtered (IntDeque.filter &(fn [x] (> @x 1)) &d4)
+          arr (IntDeque.to-array &filtered)]
+      (and (= (Array.length &arr) 2)
+           (= @(Array.unsafe-nth &arr 0) 2)
+           (= @(Array.unsafe-nth &arr 1) 3)))
+    "filter keeps elements matching predicate in order")
+
+  (assert-equal test
+    true
+    (let [d0 (IntDeque.empty)
+          d1 (IntDeque.push-back 1 &d0)
+          d2 (IntDeque.push-back 2 &d1)
+          filtered (IntDeque.filter &(fn [x] false) &d2)]
+      (IntDeque.empty? &filtered))
+    "filter with always-false yields empty deque")
+
+  (assert-equal test
+    true
+    (let [d0 (IntDeque.empty)
+          d1 (IntDeque.push-back 1 &d0)
+          d2 (IntDeque.push-back 2 &d1)
+          filtered (IntDeque.filter &(fn [x] true) &d2)]
+      (= &filtered &d2))
+    "filter with always-true preserves all elements")
+
+  (assert-memory-balance test
+                         deque-branch-lifecycle
+                         0l
+                         "persistent deque branch lifecycle is memory-balanced"))