rename ** to ?filter (internally)

README.md

@@ -110,9 +110,9 @@ operators:
 ```
 We use `{}` in the examples but all `KV Selectors` have the same behaviour.
 
-### Filter Operator - `[]`/`**` TODO TODO TODO
+### Filter Operator - `[]`/`?filter` TODO TODO TODO
 Filter .......
-  - ` [s1 sel ..]` or `(** sel ..)`: from `vector` into new `vector` using
+  - ` [s1 sel ..]` or `(?filter sel ..)`: from `vector` into new `vector` using
     `EXPR Selectors`.
 
 `EXPR Selectors` serve a similar purpose as `KV Selectors`, but they are used

src/init.lisp

@@ -2,7 +2,7 @@
 
 (defvar *qmodes* '(:+ :? :- :%))
 (defvar *operators*
-  `(:?map :@ :|| ?rec :*$ :$$ :$* :** :?fld :?xpr :?txpr :?mxpr :?srch :?grp))
+  `(:?map :@ :|| ?rec :*$ :$$ :$* :?filter :?fld :?xpr :?txpr :?mxpr :?srch :?grp))
 (defvar *opt* '(optimize (speed 3) (safety 1)))
 (defvar *fxns* '(:err :wrn :nope :noop :lst :lit :qt :hld :ghv :pnum :inum :cnt :λ
                  :fmt :out :jsnstr

src/pre-qry.lisp

@@ -92,7 +92,7 @@
   (loop for q in (pre/scan-clauses qq '#:pipe) collect
     (if (dat? q) (kw q)
       (typecase q (cons q) (boolean q)
-                  (keyword `(** ,q)) (string `(** ,q))
+                  (keyword `(?filter ,q)) (string `(?filter ,q))
                   (symbol `(?map ,q)) (vector `(?map ,@(coerce q 'list)))
                   (otherwise q)))))
 

src/qry.lisp

@@ -134,16 +134,16 @@
                  (vex ,ires ($nil ,kvres)))
            finally (return ,ires))))
 
-(defun pre/** (q &optional (mm :?)) (unless q (warn "**: missing args."))
+(defun pre/?filter (q &optional (mm :?)) (unless q (warn "?filter: missing args."))
   (labels ((unpack- (o) (dsb (m sk) (unpack-mode o mm) `(,m ,(pre/xpr-sel sk :_)))))
-    (let* ((q* (remove-if #'dat? (pre/scan-clauses q '#:**)))
+    (let* ((q* (remove-if #'dat? (pre/scan-clauses q '#:?filter)))
            (res (mapcar #'unpack- q*)))
       (if (= (length q) (length q*)) res (cons :_ res)))))
 
 (defun xpr/get-modes (cd &rest mm)
   (loop for (m expr) in (strip-all cd) if (member m mm :test #'eq) collect expr))
 
-(defun compile/** (rec conf d) ; [...] ; sel ; filter object by these expressions
+(defun compile/?filter (rec conf d) ; [...] ; sel ; filter object by these expressions
   (awg (k i kres ires itr par)
   `(let ((,par ,(gk conf :dat)))
      (labels
@@ -165,7 +165,7 @@
        (typecase ,par
          (null nil) (hash-table (do-ht)) (list (do-vec))
          (vector (do-vec)) (simple-vector (do-vec))
-         (otherwise (error "RT: ** bad type. expected hash-table or vector:~%got: ~a." ,par)))))))
+         (otherwise (error "RT: ?filter bad type. expected hash-table or vector:~%got: ~a." ,par)))))))
 
 (defun compile/?xpr/bool (rec conf cd)
   (labels ((rec (expr) (funcall rec conf expr)))
@@ -180,10 +180,10 @@
     `(∈ (:par ,(gk conf :par t) :cnt ,(gk conf :cnt t)
          :itr ,(gk conf :itr t) :key ,(gk conf :key t))
        ,(case (length d) ((0 (error "xpr: missing args.")))
-          (1 (compile/?xpr/bool rec conf (pre/** d)))
-          (2 `(if ,(compile/?xpr/bool rec conf (pre/** (butlast d 1))) ,@(do-last d 1)))
+          (1 (compile/?xpr/bool rec conf (pre/?filter d)))
+          (2 `(if ,(compile/?xpr/bool rec conf (pre/?filter (butlast d 1))) ,@(do-last d 1)))
           (otherwise `(if ,(compile/?xpr/bool rec conf
-                             (pre/** (butlast d 2))) ,@(do-last d 2)))))))
+                             (pre/?filter (butlast d 2))) ,@(do-last d 2)))))))
 
 (defun compile/?txpr (rec conf d) (funcall rec conf `(?mxpr ,d)))
 (defun compile/?mxpr (rec conf d)
@@ -231,7 +231,7 @@
          ((vectorp d) (rec conf `(?map ,@(coerce d 'list))))
          ((atom d) d)
          ((qop? :||    d) (compile/||    #'rec conf (pre/|| (cdr d))))
-         ((qop? :**    d) (compile/**    #'rec conf (pre/** (cdr d))))
+         ((qop? :?filter    d) (compile/?filter    #'rec conf (pre/?filter (cdr d))))
          ((qop? :$*    d) (compile/$*    #'rec conf (pre/$$ (cdr d))))
          ((qop? :*$    d) (compile/*$    #'rec conf (pre/$$ (cdr d))))
          ((qop? :$$    d) (compile/$$    #'rec conf (pre/$$ (cdr d))))

src/reader-macros.lisp

@@ -40,7 +40,7 @@ next symb: ~a" char (peek-char t stream t nil t))))
   (let ((*readtable* (copy-readtable)))
     (loop for o = (read-next-object #\Space #\] stream)
           while o collect o into objects
-          finally (return `(** ,@objects)))))
+          finally (return `(?filter ,@objects)))))
 
 (set-dispatch-macro-character #\# #\{ ; #{} ; sel
   (lambda (stream subchar arg)

test/test-lqn.lisp

@@ -6,15 +6,15 @@
   (is (lqn::pre/$$ '(:ccc :ddd "IIUJ" "%@UU" :?@aa :?@bb ("cc" (progn _)) (:+ "ABC" (print _)) (:% "ABC" _) (:kkk "ABC" _)))
       '((:+ "ccc" :_) (:+ "ddd" :_) (:+ "IIUJ" :_) (:% "UU" :_) (:? "aa" :_) (:? "bb" :_)
         (:+ "cc" (PROGN _)) (:+ "ABC" (PRINT _)) (:% "ABC" :_) (:+ "kkk" "ABC")))
-  (is (lqn::pre/** '(ccc :ddd "IIUJ" "%@UU" ?@aa ?@bb ("cc" (progn _)) (% "ABC" (print _)) (:% "ABC")))
+  (is (lqn::pre/?filter '(ccc :ddd "IIUJ" "%@UU" ?@aa ?@bb ("cc" (progn _)) (% "ABC" (print _)) (:% "ABC")))
      '((:? (WHEN (CCC :_) :_)) (:? (AND (LQN:STR? :_) (LQN:ISUB? :_ "ddd"))) (:? (AND (LQN:STR? :_) (LQN:SUB? :_ "IIUJ")))
        (:% (AND (LQN:STR? :_) (LQN:SUB? :_ "UU"))) (:? (WHEN (AA :_) :_)) (:? (WHEN (BB :_) :_)) (:? ("cc" (PROGN _))) (:? (% "ABC" (PRINT _)))
        (:% (AND (LQN:STR? :_) (LQN:SUB? :_ "ABC"))))))
 
 (subtest "lqn qry identities"
   (is (lqn::jsnstr (lqn:jsnqryf *test-data-fn* _)) (lqn::jsnstr (lqn:jsnqryf *test-data-fn* ($* _))))
   (is (lqn::jsnstr (lqn:jsnqryf *test-data-fn* _)) (lqn::jsnstr (lqn:jsnqryf *test-data-fn* (*$ _))))
-  (is (lqn::jsnstr (lqn:jsnqryf *test-data-fn* _)) (lqn::jsnstr (lqn:jsnqryf *test-data-fn* (** _))))
+  (is (lqn::jsnstr (lqn:jsnqryf *test-data-fn* _)) (lqn::jsnstr (lqn:jsnqryf *test-data-fn* (?filter _))))
   (is (lqn::jsnstr (lqn:jsnqryf *test-data-fn* _)) (lqn::jsnstr (lqn:jsnqryf *test-data-fn* (?map _))))
   (is (lqn::jsnstr (lqn:jsnqryf *test-data-2-fn* _)) (lqn::jsnstr (lqn:jsnqryf *test-data-2-fn* ($$ _)))))