From 87875b000b0c720f163a4eb0ada30549078d5362 Mon Sep 17 00:00:00 2001 From: okamsn Date: Sun, 27 Aug 2023 15:20:45 -0400 Subject: [PATCH] Remove some deprecated features. - Remove flag `split`. See PRs #165, #131. See issue #124. - Remove flag `lax-naming`. See PRs #165, #119. - Remove command `sub-loop`. See PRs #165, #130. See issue #127. --- CHANGELOG.md | 13 +++++- Makefile | 9 ++++ README.org | 2 + doc/loopy-doc.org | 2 +- loopy-commands.el | 23 +--------- loopy-iter.el | 100 +------------------------------------------- loopy-vars.el | 12 +----- loopy.el | 48 +-------------------- tests/iter-tests.el | 35 ++-------------- tests/misc-tests.el | 81 ----------------------------------- tests/tests.el | 89 ++------------------------------------- 11 files changed, 38 insertions(+), 376 deletions(-) create mode 100644 Makefile diff --git a/CHANGELOG.md b/CHANGELOG.md index c447b5f7..f6a30991 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -65,6 +65,17 @@ This document describes the user-facing changes to Loopy. - Relatedly, remove documentation that said `adjoin` supported `:init`. It does not. +- The deprecated flag `split` was removed ([#165], [#131], [#124]). Instead, + use named accumulation variables with the special macro argument `accum-opt` + as appropriate. + +- The deprecated flag `lax-naming` was removed ([#165], [#119]). Instead, see + `loopy-iter-bare-commands` and `loopy-iter-bare-special-macro-arguments`. + +- The deprecated command `sub-loop` was removed ([#165], [#130], [#127]). Use + the commands/macros `loopy` and `loopy-iter` instead. In `loopy`, `sub-loop` + acted like `loopy`. In `loopy-iter`, `sub-loop` acted like `loopy-iter`. + ### Command Improvements - To produce faster code, some commands now avoid creating an intermediate @@ -106,7 +117,7 @@ This document describes the user-facing changes to Loopy. `set` command, which are allowed to occur in more than one command. [#164]: https://github.com/okamsn/loopy/pull/164 - +[#165]: https://github.com/okamsn/loopy/pull/165 ## 0.11.2 diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..ce5a54bb --- /dev/null +++ b/Makefile @@ -0,0 +1,9 @@ +.PHONY: tests + +tests: + emacs -Q -batch -l ert -l tests/load-path.el -l tests/tests.el -f ert-run-tests-batch-and-exit + +.PHONY: iter-tests + +iter-tests: + emacs -Q -batch -l ert -l tests/load-path.el -l tests/iter-tests.el -f ert-run-tests-batch-and-exit diff --git a/README.org b/README.org index 6c1e31d5..af4d4db2 100644 --- a/README.org +++ b/README.org @@ -51,6 +51,8 @@ please let me know. - =reduce= has been fixed. It now works like ~cl-reduce~ when the variable starting value isn't explicitly given, storing the first value instead of storing the result of passing the first value and ~nil~ to the function. + - The deprecated flags =lax-naming= and =split= were removed. + - The deprecated command =sub-loop= was removed. - Versions 0.11.1 and 0.11.2: None. Bug fixes. - Version 0.11.0: - More incorrect destructured bindings now correctly signal an error. diff --git a/doc/loopy-doc.org b/doc/loopy-doc.org index 40144c1a..6d57054c 100644 --- a/doc/loopy-doc.org +++ b/doc/loopy-doc.org @@ -4335,7 +4335,7 @@ accumulation itself must still occur within the loop =inner=. ;; => (1 2 3 4) (loopy (named outer) (array i [(1 2) (3 4)]) - (sub-loop inner + (loopy inner (list j i) (at outer (collect coll j))) (finally-return coll)) diff --git a/loopy-commands.el b/loopy-commands.el index 06a07b06..6b87c1ab 100644 --- a/loopy-commands.el +++ b/loopy-commands.el @@ -181,24 +181,6 @@ These commands affect other loops higher up in the call list." (,target-loop ,@(loopy--parse-loop-commands commands)))))) -;;;;;; Sub-Loop -(make-obsolete 'loopy--parse-sub-loop-command - (concat "use the `loopy' or `loopy-iter' commands instead." - " See the manual and change log.") - "2022-08") -(cl-defun loopy--parse-sub-loop-command ((_ &rest body)) - "Parse the `sub-loop' command as (sub-loop BODY). - -The sub-loop is a full call to the `loopy' macro, supporting -special macro arguments. In `loopy-iter', it is specially -handled to use `loopy-iter' instead. - -The sub-loop is specially handled." - (warn (concat "The command `sub-loop' is deprecated." - " Use the commands `loopy' or `loopy-iter' instead." - " See the Info documentation and change log.")) - `((loopy--main-body ,(macroexpand `(loopy ,@body))))) - ;;;;;; Loopy (cl-defun loopy--parse-loopy-command ((_ &rest body)) "Parse the `loopy' command as (loopy BODY). @@ -1767,10 +1749,7 @@ accumulation variable. The default accumulation variable is (signal 'loopy-wrong-number-of-command-arguments-or-bad-keywords (list cmd))) (let* ((into-var (plist-get opts :into)) - (var (or into-var - (and loopy--split-implied-accumulation-results - (gensym (symbol-name name))) - 'loopy-result)) + (var (or into-var 'loopy-result)) (val (cl-first args))) (ignore var val) diff --git a/loopy-iter.el b/loopy-iter.el index e8abd6f7..a709de92 100644 --- a/loopy-iter.el +++ b/loopy-iter.el @@ -48,68 +48,12 @@ ;; Iterate, but now it just defers to what Emacs already does when expanding ;; macros, such as in `macroexpand-all'. -;;;; Flags (obsolete) -(make-obsolete-variable - 'loopy-iter--lax-naming - "Use `loopy-iter-bare-special-macro-arguments' or -`loopy-iter-bare-commands' instead. See the manual." - "2022-07") -(defvar loopy-iter--lax-naming nil - "Whether loop commands must be preceded by keywords to be recognized. - -By default, `loopy-iter' requires loop commands to be preceded by -the keywords `for', `accum', or `exit', in order to distinguish -loop commands from other Emacs features. - -The flag `lax-naming' disables this requirement, at the cost of -name collisions becoming more likely.") - -(make-obsolete 'loopy-iter--enable-flag-lax-naming nil "2022-07") -(defun loopy-iter--enable-flag-lax-naming () - "Set `loopy-iter--lax-naming' to t inside the loop." - (setq loopy-iter--lax-naming t)) - -(make-obsolete 'loopy-iter--disable-flag-lax-naming nil "2022-07") -(defun loopy-iter--disable-flag-lax-naming () - "Set `loopy-iter--lax-naming' to nil inside the loop if active." - ;; Currently redundant, but leaves room for possibilities. - (if loopy-iter--lax-naming - (setq loopy-iter--lax-naming nil))) - -(let ((f #'(lambda () - (warn (concat "loopy-iter: Flag `lax-naming' is now obsolete. " - "See manual or changelog."))))) - - (dolist (flag '(lax-naming +lax-naming lax-names +lax-names)) - (setf loopy--flag-settings - (map-insert loopy--flag-settings flag f))) - - (dolist (flag '(-lax-naming -lax-names)) - (setf loopy--flag-settings - (map-insert loopy--flag-settings flag f)))) - ;;;; Custom User Options (defgroup loopy-iter nil "Options specifically for the `loopy-iter' macro." :group 'loopy :prefix "loopy-iter-") -(make-obsolete-variable - 'loopy-iter-ignored-names - "Use `loopy-iter-bare-special-macro-arguments' or -`loopy-iter-bare-commands' instead. See the manual." - "2022-07") -(defcustom loopy-iter-ignored-names '(let*) - "Names of commands, special macro arguments, and their aliases to be ignored. - -Some aliases and command names can cause conflicts, such as `let*' as -an alias of the special macro argument `with'. - -This option always applies to special macro arguments. This -option is used with commands when the `lax-naming' flag is -enabled." - :type '(repeat symbol)) - (define-obsolete-variable-alias 'loopy-iter-command-keywords 'loopy-iter-keywords "2022-07") (defcustom loopy-iter-keywords '(accum for exit arg) @@ -129,33 +73,6 @@ Without these keywords, one must use one of the names given in `loopy-iter-bare-special-macro-arguments'." :type '(repeat symbol)) - - -;;;; Miscellaneous Helper Functions -;; (defun loopy-iter--valid-loop-command (name) -;; "Check if NAME is a known command. -;; -;; This checks for NAME as a key in `loopy-aliases' -;; and `loopy-command-parsers', in that order." -;; (if (and loopy-iter--lax-naming -;; (memq name loopy-iter-ignored-names)) -;; nil -;; (map-elt loopy-command-parsers (loopy--get-true-name name)))) -;; -;; (defun loopy-iter--literal-form-p (form) -;; "Whether FORM is a literal form that should not be interpreted." -;; (or (and (consp form) -;; (memq (cl-first form) loopy-iter--literal-forms)) -;; (arrayp form))) -;; -;; (defun loopy-iter--sub-loop-command-p (name) -;; "Whether command named NAME is a sub-loop." -;; (memq name (loopy--get-all-names 'sub-loop -;; :from-true t -;; :ignored loopy-iter-ignored-names))) - - - (def-edebug-spec loopy-iter--special-macro-arg-edebug-spec ;; This is the same as for `loopy', but without `let*'. [&or ([&or "with" "init"] &rest (symbolp &optional form)) @@ -201,9 +118,6 @@ Without these keywords, one must use one of the names given in listing listing-index listing-ref - ;; TODO: Remove once we move to a new version number. - ;; The `sub-loop' command has been deprecated. - looping mapping mapping-pairs mapping-ref @@ -239,18 +153,13 @@ Without these keywords, one must use one of the names given in stringing stringing-index stringing-ref - ;; TODO: Remove once we move to a new version number. - ;; The `sub-loop' command has been deprecated. - sub-looping thereis summing unioning vconcating) "Commands recognized in `loopy-iter' without a preceding keyword. -For special marco arguments, see `loopy-iter-bare-special-macro-arguments'. - -This option replaces the flag `lax-naming', and is always in effect." +For special marco arguments, see `loopy-iter-bare-special-macro-arguments'." :type '(repeat symbol) :group 'loopy-iter) @@ -332,8 +241,7 @@ in the expression with `loopy--optimized-accum-2'." ;;;;; Overwritten definitions (defcustom loopy-iter-overwritten-command-parsers - '((at . loopy-iter--parse-at-command) - (sub-loop . loopy-iter--parse-sub-loop-command)) + '((at . loopy-iter--parse-at-command)) "Overwritten command parsers. This is an alist of dotted pairs of base names and parsers, as in @@ -371,10 +279,6 @@ These commands affect other loops higher up in the call list." nreverse (apply #'append)))))))) -(cl-defun loopy-iter--parse-sub-loop-command ((_ &rest body)) - "Parse the `sub-loop' command in `loopy-iter'." - `((loopy--main-body ,(macroexpand `(loopy-iter ,@body))))) - ;;;; For parsing special macro arguments (defcustom loopy-iter-bare-special-macro-arguments diff --git a/loopy-vars.el b/loopy-vars.el index 3be06786..ad576394 100644 --- a/loopy-vars.el +++ b/loopy-vars.el @@ -140,7 +140,6 @@ Definition must exist. Neither argument need be quoted." elements-ref)) (skip . (skipping continue continuing)) (skip-from . (skipping-from continue-from continuing-from)) - (sub-loop . (sub-looping subloop sublooping loop looping)) (sum . (summing)) (union . (unioning)) (vconcat . (vconcating)) @@ -209,7 +208,6 @@ true names and lists of aliases. (set-prev . loopy--parse-set-prev-command) (skip . loopy--parse-skip-command) (skip-from . loopy--parse-skip-from-command) - (sub-loop . loopy--parse-sub-loop-command) (sum . loopy--parse-sum-command) (thereis . loopy--parse-thereis-command) (union . loopy--parse-union-command) @@ -246,13 +244,6 @@ exist), one could do ;;;; Flags ;;;;; Variables that can be set by flags -(defvar loopy--split-implied-accumulation-results nil - "Whether implicit accumulation commands should use separate variables. - -Nil means that each accumulation command without a named -accumulation variable should accumulate into the same variable, -by default named `loopy-result'.") - (defvar loopy--destructuring-for-with-vars-function nil "The function used for destructuring `with' variables. @@ -675,8 +666,7 @@ known to fall into the first group.") ;; -- Flag Variables -- loopy--destructuring-for-with-vars-function loopy--destructuring-for-iteration-function - loopy--destructuring-accumulation-parser - loopy--split-implied-accumulation-results) + loopy--destructuring-accumulation-parser) "These variables must be `let'-bound around the loop. This list is mainly fed to the macro `loopy--wrap-variables-around-body'.")) diff --git a/loopy.el b/loopy.el index c63d0c9b..09d7a06e 100644 --- a/loopy.el +++ b/loopy.el @@ -130,40 +130,12 @@ (require 'loopy-vars) ;;;; Built-in flags -;;;;; Split -(make-obsolete 'loopy--enable-flag-split - (concat "use the `accum-opt' special macro argument." - " See the Info documentation.") - "2022-08") -(defun loopy--enable-flag-split () - "Set `loopy-split-implied-accumulation-results' to t inside the loop." - (warn "The flag `split' is deprecated. Use `accum-opt' instead.") - (setq loopy--split-implied-accumulation-results t)) - -(make-obsolete 'loopy--disable-flag-split - (concat "use the `accum-opt' special macro argument." - " See the Info documentation.") - "2022-08") -(defun loopy--disable-flag-split () - "Set `loopy-split-implied-accumulation-results' to t inside the loop." - (warn "The flag `split' is deprecated. Use `accum-opt' instead.") - ;; Currently redundant, but leaves room for possibilities. - (if loopy--split-implied-accumulation-results - (setq loopy--split-implied-accumulation-results nil))) - -(with-suppressed-warnings ((obsolete loopy--enable-flag-split - loopy--disable-flag-split)) - (dolist (flag '(split +split)) - (cl-callf map-insert loopy--flag-settings flag #'loopy--enable-flag-split)) - - (cl-callf map-insert loopy--flag-settings '-split #'loopy--disable-flag-split)) ;;;;;; Default ;; It doesn't make sense to allow the disabling of this one. (defun loopy--enable-flag-default () "Set `loopy' behavior back to its default state for the loop." - (setq loopy--split-implied-accumulation-results nil - loopy--destructuring-for-with-vars-function + (setq loopy--destructuring-for-with-vars-function #'loopy--destructure-for-with-vars-default loopy--destructuring-accumulation-parser #'loopy--parse-destructuring-accumulation-command)) @@ -459,13 +431,7 @@ The function creates quoted code that should be used by a macro." ;; Be sure that the `cl-block' defaults to returning the ;; implicit return, which can be nil. This can be ;; overridden by any call to `cl-return-from'. - ,(if (and loopy--split-implied-accumulation-results - loopy--implicit-return - (or loopy--after-do - loopy--final-do - loopy--final-return)) - `(setq loopy-result ,loopy--implicit-return) - loopy--implicit-return)) + ,loopy--implicit-return) ;; Will always be a single expression after wrapping with ;; `cl-block'. result-is-one-expression t) @@ -511,16 +477,6 @@ The function creates quoted code that should be used by a macro." (setq result `(let* ,loopy--accumulation-vars ,@(get-result)) result-is-one-expression t)) - ;; Bind `loopy-result' if using split accumulation variables. - ;; In such case, no command requests this, so we do it here. - (when (and loopy--split-implied-accumulation-results - loopy--implicit-return - (or loopy--after-do - loopy--final-do - loopy--final-return)) - (setq result `(let ((loopy-result nil)) ,@(get-result)) - result-is-one-expression t)) - ;; Declare the With variables. (when loopy--with-vars (setq result `(,@(loopy--destructure-for-with-vars loopy--with-vars) diff --git a/tests/iter-tests.el b/tests/iter-tests.el index 28cf367f..5f0cd2d1 100644 --- a/tests/iter-tests.el +++ b/tests/iter-tests.el @@ -487,11 +487,6 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the j))) (accum collect a)))))))) -;;; lax naming -;; TODO: HERE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -;; (ert-deftest deprecate-flag-lax-naming () -;; (should-error )) - ;; Wrap in accum (ert-deftest wrap-expressions-in-loop-commands () (should @@ -639,26 +634,6 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the (summing important-val val))) (finally-return important-val))))))) - -(ert-deftest sub-loop () - (should (equal '(2 3 4 5 6) - (loopy-iter outer - (for list i '(1 2 3 4 5)) - (for loop - (for repeat 1) - (for set j (1+ i)) - (for at outer - (accum collect j)))))) - - (should (equal '(2 3 4 5 6) - (loopy-iter (named outer) - (listing i '(1 2 3 4 5)) - (looping - (repeating 1) - (setting j (1+ i)) - (at outer - (collecting j))))))) - (ert-deftest loopy-iter-sub-loop () (should (equal '(2 3 4 5 6) (loopy-iter (named outer) @@ -738,9 +713,9 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the (loopy-iter outer (for repeat 2) - (for loop inner1 + (for loopy-iter inner1 (for list j '(3 4)) - (for loop + (for loopy-iter (for list k '(5 6 7)) (if (= k 6) ;; Return from inner1 so never reach 4. @@ -767,7 +742,7 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the (let ((test-eshell-visual-subcommands)) (loopy-iter (for list (cmd &rest subcmds) '(("git" "log" "diff" "show"))) - (for loop + (for loopy-iter (for list subcmd subcmds) (push subcmd (alist-get cmd test-eshell-visual-subcommands nil nil #'equal)))) @@ -799,7 +774,7 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the (eval (quote (loopy-iter my-loop (for array i [(1 2) (3 4)]) (accum collect i :at start) - (for loop inner + (for loopy-iter inner (for list j i) (for at my-loop (accum collect j :at @@ -837,7 +812,6 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the (loopy--accumulation-variable-info)) (macroexpand '(loopy-iter main - (flag lax-naming) (with (a 1) (b 2) (c 3)) (while clause) (loopy-let* ((key (pop clause)) @@ -862,7 +836,6 @@ E.g., \"(let ((for list)) ...)\" should not try to operate on the (loopy--accumulation-variable-info)) (macroexpand '(loopy-iter main - (flag lax-naming) (with (a 1) (b 2) (c 3)) (while clause) (loopy-let* ((key (pop clause)) diff --git a/tests/misc-tests.el b/tests/misc-tests.el index 10447e54..6710e095 100644 --- a/tests/misc-tests.el +++ b/tests/misc-tests.el @@ -605,88 +605,7 @@ INPUT is the destructuring usage. OUTPUT-PATTERN is what to match." cat (cl-map 'vector #'1+ cat))) arr)))) -;;;;; Split flag -(ert-deftest split-flag () - (should (equal '((1 3) (2)) - (eval (quote (loopy (flag split) - (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i)))))))) -(ert-deftest split-flag-default () - (should (equal '((1 3) (2)) - (let ((loopy-default-flags '(split))) - (eval (quote (loopy (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i))))))))) - -(ert-deftest split-flag-default-disable () - (should (equal '(1 2 3) - (let ((loopy-default-flags '(split))) - (eval (quote (loopy (flag -split) - (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i))))))))) - -(ert-deftest split-flag-enable-disable () - (should (equal '(1 2 3) - (eval (quote (loopy (flag +split -split) - (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i)))))))) - -(ert-deftest loopy-result-with-split () - (should (equal '((2 4) 15) - (eval (quote (loopy (flag split) - (nums i 1 5) - (when (cl-evenp i) - (collect i)) - (sum i) - (finally-return loopy-result)))))) - - (should (equal '(1 2 3 4 5) - (eval (quote (loopy (flag split) - (nums i 1 5) - (collect i) - (finally-return loopy-result))))))) - -(ert-deftest loopy-result-with-split-with-leave () - (should (equal '((2 4 6) 21) - (eval (quote (loopy (flag split) - (nums i 1 10) - (when (cl-evenp i) - (collect i :at end)) - (when (> i 6) - (leave)) - (sum i) - (finally-return loopy-result))))))) - ;;;;; Default flag -(ert-deftest default-flag-disable-split () - (should (equal '(1 2 3) - (let ((loopy-default-flags '(split))) - (eval (quote (loopy (flag default) - (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i)))))))) - (should (equal '(1 2 3) - (eval (quote (loopy (flags split default) - (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i)))))))) - -(ert-deftest default-flag-then-split () - (should (equal '((1 3) (2)) - (eval (quote (loopy (flags default split) - (list i '(1 2 3)) - (if (cl-oddp i) - (collect i) - (collect i)))))))) (ert-deftest accumulation-recursive-destructuring () (should (and diff --git a/tests/tests.el b/tests/tests.el index a747ef0e..ec3a2db6 100644 --- a/tests/tests.el +++ b/tests/tests.el @@ -561,88 +561,7 @@ SYMS-STR are the string names of symbols from `loopy-iter-bare-commands'." ;;; Loop Commands ;;;; Sub-loop Commands -;;;;; At and sub-loop -;; NOTE: `sub-loop' is deprecated. -(ert-deftest sub-loop-implicit-accum-in-loop () - (should (equal '((1 . 4) (1 . 5) (2 . 4) (2 . 5)) - (lq outer - (list i '(1 2)) - (loop (list j '(4 5)) - (at outer (collect (cons i j))))))) - - (should (equal "14152425" - (lq (named outer) - (list i '("1" "2")) - (loop (list j '("4" "5")) - (at outer (concat (concat i j))))))) - - (should (equal '(0 (1 . 4) (1 . 5) (2 . 4) (2 . 5)) - (lq outer - (list i '(1 2)) - (loop (list j '(4 5)) - (at outer (collect (cons i j)))) - (finally-return (cons 0 loopy-result)))))) - -(ert-deftest sub-loop-explicit-accum-in-loop () - (should (equal '(0 (1 . 4) (1 . 5) (2 . 4) (2 . 5)) - (lq outer - (list i '(1 2)) - (loop (list j '(4 5)) - (at outer (collect my-coll (cons i j)))) - (finally-return (cons 0 my-coll))))) - - (should (equal "014152425" - (lq (named outer) - (list i '("1" "2")) - (loop (list j '("4" "5")) - (at outer (concat my-str (concat i j)))) - (finally-return (concat "0" my-str)))))) -;; -(ert-deftest sub-loop-leave-early () - "A `leave' in a sub-loop should not affect the outer loop." - (should (equal '(1 2 3) - (lq outer - (list i '(1 2 3)) - (loop (list j '(4 5 6)) - (leave) - (at outer (collect j))) - (collect i))))) - -(ert-deftest sub-loop-skip () - "A `skip' in a sub-loop should not affect the outer loop." - (should (equal '(5 7 1 5 7 2 5 7 3) - (lq outer - (list i '(1 2 3)) - (loop (list j '(4 5 6 7 8)) - (when (cl-evenp j) - (continue)) - (at outer (collect j))) - (collect i))))) - -(ert-deftest sub-loop-return-from-outer () - (should (= 3 (lq (named outer) - (list i '(1 2 3)) - (loop (list j '(4 5 6 3)) - (when (= j i) - (return-from outer j))))))) - -(ert-deftest sub-loop-named () - (should - (equal - '((3 5) (3 5)) - (lq outer - (repeat 2) - (loop inner1 - (list j '(3 4)) - (loop (list k '(5 6 7)) - (if (= k 6) - ;; Return from inner1 so never reach 4. - (return-from inner1) - (at outer (collect (list j k)))))))))) - ;;;;; loopy command -;; NOTE: This duplicates the tests from the `sub-loop' command, which will be -;; removed. (loopy-deftest same-level-at-accum :result '(1 2 3 4) @@ -5289,16 +5208,16 @@ This assumes that you're on guix." ;;; Custom Aliases (loopy-deftest custom-alias-flag - :result '((1) (2)) + :doc "Test with `default' flag, which is essentially a no-op." + :result '(1) :wrap ((x . `(let ((loopy-aliases (map-copy loopy-aliases)) (loopy-iter-bare-special-macro-arguments (cons 'f loopy-iter-bare-special-macro-arguments))) (loopy-defalias f flag) (eval (quote ,x) t)))) - :body ((f split) + :body ((f default) (list i '(1)) - (collect i) - (collect (1+ i))) + (collect i)) :loopy t :iter-keyword (list collect f) :iter-bare ((list . listing)