opportunistic move

should be way faster now

src/systems/stl/str.rs

@@ -2,26 +2,37 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::interner::Interner;
 use crate::representations::OrcString;
-use crate::systems::cast_exprinst::with_str;
 use crate::systems::codegen::{orchid_opt, tuple};
 use crate::systems::RuntimeError;
 use crate::utils::iter_find;
 use crate::{define_fn, ConstTree, Literal};
 
-define_fn! {expr=x in
-  /// Append a string to another
-  pub Concatenate { a: OrcString, b: OrcString }
-  => Ok(Literal::Str((a.get_string() + b.as_str()).into()).into())
-}
+define_fn! {
+  pub Len = |x| Ok(Literal::Uint(
+    (*x.downcast::<OrcString>()?)
+      .graphemes(true)
+      .count() as u64
+  ).into());
+
+  pub Size = |x| Ok(Literal::Uint(
+    (*x.downcast::<OrcString>()?)
+      .as_bytes()
+      .len() as u64
+  ).into());
+
+expr=x in
+  /// Append a string to another
+  pub Concatenate { a: OrcString, b: OrcString } => Ok(
+    Literal::Str((a.get_string() + b.as_str()).into()).into()
+  );
 
-define_fn! {expr=x in
   pub Slice { s: OrcString, i: u64, len: u64 } => {
     let graphs = s.as_str().graphemes(true);
-    if *i == 0 {
-      let orc_str = graphs.take(*len as usize).collect::<String>().into();
+    if i == 0 {
+      let orc_str = graphs.take(len as usize).collect::<String>().into();
       Ok(Literal::Str(orc_str).into())
     } else {
-      let mut prefix = graphs.skip(*i as usize - 1);
+      let mut prefix = graphs.skip(i as usize - 1);
       if prefix.next().is_none() {
         RuntimeError::fail(
           "Character index out of bounds".to_string(),
@@ -29,10 +40,10 @@ define_fn! {expr=x in
         )
       } else {
         let mut count = 0;
-        let ret = (prefix.take(*len as usize))
+        let ret = (prefix.take(len as usize))
             .map(|x| { count+=1; x })
             .collect::<String>().into();
-        if count == *len {
+        if count == len {
           Ok(Literal::Str(ret).into())
         } else {
           RuntimeError::fail(
@@ -42,38 +53,22 @@ define_fn! {expr=x in
         }
       }
     }
-  }
-}
+  };
 
-define_fn! {expr=x in
   pub Find { haystack: OrcString, needle: OrcString } => {
     let haystack_graphs = haystack.as_str().graphemes(true);
     let found = iter_find(haystack_graphs, needle.as_str().graphemes(true));
     Ok(orchid_opt(found.map(|x| Literal::Uint(x as u64).into())))
-  }
-}
+  };
 
-define_fn! {expr=x in
   pub Split { s: OrcString, i: u64 } => {
     let mut graphs = s.as_str().graphemes(true);
-    let a = graphs.by_ref().take(*i as usize).collect::<String>();
+    let a = graphs.by_ref().take(i as usize).collect::<String>();
     let b = graphs.collect::<String>();
     Ok(tuple(vec![a.into(), b.into()]))
   }
 }
 
-define_fn! {
-  pub Len = |x| with_str(x, |s| {
-    Ok(Literal::Uint(s.graphemes(true).count() as u64).into())
-  })
-}
-
-define_fn! {
-  pub Size = |x| with_str(x, |s| {
-    Ok(Literal::Uint(s.as_bytes().len() as u64).into())
-  })
-}
-
 pub fn str(i: &Interner) -> ConstTree {
   ConstTree::tree([(
     i.i("str"),