experimental shorthand of method calling; tag 0.9.15

Author: tiye

Cargo.lock

@@ -1,7 +1,7 @@
 
 [package]
 name = "calcit"
-version = "0.9.14"
+version = "0.9.15"
 authors = ["jiyinyiyong <jiyinyiyong@gmail.com>"]
 edition = "2024"
 license = "MIT"

Cargo.toml

@@ -189,6 +189,8 @@
                 js/console.log pattern
                 assert= true $ .!test pattern "|12"
                 assert= false $ .!test pattern "|xy"
+                assert= true $ pattern.!test |12
+                assert= false $ pattern.!test |xy
         |test-property $ %{} :CodeEntry (:doc "|try property ops")
           :code $ quote
             fn ()

calcit/test-js.cirru

@@ -9,7 +9,7 @@
           :code $ quote (defatom *counted 0)
         |main! $ %{} :CodeEntry (:doc |)
           :code $ quote
-            defn main! () (log-title "|Testing list") (test-list) (log-title "|Testing foldl") (test-foldl) (log-title "|Testing every/any") (test-every) (log-title "|Testing groups") (test-groups) (log-title "|Testing apply") (test-apply) (log-title "|Testing join") (test-join) (log-title "|Testing repeat") (test-repeat) (log-title "|Testing sort") (test-sort) (test-alias) (test-doseq) (test-let[]) (test-methods) (test-pair) (test-match) (do true)
+            defn main! () (log-title "|Testing list") (test-list) (log-title "|Testing foldl") (test-foldl) (log-title "|Testing every/any") (test-every) (log-title "|Testing groups") (test-groups) (log-title "|Testing apply") (test-apply) (log-title "|Testing join") (test-join) (log-title "|Testing repeat") (test-repeat) (log-title "|Testing sort") (test-sort) (test-alias) (test-doseq) (test-let[]) (test-methods) (test-methods-shorthand) (test-pair) (test-match) (do true)
         |test-alias $ %{} :CodeEntry (:doc |)
           :code $ quote
             fn () (log-title "|Testing alias")
@@ -427,6 +427,13 @@
                 .dissoc ([] :a :b :c) 2
               assert= ([] 1 2 3)
                 distinct $ [] 1 2 3 1 2
+        |test-methods-shorthand $ %{} :CodeEntry (:doc "|test shorthand")
+          :code $ quote
+            fn ()
+              &let
+                xs $ [] 1 2 3 4
+                assert= 1 $ xs.get 0
+                assert= true $ xs.any? $ fn (x) (&> x 3)
         |test-pair $ %{} :CodeEntry (:doc |)
           :code $ quote
             fn ()

calcit/test-list.cirru

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

package.json

@@ -104,8 +104,9 @@ pub fn code_to_calcit(xs: &Cirru, ns: &str, def: &str, coord: Vec<u8>) -> Result
     Cirru::List(ys) => {
       let mut zs: Vec<Calcit> = vec![];
       for (idx, y) in ys.iter().enumerate() {
-        let mut next_coord: Vec<u8> = (*coord).to_owned();
-        next_coord.push(idx as u8); // code not supposed to be fatter than 256 children
+        if idx > 255 {
+          return Err(format!("Cirru code too large, index: {idx}"));
+        }
 
         if let Cirru::List(ys) = y
           && ys.len() > 1
@@ -122,6 +123,24 @@ pub fn code_to_calcit(xs: &Cirru, ns: &str, def: &str, coord: Vec<u8>) -> Result
             return Err(format!("expected 1 argument, got: {ys:?}"));
           }
         }
+        let mut next_coord: Vec<u8> = (*coord).to_owned();
+        next_coord.push(idx as u8); // clamp to prevent overflow, code not supposed to be larger than 256 children
+
+        if idx == 0
+          && let Cirru::Leaf(s) = y
+        {
+          // dirty hack to support shorthand of method calling,
+          // this feature is EXPERIMENTAL and might change in future
+          if let Some((obj, method)) = split_leaf_to_method_call(s) {
+            zs.push(method);
+            zs.push(Calcit::Symbol {
+              sym: Arc::from(obj),
+              info: symbol_info.to_owned(),
+              location: Some(next_coord.into()),
+            });
+            continue;
+          }
+        }
 
         zs.push(code_to_calcit(y, ns, def, next_coord)?);
       }
@@ -130,6 +149,50 @@ pub fn code_to_calcit(xs: &Cirru, ns: &str, def: &str, coord: Vec<u8>) -> Result
   }
 }
 
+/// split `a.b` into `.b` and `a`, `a.-b` into `.-b` and `a`, `a.!b` into `.!b` and `a`, etc.
+/// some characters available for variables are okey here, for example `-`, `!`, `?`, `*``, etc.
+fn split_leaf_to_method_call(s: &str) -> Option<(String, Calcit)> {
+  if let Some((obj, method)) = s.split_once(".-") {
+    if is_valid_symbol(obj) && is_valid_symbol(method) {
+      return Some((obj.to_owned(), Calcit::Method(method.into(), MethodKind::Access)));
+    }
+  }
+  if let Some((obj, method)) = s.split_once(".!") {
+    if is_valid_symbol(obj) && is_valid_symbol(method) {
+      return Some((obj.to_owned(), Calcit::Method(method.into(), MethodKind::InvokeNative)));
+    }
+  }
+  if let Some((obj, method)) = s.split_once(".") {
+    if is_valid_symbol(obj) && is_valid_symbol(method) {
+      return Some((obj.to_owned(), Calcit::Method(method.into(), MethodKind::Invoke)));
+    }
+  }
+
+  None
+}
+
+fn is_valid_symbol(s: &str) -> bool {
+  // empty space is not valid symbol
+  if s.is_empty() {
+    return false;
+  }
+  // symbol should not start with a digit
+  if s.chars().next().unwrap().is_ascii_digit() {
+    return false;
+  }
+  // every character should be valid, a-z, A-Z, 0-9, -, _, ?, !, *, etc.
+  for c in s.chars() {
+    if c.is_alphabetic() {
+      continue;
+    }
+    if c.is_ascii_digit() || c == '-' || c == '_' || c == '?' || c == '!' || c == '*' {
+      continue;
+    }
+    return false;
+  }
+  true
+}
+
 /// transform Cirru to Calcit data directly
 pub fn cirru_to_calcit(xs: &Cirru) -> Calcit {
   match xs {