experiment on "no drop"

Author: tiye

calcit.cirru

@@ -63,21 +63,17 @@
               println "\"%%% test variable holding regex"
               let
                   pattern $ re-pattern "\"\\d+"
-                  p2 $ re-pattern "\"\\w+"
                 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"
-                w-log $ re-drop p2
-                w-log $ re-drop pattern
-                w-log $ re-drop pattern
       :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 re-pattern re-drop
+            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 $ {}

compact.cirru

@@ -1,16 +1,8 @@
-use std::{
-  cell::RefCell,
-  sync::{Arc, Mutex},
-};
+use std::{cell::RefCell, sync::Arc};
 
 use cirru_edn::{Edn, EdnAnyRef, EdnListView};
-use lazy_static::lazy_static;
 use regex::Regex;
 
-lazy_static! {
-  static ref PATTERNS: Mutex<Vec<EdnAnyRef>> = Mutex::from(vec![]);
-}
-
 #[no_mangle]
 pub fn abi_version() -> String {
   String::from("0.0.8")
@@ -23,11 +15,8 @@ pub fn re_pattern(args: Vec<Edn>) -> Result<Edn, String> {
       Edn::Str(s) => match Regex::new(s) {
         Ok(pattern) => {
           let p = Arc::from(RefCell::new(pattern));
-          // push to PATTERNS
-          let v = EdnAnyRef(p);
-          let mut patterns = PATTERNS.lock().unwrap();
-          patterns.push(v.to_owned());
-          Ok(Edn::AnyRef(v))
+
+          Ok(Edn::AnyRef(EdnAnyRef(p)))
         }
         Err(e) => Err(format!("re-pattern failed, {}", e)),
       },
@@ -38,38 +27,6 @@ pub fn re_pattern(args: Vec<Edn>) -> Result<Edn, String> {
   }
 }
 
-/// re_drop drops pattern from global PATTERNS
-#[no_mangle]
-pub fn re_drop(args: Vec<Edn>) -> Result<Edn, String> {
-  if args.len() == 1 {
-    match &args[0] {
-      Edn::AnyRef(p) => {
-        let mut patterns = PATTERNS.lock().unwrap();
-        let mut i = 0;
-        let mut found = false;
-        println!("patterns size {}", patterns.len());
-        for v in patterns.iter() {
-          if v == p {
-            found = true;
-            break;
-          }
-          i += 1;
-        }
-        println!("re-drop found {} at {}\n", found, i);
-        if found {
-          patterns.remove(i);
-          Ok(Edn::from(true))
-        } else {
-          Ok(Edn::from(false))
-        }
-      }
-      _ => Err(format!("re-drop expect 1 pattern, got {:?}", args)),
-    }
-  } else {
-    Err(format!("re-drop expect 1 pattern, got {:?}", args))
-  }
-}
-
 #[no_mangle]
 pub fn re_matches(args: Vec<Edn>) -> Result<Edn, String> {
   if args.len() == 2 {