Regex builtins: re_match / re_find / re_find_all / re_replace / re_split

Third piece of the Python-ergonomics catch-up. Wraps the `regex`
crate (already a workspace dep) behind 5 OMC builtins covering the
common Python `re` module surface:

  re_match(pattern, text) -> 0 or 1
    Returns 1 if the pattern matches anywhere in text. Use ^/$ to
    anchor. Compiles on every call (one-shot use cheap; for tight
    loops, wrap+memoize at the OMC level).

  re_find(pattern, text) -> string
    First match as a string. Returns "" if no match (NOT null, for
    easier downstream string-handling).

  re_find_all(pattern, text) -> array of strings
    All non-overlapping matches in order. Empty array if no matches.

  re_replace(pattern, text, replacement) -> string
    All matches replaced. Supports Rust regex's $1, $2, ${name}
    backref syntax for capture-group substitution.

  re_split(pattern, text) -> array of strings
    Split at each match. Adjacent matches produce empty strings in
    the output (Python's re.split semantics).

Tests (examples/tests/test_regex.omc — 10 tests, all pass):
  - Basic match / anchored match / character class
  - First find / find-all
  - Replace literal / replace with backref-swap
  - Split on whitespace / CSV-style split
  - Edge: empty pattern matches everything, non-empty on empty text

Registered in:
  - is_known_builtin matches!()
  - HEAL_BUILTIN_NAMES (so heal pass doesn't flag them as typos)
  - compiler type-tag: re_match returns int (JIT compatibility)

Regression: 8 exception + 10 f-string + 57 substrate + 70 builtins
+ 18 harmonic libs + 16 heal + 10 new regex = 189 OMC tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/tests/test_regex.omc

@@ -0,0 +1,65 @@
+# Tests for regex builtins: re_match, re_find, re_find_all, re_replace, re_split.
+
+fn assert_eq(actual, expected, msg) {
+    if actual != expected {
+        test_record_failure(msg + ": expected " + to_string(expected) + " got " + to_string(actual));
+    }
+}
+
+fn test_re_match_basic() {
+    assert_eq(re_match("foo", "barfoobaz"), 1, "foo matches in barfoobaz");
+    assert_eq(re_match("xyz", "abc"), 0, "xyz does not match abc");
+}
+
+fn test_re_match_anchored() {
+    assert_eq(re_match("^abc", "abcdef"), 1, "^abc matches abcdef");
+    assert_eq(re_match("^abc", "xabcdef"), 0, "^abc does NOT match xabcdef");
+}
+
+fn test_re_match_classes() {
+    assert_eq(re_match("[0-9]+", "abc 42 xyz"), 1, "digit class matches");
+    assert_eq(re_match("^[a-z]+$", "hello"), 1, "lowercase-only matches");
+    assert_eq(re_match("^[a-z]+$", "Hello"), 0, "uppercase rejected");
+}
+
+fn test_re_find() {
+    assert_eq(re_find("[0-9]+", "abc 42 xyz"), "42", "first digit match");
+    assert_eq(re_find("[0-9]+", "abc"), "", "no match -> empty string");
+}
+
+fn test_re_find_all() {
+    h matches = re_find_all("[0-9]+", "1 2 3 hello 42");
+    assert_eq(arr_len(matches), 4, "4 numeric tokens");
+    assert_eq(arr_get(matches, 0), "1", "first match");
+    assert_eq(arr_get(matches, 3), "42", "last match");
+}
+
+fn test_re_replace_basic() {
+    assert_eq(re_replace("[0-9]+", "abc 42 xyz", "N"), "abc N xyz", "replace digits with N");
+    assert_eq(re_replace("o", "foo", "0"), "f00", "replace all o with 0");
+}
+
+fn test_re_replace_backref() {
+    # Rust regex syntax uses ${n} or $n for capture groups in replacement.
+    assert_eq(re_replace("(\\w+) (\\w+)", "hello world", "$2 $1"),
+              "world hello", "swap with backrefs");
+}
+
+fn test_re_split() {
+    h parts = re_split("\\s+", "hello   world  foo");
+    assert_eq(arr_len(parts), 3, "3 whitespace-split parts");
+    assert_eq(arr_get(parts, 0), "hello", "first part");
+    assert_eq(arr_get(parts, 1), "world", "second part");
+    assert_eq(arr_get(parts, 2), "foo", "third part");
+}
+
+fn test_re_split_csv() {
+    h parts = re_split(",\\s*", "a, b,c,  d");
+    assert_eq(arr_len(parts), 4, "4 comma-split parts");
+    assert_eq(arr_get(parts, 2), "c", "trim works");
+}
+
+fn test_re_match_empty_string() {
+    assert_eq(re_match("", "anything"), 1, "empty pattern matches everything");
+    assert_eq(re_match("anything", ""), 0, "non-empty pattern on empty text");
+}

omnimcode-core/src/compiler.rs

@@ -182,6 +182,8 @@ impl Compiler {
                         // String → int parsers + counters + size queries
                         | "str_to_int" | "str_count" | "str_is_empty"
                         | "dict_size" | "dict_pop"
+                        // Regex predicate returns int
+                        | "re_match"
                         // Array index/aggregate ints
                         | "arr_argmax" | "arr_argmin"
                         // Bit/digit/modular int returns

omnimcode-core/src/interpreter.rs

@@ -1914,6 +1914,7 @@ impl Interpreter {
             | "str_repeat" | "str_reverse" | "str_uppercase" | "str_lowercase"
             | "str_split_lines" | "str_count" | "str_is_empty"
             | "str_to_int" | "str_to_float" | "str_capitalize"
+            | "re_match" | "re_find" | "re_find_all" | "re_replace" | "re_split"
             // Arrays
             | "arr_new" | "arr_from_range" | "arr_len" | "arr_get" | "arr_set"
             | "arr_push" | "arr_first" | "arr_last" | "arr_slice" | "arr_concat"
@@ -3099,6 +3100,88 @@ impl Interpreter {
                 }
                 Ok(Value::String(s.replace(&old, &new_s)))
             }
+            // ---- Regex (PCRE-style via the `regex` crate) -----------
+            // Compiles the pattern on every call; for inner loops that
+            // want a compiled regex reused, wrap the call in a fn and
+            // memoize at the OMC level. Cheap-enough for one-shot use.
+            "re_match" => {
+                // re_match(pattern, text) -> 1 if pattern matches anywhere
+                // in text, 0 otherwise. Anchor with ^/$ if you need
+                // full-string matching.
+                if args.len() < 2 {
+                    return Err("re_match requires (pattern, text)".to_string());
+                }
+                let pat = self.eval_expr(&args[0])?.to_display_string();
+                let text = self.eval_expr(&args[1])?.to_display_string();
+                match regex::Regex::new(&pat) {
+                    Ok(re) => Ok(Value::HInt(HInt::new(if re.is_match(&text) { 1 } else { 0 }))),
+                    Err(e) => Err(format!("re_match: invalid pattern {:?}: {}", pat, e)),
+                }
+            }
+            "re_find" => {
+                // re_find(pattern, text) -> first match as string, or "" if no match.
+                if args.len() < 2 {
+                    return Err("re_find requires (pattern, text)".to_string());
+                }
+                let pat = self.eval_expr(&args[0])?.to_display_string();
+                let text = self.eval_expr(&args[1])?.to_display_string();
+                match regex::Regex::new(&pat) {
+                    Ok(re) => {
+                        let m = re.find(&text).map(|m| m.as_str().to_string()).unwrap_or_default();
+                        Ok(Value::String(m))
+                    }
+                    Err(e) => Err(format!("re_find: invalid pattern {:?}: {}", pat, e)),
+                }
+            }
+            "re_find_all" => {
+                // re_find_all(pattern, text) -> array of all matches (in order).
+                if args.len() < 2 {
+                    return Err("re_find_all requires (pattern, text)".to_string());
+                }
+                let pat = self.eval_expr(&args[0])?.to_display_string();
+                let text = self.eval_expr(&args[1])?.to_display_string();
+                match regex::Regex::new(&pat) {
+                    Ok(re) => {
+                        let matches: Vec<Value> = re.find_iter(&text)
+                            .map(|m| Value::String(m.as_str().to_string()))
+                            .collect();
+                        Ok(Value::Array(HArray::from_vec(matches)))
+                    }
+                    Err(e) => Err(format!("re_find_all: invalid pattern {:?}: {}", pat, e)),
+                }
+            }
+            "re_replace" => {
+                // re_replace(pattern, text, replacement) -> text with all
+                // pattern matches replaced. Supports $1, $2 backrefs in
+                // replacement string (Rust regex syntax).
+                if args.len() < 3 {
+                    return Err("re_replace requires (pattern, text, replacement)".to_string());
+                }
+                let pat = self.eval_expr(&args[0])?.to_display_string();
+                let text = self.eval_expr(&args[1])?.to_display_string();
+                let repl = self.eval_expr(&args[2])?.to_display_string();
+                match regex::Regex::new(&pat) {
+                    Ok(re) => Ok(Value::String(re.replace_all(&text, repl.as_str()).into_owned())),
+                    Err(e) => Err(format!("re_replace: invalid pattern {:?}: {}", pat, e)),
+                }
+            }
+            "re_split" => {
+                // re_split(pattern, text) -> array of substrings split at pattern.
+                if args.len() < 2 {
+                    return Err("re_split requires (pattern, text)".to_string());
+                }
+                let pat = self.eval_expr(&args[0])?.to_display_string();
+                let text = self.eval_expr(&args[1])?.to_display_string();
+                match regex::Regex::new(&pat) {
+                    Ok(re) => {
+                        let parts: Vec<Value> = re.split(&text)
+                            .map(|s| Value::String(s.to_string()))
+                            .collect();
+                        Ok(Value::Array(HArray::from_vec(parts)))
+                    }
+                    Err(e) => Err(format!("re_split: invalid pattern {:?}: {}", pat, e)),
+                }
+            }
             "str_index_of" => {
                 if args.len() < 2 {
                     return Err("str_index_of requires (haystack, needle)".to_string());
@@ -7771,6 +7854,7 @@ pub(crate) const HEAL_BUILTIN_NAMES: &[&str] = &[
     "str_pad_left", "str_pad_right",
     "str_split_lines", "str_count", "str_is_empty",
     "str_to_int", "str_to_float", "str_capitalize",
+    "re_match", "re_find", "re_find_all", "re_replace", "re_split",
     // Arrays
     "arr_new", "arr_from_range", "arr_len", "arr_get", "arr_set",
     "arr_push", "arr_first", "arr_last", "arr_slice", "arr_concat",