add &tuple:params

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "calcit"
-version = "0.7.7"
+version = "0.7.12"
 authors = ["jiyinyiyong <[email protected]>"]
 edition = "2021"
 license = "MIT"
@@ -22,7 +22,7 @@ exclude = [
 [dependencies]
 cirru_edn = "0.4.0"
 # cirru_edn = { path = "/Users/chenyong/repo/cirru/edn.rs" }
-cirru_parser = "0.1.24"
+cirru_parser = "0.1.25"
 clap = "3.2.25"
 dirs = "5.0.1"
 lazy_static = "1.4.0"

calcit/test-cond.cirru

@@ -120,7 +120,7 @@
                 match-ab (:: :a 1)
                 [] "|pattern a:" 1
               assert=
-                match-ab ([] :b 1 2)
+                match-ab (:: :b 1 2)
                 [] "|pattern b:" 1 2
               assert=
                 match-ab (:: :c 1 2)

calcit/test-list.cirru

@@ -360,6 +360,35 @@
                 fn (k n)
                   > n 10
 
+        |test-match $ quote
+          fn ()
+            log-title "|Testing list match"
+            assert= :empty
+              list-match ([])
+                () :empty
+                (a b) :something
+            assert= :something
+              list-match ([] 1)
+                () :empty
+                (a b) :something
+
+            assert= :something0
+              list-match ([] 1)
+                (a b) :something0
+                () :empty
+
+            assert=
+              [] 1 $ [] 2 3
+              list-match ([] 1 2 3)
+                () nil
+                (l0 ls) ([] l0 ls)
+
+            assert=
+              [] 1 $ [] 2 3
+              list-match ([] 1 2 3)
+                () nil
+                (l0 ls) (println "|...effect in match") ([] l0 ls)
+
         |test-methods $ quote
           fn ()
             log-title "|Testing list methods"
@@ -628,6 +657,8 @@
 
             test-pair
 
+            test-match
+
             do true
 
       :proc $ quote ()

calcit/test-map.cirru

@@ -207,9 +207,9 @@
 
             &let
               m $ &{} :a 1 :b 2 :c 3 :d 4
-              assert= (first m) (first m)
-              assert= (rest m) (rest m)
-              assert= 3 (count $ rest m)
+              assert= (first $ &map:destruct m) (first $ &map:destruct m)
+              assert= (last $ &map:destruct m) (last $ &map:destruct m)
+              assert= 3 (count $ last $ &map:destruct m)
 
               assert= 10
                 foldl m 0 $ fn (acc pair)
@@ -365,13 +365,18 @@
               #{} 1 2 3
               .values $ &{} :a 1 :b 2 :c 3
 
+            println $ .destruct $ &{} :a 1 :b 2 :c 3
             assert= true
-              list? $ .first $ &{} :a 1 :b 2 :c 3
-            assert= 2
-              count $ .first $ &{} :a 1 :b 2 :c 3
+              tag? $ nth (.destruct $ &{} :a 1 :b 2 :c 3) 0
+            assert= true
+              number? $ nth (.destruct $ &{} :a 1 :b 2 :c 3) 1
+            assert= true
+              map? $ nth (.destruct $ &{} :a 1 :b 2 :c 3) 2
+            assert= 3
+              count (.destruct $ &{} :a 1 :b 2 :c 3)
 
             assert= 2
-              .count $ .rest $ &{} :a 1 :b 2 :c 3
+              .count $ last $ .destruct $ &{} :a 1 :b 2 :c 3
 
             assert=
               &{} :c 3

calcit/test-set.cirru

@@ -112,11 +112,13 @@
             assert=
               #{} 1 2 3
               .union (#{} 1 2) (#{} 2 3)
-
-            assert= true
-              some? $ .first $ #{} 1 2 3
-            assert= 2
-              count $ .rest $ #{} 1 2 3
+
+            &let
+              pair $ &set:destruct $ #{} 1 2 3
+              assert= true
+                some? $ nth pair 0
+              assert= 2
+                count $ nth pair 1
 
             assert=
               #{} 1 3 5

calcit/test-tuple.cirru

@@ -0,0 +1,62 @@
+
+{} (:package |test-tuple)
+  :configs $ {} (:init-fn |test-tuple.main/main!) (:reload-fn |test-tuple.main/reload!)
+  :files $ {}
+    |test-tuple.main $ {}
+      :ns $ quote
+        ns test-tuple.main $ :require
+          util.core :refer $ log-title
+      :defs $ {}
+
+        |main! $ quote
+          defn main! ()
+            log-title "|Testing tuple"
+
+            assert=
+              :: :parts |1 |23
+              tag-match (destruct-str "|123")
+                (:none) (:: :empty)
+                (:some s0 ss) (:: :parts s0 ss)
+
+            assert=
+              :: :empty
+              tag-match (destruct-str "|")
+                (:none) (:: :empty)
+                (:some s0 ss) (:: :parts s0 ss)
+
+            assert=
+              :: :parts 1 $ [] 2 3
+              tag-match (destruct-list $ [] 1 2 3)
+                (:none) (:: :empty)
+                (:some l0 ls) (:: :parts l0 ls)
+
+            assert=
+              :: :empty
+              tag-match (destruct-list $ [])
+                (:none) (:: :empty)
+                (:some l0 ls) (:: :parts l0 ls)
+
+            assert=
+              :: :parts true 2
+              tag-match (destruct-set $ #{} 1 2 3)
+                (:none) (:: :empty)
+                (:some l0 ls) (:: :parts (number? l0) (count ls))
+
+            assert=
+              :: :empty
+              tag-match (destruct-set $ #{})
+                (:none) (:: :empty)
+                (:some l0 ls) (:: :parts (number? l0) (count ls))
+
+            assert=
+              :: :parts true true 1
+              tag-match (destruct-map $ &{} :a 1 :b 2)
+                (:none) (:: :empty)
+                (:some k0 v0 ms) (:: :parts (tag? k0) (number? v0) (count ms))
+
+            assert=
+              :: :empty
+              tag-match (destruct-map $ &{})
+                (:none) (:: :empty)
+                (:some k0 v0 ms) (:: :parts (count ms))
+

calcit/test.cirru

@@ -5,7 +5,7 @@
       , |./test-lens.cirru |./test-list.cirru |./test-macro.cirru |./test-map.cirru
       , |./test-math.cirru |./test-recursion.cirru |./test-set.cirru
       , |./test-string.cirru |./test-js.cirru |./test-record.cirru
-      , |./test-nil.cirru |./test-fn.cirru |./test-algebra.cirru
+      , |./test-nil.cirru |./test-fn.cirru |./test-tuple.cirru |./test-algebra.cirru
       , |./util.cirru
   :files $ {}
     |app.main $ {}
@@ -25,6 +25,7 @@
           test-record.main :as test-record
           test-nil.main :as test-nil
           test-fn.main :as test-fn
+          test-tuple.main :as test-tuple
           test-algebra.main :as test-algebra
           util.core :refer $ log-title inside-eval: inside-js:
       :defs $ {}
@@ -302,7 +303,11 @@
                   :get $ fn (self) 1
                 b $ &tuple:with-class a %r
               assert= %r $ &tuple:class b
-
+
+              assert=
+                &tuple:params (:: :a 1 2 3)
+                [] 1 2 3
+
             assert= "|(:: :a :b :c)"
               str $ :: :a :b :c
 
@@ -376,6 +381,7 @@
             test-record/main!
             test-nil/main!
             test-fn/main!
+            test-tuple/main!
             test-algebra/main!
 
             test-buffer

package.json

@@ -1,9 +1,9 @@
 {
   "name": "@calcit/procs",
-  "version": "0.7.7",
+  "version": "0.7.12",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
-    "@types/node": "^20.4.4",
+    "@types/node": "^20.4.6",
     "typescript": "^5.1.6"
   },
   "scripts": {
@@ -20,6 +20,6 @@
   "dependencies": {
     "@calcit/ternary-tree": "0.0.22",
     "@cirru/parser.ts": "^0.0.6",
-    "@cirru/writer.ts": "^0.1.3"
+    "@cirru/writer.ts": "^0.1.4"
   }
 }

src/builtins.rs

@@ -78,6 +78,7 @@ fn handle_proc_internal(name: CalcitProc, args: &CalcitItems, call_stack: &CallS
     CalcitProc::NativeTupleAssoc => meta::assoc(args),
     CalcitProc::NativeTupleCount => meta::tuple_count(args),
     CalcitProc::NativeTupleClass => meta::tuple_class(args),
+    CalcitProc::NativeTupleParams => meta::tuple_params(args),
     CalcitProc::NativeTupleWithClass => meta::tuple_with_class(args),
     // effects
     CalcitProc::NativeDisplayStack => meta::display_stack(args, call_stack),
@@ -190,8 +191,7 @@ fn handle_proc_internal(name: CalcitProc, args: &CalcitItems, call_stack: &CallS
     CalcitProc::NativeMapEmpty => maps::empty_ques(args),
     CalcitProc::NativeMapContains => maps::contains_ques(args),
     CalcitProc::NativeMapIncludes => maps::includes_ques(args),
-    CalcitProc::NativeMapFirst => maps::first(args),
-    CalcitProc::NativeMapRest => maps::rest(args),
+    CalcitProc::NativeMapDestruct => maps::destruct(args),
     CalcitProc::NativeMapGet => maps::get(args),
     CalcitProc::NativeMapAssoc => maps::assoc(args),
     CalcitProc::NativeMapDissoc => maps::dissoc(args),
@@ -209,8 +209,7 @@ fn handle_proc_internal(name: CalcitProc, args: &CalcitItems, call_stack: &CallS
     CalcitProc::NativeSetCount => sets::count(args),
     CalcitProc::NativeSetEmpty => sets::empty_ques(args),
     CalcitProc::NativeSetIncludes => sets::includes_ques(args),
-    CalcitProc::NativeSetFirst => sets::first(args),
-    CalcitProc::NativeSetRest => sets::rest(args),
+    CalcitProc::NativeSetDestruct => sets::destruct(args),
     // refs
     CalcitProc::Atom => refs::atom(args),
     CalcitProc::Deref => refs::deref(args),

src/builtins/maps.rs

@@ -195,31 +195,19 @@ pub fn includes_ques(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
   }
 }
 
-/// use builtin function since maps need to be handled specifically
-pub fn first(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
-  match xs.get(0) {
-    Some(Calcit::Map(ys)) => match ys.iter().next() {
-      // TODO order may not be stable enough
-      Some((k, v)) => Ok(Calcit::List(TernaryTreeList::from(&[k.to_owned(), v.to_owned()]))),
-      None => Ok(Calcit::Nil),
-    },
-    Some(a) => CalcitErr::err_str(format!("map:first expected a map, got: {a}")),
-    None => CalcitErr::err_str("map:first expected 1 argument"),
-  }
-}
-
-pub fn rest(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
+pub fn destruct(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
   match xs.get(0) {
     Some(Calcit::Map(ys)) => match ys.keys().next() {
+      // order not stable
       Some(k0) => {
         let mut zs = ys.to_owned();
         zs.remove_mut(k0);
-        Ok(Calcit::Map(zs))
+        Ok(Calcit::List(vec![k0.to_owned(), ys[k0].to_owned(), Calcit::Map(zs)].into()))
       }
       None => Ok(Calcit::Nil),
     },
-    Some(a) => CalcitErr::err_str(format!("map:rest expected a map, got: {a}")),
-    None => CalcitErr::err_str("map:rest expected 1 argument"),
+    Some(a) => CalcitErr::err_str(format!("&map:destruct expected a map, got: {a}")),
+    None => CalcitErr::err_str("&map:destruct expected 1 argument"),
   }
 }
 

src/builtins/meta.rs

@@ -466,6 +466,16 @@ pub fn tuple_class(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
   }
 }
 
+pub fn tuple_params(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
+  if xs.len() != 1 {
+    return CalcitErr::err_str(format!("tuple:params expected 1 argument, got: {xs:?}"));
+  }
+  match &xs[0] {
+    Calcit::Tuple(_tag, extra, _class) => Ok(Calcit::List(extra.into())),
+    x => CalcitErr::err_str(format!("&tuple:params expected a tuple, got: {x}")),
+  }
+}
+
 pub fn tuple_with_class(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
   if xs.len() != 2 {
     return CalcitErr::err_str(format!("tuple:with-class expected 2 arguments, got: {xs:?}"));

src/builtins/sets.rs

@@ -117,29 +117,18 @@ pub fn includes_ques(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
 }
 
 /// use builtin function since sets need to be handled specifically
-pub fn first(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
-  match xs.get(0) {
-    Some(Calcit::Set(ys)) => match ys.iter().next() {
-      // TODO first element of a set.. need to be more sure...
-      Some(v) => Ok(v.to_owned()),
-      None => Ok(Calcit::Nil),
-    },
-    Some(a) => CalcitErr::err_str(format!("set:first expected a set, got: {a}")),
-    None => CalcitErr::err_str("set:first expected 1 argument"),
-  }
-}
-
-pub fn rest(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
+pub fn destruct(xs: &CalcitItems) -> Result<Calcit, CalcitErr> {
   match xs.get(0) {
     Some(Calcit::Set(ys)) => match ys.iter().next() {
+      // first element of a set might be random
       Some(y0) => {
         let mut zs = ys.to_owned();
         zs.remove_mut(y0);
-        Ok(Calcit::Set(zs))
+        Ok(Calcit::List(vec![y0.to_owned(), Calcit::Set(zs)].into()))
       }
       None => Ok(Calcit::Nil),
     },
-    Some(a) => CalcitErr::err_str(format!("set:rest expected a set, got: {a}")),
-    None => CalcitErr::err_str("set:rest expected 1 argument"),
+    Some(a) => CalcitErr::err_str(format!("&set:destruct expected a set, got: {a}")),
+    None => CalcitErr::err_str("&set:destruct expected 1 argument"),
   }
 }