feat: scan functions (#1339)

Author: eriksvedang

core/Array.carp

@@ -43,6 +43,30 @@ It will sum the previous sum with each new value, starting at `0`.")
           (set! total (~f total (unsafe-nth xs i))))
         total)))
 
+  (doc scan "Similar to `Array.reduce`, but instead returns an array with the starting element,
+and then all intermediate values.
+
+For example, a scan using `Int.+` over the array [1 1 1 1 1] (starting at 0) will return [0 1 2 3 4 5].")
+  (defn scan [f x xs]
+    (let [n (length xs)
+          ys (allocate (inc n))]
+      (do
+        (aset-uninitialized! &ys 0 @&x)
+        (for [i 1 (inc n)]
+          (aset-uninitialized! &ys i (~f (unsafe-nth &ys (dec i)) (unsafe-nth xs (dec i)))))
+        ys)))
+
+  (doc endo-scan "Like `Array.scan`, but uses the first element of the array as the starting value.
+Also does not create a new array, but reuses the initial one instead (by taking ownership over `xs`.)
+
+For example, an endo-scan using `Int.+` over the array [1 1 1 1 1] will return [1 2 3 4 5]")
+  (defn endo-scan [f xs]
+    (let [n (length &xs)]
+      (do
+        (for [i 1 n]
+          (aset! &xs i (~f (unsafe-nth &xs (dec i)) (unsafe-nth &xs i))))
+        xs)))
+
   (doc empty? "checks whether the array `a` is empty.")
   (defn empty? [a]
     (= (Array.length a) 0))

core/StaticArray.carp

@@ -38,6 +38,14 @@ stack-allocated. For a more flexible, heap-allocated version, you might want to
           (set! total (~f total (StaticArray.unsafe-nth xs i))))
         total)))
 
+    (doc scan! "Scans and replaces the array in-place, using a binary function.
+
+For example, give `(def numbers [1 1 1])`, a `scan!` using `Int.+` will mutate `numbers` to be `[1 2 3]`.")
+  (defn scan! [f xs]
+    (let [n (StaticArray.length xs)]
+      (for [i 1 n]
+        (StaticArray.aset! xs i (~f @(unsafe-nth xs (dec i)) @(unsafe-nth xs i))))))
+
   (doc = "compares two static arrays.")
   (defn = [a b]
     (if (/= (StaticArray.length a) (StaticArray.length b))

test/array.carp

@@ -335,4 +335,20 @@
                     (Pair.init 6 [2 4 6])
                     (map-reduce &(fn [acc x] (Pair.init (+ @x @acc) (* @x 2))) 0 &[1 2 3])
                     "map-reduce works")
+  (assert-ref-equal test
+                    [0 1 2 3 4 5]
+                    (scan &(fn [x y] (+ @x @y)) 0 &[1 1 1 1 1])
+                    "scan works")
+  (assert-ref-equal test
+                    [@"" @"a" @"ab" @"abc"]
+                    (Array.scan &(fn [a b] (String.append a b)) @"" &[@"a" @"b" @"c"])
+                    "scan works on managed type")
+  (assert-ref-equal test
+                    [1 2 3 4 5]
+                    (endo-scan &(fn [x y] (+ @x @y)) [1 1 1 1 1])
+                    "endo-scan works")
+  (assert-ref-equal test
+                    [@"a" @"ab" @"abc"]
+                    (Array.endo-scan &String.append [@"a" @"b" @"c"])
+                    "endo-scan works on managed type")
 )

test/static_array.carp

@@ -216,4 +216,14 @@
   (assert-equal test
                 &2
                 (Pointer.to-ref (Pointer.inc (unsafe-raw $[1 2 3])))
-                "unsafe-raw works as expected II"))
+                "unsafe-raw works as expected II")
+
+  (let [arr $[1 1 1 1 1]]
+    (assert-equal test
+                  $[1 2 3 4 5]
+                  (do
+                    (StaticArray.scan! &Int.+ arr)
+                    arr)
+                  "scan! works"))
+
+  )