gemini refactor for rs taste; tag 0.9.16

Author: tiye

Cargo.lock

@@ -1,7 +1,7 @@
 
 [package]
 name = "calcit"
-version = "0.9.15"
+version = "0.9.16"
 authors = ["jiyinyiyong <jiyinyiyong@gmail.com>"]
 edition = "2024"
 license = "MIT"
@@ -53,6 +53,6 @@ path = "src/bin/bundle_calcit.rs"
 name = "caps"
 path = "src/bin/calcit_deps.rs"
 
-# [profile.release]
-# debug = true
-# opt-level = 1
+[profile.release]
+lto = true
+opt-level = 3

Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.9.15",
+  "version": "0.9.16",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^22.15.24",

package.json

@@ -1,6 +1,8 @@
 use core::cmp::Ordering;
 use std::sync::Arc;
 
+use rpds::HashTrieSet;
+
 use crate::calcit::{Calcit, CalcitErr, CalcitList, CalcitTuple};
 use crate::util::number::f64_to_usize;
 
@@ -44,15 +46,12 @@ pub fn slice(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
   }
   match (&xs[0], &xs[1]) {
     (Calcit::List(ys), Calcit::Number(from)) => {
+      let from_idx = f64_to_usize(*from)?;
       let to_idx = match xs.get(2) {
-        Some(Calcit::Number(to)) => {
-          let idx: usize = unsafe { to.to_int_unchecked() };
-          idx
-        }
+        Some(Calcit::Number(to)) => f64_to_usize(*to)?,
         Some(a) => return CalcitErr::err_str(format!("slice expected number index, got: {a}")),
         None => ys.len(),
       };
-      let from_idx: usize = unsafe { from.to_int_unchecked() };
 
       Ok(Calcit::List(Arc::new(ys.slice(from_idx, to_idx)?)))
     }
@@ -112,16 +111,23 @@ pub fn butlast(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
 }
 
 pub fn concat(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
-  let mut ys = vec![];
+  let mut total_size = 0;
   for x in xs {
     if let Calcit::List(zs) = x {
-      for z in &**zs {
-        ys.push(z.to_owned());
-      }
+      total_size += zs.len();
     } else {
       return CalcitErr::err_str(format!("concat expects list arguments, got: {x}"));
     }
   }
+
+  let mut ys = Vec::with_capacity(total_size);
+  for x in xs {
+    if let Calcit::List(zs) = x {
+      // Use extend to efficiently append elements from the inner list
+      ys.extend(zs.iter().map(|v| v.to_owned()));
+    }
+    // no need for else, already checked
+  }
   Ok(Calcit::List(Arc::new(CalcitList::Vector(ys))))
 }
 
@@ -184,13 +190,13 @@ pub fn foldl(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calcit, Calcit
     match (&xs[0], &xs[2]) {
       // dirty since only functions being call directly then we become fast
       (Calcit::List(xs), Calcit::Fn { info, .. }) => {
-        for x in &**xs {
+        for x in xs.iter() {
           ret = runner::run_fn(&[ret, (*x).to_owned()], info, call_stack)?;
         }
         Ok(ret)
       }
       (Calcit::List(xs), Calcit::Proc(proc)) => {
-        for x in &**xs {
+        for x in xs.iter() {
           // println!("foldl args, {} {}", ret, x.to_owned());
           ret = builtins::handle_proc(*proc, &[ret, (*x).to_owned()], call_stack)?;
         }
@@ -257,7 +263,7 @@ pub fn foldl_shortcut(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calci
       // dirty since only functions being call directly then we become fast
       (Calcit::List(xs), Calcit::Fn { info, .. }) => {
         let mut state = acc.to_owned();
-        for x in &**xs {
+        for x in xs.iter() {
           let pair = runner::run_fn(&[state.to_owned(), (*x).to_owned()], info, call_stack)?;
           match pair {
             Calcit::Tuple(CalcitTuple { tag: x0, extra, .. }) => match &*x0 {
@@ -456,10 +462,7 @@ pub fn sort(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calcit, CalcitE
     match (&xs[0], &xs[1]) {
       // dirty since only functions being call directly then we become fast
       (Calcit::List(xs), Calcit::Fn { info, .. }) => {
-        let mut xs2: Vec<Calcit> = vec![];
-        xs.traverse(&mut |x| {
-          xs2.push(x.to_owned());
-        });
+        let mut xs2: Vec<Calcit> = xs.to_vec(); // Use existing to_vec()
         xs2.sort_by(|a, b| -> Ordering {
           let v = runner::run_fn(&[(*a).to_owned(), (*b).to_owned()], info, call_stack);
           match v {
@@ -476,17 +479,10 @@ pub fn sort(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calcit, CalcitE
             }
           }
         });
-        let mut ys = CalcitList::new_inner();
-        for x in xs2.iter() {
-          ys = ys.push_right(x.to_owned())
-        }
-        Ok(Calcit::List(Arc::new(ys.into())))
+        Ok(Calcit::List(Arc::new(CalcitList::Vector(xs2))))
       }
       (Calcit::List(xs), Calcit::Proc(proc)) => {
-        let mut xs2: Vec<Calcit> = vec![];
-        xs.traverse(&mut |x| {
-          xs2.push(x.to_owned());
-        });
+        let mut xs2: Vec<Calcit> = xs.to_vec(); // Use existing to_vec()
         xs2.sort_by(|a, b| -> Ordering {
           let v = builtins::handle_proc(*proc, &[(*a).to_owned(), (*b).to_owned()], call_stack);
           match v {
@@ -503,11 +499,7 @@ pub fn sort(xs: &[Calcit], call_stack: &CallStackList) -> Result<Calcit, CalcitE
             }
           }
         });
-        let mut ys = CalcitList::new_inner();
-        for x in xs2.iter() {
-          ys = ys.push_right(x.to_owned())
-        }
-        Ok(Calcit::List(Arc::new(ys.into())))
+        Ok(Calcit::List(Arc::new(CalcitList::Vector(xs2)))) // Directly create from Vec
       }
       (a, b) => Err(CalcitErr::use_msg_stack_location(
         format!("sort expected list and function, got: {a} {b}"),
@@ -661,9 +653,11 @@ pub fn distinct(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
   }
   match &xs[0] {
     Calcit::List(ys) => {
+      let mut seen = HashTrieSet::new_sync();
       let mut zs = CalcitList::new_inner();
       ys.traverse(&mut |y| {
-        if zs.index_of(y).is_none() {
+        if !seen.contains(y) {
+          seen.insert_mut(y.to_owned());
           zs = zs.push_right(y.to_owned());
         }
       });

src/builtins/lists.rs

@@ -1,17 +1,19 @@
-use std::char;
 use std::cmp::Ordering;
 
-use im_ternary_tree::TernaryTreeList;
-
-use crate::calcit::CalcitList;
-use crate::calcit::{Calcit, CalcitErr};
+use crate::calcit::{Calcit, CalcitErr, CalcitList};
 use crate::util::number::f64_to_usize;
 
 pub fn binary_str_concat(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
   match (xs.first(), xs.get(1)) {
     (Some(Calcit::Nil), Some(Calcit::Nil)) => Ok(Calcit::new_str("")),
     (Some(Calcit::Nil), Some(b)) => Ok(Calcit::Str(b.turn_string().into())),
     (Some(a), Some(Calcit::Nil)) => Ok(Calcit::Str(a.turn_string().into())),
+    (Some(Calcit::Str(s1)), Some(Calcit::Str(s2))) => {
+      let mut s = String::with_capacity(s1.len() + s2.len());
+      s.push_str(s1);
+      s.push_str(s2);
+      Ok(Calcit::Str(s.into()))
+    }
     (Some(a), Some(b)) => {
       let mut s = a.turn_string();
       s.push_str(&b.turn_string());
@@ -61,14 +63,12 @@ pub fn turn_string(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
 pub fn split(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
   match (xs.first(), xs.get(1)) {
     (Some(Calcit::Str(s)), Some(Calcit::Str(pattern))) => {
-      let pieces = (**s).split(&**pattern);
-      let mut ys = vec![];
-      for p in pieces {
-        if !p.is_empty() {
-          ys.push(Calcit::Str(p.into()));
-        }
-      }
-      Ok(Calcit::from(ys))
+      let pieces = (**s)
+        .split(&**pattern)
+        .filter(|s| !s.is_empty())
+        .map(|s| Calcit::Str(s.into()))
+        .collect::<Vec<Calcit>>();
+      Ok(Calcit::from(pieces))
     }
     (Some(a), Some(b)) => CalcitErr::err_str(format!("split expected 2 strings, got: {a} {b}")),
     (_, _) => CalcitErr::err_str("split expected 2 arguments, got nothing"),
@@ -114,41 +114,32 @@ pub fn replace(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
 pub fn split_lines(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
   match xs.first() {
     Some(Calcit::Str(s)) => {
-      let lines = s.split('\n');
-      let mut ys = TernaryTreeList::Empty;
-      for line in lines {
-        ys = ys.push_right(Calcit::Str(line.to_owned().into()));
-      }
-      Ok(Calcit::from(CalcitList::List(ys)))
+      let lines = s.lines().map(|line| Calcit::Str(line.to_owned().into())).collect::<Vec<Calcit>>();
+      Ok(Calcit::from(lines))
     }
     Some(a) => CalcitErr::err_str(format!("split-lines expected 1 string, got: {a}")),
     _ => CalcitErr::err_str("split-lines expected 1 argument, got nothing"),
   }
 }
 pub fn str_slice(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
-  match (xs.first(), xs.get(1)) {
-    (Some(Calcit::Str(s)), Some(Calcit::Number(n))) => match f64_to_usize(*n) {
-      Ok(from) => {
-        let to: usize = match xs.get(2) {
-          Some(Calcit::Number(n2)) => match f64_to_usize(*n2) {
-            Ok(idx2) => idx2,
-            Err(e) => return CalcitErr::err_str(format!("&str:slice expected number, got: {e}")),
-          },
-          Some(a) => return CalcitErr::err_str(format!("&str:slice expected number, got: {a}")),
-          None => s.chars().count(),
-        };
-        if from >= to {
-          Ok(Calcit::new_str(""))
-        } else {
-          // turn into vec first to also handle UTF8
-          let s_vec = s.chars().collect::<Vec<_>>();
-          Ok(Calcit::Str(s_vec[from..to].iter().to_owned().collect::<String>().into()))
-        }
+  match (xs.first(), xs.get(1), xs.get(2)) {
+    (Some(Calcit::Str(s)), Some(Calcit::Number(n_from)), n_to) => {
+      let from = f64_to_usize(*n_from)?;
+      let to = match n_to {
+        Some(Calcit::Number(n)) => f64_to_usize(*n)?,
+        Some(a) => return CalcitErr::err_str(format!("&str:slice expected number, got: {a}")),
+        None => s.chars().count(),
+      };
+
+      if from >= to {
+        Ok(Calcit::new_str(""))
+      } else {
+        let s: String = s.chars().skip(from).take(to - from).collect();
+        Ok(Calcit::Str(s.into()))
       }
-      Err(e) => CalcitErr::err_str(e),
-    },
-    (Some(a), Some(b)) => CalcitErr::err_str(format!("&str:slice expected string and number, got: {a} {b}")),
-    (_, _) => CalcitErr::err_nodes("&str:slice expected string and numbers, got:", xs),
+    }
+    (Some(a), Some(b), ..) => CalcitErr::err_str(format!("&str:slice expected string and number, got: {a} {b}")),
+    (_, _, _) => CalcitErr::err_nodes("&str:slice expected string and numbers, got:", xs),
   }
 }
 
@@ -321,18 +312,7 @@ pub fn first(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
 
 pub fn rest(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
   match xs.first() {
-    Some(Calcit::Str(s)) => {
-      let mut buffer = String::with_capacity(s.len() - 1);
-      let mut is_first = true;
-      for c in s.chars() {
-        if is_first {
-          is_first = false;
-          continue;
-        }
-        buffer.push(c)
-      }
-      Ok(Calcit::Str(buffer.into()))
-    }
+    Some(Calcit::Str(s)) => Ok(Calcit::Str(s.chars().skip(1).collect::<String>().into())),
     Some(a) => CalcitErr::err_str(format!("str:rest expected a string, got: {a}")),
     None => CalcitErr::err_str("str:rest expected 1 argument, got nothing"),
   }
@@ -347,21 +327,17 @@ pub fn pad_left(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
           return CalcitErr::err_str("&str:pad-left expected non-empty pattern");
         }
         if s.len() >= size {
-          Ok(xs[0].to_owned())
-        } else {
-          let mut buffer = String::with_capacity(size);
-          let pad_size = size - s.len();
-          'write: loop {
-            for c in pattern.chars() {
-              buffer.push(c);
-              if buffer.len() >= pad_size {
-                break 'write;
-              }
-            }
-          }
-          buffer.push_str(s);
-          Ok(Calcit::Str(buffer.into()))
+          return Ok(xs[0].to_owned());
+        }
+
+        let pad_size = size - s.len();
+        let mut buffer = String::with_capacity(size);
+        // Directly iterate over pattern characters
+        for c in pattern.chars().cycle().take(pad_size) {
+          buffer.push(c);
         }
+        buffer.push_str(s);
+        Ok(Calcit::Str(buffer.into()))
       }
       (a, b, c) => CalcitErr::err_str(format!("&str:pad-left expected string, number, string, got: {a} {b} {c}")),
     }
@@ -379,20 +355,16 @@ pub fn pad_right(xs: &[Calcit]) -> Result<Calcit, CalcitErr> {
           return CalcitErr::err_str("&str:pad-right expected non-empty pattern");
         }
         if s.len() >= size {
-          Ok(xs[0].to_owned())
-        } else {
-          let mut buffer = String::with_capacity(size);
-          buffer.push_str(s);
-          'write: loop {
-            for c in pattern.chars() {
-              buffer.push(c);
-              if buffer.len() >= size {
-                break 'write;
-              }
-            }
-          }
-          Ok(Calcit::Str(buffer.into()))
+          return Ok(xs[0].to_owned());
+        }
+
+        let mut buffer = String::with_capacity(size);
+        buffer.push_str(s);
+        // Directly iterate over pattern characters
+        for c in pattern.chars().cycle().take(size - s.len()) {
+          buffer.push(c);
         }
+        Ok(Calcit::Str(buffer.into()))
       }
       (a, b, c) => CalcitErr::err_str(format!("&str:pad-right expected string, number, string, got: {a} {b} {c}")),
     }

src/builtins/strings.rs

@@ -352,14 +352,11 @@ impl CalcitList {
   }
 
   pub fn assoc_after(&self, idx: usize, x: Calcit) -> Result<Self, String> {
-    match self {
-      CalcitList::Vector(xs) => {
-        let mut ys = TernaryTreeList::from(xs);
-        ys = ys.assoc_after(idx, x)?;
-        Ok(CalcitList::List(ys))
-      }
-      CalcitList::List(xs) => Ok(CalcitList::List(xs.assoc_after(idx, x)?)),
-    }
+    let base_list = match self {
+      CalcitList::Vector(xs) => TernaryTreeList::from(xs),
+      CalcitList::List(xs) => xs.clone(),
+    };
+    Ok(CalcitList::List(base_list.assoc_after(idx, x)?))
   }
 
   pub fn index_of(&self, x: &Calcit) -> Option<usize> {

src/calcit/list.rs

@@ -42,7 +42,8 @@ pub fn data_to_calcit(x: &Calcit, ns: &str, at_def: &str) -> Result<Calcit, Stri
       Ok(Calcit::from(ys))
     }
     Calcit::List(xs) => {
-      let mut ys = vec![Calcit::Proc(CalcitProc::List)];
+      let mut ys = Vec::with_capacity(xs.len() + 1);
+      ys.push(Calcit::Proc(CalcitProc::List));
       xs.traverse_result::<String>(&mut |x| {
         ys.push(data_to_calcit(x, ns, at_def)?);
         Ok(())