experimentally holding regex with any-ref; tag 0.0.5-a1

Author: tiye

.github/workflows/check.yaml

@@ -16,7 +16,7 @@ jobs:
 
       - uses: calcit-lang/[email protected]
         with:
-          version: "0.8.50"
+          version: "0.8.51-a1"
 
       - uses: dtolnay/rust-toolchain@stable
         with:

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "calcit_regex"
-version = "0.0.4"
+version = "0.0.5-a1"
 authors = ["jiyinyiyong <[email protected]>"]
 edition = "2021"
 
@@ -13,6 +13,7 @@ crate-type = ["dylib"] # Creates dynamic lib
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cirru_edn = "0.6.3"
+cirru_edn = "0.6.4-a1"
+# cirru_edn = { path = "/Users/chenyong/repo/cirru/edn.rs" }
 cirru_parser = "0.1.29"
 regex = "1.10.4"

Cargo.toml

@@ -25,6 +25,9 @@ regex.core/re-replace-all |1ab22c333 |\d{2} "\"X"
 
 regex.core/re-split |1ab22c333 |\d{2}
 ; [] "\"1ab" "\"c" "\"3"
+
+regex.core/re-pattern |\d+
+; "creates any-ref to hold a native regex pattern"
 ```
 
 Install to `~/.config/calcit/modules/`, compile and provide `*.{dylib,so}` file with `./build.sh`.

README.md

@@ -1,6 +1,6 @@
 
 {} (:package |regex)
-  :configs $ {} (:init-fn |regex.test/main!) (:reload-fn |regex.test/reload!) (:version |0.0.3)
+  :configs $ {} (:init-fn |regex.test/main!) (:reload-fn |regex.test/reload!) (:version |0.0.5-a1)
     :modules $ []
   :entries $ {}
   :files $ {}
@@ -22,6 +22,10 @@
           :code $ quote
             defn re-matches (s pattern)
               &call-dylib-edn (get-dylib-path "\"/dylibs/libcalcit_std") "\"re_matches" s pattern
+        |re-pattern $ %{} :CodeEntry (:doc |)
+          :code $ quote
+            defn re-pattern (pattern)
+              &call-dylib-edn (get-dylib-path "\"/dylibs/libcalcit_std") "\"re_pattern" pattern
         |re-replace-all $ %{} :CodeEntry (:doc |)
           :code $ quote
             defn re-replace-all (s pattern next)
@@ -52,10 +56,20 @@
               assert= ([] |1 |2 |34) (re-find-all |1a2a34 |\d+)
               assert= |1abXcX3 $ re-replace-all |1ab22c333 |\d{2} "\"X"
               assert= ([] "\"1ab" "\"c" "\"3") (re-split |1ab22c333 |\d{2})
+              println "\"%%% test variable holding regex"
+              let
+                  pattern $ re-pattern "\"\\d+"
+                println "\"Pattern is:" pattern
+                assert= true $ re-matches |2 pattern
+                assert= true $ re-matches |23 pattern
+                assert= false $ re-matches |qq pattern
+                assert= "\"22" $ re-find |q22 pattern
+                assert= ([] |1 |2 |3) (re-find-all |1q2q3 pattern)
+                assert= |XabXcX $ re-replace-all |1ab22c333 pattern "\"X"
       :ns $ %{} :CodeEntry (:doc |)
         :code $ quote
           ns regex.test $ :require
-            regex.core :refer $ re-matches re-find-index re-find re-find-all re-split re-replace-all
+            regex.core :refer $ re-matches re-find-index re-find re-find-all re-split re-replace-all re-pattern
             regex.$meta :refer $ calcit-dirname calcit-filename
     |regex.util $ %{} :FileEntry
       :defs $ {}

calcit.cirru

@@ -1,9 +1,26 @@
-use cirru_edn::{Edn, EdnListView};
+use std::sync::Arc;
+
+use cirru_edn::{Edn, EdnAnyRef, EdnListView};
 use regex::Regex;
 
 #[no_mangle]
 pub fn abi_version() -> String {
-  String::from("0.0.7")
+  String::from("0.0.8")
+}
+
+#[no_mangle]
+pub fn re_pattern(args: Vec<Edn>) -> Result<Edn, String> {
+  if args.len() == 1 {
+    match &args[0] {
+      Edn::Str(s) => match Regex::new(s) {
+        Ok(pattern) => Ok(Edn::AnyRef(EdnAnyRef(Arc::from(pattern)))),
+        Err(e) => Err(format!("re-pattern failed, {}", e)),
+      },
+      _ => Err(format!("re-pattern expect 1 string, got {:?}", args)),
+    }
+  } else {
+    Err(format!("re-pattern expect 1 string, got {:?}", args))
+  }
 }
 
 #[no_mangle]
@@ -14,6 +31,13 @@ pub fn re_matches(args: Vec<Edn>) -> Result<Edn, String> {
         Ok(p) => Ok(Edn::Bool(p.is_match(s))),
         Err(e) => Err(format!("re-matches failed, {}", e)),
       },
+      (Edn::Str(s), Edn::AnyRef(EdnAnyRef(p))) => {
+        if let Some(pattern) = p.downcast_ref::<Regex>() {
+          Ok(Edn::Bool(pattern.is_match(s)))
+        } else {
+          Err(format!("re-matches expected a regex, got {:?}", p))
+        }
+      }
       (_, _) => Err(format!("re-matches expected 2 strings: {:?}", args)),
     }
   } else {
@@ -34,6 +58,16 @@ pub fn re_find_index(args: Vec<Edn>) -> Result<Edn, String> {
           Err(e) => Err(format!("re-find-index failed, {}", e)),
         }
       }
+      (Edn::Str(s), Edn::AnyRef(EdnAnyRef(p))) => {
+        if let Some(pattern) = p.downcast_ref::<Regex>() {
+          match pattern.find(s) {
+            Some(matched) => Ok(Edn::Number(matched.start() as f64)),
+            None => Ok(Edn::Number(-1.0)), // TODO maybe nil
+          }
+        } else {
+          Err(format!("re-find-index expected a regex, got {:?}", p))
+        }
+      }
       (_, _) => Err(format!("re-find-index expected 2 strings: {:?}", args)),
     }
   } else {
@@ -51,13 +85,24 @@ pub fn re_find(args: Vec<Edn>) -> Result<Edn, String> {
           Ok(p) => {
             let mut matched = p.find_iter(s);
             match matched.next() {
-              Some(v) => Ok(Edn::Str(v.as_str().to_string().into())),
-              None => Ok(Edn::Str("".to_owned().into())), // TODO maybe nil
+              Some(v) => Ok(Edn::str(v.as_str().to_string())),
+              None => Ok(Edn::from("")), // TODO maybe nil
             }
           }
           Err(e) => Err(format!("re-find failed, {}", e)),
         }
       }
+      (Edn::Str(s), Edn::AnyRef(EdnAnyRef(p))) => {
+        if let Some(pattern) = p.downcast_ref::<Regex>() {
+          let mut matched = pattern.find_iter(s);
+          match matched.next() {
+            Some(v) => Ok(Edn::str(v.as_str().to_string())),
+            None => Ok(Edn::from("")), // TODO maybe nil
+          }
+        } else {
+          Err(format!("re-find expected a regex, got {:?}", p))
+        }
+      }
       (_, _) => Err(format!("re-find expected 2 strings: {:?}", args)),
     }
   } else {
@@ -79,6 +124,17 @@ pub fn re_find_all(args: Vec<Edn>) -> Result<Edn, String> {
         }
         Err(e) => Err(format!("re-find-all failed, {}", e)),
       },
+      (Edn::Str(s), Edn::AnyRef(EdnAnyRef(p))) => {
+        if let Some(pattern) = p.downcast_ref::<Regex>() {
+          let mut ys: Vec<Edn> = vec![];
+          for v in pattern.find_iter(s) {
+            ys.push(Edn::Str(v.as_str().to_string().into()))
+          }
+          Ok(Edn::List(EdnListView(ys)))
+        } else {
+          Err(format!("re-find-all expected a regex, got {:?}", p))
+        }
+      }
       (_, _) => Err(format!("re-find-all expected 2 strings: {:?}", args)),
     }
   } else {
@@ -100,6 +156,17 @@ pub fn re_split(args: Vec<Edn>) -> Result<Edn, String> {
         }
         Err(e) => Err(format!("re-split failed, {}", e)),
       },
+      (Edn::Str(s), Edn::AnyRef(EdnAnyRef(p))) => {
+        if let Some(pattern) = p.downcast_ref::<Regex>() {
+          let mut ys: Vec<Edn> = vec![];
+          for piece in pattern.split(s) {
+            ys.push(Edn::str(piece));
+          }
+          Ok(Edn::List(EdnListView(ys)))
+        } else {
+          Err(format!("re-split expected a regex, got {:?}", p))
+        }
+      }
       (_, _) => Err(format!("re-split expected 2 strings: {:?}", args)),
     }
   } else {
@@ -115,6 +182,13 @@ pub fn re_replace_all(args: Vec<Edn>) -> Result<Edn, String> {
         Ok(p) => Ok(Edn::str(p.replace_all(s, &**next).into_owned())),
         Err(e) => Err(format!("re-replace-all failed, {}", e)),
       },
+      (Edn::Str(s), Edn::AnyRef(EdnAnyRef(p)), Edn::Str(next)) => {
+        if let Some(pattern) = p.downcast_ref::<Regex>() {
+          Ok(Edn::str(pattern.replace_all(s, &**next).into_owned()))
+        } else {
+          Err(format!("re-replace-all expected a regex, got {:?}", p))
+        }
+      }
       (a, b, c) => Err(format!("re-replace-all expected 3 strings: {} {} {}", a, b, c)),
     }
   } else {