feat(stdlib): improve String module with functional API and optimizations

- Added String.map, String.filter, String.any?, String.all?, String.reduce
- Added String.replace utility
- Optimized starts-with? and ends-with? with efficient C implementations
- Integrated tests for new functionality into test/string.carp
- Updated CHANGELOG.md

Author: sqrew

CHANGELOG.md

@@ -20,6 +20,8 @@
 - fix: #1347 by ignoring generically typed symbols on printing C (#1373)
 - fix: nix install by using correct pkg-configDepends config key (#1372)
 - fix: type signature of Array.unsafe-raw (#1375)
+- feat: add map, filter, any?, all?, reduce, and replace to String (#XXXX)
+- perf: optimize starts-with? and ends-with? in String (#XXXX)
 - docs: Instructions to ensure correct handling of utf-8 (#1367)
 
 # 0.5.4

core/String.carp

@@ -101,16 +101,8 @@
   (defn suffix [s b]
     (from-chars &(Array.suffix &(chars s) b)))
 
-  (doc starts-with? "Check if the string `s` begins with the string `sub`.")
-  (defn starts-with? [s sub]
-    (let [ls (length sub)]
-      (and (>= (length s) ls) (= sub &(prefix s ls)))))
-
-  (doc ends-with? "Check if the string `s` ends with the string `sub`.")
-  (defn ends-with? [s sub]
-    (let [ls (length s)
-          lsub (length sub)]
-      (and (>= ls lsub) (= sub &(suffix s (- ls lsub))))))
+  (register starts-with? (Fn [&String &String] Bool))
+  (register ends-with? (Fn [&String &String] Bool))
 
   (doc zero "The empty string.")
   (defn zero [] @"")
@@ -121,7 +113,7 @@
     (let-do [sum 0
              lstrings (Array.length strings)]
       (for [i 0 lstrings]
-        (set! sum (+ sum (String.length (Array.unsafe-nth strings i)))))
+        (set! sum (+ sum (length (Array.unsafe-nth strings i)))))
       sum))
 
   (doc concat "Returns a new string which is the concatenation of the provided `strings`.")
@@ -189,6 +181,47 @@
   (doc  ascii-to-upper "converts each character in this string to upper case using toupper() from standard C library. Note: this will only work for ASCII characters.")
   (defn ascii-to-upper [s]
     (String.from-bytes &(Array.endo-map &(fn [c] (Byte.toupper- c)) (String.to-bytes s))) )
+
+  (doc map "Maps a function over the characters of a string, returning a new string.")
+  (defn map [f s]
+    (from-chars &(Array.copy-map f &(chars s))))
+
+  (doc filter "Filters the characters of a string using a predicate, returning a new string.")
+  (defn filter [f s]
+    (from-chars &(Array.copy-filter f &(chars s))))
+
+  (doc any? "Checks if any character in a string satisfies a predicate.")
+  (defn any? [f s]
+    (Array.any? f &(chars s)))
+
+  (doc all? "Checks if all characters in a string satisfy a predicate.")
+  (defn all? [f s]
+    (Array.all? f &(chars s)))
+
+  (doc reduce "Reduces a string using a function and an initial value.")
+  (defn reduce [f init s]
+    (Array.reduce f init &(chars s)))
+
+  (doc replace "Replaces all occurrences of a substring in a string with another string.")
+  (defn replace [s needle replacement]
+    (if (empty? needle)
+      @s
+      (let [parts []
+            start 0
+            len (length s)
+            nlen (length needle)]
+        (do
+          (while (< start len)
+            (let [idx (index-of-string &(suffix s start) needle)]
+              (if (= idx -1)
+                (do
+                  (Array.push-back! &parts (suffix s start))
+                  (set! start len))
+                (do
+                  (Array.push-back! &parts (slice s start (+ start idx)))
+                  (Array.push-back! &parts @replacement)
+                  (set! start (+ start (+ idx nlen)))))))
+          (concat &parts)))))
 )
 
 (defmodule StringCopy
@@ -526,4 +559,3 @@
       (cdr (String.split-on "" s)))
   )
 )
-

core/carp_string.h

@@ -191,6 +191,20 @@ String String_tail(const String* s) {
     return news;
 }
 
+bool String_starts_MINUS_with_QMARK_(const String* s, const String* sub) {
+    size_t ls = strlen(*s);
+    size_t lsub = strlen(*sub);
+    if (lsub > ls) return false;
+    return memcmp(*s, *sub, lsub) == 0;
+}
+
+bool String_ends_MINUS_with_QMARK_(const String* s, const String* sub) {
+    size_t ls = strlen(*s);
+    size_t lsub = strlen(*sub);
+    if (lsub > ls) return false;
+    return memcmp(*s + (ls - lsub), *sub, lsub) == 0;
+}
+
 String String_empty() {
     String s = CARP_MALLOC(1);
     s[0] = '\0';

test/string.carp

@@ -400,4 +400,49 @@
                 3
                 (Dynamic.length (Dynamic.String.to-array "abc"))
                 "Dynamic.String.to-array works as expected (check length)")
+
+  (assert-equal test
+                "bcde"
+                &(map &(fn [c] (Char.from-int (Int.inc (Char.to-int @c)))) "abcd")
+                "map works as expected")
+  (assert-equal test
+                "bd"
+                &(filter &(fn [c] (or (= @c \b) (= @c \d))) "abcd")
+                "filter works as expected")
+  (assert-true test
+               (any? &(fn [c] (= @c \c)) "abcd")
+               "any? works as expected I")
+  (assert-false test
+                (any? &(fn [c] (= @c \z)) "abcd")
+                "any? works as expected II")
+  (assert-true test
+               (all? &(fn [c] (not (= @c \z))) "abcd")
+               "all? works as expected I")
+  (assert-false test
+                (all? &(fn [c] (= @c \a)) "abcd")
+                "all? works as expected II")
+  (assert-equal test
+                4
+                (reduce &(fn [acc c] (Int.inc acc)) 0 "abcd")
+                "reduce works as expected (counting characters)")
+  (assert-equal test
+                "hEllo world"
+                &(replace "hello world" "e" "E")
+                "replace works as expected I")
+  (assert-equal test
+                "hi there hi"
+                &(replace "hello there hello" "hello" "hi")
+                "replace works as expected II")
+  (assert-equal test
+                "aaaaa"
+                &(replace "aba" "b" "aaa")
+                "replace works as expected III")
+  (assert-equal test
+                "xyz"
+                &(replace "xyz" "" "abc")
+                "replace with empty needle returns original string")
+  (assert-equal test
+                ""
+                &(replace "aaaaa" "a" "")
+                "replace with empty replacement works")
 )