* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` @ 2023-12-03 20:33 Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-04 19:08 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 25+ messages in thread From: Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-03 20:33 UTC (permalink / raw) To: 67611; +Cc: Stefan Monnier [-- Attachment #1: Type: text/plain, Size: 1108 bytes --] Hello, The attached patch adds the pattern `cl-lambda` for Pcase, which works like `cl-destructuring-bind`. There are two differences with the lambda lists: 1. It does not support `&environment` 2. Without `&allow-other-keys` or `:allow-other-keys t`, the pattern will fail to match if their are unmatched keys in EXPVAL, but it does not throw an error. The variable that would be bound in the lambda list can be Pcase patterns themselves, with two exceptions: 1. Using a sub-pattern as the cdr of a dotted list, like "(cl-lambda (a . `(,b . ,c))" doesn't work, since the pattern won't always look like a dotted list. 2. For constructs that use a sub-list to provide additional values, such as `&optional`, `&key`, and `&aux`, the sub-pattern only works inside the sub-list. For example, one could do "(cl-lambda (&optional (`(,a ,b))" but not "(cl-lambda (&optional `(,a ,b)))". The pattern is useful when one wants to combine the features of `pcase` and `cl-destructuring-bind`, such combining the optional values with the `pred` or `guard` patterns. Thank you. [-- Attachment #2: 0001-Add-the-Pcase-pattern-cl-lambda-for-matching-lambda-.patch --] [-- Type: text/x-patch, Size: 37534 bytes --] From a16bf1ded587b7cc974dafa5f72427f3a1f6c5ff Mon Sep 17 00:00:00 2001 From: Earl Hyatt <okamsn@protonmail.com> Date: Sat, 25 Nov 2023 13:00:03 -0500 Subject: [PATCH] Add the Pcase pattern `cl-lambda' for matching lambda list. This pattern matches function argument lists as described in the Info node `(cl)Argument Lists'. * lisp/emacs-lisp/cl-macs.el (cl-lambda--pcase-macroexpander) (cl-lambda, cl--pcase-lambda-list-get-var-groups) (cl--pcase-cl-lambda-positional-pattern) (cl--pcase-cl-lambda-plist-keys) (cl--pcase-cl-lambda-&key-pattern) (cl--pcase-cl-lambda-&aux-pattern): Add pattern and supporting functions. * test/lisp/emacs-lisp/pcase-tests.el: (pcase-tests-cl-lambda-&whole-should-error) (pcase-tests-cl-lambda-&whole) (pcase-tests-cl-lambda-pos, pcase-tests-cl-lambda-pos-sub-patterns) (pcase-tests-cl-lambda-&optional-should-error) (pcase-tests-cl-lambda-&optional) (pcase-tests-cl-lambda-&optional-sub-patterns) (pcase-tests-cl-lambda-&rest-should-error) (pcase-tests-cl-lambda-&rest-nonlist-cdr) (pcase-tests-cl-lambda-&rest-with-&whole) (pcase-tests-cl-lambda-&rest-only) (pcase-tests-cl-lambda-&rest-after-&optional) (pcase-tests-cl-lambda-&rest-sub-patterns) (pcase-tests-cl-lambda-&key-should-error) (pcase-tests-cl-lambda-&key-exact) (pcase-tests-cl-lambda-&key-permissive) (pcase-tests-cl-lambda-&key-not-first) (pcase-tests-cl-lambda-&key-full-form) (pcase-tests-cl-lambda-&key-sub-patterns) (pcase-tests-cl-lambda-&aux-should-error) (pcase-tests-cl-lambda-&aux) (pcase-tests-cl-lambda-&aux-sub-patterns) (pcase-tests-cl-lambda-all): Add tests. --- lisp/emacs-lisp/cl-macs.el | 325 ++++++++++++++++++ test/lisp/emacs-lisp/pcase-tests.el | 515 ++++++++++++++++++++++++++++ 2 files changed, 840 insertions(+) diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el index 7c207d372fc..00c10f6458f 100644 --- a/lisp/emacs-lisp/cl-macs.el +++ b/lisp/emacs-lisp/cl-macs.el @@ -3825,6 +3825,331 @@ cl-type TYPE is a type descriptor as accepted by `cl-typep', which see." `(pred (pcase--flip cl-typep ',type))) +;;; Pcase lambda-list pattern + +;; This pattern is like `cl-destructuring-bind', but with `pcase'. We +;; can't use `cl--do-arglist' for this, because `cl--do-arglist' uses +;; `pop' to modify earlier variables while setting later ones, which +;; doesn't seem to work with `pcase'. + +(defconst cl--pcase-lambda-list-constructs + '(&whole &optional &rest &key &allow-other-keys &aux) + "Symbols that change how the following elements are understood.") + +(define-error 'cl--pcase-lambda-list-bad-lambda-list + "Error in `cl-lambda' pattern.") + +(defun cl--pcase-cl-lambda-var-groups (lambda-list) + "Return the alist of variable groups in LAMBDA-LIST. + +Lists are of the form +`([&whole WHOLE-VAR] [POS-VARS] [&optional OPT-VARS] [&rest REST-VAR] +[&key KEY-VARS] [&aux AUX-VARS])'." + (let ((whole-var) (processing-whole) + (pos-var) + (opt-var) (processing-opts) + (rest-var) (processing-rest) (dotted-rest-var) + (key-var) (processing-keys) (allow-other-keys) + (aux-var) (processing-auxs) + (remaining-list (cl-copy-list lambda-list))) + + (when (not (proper-list-p remaining-list)) + (cl-shiftf dotted-rest-var + (cdr (last remaining-list)) + nil)) + + (cl-flet ((missing-after (cdr) (or (null cdr) + (memq (car cdr) cl--pcase-lambda-list-constructs))) + (stop-processing () (setq processing-whole nil + processing-opts nil + processing-rest nil + processing-keys nil + processing-auxs nil))) + (cl-loop + for (first . rest) on lambda-list + do + (pcase first + ('&whole + (if (or (missing-after rest) + whole-var pos-var opt-var + rest-var key-var allow-other-keys aux-var) + (signal 'cl--pcase-lambda-list-bad-lambda-list (list lambda-list)) + (stop-processing) + (setq processing-whole t))) + + ('&optional + (if (or (missing-after rest) + opt-var rest-var key-var allow-other-keys aux-var) + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list)) + (stop-processing) + (setq processing-opts t))) + + ((or '&rest '&body) + (if (or (missing-after rest) + rest-var key-var allow-other-keys aux-var + dotted-rest-var) + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list)) + (stop-processing) + (setq processing-rest t))) + + ('&key + (if (or (missing-after rest) + key-var allow-other-keys aux-var + dotted-rest-var) + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list)) + (stop-processing) + (setq processing-keys t))) + + ('&allow-other-keys + (if (or (not processing-keys) + allow-other-keys + dotted-rest-var) + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list)) + (stop-processing) + (setq allow-other-keys t))) + + ('&aux + (if (or (missing-after rest) + aux-var + dotted-rest-var) + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list)) + (stop-processing) + (setq processing-auxs t))) + + ((guard processing-whole) + (setq whole-var first + processing-whole nil)) + + ((guard processing-rest) + (setq rest-var first + processing-rest nil)) + + ((guard processing-opts) + (push first opt-var)) + + ((guard processing-keys) + (push first key-var)) + + ((guard processing-auxs) + (push first aux-var)) + + ('&environment + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list))) + + (_ + (if (or opt-var rest-var key-var aux-var + allow-other-keys) + (signal 'cl--pcase-lambda-list-bad-lambda-list + (list lambda-list)) + (push first pos-var)))))) + + `((whole . ,whole-var) + (pos . ,(nreverse pos-var)) + (opt . ,(nreverse opt-var)) + (rest . ,(or dotted-rest-var rest-var)) + (key . ,(nreverse key-var)) + (allow-other-keys . ,allow-other-keys) + (aux . ,(nreverse aux-var))))) + +(defun cl--pcase-cl-lambda-positional-pattern (pos-vars opt-vars rest-var key-vars) + "Build a pattern for the positional, `&optional', and `&rest' variables. + +POS-VARS is the list of the positional variables. OPT-VARS is the list of +the optional variables. REST-VAR is the `&rest' variable." + ;; A modified version of the back-quote pattern to better work with + ;; optional values. + (cond + (pos-vars `(and (pred consp) + (app car-safe ,(car pos-vars)) + (app cdr-safe ,(cl--pcase-cl-lambda-positional-pattern + (cdr pos-vars) opt-vars + rest-var key-vars)))) + (opt-vars (pcase-let (((or `(,var ,default ,supplied) + `(,var ,default) + `(,var) + var) + (car opt-vars))) + `(and (pred listp) + (app car-safe (or (and (pred null) + ,@(when supplied `((let ,supplied nil))) + ,@(when default `((let ,var ,default)))) + ,(if supplied + `(and (let ,supplied t) + ,var) + var))) + (app cdr-safe ,(cl--pcase-cl-lambda-positional-pattern + nil (cdr opt-vars) + rest-var key-vars))))) + (rest-var rest-var) + ;; `pcase' allows `(,a ,b) to match (1 2 3), so we need to make + ;; sure there aren't more values left. However, if we are using + ;; `&key', then we allow more values. + (key-vars '_) + (t '(pred null)))) + +;;;###autoload +(defun cl--pcase-cl-lambda-plist-keys (list) + "Get every other element in LIST, to get the keys in a property list." + (cl-loop for key in list by #'cddr collect key)) + +(defun cl--pcase-cl-lambda-&key-pattern (key-vars allow-other-keys plist-var) + "Build a `pcase' pattern for the `&key' variables. + +KEY-VARS are the forms of the key variables. ALLOW-OTHER-KEYS is +whether `&allow-other-keys' was used. PLIST-VAR is the variable +holding the property list." + (let* ((specified-keys nil) + (pat-list + (cl-loop + for bind in key-vars + append (pcase-let* (((or (or `((,key ,var) ,default ,supplied) + `((,key ,var) ,default) + `((,key ,var))) + (and (or `(,var ,default ,supplied) + `(,var ,default) + `(,var) + (and (pred symbolp) + var)) + ;; Strip a leading underscore, since it + ;; only means that this argument is + ;; unused, but shouldn't affect the + ;; key's name (bug#12367). + (let key (intern + (format ":%s" + (let ((name (symbol-name var))) + (if (eq ?_ (aref name 0)) + (substring name 1) + name))))))) + bind) + (const-key (macroexp-const-p key)) + (used-key (if const-key + key + (gensym (format "plist-key-%s" var))))) + (unless allow-other-keys + (push key specified-keys)) + `(,@(unless (equal used-key key) + `((let ,used-key ,key))) + ,@(cond + (supplied + (let ((key-found (gensym "key-found"))) + `((let ,key-found (plist-member ,plist-var ,used-key + #'equal)) + (or (and (guard ,key-found) + (let ,var (cadr ,key-found)) + (let ,supplied t)) + (and (let ,var ,default) + (let ,supplied nil)))))) + (default + (let ((key-found (gensym "key-found"))) + `((let ,var + (if-let ((,key-found (plist-member ,plist-var + ,used-key + #'equal))) + (cl-second ,key-found) + ,default))))) + (t + `((let ,var (plist-get ,plist-var ,used-key #'equal)))))))))) + `(and ,@(unless allow-other-keys + `((guard (or (null (cl-set-difference (cl--pcase-cl-lambda-plist-keys ,plist-var) + (list ,@specified-keys) + :test #'equal)) + (plist-get ,plist-var :allow-other-keys))))) + ,@pat-list))) + +(defun cl--pcase-cl-lambda-&aux-pattern (aux-vars) + "Build `pcase' pattern for `&aux' variables. + +AUX-VARS is the list of bindings." + `(and ,@(cl-loop for bind in aux-vars + collect (pcase-let (((or `(,var ,val) + `(,var) + var) + bind)) + `(let ,var ,val))))) + +;;;###autoload +(pcase-defmacro cl-lambda (lambda-list) + "Match a CL lambda list. See the Info node `(cl)Argument Lists'. + +This pattern does not support `&environment'. + +`&key' will fail to match if there are more keys in the plist +then specified, unless `&allow-other-keys' is given or unless the +plist associates the key `:allow-other-keys' with a non-nil +value. Unlike `cl-destructuring-bind', this pattern does not +signal an error if there are unmatched keys in the plist. + +Unlike the back-quote pattern, the pattern will fail to match if the +non-optional part of LAMBDA-LIST is shorter than EXPVAL. + +For this `pcase' pattern, the variables in LAMBDA-LIST can +themselves be `pcase' patterns, instead of just symbols as in a +normal CL lambda list. However, lambda-list constructs like +`&optional', `&key', and `&aux' use sub-lists to specify default +values and other features. For example, + + (cl-lambda (&optional (opt1 default1 opt1-supplied))) + +Therefore, to avoid ambiguity, the use of sub-patterns can only +be done within the sub-list for those constructs. For example, + + (cl-lambda (&optional ((and opt1 (guard (listp opt1))) + nil))) + +For similar reasons, the cdr of a dotted list (as opposed to the +element following `&rest') for the remainder of a list cannot be +a sub-pattern." + (let* ((groups (cl--pcase-cl-lambda-var-groups lambda-list)) + (whole-var (alist-get 'whole groups)) + (pos-vars (alist-get 'pos groups)) + (opt-vars (alist-get 'opt groups)) + (rest-var (alist-get 'rest groups)) + (key-vars (alist-get 'key groups)) + (allow-other-keys (alist-get 'allow-other-keys groups)) + (aux-vars (alist-get 'aux groups))) + (remq nil + `(and (pred listp) + ,(when whole-var + whole-var) + ,(when (or pos-vars opt-vars rest-var) + (cl--pcase-cl-lambda-positional-pattern + pos-vars opt-vars + rest-var key-vars)) + ,@(when key-vars + (let ((plist-var (gensym "maybe-plist"))) + (cond + (rest-var + (list (cl--pcase-cl-lambda-&key-pattern + key-vars allow-other-keys + rest-var))) + ((or pos-vars opt-vars) + (if whole-var + `((let ,plist-var (nthcdr ,(+ (length pos-vars) + (length opt-vars)) + ,whole-var)) + ,(cl--pcase-cl-lambda-&key-pattern + key-vars allow-other-keys + plist-var)) + `((app (nthcdr ,(+ (length pos-vars) + (length opt-vars))) + ,plist-var) + ,(cl--pcase-cl-lambda-&key-pattern + key-vars allow-other-keys + plist-var)))) + (t + `((and ,plist-var + ,(cl--pcase-cl-lambda-&key-pattern + key-vars allow-other-keys + plist-var))))))) + ,(when aux-vars + (cl--pcase-cl-lambda-&aux-pattern aux-vars)))))) + ;; Local variables: ;; generated-autoload-file: "cl-loaddefs.el" ;; End: diff --git a/test/lisp/emacs-lisp/pcase-tests.el b/test/lisp/emacs-lisp/pcase-tests.el index 799e8d36647..9c32259e953 100644 --- a/test/lisp/emacs-lisp/pcase-tests.el +++ b/test/lisp/emacs-lisp/pcase-tests.el @@ -160,4 +160,519 @@ pcase-tests-setq (should-error (pcase-setq a) :type '(wrong-number-of-arguments))) +;;; Tests for the `cl-lambda' `pcase' pattern. + +(ert-deftest pcase-tests-cl-lambda-&whole-should-error () + "`&whole' must come first if given, and must be followed by a patter." + (should-error (pcase (list 1 2 3) + ((cl-lambda (&whole)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (a b &whole c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&rest a &whole c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&key a &whole c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&aux (a 1) &whole c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&optional (a 1) &whole c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&whole whole1 &whole whole2)) + (list whole1 whole2))) + :type 'cl--pcase-lambda-list-bad-lambda-list)) + +(ert-deftest pcase-tests-cl-lambda-&whole () + "`&whole' can be a `pcase' pattern." + (should (equal (list (list 1 2 3) 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (&whole whole a b c)) + (list whole a b c))))) + + (should (equal (list 1 2 3 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (&whole `(,a0 ,b0 ,c0) a b c)) + (list a0 b0 c0 a b c)))))) + +(ert-deftest pcase-tests-cl-lambda-pos () + "Positional variables must match the length of EXPVAL." + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (a b c)) + (list a b c))))) + + (should (equal nil + (pcase (list (list 1)) + ((cl-lambda (a b)) + (list a b))))) + + (should (equal nil + (pcase (list (list 1 2 3)) + ((cl-lambda (a b)) + (list a b)))))) + +(ert-deftest pcase-tests-cl-lambda-pos-sub-patterns () + (should (equal (list 1 2 3 4) + (pcase (list 1 2 (list 3 4)) + ((cl-lambda (a b (cl-lambda (c d)))) + (list a b c d))))) + + (should (equal (list 1 2) + (pcase (list (list 1 2)) + ((cl-lambda (`(,a ,b))) + (list a b)))))) + +(ert-deftest pcase-tests-cl-lambda-&optional-should-error () + "`&optional' cannot be used after `&optional', `&rest', `&key', and `&aux'." + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (&rest a &optional b c)) + (list a b c)))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&body a &optional b c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&key a &optional b c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&allow-other-keys &optional b c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&aux (a 1) &optional b c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&optional a &optional b c)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list)) + +(ert-deftest pcase-tests-cl-lambda-&optional () + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (a b &optional c)) + (list a b c))))) + + (should (equal (list 1 2 nil) + (pcase (list 1 2) + ((cl-lambda (a b &optional c)) + (list a b c))))) + + (should (equal (list 1 2 13) + (pcase (list 1 2) + ((cl-lambda (a b &optional (c 13))) + (list a b c))))) + + (should (equal (list 1 2 13 nil) + (pcase (list 1 2) + ((cl-lambda (a b &optional (c 13 c-supplied))) + (list a b c c-supplied))))) + + (should (equal (list 1 2 3 t) + (pcase (list 1 2 3) + ((cl-lambda (a b &optional (c 13 c-supplied))) + (list a b c c-supplied)))))) + +(ert-deftest pcase-tests-cl-lambda-&optional-sub-patterns () + "Test using sub-patterns in `cl-lambda' pattern. +Sub-patterns must be contained within a sub-list, since a sub-list +also provides a default value." + (should-error (pcase (list 1 2 (list 3 4)) + ((cl-lambda (a b &optional `(,c ,d))) + (list a b c d)))) + + (should (equal (list 1 2 33) + (pcase (list 1 2) + ((cl-lambda (a b &optional ((and opt1 + (guard (numberp opt1))) + 33))) + (list a b opt1))))) + + (should (equal nil + (pcase (list 1 2 'not-num) + ((cl-lambda (a b &optional ((and opt1 + (guard (numberp opt1))) + 33))) + (list a b opt1))))) + + (should (equal nil + (pcase (list 1 2 nil) + ((cl-lambda (a b &optional ((and opt1 + (guard (numberp opt1))) + 'not-num))) + (list a b opt1))))) + + (should (equal (list 1 2 3 4) + (pcase (list 1 2 (list 3 4)) + ((cl-lambda (a b &optional (`(,c ,d)))) + (list a b c d))))) + + (should (equal (list 1 2 nil nil) + (pcase (list 1 2) + ((cl-lambda (a b &optional (`(,c ,d)))) + (list a b c d))))) + + (should (equal (list 1 2 13 14) + (pcase (list 1 2) + ((cl-lambda (a b &optional (`(,c ,d) (list 13 14)))) + (list a b c d))))) + + (should (equal (list 1 2 13 14) + (pcase (list 1 2) + ((cl-lambda ( a b + &optional ((cl-lambda (c &optional (d 14))) + (list 13)))) + (list a b c d))))) + + (should (equal (list 1 2 13 14 nil) + (pcase (list 1 2) + ((cl-lambda (a b &optional (`(,c ,d) (list 13 14) cd-supplied))) + (list a b c d cd-supplied))))) + + (should (equal (list 1 2 13 14 nil t nil) + (pcase (list 1 2) + ((cl-lambda ( a b + &optional + ((cl-lambda (&optional (c 27 c-sub-sup) + (d 14 d-sub-sup))) + (list 13) + cd-supplied))) + (list a b c d cd-supplied c-sub-sup d-sub-sup)))))) + +(ert-deftest pcase-tests-cl-lambda-&rest-should-error () + "`&rest' (`&body', `.') cannot be used after `&rest', `&body', `&key',and `&aux'." + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (&rest a &rest b)) + (list a b c)))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (&body a &body b)) + (list a b c)))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (&body a . b)) + (list a b c)))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&body a &rest b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&rest a &body b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&key a &rest b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&key a &body b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&key a . b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&allow-other-keys &rest b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&allow-other-keys &body b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&allow-other-keys . b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&aux (a 1) &rest b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&aux (a 1) &body b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list 1 2 3) + ((cl-lambda (&aux (a 1) . b)) + (list a b c))) + :type 'cl--pcase-lambda-list-bad-lambda-list)) + +(ert-deftest pcase-tests-cl-lambda-&rest-nonlist-cdr () + (should (equal (list 1 2) + (pcase (cons 1 2) + ((cl-lambda (a &rest b)) + (list a b))))) + + (should (equal (list 1 2) + (pcase (cons 1 2) + ((cl-lambda (a &body b)) + (list a b))))) + + (should (equal (list 1 2) + (pcase (cons 1 2) + ((cl-lambda (a . b)) + (list a b)))))) + +(ert-deftest pcase-tests-cl-lambda-&rest-with-&whole () + (should (equal (list (cons 1 2) 1 2) + (pcase (cons 1 2) + ((cl-lambda (&whole whole a &rest b)) + (list whole a b))))) + + (should (equal (list (cons 1 2) 1 2) + (pcase (cons 1 2) + ((cl-lambda (&whole whole a &body b)) + (list whole a b))))) + + (should (equal (list (cons 1 2) 1 2) + (pcase (cons 1 2) + ((cl-lambda (&whole whole a . b)) + (list whole a b)))))) + +(ert-deftest pcase-tests-cl-lambda-&rest-only () + "Using only `&rest' should work like `&whole'." + (should (equal (list (list 1 2)) + (pcase (list 1 2) + ((cl-lambda (&rest a)) + (list a))))) + + (should (equal (list (cons 1 2)) + (pcase (cons 1 2) + ((cl-lambda (&body a)) + (list a)))))) + +(ert-deftest pcase-tests-cl-lambda-&rest-after-&optional () + (should (equal (list 1 2 3 (list 4 5)) + (pcase (list 1 2 3 4 5) + ((cl-lambda (&optional a b c &rest d)) + (list a b c d))))) + + (should (equal (list 1 2 3 (list 4 5)) + (pcase (list 1 2 3 4 5) + ((cl-lambda (&optional a b c &body d)) + (list a b c d))))) + + (should (equal (list 1 2 3 (list 4 5)) + (pcase (list 1 2 3 4 5) + ((cl-lambda (&optional a b c . d)) + (list a b c d)))))) + +(ert-deftest pcase-tests-cl-lambda-&rest-sub-patterns () + ;; We can't do (a . `(,b . ,c)), so we don't test that. + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (a &rest (cl-lambda (b c)))) + (list a b c))))) + + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-lambda (a &body `(,b ,c))) + (list a b c)))))) + +(ert-deftest pcase-tests-cl-lambda-&key-should-error () + "`&key' cannot be used after `&key', `&allow-other-keys', and `&aux'." + (should-error (pcase (list :a 1 :b 2) + ((cl-lambda (&key a &key b)) + (list a b))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list :a 1 :b 2) + ((cl-lambda (&aux (a 1) &key b)) + (list a b))) + :type 'cl--pcase-lambda-list-bad-lambda-list) + + (should-error (pcase (list :a 1 :b 2) + ((cl-lambda (&allow-other-keys &key b)) + (list a b))) + :type 'cl--pcase-lambda-list-bad-lambda-list)) + +(ert-deftest pcase-tests-cl-lambda-&key-exact () + "`&key' doesn't match unspecified keys unless `&allow-other-keys' or `:allow-other-keys' is given." + (should (equal (list 1 2) + (pcase (list :a 1 :b 2) + ((cl-lambda (&key a b)) + (list a b))))) + + (should (equal nil + (pcase (list :a 1 :b 2 :c 3) + ((cl-lambda (&key a b)) + (list a b))))) + + (should (equal (list 1 2 nil) + (pcase (list :a 1 :b 2) + ((cl-lambda (&key a b c)) + (list a b c)))))) + +(ert-deftest pcase-tests-cl-lambda-&key-permissive () + "`&key' doesn't match unspecified keys unless `&allow-other-keys' or `:allow-other-keys' is given." + (should (equal (list 1 2) + (pcase (list :a 1 :b 2 :c 3) + ((cl-lambda (&key a b &allow-other-keys)) + (list a b))))) + + (should (equal (list 1 2) + (pcase (list :a 1 :b 2 :c 3 :allow-other-keys t) + ((cl-lambda (&key a b)) + (list a b)))))) + +(ert-deftest pcase-tests-cl-lambda-&key-not-first () + "The plist should be after positional values and equal to `&rest'." + (should (equal (list 1 2 3 11 22) + (pcase (list 1 2 3 :k1 11 :k2 22) + ((cl-lambda (a b c &key k1 k2)) + (list a b c k1 k2))))) + + (should (equal (list 1 2 3 (list :k1 11 :k2 22) 11 22) + (pcase (list 1 2 3 :k1 11 :k2 22) + ((cl-lambda (a b c &rest r1 &key k1 k2)) + (list a b c r1 k1 k2)))))) + +(ert-deftest pcase-tests-cl-lambda-&key-full-form () + (should (equal (list 1 2) + (pcase (list :a 1 :b 2) + ((cl-lambda (&key a (b 13))) + (list a b))))) + + (should (equal (list 1 13) + (pcase (list :a 1) + ((cl-lambda (&key a (b 13))) + (list a b))))) + + (should (equal (list 1 13 nil) + (pcase (list :a 1) + ((cl-lambda (&key a (b 13 b-supplied))) + (list a b b-supplied))))) + + (should (equal (list 1 2 t) + (pcase (list :a 1 :b 2) + ((cl-lambda (&key a (b 13 b-supplied))) + (list a b b-supplied))))) + + (should (equal (list 1 2 t) + (pcase (list :a 1 :bat 2) + ((cl-lambda (&key a ((:bat b) 13 b-supplied))) + (list a b b-supplied))))) + + (should (equal (list 1 2 t) + (let ((key :bat)) + (pcase (list :a 1 :bat 2) + ((cl-lambda (&key a ((key b) 13 b-supplied))) + (list a b b-supplied))))))) + +(ert-deftest pcase-tests-cl-lambda-&key-sub-patterns () + (should (equal '(1 2 (:c 77 :e should-ignore) nil 77 t 99 nil) + (pcase '(:ab (1 2)) + ((cl-lambda (&key + ((:ab `(,a ,b))) + ((:cd (cl-lambda ( &whole cd + &key + (c 88 c-supp) + ((:d d) 99 d-supp) + &allow-other-keys))) + (list :c 77 :e 'should-ignore) + cd-supp))) + (list a b cd cd-supp c c-supp d d-supp))))) + + (should (equal '( 1 2 (:c 77 :e should-ignore :allow-other-keys t) nil + 77 t 99 nil) + (pcase '(:ab (1 2)) + ((cl-lambda (&key + ((:ab `(,a ,b))) + ((:cd (cl-lambda ( &whole cd + &key + (c 88 c-supp) + ((:d d) 99 d-supp)))) + (list :c 77 :e 'should-ignore + :allow-other-keys t) + cd-supp))) + (list a b cd cd-supp c c-supp d d-supp))))) + + (should (equal nil + (pcase '(:ab (1 2)) + ((cl-lambda (&key + ((:ab `(,a ,b))) + ((:cd (cl-lambda ( &whole cd + &key + (c 88 c-supp) + ((:d d) 99 d-supp)))) + (list :c 77 :e 'should-fail) + cd-supp))) + (list a b cd cd-supp c c-supp d d-supp)))))) + +(ert-deftest pcase-tests-cl-lambda-&aux-should-error () + "`&aux' cannot be used after `&aux'." + (should-error (pcase nil + ((cl-lambda (&aux a &aux b)) + (list a b))) + :type 'cl--pcase-lambda-list-bad-lambda-list)) + +(ert-deftest pcase-tests-cl-lambda-&aux () + (should (equal (list 1 2 nil nil) + (pcase nil + ((cl-lambda (&aux (a 1) (b 2) (c) d)) + (list a b c d))))) + + (should (equal (list 0 1 2 nil nil) + (pcase (list 0) + ((cl-lambda (z0 &aux (a 1) (b 2) (c) d)) + (list z0 a b c d)))))) + +(ert-deftest pcase-tests-cl-lambda-&aux-sub-patterns () + (should (equal (list 1 2) + (pcase nil + ((cl-lambda (&aux (`(,a ,b) (list 1 2)))) + (list a b )))))) + +(ert-deftest pcase-tests-cl-lambda-all () + (should (equal '(1 2 3 4 5 (:k1 111 :k2 222) 111 222 333 444) + (pcase (list 1 2 3 4 5 :k1 111 :k2 222) + ((cl-lambda ( a b c + &optional d e + &rest r + &key k1 k2 + &aux (x1 333) (x2 444))) + (list a b c d e r k1 k2 x1 x2)))))) + ;;; pcase-tests.el ends here. -- 2.34.1 ^ permalink raw reply related [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2023-12-03 20:33 bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-04 19:08 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 2:42 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors ` (2 more replies) 0 siblings, 3 replies; 25+ messages in thread From: Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-04 19:08 UTC (permalink / raw) To: Okamsn; +Cc: 67611 > The attached patch adds the pattern `cl-lambda` for Pcase, which works > like `cl-destructuring-bind`. There are two differences with the lambda > lists: Hmm... I'm not sure mixing the CL destructuring patterns with the Pcase patterns (both of which are rather featureful and complex) will help their popularity. Beside that problem (which means I'm not very favorable to the addition), the name should be changed because "lambda" is misleading. It suggests this has to do with a function (I had to read the code to understand what this is doing). > The pattern is useful when one wants to combine the features of `pcase` > and `cl-destructuring-bind`, such combining the optional values with the > `pred` or `guard` patterns. Do you have examples uses? Maybe we could introduce a different Pcase pattern which covers those needs but stays closer to the Pcase pattern syntax? Stefan ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2023-12-04 19:08 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-05 2:42 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 9:26 ` João Távora 2023-12-05 9:21 ` João Távora 2023-12-25 21:30 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2 siblings, 1 reply; 25+ messages in thread From: Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-05 2:42 UTC (permalink / raw) To: Stefan Monnier; +Cc: 67611 Stefan Monnier wrote: >> The attached patch adds the pattern `cl-lambda` for Pcase, which works >> like `cl-destructuring-bind`. There are two differences with the lambda >> lists: > > Hmm... I'm not sure mixing the CL destructuring patterns with the Pcase > patterns (both of which are rather featureful and complex) will help > their popularity. > > Beside that problem (which means I'm not very favorable to the > addition), the name should be changed because "lambda" is misleading. > It suggests this has to do with a function (I had to read the code to > understand what this is doing). I agree that the name is not ideal. When I searched for what the destructuring pattern was called, the website Common Lisp HyperSpec called it a "destructuring lambda list" (https://www.lispworks.com/documentation/HyperSpec/Body/03_de.htm). I would have suggested "cl", as it is the kind of destructuring used by the macros of cl-lib, but I thought that would not work well with the existence of the "cl-type" pattern. I also thought about something like "cl-arglist", if that is better. >> The pattern is useful when one wants to combine the features of `pcase` >> and `cl-destructuring-bind`, such combining the optional values with the >> `pred` or `guard` patterns. > > Do you have examples uses? Not of that idea, no. I maintain a library that implements a destructuring pattern like cl-lib (https://github.com/okamsn/loopy/blob/master/doc/loopy-doc.org#basic-destructuring) and I have been thinking about how I could use Pcase to simplify the implementation of the destructuring and to stop using a re-invented wheel. While doing that, it occurred to me that cl-lib itself might be a better place for such a Pcase pattern. To be clear, the patch only implements the cl-lib destructuring, not the other destructuring ideas from my library. For me, I am interested in using such a destructuring pattern with `pcase-let` and `pcase-setq`, but not so much with `pcase` itself. > Maybe we could introduce a different Pcase pattern which covers those > needs but stays closer to the Pcase pattern syntax? As far as I understand Pcase, one thing that I think cl-lib does better is specifying default values for multiple optional variables. For example, for `(a &optional (b 2) (c 3))` in Pcase, I would write (or `(,a ,b ,c) (and `(,a ,b) (let c 3)) (and `(,a) (let c 3) (let b 2))) or `(,a . ,(or `(,b . ,(or `(,c) (let c 3))) (and (let b 2) (let c 3)))) in which there is repetition in the default values. Is there a better way to specify default values for optional elements? Thank you. ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2023-12-05 2:42 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-05 9:26 ` João Távora 0 siblings, 0 replies; 25+ messages in thread From: João Távora @ 2023-12-05 9:26 UTC (permalink / raw) To: Okamsn; +Cc: 67611, Stefan Monnier On Tue, Dec 5, 2023 at 2:43 AM Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors <bug-gnu-emacs@gnu.org> wrote: > For me, I am interested in using such a destructuring pattern with > `pcase-let` and `pcase-setq`, but not so much with `pcase` itself. > > > Maybe we could introduce a different Pcase pattern which covers those > > needs but stays closer to the Pcase pattern syntax? > > As far as I understand Pcase, one thing that I think cl-lib does better > is specifying default values for multiple optional variables. For > example, for `(a &optional (b 2) (c 3))` in Pcase, I would write Yes. cl-lib has a couple of neat tricks up its sleeve, still. And what about keyword arguments in plists? Can pcase destructure them? If so, does it bind the "supplied-p" variable? And can it rename the variable being destructured to something else non-clashing? All these things are useful in CL's destructuring-bind, but it is missing other stuff like "casing" logic. So at least on a first glimpse, this reunion would be welcome by me. With the caveat that I haven't seen any examples or the patch yet, and it matters. João ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2023-12-04 19:08 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 2:42 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-05 9:21 ` João Távora 2023-12-25 21:30 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2 siblings, 0 replies; 25+ messages in thread From: João Távora @ 2023-12-05 9:21 UTC (permalink / raw) To: Stefan Monnier; +Cc: Okamsn, 67611 On Mon, Dec 4, 2023 at 7:09 PM Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors <bug-gnu-emacs@gnu.org> wrote: > > > The attached patch adds the pattern `cl-lambda` for Pcase, which works > > like `cl-destructuring-bind`. There are two differences with the lambda > > lists: > > Hmm... I'm not sure mixing the CL destructuring patterns with the Pcase > patterns (both of which are rather featureful and complex) will help > their popularity. > > Beside that problem (which means I'm not very favorable to the > addition), the name should be changed because "lambda" is misleading. > It suggests this has to do with a function (I had to read the code to > understand what this is doing). > > > The pattern is useful when one wants to combine the features of `pcase` > > and `cl-destructuring-bind`, such combining the optional values with the > > `pred` or `guard` patterns. > > Do you have examples uses? I for one would like to see some examples too. Okamsn's description of this pcase extension sounds interesting. In fact, it sounds very much like the slime-dcase and sly-dcase macros in SLIME and SLY respectively. João ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2023-12-04 19:08 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 2:42 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 9:21 ` João Távora @ 2023-12-25 21:30 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-11 21:12 ` Stefan Kangas 2 siblings, 1 reply; 25+ messages in thread From: Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2023-12-25 21:30 UTC (permalink / raw) To: Stefan Monnier; +Cc: 67611, joaotavora [-- Attachment #1: Type: text/plain, Size: 1542 bytes --] Stefan Monnier wrote: >> The attached patch adds the pattern `cl-lambda` for Pcase, which works >> like `cl-destructuring-bind`. There are two differences with the lambda >> lists: > > Hmm... I'm not sure mixing the CL destructuring patterns with the Pcase > patterns (both of which are rather featureful and complex) will help > their popularity. > > Beside that problem (which means I'm not very favorable to the > addition), the name should be changed because "lambda" is misleading. > It suggests this has to do with a function (I had to read the code to > understand what this is doing). > >> The pattern is useful when one wants to combine the features of `pcase` >> and `cl-destructuring-bind`, such combining the optional values with the >> `pred` or `guard` patterns. > > Do you have examples uses? > > Maybe we could introduce a different Pcase pattern which covers those > needs but stays closer to the Pcase pattern syntax? > > > Stefan > Hello, Because I wrote this patch with the thought that others might want it, I don't have any nontrivial examples to share right now. The best example I have for the use of the optional arguments is for the implementing of the optional arguments, which isn't very convincing. I've updated the patch to rename the pattern to `cl-arglist` and to avoid creating intermediate variables using the `let` pattern, but I'm fine with resting the discussion here until a stronger argument can be made in favor of the patch. Thank you. [-- Attachment #2: v2-0001-Add-the-Pcase-pattern-cl-arglist-for-matching-a-C.patch --] [-- Type: text/x-patch, Size: 38778 bytes --] From e1752da863b44c93d139ca88bf8c7f6549229d18 Mon Sep 17 00:00:00 2001 From: Earl Hyatt <okamsn@protonmail.com> Date: Sat, 25 Nov 2023 13:00:03 -0500 Subject: [PATCH v2] Add the Pcase pattern `cl-arglist' for matching a CL argument list. This pattern matches function argument lists as described in the Info node `(cl)Argument Lists'. * lisp/emacs-lisp/cl-macs.el (cl-arglist--pcase-macroexpander) (cl-arglist, cl--pcase-arglist-list-get-var-groups) (cl--pcase-cl-arglist-positional-pattern) (cl--pcase-cl-arglist-plist-keys) (cl--pcase-cl-arglist-&key-pattern) (cl--pcase-cl-arglist-&aux-pattern): Add pattern and supporting functions. * test/lisp/emacs-lisp/pcase-tests.el: (pcase-tests-cl-arglist-&whole-should-error) (pcase-tests-cl-arglist-&whole) (pcase-tests-cl-arglist-pos, pcase-tests-cl-arglist-pos-sub-patterns) (pcase-tests-cl-arglist-&optional-should-error) (pcase-tests-cl-arglist-&optional) (pcase-tests-cl-arglist-&optional-sub-patterns) (pcase-tests-cl-arglist-&rest-should-error) (pcase-tests-cl-arglist-&rest-nonlist-cdr) (pcase-tests-cl-arglist-&rest-with-&whole) (pcase-tests-cl-arglist-&rest-only) (pcase-tests-cl-arglist-&rest-after-&optional) (pcase-tests-cl-arglist-&rest-sub-patterns) (pcase-tests-cl-arglist-&key-should-error) (pcase-tests-cl-arglist-&key-exact) (pcase-tests-cl-arglist-&key-permissive) (pcase-tests-cl-arglist-&key-not-first) (pcase-tests-cl-arglist-&key-full-form) (pcase-tests-cl-arglist-&key-sub-patterns) (pcase-tests-cl-arglist-&aux-should-error) (pcase-tests-cl-arglist-&aux) (pcase-tests-cl-arglist-&aux-sub-patterns) (pcase-tests-cl-arglist-all): Add tests. --- lisp/emacs-lisp/cl-macs.el | 343 ++++++++++++++++++ test/lisp/emacs-lisp/pcase-tests.el | 515 ++++++++++++++++++++++++++++ 2 files changed, 858 insertions(+) diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el index 7c207d372fc..0e10011a506 100644 --- a/lisp/emacs-lisp/cl-macs.el +++ b/lisp/emacs-lisp/cl-macs.el @@ -3825,6 +3825,349 @@ cl-type TYPE is a type descriptor as accepted by `cl-typep', which see." `(pred (pcase--flip cl-typep ',type))) +;;; Pcase lambda-list pattern + +;; This pattern is like `cl-destructuring-bind', but with `pcase'. We +;; can't use `cl--do-arglist' for this, because `cl--do-arglist' uses +;; `pop' to modify earlier variables while setting later ones, which +;; doesn't seem to work with `pcase'. + +(define-error 'cl--pcase-cl-arglist-invalid-arg-list + "Invalid argument list used in `cl-arglist' pattern.") + +(defun cl--pcase-cl-arglist-var-groups (lambda-list) + "Return the alist of variable groups in LAMBDA-LIST. + +Lists are of the form +`([&whole WHOLE-VAR] [POS-VARS] [&optional OPT-VARS] [&rest REST-VAR] +[&key KEY-VARS] [&aux AUX-VARS])'." + (let ((whole-var) (processing-whole) + (pos-var) + (opt-var) (processing-opts) + (rest-var) (processing-rest) (dotted-rest-var) + (key-var) (processing-keys) (allow-other-keys) + (aux-var) (processing-auxs) + (remaining-list (cl-copy-list lambda-list))) + + (when (not (proper-list-p remaining-list)) + (cl-shiftf dotted-rest-var + (cdr (last remaining-list)) + nil)) + + (cl-flet ((missing-after (cdr) (or (null cdr) + (memq (car cdr) cl--lambda-list-keywords))) + (stop-processing () (setq processing-whole nil + processing-opts nil + processing-rest nil + processing-keys nil + processing-auxs nil))) + + (cl-loop + for (first . rest) on remaining-list + do + (pcase first + ('&whole + (if (or (missing-after rest) + whole-var pos-var opt-var + rest-var key-var allow-other-keys aux-var) + (signal 'cl--pcase-cl-arglist-invalid-arg-list (list lambda-list)) + (stop-processing) + (setq processing-whole t))) + + ('&optional + (if (or (missing-after rest) + opt-var rest-var key-var allow-other-keys aux-var) + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list)) + (stop-processing) + (setq processing-opts t))) + + ((or '&rest '&body) + (if (or (missing-after rest) + rest-var key-var allow-other-keys aux-var + dotted-rest-var) + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list)) + (stop-processing) + (setq processing-rest t))) + + ('&key + (if (or (missing-after rest) + key-var allow-other-keys aux-var + dotted-rest-var) + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list)) + (stop-processing) + (setq processing-keys t))) + + ('&allow-other-keys + (if (or (not processing-keys) + allow-other-keys + dotted-rest-var) + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list)) + (stop-processing) + (setq allow-other-keys t))) + + ('&aux + (if (or (missing-after rest) + aux-var + dotted-rest-var) + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list)) + (stop-processing) + (setq processing-auxs t))) + + ((guard processing-whole) + (setq whole-var first + processing-whole nil)) + + ((guard processing-rest) + (setq rest-var first + processing-rest nil)) + + ((guard processing-opts) + (push first opt-var)) + + ((guard processing-keys) + (push first key-var)) + + ((guard processing-auxs) + (push first aux-var)) + + ('&environment + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list))) + + (_ + (if (or opt-var rest-var key-var aux-var + allow-other-keys) + (signal 'cl--pcase-cl-arglist-invalid-arg-list + (list lambda-list)) + (push first pos-var)))))) + + `((whole . ,whole-var) + (pos . ,(nreverse pos-var)) + (opt . ,(nreverse opt-var)) + (rest . ,(or dotted-rest-var rest-var)) + (key . ,(nreverse key-var)) + (allow-other-keys . ,allow-other-keys) + (aux . ,(nreverse aux-var))))) + +(defun cl--pcase-cl-arglist-positional-pattern (pos-vars opt-vars rest-var key-vars) + "Build a pattern for the positional, `&optional', and `&rest' variables. + +POS-VARS is the list of the positional variables. OPT-VARS is the list of +the optional variables. REST-VAR is the `&rest' variable." + ;; A modified version of the back-quote pattern to better work with + ;; optional values. + (cond + (pos-vars `(and (pred consp) + (app car-safe ,(car pos-vars)) + (app cdr-safe ,(cl--pcase-cl-arglist-positional-pattern + (cdr pos-vars) opt-vars + rest-var key-vars)))) + (opt-vars (pcase-let (((or `(,var ,default ,supplied) + `(,var ,default) + `(,var) + var) + (car opt-vars))) + `(and (pred listp) + (app car-safe (or (and (pred null) + ,@(when supplied `((let ,supplied nil))) + ,@(when default `((let ,var ,default)))) + ,(if supplied + `(and (let ,supplied t) + ,var) + var))) + (app cdr-safe ,(cl--pcase-cl-arglist-positional-pattern + nil (cdr opt-vars) + rest-var key-vars))))) + (rest-var rest-var) + ;; `pcase' allows `(,a ,b) to match (1 2 3), so we need to make + ;; sure there aren't more values left. However, if we are using + ;; `&key', then we allow more values. + (key-vars '_) + (t '(pred null)))) + +(defun cl--pcase-cl-arglist-&key-pattern (key-vars allow-other-keys) + "Build a `pcase' pattern for the `&key' variables. + +KEY-VARS are the forms of the key variables. ALLOW-OTHER-KEYS is +whether `&allow-other-keys' was used. PLIST-VAR is the variable +holding the property list." + ;; If we aren't checking whether all keys in EXPVAL were given, + ;; then we can use simpler patterns since we don't need to store the + ;; value of the key. + (cl-flet ((get-var-data (var-form) + (pcase-let (((or (or `((,key ,var) ,default ,supplied) + `((,key ,var) ,default) + `((,key ,var))) + (and (or `(,var ,default ,supplied) + `(,var ,default) + `(,var) + (and (pred symbolp) + var)) + ;; Strip a leading underscore, since it + ;; only means that this argument is + ;; unused, but shouldn't affect the + ;; key's name (bug#12367). + (let key (intern + (format ":%s" + (let ((name (symbol-name var))) + (if (eq ?_ (aref name 0)) + (substring name 1) + name))))))) + var-form)) + (list key var default supplied)))) + (if allow-other-keys + `(and ,@(mapcar (lambda (var-form) + (pcase-let ((`(,key ,var ,default ,supplied) (get-var-data var-form)) + (key-found (gensym "key-found")) + (plist (gensym "plist"))) + (cond (supplied + `(app (lambda (,plist) + (let ((,key-found (plist-member ,plist ,key))) + (if ,key-found + (cons t (cadr ,plist)) + (cons nil ,default)))) + (,'\` ((,'\, ,supplied) . (,'\, ,var))))) + (default + `(app (lambda (,plist) + (let ((,key-found (plist-member ,plist ,key))) + (if ,key-found + (cadr ,plist) + ,default))) + ,var)) + (t + `(app (pcase--flip plist-get ,key) + ,var))))) + key-vars)) + ;; If we are checking whether there are no other keys in EXPVAL, + ;; then we use a single function for extracting the associated + ;; values and performing the check, whose output we match against + ;; a list of patterns. + (let ((res (gensym "res")) + (keys (gensym "keys")) + (plist (gensym "plist")) + (pats nil)) + `(app (lambda (,plist) + (let ((,res nil) + (,keys nil)) + ,@(cl-loop + for (key var default supplied) in (mapcar #'get-var-data key-vars) + collect (macroexp-let2* ((keyval key)) + nil + `(progn + (push ,keyval ,keys) + ,(cond + (supplied + (push supplied pats) + (push var pats) + (cl-once-only ((key-found `(plist-member ,plist ,keyval))) + `(if ,key-found + (progn + (push t ,res) + (push (cadr ,key-found) ,res)) + (push nil ,res) + (push ,default ,res)))) + (default + (push var pats) + (cl-once-only ((key-found `(plist-member ,plist ,keyval))) + `(if ,key-found + (push (cadr ,key-found) ,res) + (push ,default ,res)))) + (t + (push var pats) + `(push (plist-get ,plist ,keyval) + ,res)))))) + (push (or (plist-get ,plist :allow-other-keys) + (cl-loop for (key _val) on ,plist by #'cddr + always (memq key ,keys))) + ,res) + ;; Reverse in case a latter pattern use a variable + ;; from an earlier pattern. + (nreverse ,res))) + (,'\` ,(cl-loop for pat in (reverse (cons '(pred (not null)) + pats)) + collect `(,'\, ,pat)))))))) + +(defun cl--pcase-cl-arglist-&aux-pattern (aux-vars) + "Build `pcase' pattern for `&aux' variables. + +AUX-VARS is the list of bindings." + `(and ,@(cl-loop for bind in aux-vars + collect (pcase-let (((or `(,var ,val) + `(,var) + var) + bind)) + `(let ,var ,val))))) + +;;;###autoload +(pcase-defmacro cl-arglist (arglist) + "Match a CL argument list, as in `cl-defun' and `cl-defmacro'. + +See the Info node `(cl)Argument Lists'. + +This pattern does not support `&environment'. + +`&key' will fail to match if there are more keys in the plist +then specified, unless `&allow-other-keys' is given or unless the +plist associates the key `:allow-other-keys' with a non-nil +value. Unlike `cl-destructuring-bind', this pattern does not +signal an error if there are unmatched keys in the plist. + +Unlike the back-quote pattern, the pattern will fail to match if the +non-optional part of ARGLIST is shorter than EXPVAL. + +For this `pcase' pattern, the variables in ARGLIST can +themselves be `pcase' patterns, instead of just symbols as in a +normal CL lambda list. However, argument-list constructs like +`&optional', `&key', and `&aux' use sub-lists to specify default +values and other features. For example, + + (cl-arglist (&optional (opt1 default1 opt1-supplied))) + +Therefore, to avoid ambiguity, the use of sub-patterns can only +be done within the sub-list for those constructs. For example, + + (cl-arglist (&optional ((and opt1 (guard (listp opt1))) + nil))) + +For similar reasons, the cdr of a dotted list (as opposed to the +element following `&rest') for the remainder of a list cannot be +a sub-pattern." + (let* ((groups (cl--pcase-cl-arglist-var-groups arglist)) + (whole-var (alist-get 'whole groups)) + (pos-vars (alist-get 'pos groups)) + (opt-vars (alist-get 'opt groups)) + (rest-var (alist-get 'rest groups)) + (key-vars (alist-get 'key groups)) + (allow-other-keys (alist-get 'allow-other-keys groups)) + (aux-vars (alist-get 'aux groups))) + (remq nil + `(and (pred listp) + ,(when whole-var + whole-var) + ,(when (or pos-vars opt-vars rest-var) + (cl--pcase-cl-arglist-positional-pattern + pos-vars opt-vars + rest-var key-vars)) + ,(when key-vars + (cond + (rest-var `(app (lambda (_) ,rest-var) + ,(cl--pcase-cl-arglist-&key-pattern + key-vars allow-other-keys))) + ((or pos-vars opt-vars) + `(app (nthcdr ,(+ (length pos-vars) + (length opt-vars))) + ,(cl--pcase-cl-arglist-&key-pattern + key-vars allow-other-keys))) + (t (cl--pcase-cl-arglist-&key-pattern + key-vars allow-other-keys)))) + ,(when aux-vars + (cl--pcase-cl-arglist-&aux-pattern aux-vars)))))) + ;; Local variables: ;; generated-autoload-file: "cl-loaddefs.el" ;; End: diff --git a/test/lisp/emacs-lisp/pcase-tests.el b/test/lisp/emacs-lisp/pcase-tests.el index 799e8d36647..108e4b96d04 100644 --- a/test/lisp/emacs-lisp/pcase-tests.el +++ b/test/lisp/emacs-lisp/pcase-tests.el @@ -160,4 +160,519 @@ pcase-tests-setq (should-error (pcase-setq a) :type '(wrong-number-of-arguments))) +;;;; Tests for the `cl-arglist' `pcase' pattern. + +(ert-deftest pcase-tests-cl-arglist-&whole-should-error () + "`&whole' must come first if given, and must be followed by a patter." + (should-error (pcase (list 1 2 3) + ((cl-arglist (&whole)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (a b &whole c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&rest a &whole c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&key a &whole c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&aux (a 1) &whole c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&optional (a 1) &whole c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&whole whole1 &whole whole2)) + (list whole1 whole2))) + :type 'cl--pcase-cl-arglist-invalid-arg-list)) + +(ert-deftest pcase-tests-cl-arglist-&whole () + "`&whole' can be a `pcase' pattern." + (should (equal (list (list 1 2 3) 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (&whole whole a b c)) + (list whole a b c))))) + + (should (equal (list 1 2 3 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (&whole `(,a0 ,b0 ,c0) a b c)) + (list a0 b0 c0 a b c)))))) + +(ert-deftest pcase-tests-cl-arglist-pos () + "Positional variables must match the length of EXPVAL." + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (a b c)) + (list a b c))))) + + (should (equal nil + (pcase (list (list 1)) + ((cl-arglist (a b)) + (list a b))))) + + (should (equal nil + (pcase (list (list 1 2 3)) + ((cl-arglist (a b)) + (list a b)))))) + +(ert-deftest pcase-tests-cl-arglist-pos-sub-patterns () + (should (equal (list 1 2 3 4) + (pcase (list 1 2 (list 3 4)) + ((cl-arglist (a b (cl-arglist (c d)))) + (list a b c d))))) + + (should (equal (list 1 2) + (pcase (list (list 1 2)) + ((cl-arglist (`(,a ,b))) + (list a b)))))) + +(ert-deftest pcase-tests-cl-arglist-&optional-should-error () + "`&optional' cannot be used after `&optional', `&rest', `&key', and `&aux'." + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (&rest a &optional b c)) + (list a b c)))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&body a &optional b c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&key a &optional b c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&allow-other-keys &optional b c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&aux (a 1) &optional b c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&optional a &optional b c)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list)) + +(ert-deftest pcase-tests-cl-arglist-&optional () + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (a b &optional c)) + (list a b c))))) + + (should (equal (list 1 2 nil) + (pcase (list 1 2) + ((cl-arglist (a b &optional c)) + (list a b c))))) + + (should (equal (list 1 2 13) + (pcase (list 1 2) + ((cl-arglist (a b &optional (c 13))) + (list a b c))))) + + (should (equal (list 1 2 13 nil) + (pcase (list 1 2) + ((cl-arglist (a b &optional (c 13 c-supplied))) + (list a b c c-supplied))))) + + (should (equal (list 1 2 3 t) + (pcase (list 1 2 3) + ((cl-arglist (a b &optional (c 13 c-supplied))) + (list a b c c-supplied)))))) + +(ert-deftest pcase-tests-cl-arglist-&optional-sub-patterns () + "Test using sub-patterns in `cl-arglist' pattern. +Sub-patterns must be contained within a sub-list, since a sub-list +also provides a default value." + (should-error (pcase (list 1 2 (list 3 4)) + ((cl-arglist (a b &optional `(,c ,d))) + (list a b c d)))) + + (should (equal (list 1 2 33) + (pcase (list 1 2) + ((cl-arglist (a b &optional ((and opt1 + (guard (numberp opt1))) + 33))) + (list a b opt1))))) + + (should (equal nil + (pcase (list 1 2 'not-num) + ((cl-arglist (a b &optional ((and opt1 + (guard (numberp opt1))) + 33))) + (list a b opt1))))) + + (should (equal nil + (pcase (list 1 2 nil) + ((cl-arglist (a b &optional ((and opt1 + (guard (numberp opt1))) + 'not-num))) + (list a b opt1))))) + + (should (equal (list 1 2 3 4) + (pcase (list 1 2 (list 3 4)) + ((cl-arglist (a b &optional (`(,c ,d)))) + (list a b c d))))) + + (should (equal (list 1 2 nil nil) + (pcase (list 1 2) + ((cl-arglist (a b &optional (`(,c ,d)))) + (list a b c d))))) + + (should (equal (list 1 2 13 14) + (pcase (list 1 2) + ((cl-arglist (a b &optional (`(,c ,d) (list 13 14)))) + (list a b c d))))) + + (should (equal (list 1 2 13 14) + (pcase (list 1 2) + ((cl-arglist ( a b + &optional ((cl-arglist (c &optional (d 14))) + (list 13)))) + (list a b c d))))) + + (should (equal (list 1 2 13 14 nil) + (pcase (list 1 2) + ((cl-arglist (a b &optional (`(,c ,d) (list 13 14) cd-supplied))) + (list a b c d cd-supplied))))) + + (should (equal (list 1 2 13 14 nil t nil) + (pcase (list 1 2) + ((cl-arglist ( a b + &optional + ((cl-arglist (&optional (c 27 c-sub-sup) + (d 14 d-sub-sup))) + (list 13) + cd-supplied))) + (list a b c d cd-supplied c-sub-sup d-sub-sup)))))) + +(ert-deftest pcase-tests-cl-arglist-&rest-should-error () + "`&rest' (`&body', `.') cannot be used after `&rest', `&body', `&key',and `&aux'." + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (&rest a &rest b)) + (list a b c)))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (&body a &body b)) + (list a b c)))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (&body a . b)) + (list a b c)))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&body a &rest b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&rest a &body b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&key a &rest b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&key a &body b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&key a . b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&allow-other-keys &rest b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&allow-other-keys &body b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&allow-other-keys . b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&aux (a 1) &rest b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&aux (a 1) &body b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list 1 2 3) + ((cl-arglist (&aux (a 1) . b)) + (list a b c))) + :type 'cl--pcase-cl-arglist-invalid-arg-list)) + +(ert-deftest pcase-tests-cl-arglist-&rest-nonlist-cdr () + (should (equal (list 1 2) + (pcase (cons 1 2) + ((cl-arglist (a &rest b)) + (list a b))))) + + (should (equal (list 1 2) + (pcase (cons 1 2) + ((cl-arglist (a &body b)) + (list a b))))) + + (should (equal (list 1 2) + (pcase (cons 1 2) + ((cl-arglist (a . b)) + (list a b)))))) + +(ert-deftest pcase-tests-cl-arglist-&rest-with-&whole () + (should (equal (list (cons 1 2) 1 2) + (pcase (cons 1 2) + ((cl-arglist (&whole whole a &rest b)) + (list whole a b))))) + + (should (equal (list (cons 1 2) 1 2) + (pcase (cons 1 2) + ((cl-arglist (&whole whole a &body b)) + (list whole a b))))) + + (should (equal (list (cons 1 2) 1 2) + (pcase (cons 1 2) + ((cl-arglist (&whole whole a . b)) + (list whole a b)))))) + +(ert-deftest pcase-tests-cl-arglist-&rest-only () + "Using only `&rest' should work like `&whole'." + (should (equal (list (list 1 2)) + (pcase (list 1 2) + ((cl-arglist (&rest a)) + (list a))))) + + (should (equal (list (cons 1 2)) + (pcase (cons 1 2) + ((cl-arglist (&body a)) + (list a)))))) + +(ert-deftest pcase-tests-cl-arglist-&rest-after-&optional () + (should (equal (list 1 2 3 (list 4 5)) + (pcase (list 1 2 3 4 5) + ((cl-arglist (&optional a b c &rest d)) + (list a b c d))))) + + (should (equal (list 1 2 3 (list 4 5)) + (pcase (list 1 2 3 4 5) + ((cl-arglist (&optional a b c &body d)) + (list a b c d))))) + + (should (equal (list 1 2 3 (list 4 5)) + (pcase (list 1 2 3 4 5) + ((cl-arglist (&optional a b c . d)) + (list a b c d)))))) + +(ert-deftest pcase-tests-cl-arglist-&rest-sub-patterns () + ;; We can't do (a . `(,b . ,c)), so we don't test that. + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (a &rest (cl-arglist (b c)))) + (list a b c))))) + + (should (equal (list 1 2 3) + (pcase (list 1 2 3) + ((cl-arglist (a &body `(,b ,c))) + (list a b c)))))) + +(ert-deftest pcase-tests-cl-arglist-&key-should-error () + "`&key' cannot be used after `&key', `&allow-other-keys', and `&aux'." + (should-error (pcase (list :a 1 :b 2) + ((cl-arglist (&key a &key b)) + (list a b))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list :a 1 :b 2) + ((cl-arglist (&aux (a 1) &key b)) + (list a b))) + :type 'cl--pcase-cl-arglist-invalid-arg-list) + + (should-error (pcase (list :a 1 :b 2) + ((cl-arglist (&allow-other-keys &key b)) + (list a b))) + :type 'cl--pcase-cl-arglist-invalid-arg-list)) + +(ert-deftest pcase-tests-cl-arglist-&key-exact () + "`&key' doesn't match unspecified keys unless `&allow-other-keys' or `:allow-other-keys' is given." + (should (equal (list 1 2) + (pcase (list :a 1 :b 2) + ((cl-arglist (&key a b)) + (list a b))))) + + (should (equal nil + (pcase (list :a 1 :b 2 :c 3) + ((cl-arglist (&key a b)) + (list a b))))) + + (should (equal (list 1 2 nil) + (pcase (list :a 1 :b 2) + ((cl-arglist (&key a b c)) + (list a b c)))))) + +(ert-deftest pcase-tests-cl-arglist-&key-permissive () + "`&key' doesn't match unspecified keys unless `&allow-other-keys' or `:allow-other-keys' is given." + (should (equal (list 1 2) + (pcase (list :a 1 :b 2 :c 3) + ((cl-arglist (&key a b &allow-other-keys)) + (list a b))))) + + (should (equal (list 1 2) + (pcase (list :a 1 :b 2 :c 3 :allow-other-keys t) + ((cl-arglist (&key a b)) + (list a b)))))) + +(ert-deftest pcase-tests-cl-arglist-&key-not-first () + "The plist should be after positional values and equal to `&rest'." + (should (equal (list 1 2 3 11 22) + (pcase (list 1 2 3 :k1 11 :k2 22) + ((cl-arglist (a b c &key k1 k2)) + (list a b c k1 k2))))) + + (should (equal (list 1 2 3 (list :k1 11 :k2 22) 11 22) + (pcase (list 1 2 3 :k1 11 :k2 22) + ((cl-arglist (a b c &rest r1 &key k1 k2)) + (list a b c r1 k1 k2)))))) + +(ert-deftest pcase-tests-cl-arglist-&key-full-form () + (should (equal (list 1 2) + (pcase (list :a 1 :b 2) + ((cl-arglist (&key a (b 13))) + (list a b))))) + + (should (equal (list 1 13) + (pcase (list :a 1) + ((cl-arglist (&key a (b 13))) + (list a b))))) + + (should (equal (list 1 13 nil) + (pcase (list :a 1) + ((cl-arglist (&key a (b 13 b-supplied))) + (list a b b-supplied))))) + + (should (equal (list 1 2 t) + (pcase (list :a 1 :b 2) + ((cl-arglist (&key a (b 13 b-supplied))) + (list a b b-supplied))))) + + (should (equal (list 1 2 t) + (pcase (list :a 1 :bat 2) + ((cl-arglist (&key a ((:bat b) 13 b-supplied))) + (list a b b-supplied))))) + + (should (equal (list 1 2 t) + (let ((key :bat)) + (pcase (list :a 1 :bat 2) + ((cl-arglist (&key a ((key b) 13 b-supplied))) + (list a b b-supplied))))))) + +(ert-deftest pcase-tests-cl-arglist-&key-sub-patterns () + (should (equal '(1 2 (:c 77 :e should-ignore) nil 77 t 99 nil) + (pcase '(:ab (1 2)) + ((cl-arglist (&key + ((:ab `(,a ,b))) + ((:cd (cl-arglist ( &whole cd + &key + (c 88 c-supp) + ((:d d) 99 d-supp) + &allow-other-keys))) + (list :c 77 :e 'should-ignore) + cd-supp))) + (list a b cd cd-supp c c-supp d d-supp))))) + + (should (equal '( 1 2 (:c 77 :e should-ignore :allow-other-keys t) nil + 77 t 99 nil) + (pcase '(:ab (1 2)) + ((cl-arglist (&key + ((:ab `(,a ,b))) + ((:cd (cl-arglist ( &whole cd + &key + (c 88 c-supp) + ((:d d) 99 d-supp)))) + (list :c 77 :e 'should-ignore + :allow-other-keys t) + cd-supp))) + (list a b cd cd-supp c c-supp d d-supp))))) + + (should (equal nil + (pcase '(:ab (1 2)) + ((cl-arglist (&key + ((:ab `(,a ,b))) + ((:cd (cl-arglist ( &whole cd + &key + (c 88 c-supp) + ((:d d) 99 d-supp)))) + (list :c 77 :e 'should-fail) + cd-supp))) + (list a b cd cd-supp c c-supp d d-supp)))))) + +(ert-deftest pcase-tests-cl-arglist-&aux-should-error () + "`&aux' cannot be used after `&aux'." + (should-error (pcase nil + ((cl-arglist (&aux a &aux b)) + (list a b))) + :type 'cl--pcase-cl-arglist-invalid-arg-list)) + +(ert-deftest pcase-tests-cl-arglist-&aux () + (should (equal (list 1 2 nil nil) + (pcase nil + ((cl-arglist (&aux (a 1) (b 2) (c) d)) + (list a b c d))))) + + (should (equal (list 0 1 2 nil nil) + (pcase (list 0) + ((cl-arglist (z0 &aux (a 1) (b 2) (c) d)) + (list z0 a b c d)))))) + +(ert-deftest pcase-tests-cl-arglist-&aux-sub-patterns () + (should (equal (list 1 2) + (pcase nil + ((cl-arglist (&aux (`(,a ,b) (list 1 2)))) + (list a b )))))) + +(ert-deftest pcase-tests-cl-arglist-all () + (should (equal '(1 2 3 4 5 (:k1 111 :k2 222) 111 222 333 444) + (pcase (list 1 2 3 4 5 :k1 111 :k2 222) + ((cl-arglist ( a b c + &optional d e + &rest r + &key k1 k2 + &aux (x1 333) (x2 444))) + (list a b c d e r k1 k2 x1 x2)))))) + ;;; pcase-tests.el ends here. -- 2.34.1 ^ permalink raw reply related [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2023-12-25 21:30 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-11 21:12 ` Stefan Kangas 2024-01-11 21:56 ` João Távora 0 siblings, 1 reply; 25+ messages in thread From: Stefan Kangas @ 2024-01-11 21:12 UTC (permalink / raw) To: Okamsn; +Cc: 67611, Stefan Monnier, joaotavora severity 67611 wishlist tags 67611 + notabug wontfix close 67611 thanks Okamsn <okamsn@protonmail.com> writes: > Hello, > > Because I wrote this patch with the thought that others might want it, I > don't have any nontrivial examples to share right now. The best example > I have for the use of the optional arguments is for the implementing of > the optional arguments, which isn't very convincing. > > I've updated the patch to rename the pattern to `cl-arglist` and to > avoid creating intermediate variables using the `let` pattern, but I'm > fine with resting the discussion here until a stronger argument can be > made in favor of the patch. > > Thank you. Thanks for the patch. I can only echo the sentiment already given here, that making `pcase' more complex won't do much for its popularity. It sounds like we mostly agree that no change should be made here, at least not for the moment, so I'm inclined to close this one as wontfix. It's always awkward to have to say no to a well-reasoned patch, but sometimes a decision has to be made. I hope you can understand, and apologies for not accepting your patch. I'm closing the bug with this message. Thank you again for contributing. ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-11 21:12 ` Stefan Kangas @ 2024-01-11 21:56 ` João Távora 2024-01-11 22:13 ` Stefan Kangas 2024-01-12 3:04 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 2 replies; 25+ messages in thread From: João Távora @ 2024-01-11 21:56 UTC (permalink / raw) To: Stefan Kangas; +Cc: Okamsn, 67611, Stefan Monnier On Thu, Jan 11, 2024 at 9:12 PM Stefan Kangas <stefankangas@gmail.com> wrote: > Thanks for the patch. I can only echo the sentiment already given here, > that making `pcase' more complex won't do much for its popularity. This sentiment is not unanimous. If pcase is naturally extensible, using that ability is not making it more complex. That'd be akin to saying "defun" is made more complex because too many functions are popping up. Just wanted register this position. Though I don't know for sure if the patch is simply adding a new extension to pcase or changing its core structure. I wish Okamsn would show one or two simple examples usage of something you can't do with pcase today, but you would be able to with the patch. João ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-11 21:56 ` João Távora @ 2024-01-11 22:13 ` Stefan Kangas 2024-01-11 22:46 ` João Távora 2024-01-12 3:04 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 1 sibling, 1 reply; 25+ messages in thread From: Stefan Kangas @ 2024-01-11 22:13 UTC (permalink / raw) To: João Távora; +Cc: Okamsn, 67611, Stefan Monnier João Távora <joaotavora@gmail.com> writes: > On Thu, Jan 11, 2024 at 9:12 PM Stefan Kangas <stefankangas@gmail.com> wrote: > >> Thanks for the patch. I can only echo the sentiment already given here, >> that making `pcase' more complex won't do much for its popularity. > > This sentiment is not unanimous. If pcase is naturally extensible, > using that ability is not making it more complex. That'd be akin > to saying "defun" is made more complex because too many functions > are popping up. > > Just wanted register this position. Though I don't know for sure if > the patch is simply adding a new extension to pcase or changing > its core structure. > > I wish Okamsn would show one or two simple examples usage > of something you can't do with pcase today, but you would be > able to with the patch. feel free to reopen the bug report if you think it makes sense. ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-11 22:13 ` Stefan Kangas @ 2024-01-11 22:46 ` João Távora 2024-01-12 0:55 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-13 6:38 ` Stefan Kangas 0 siblings, 2 replies; 25+ messages in thread From: João Távora @ 2024-01-11 22:46 UTC (permalink / raw) To: Stefan Kangas; +Cc: Okamsn, 67611, Stefan Monnier On Thu, Jan 11, 2024 at 10:13 PM Stefan Kangas <stefankangas@gmail.com> wrote: > > João Távora <joaotavora@gmail.com> writes: > > > On Thu, Jan 11, 2024 at 9:12 PM Stefan Kangas <stefankangas@gmail.com> wrote: > > > >> Thanks for the patch. I can only echo the sentiment already given here, > >> that making `pcase' more complex won't do much for its popularity. > > > > This sentiment is not unanimous. If pcase is naturally extensible, > > using that ability is not making it more complex. That'd be akin > > to saying "defun" is made more complex because too many functions > > are popping up. > > > > Just wanted register this position. Though I don't know for sure if > > the patch is simply adding a new extension to pcase or changing > > its core structure. > > > > I wish Okamsn would show one or two simple examples usage > > of something you can't do with pcase today, but you would be > > able to with the patch. In the meantime, I've had a look at the patch file to learn about this pcase extension. 1. It is a pure extension. The extension code happens in cl-macs.el 2. It is an alternative to cl-destructuring-bind, also defined in that file, with more typing involved. 3. It _seems_ it has the advantage that it relies on very little of cl-macs.el, like maybe just cl-copy-list. Ie it could easily be changed to live in another file. It could even be a (better?) base to write cl-destructuring-bind and other cl-macs things on top of. And to write other utils like Alexandria's cl-parse-ordinary-lambda-list or destructuring-case [1]. A good lambda-list destructuring tool is valuable by itself, even without pcase integration. 4. Pcase integration is a "nice to have". In the provided tests, the new extension is only tested as a destructuring aid, so I cannot tell very well how it fares int the matching aspect of pcase. For example I did this experiment: (pcase (list 42 41 :c 42) ((cl-arglist (42 42 &key c)) (list c)) ((cl-arglist (42 b &rest more)) (list b more))) This matches the second case, which is good and returns (41 (:c 42)) But how do I construct a case that matches only if the provided value to c is 42, if this is at all possible? > feel free to reopen the bug report if you think it makes sense. I think it makes sense, but I don't know how to do that. Just write reopen 67611/thanks to this tracker? João [1]: https://gitlab.common-lisp.net/alexandria/alexandria ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-11 22:46 ` João Távora @ 2024-01-12 0:55 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-13 6:38 ` Stefan Kangas 1 sibling, 0 replies; 25+ messages in thread From: Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-12 0:55 UTC (permalink / raw) To: João Távora, Stefan Kangas; +Cc: 67611, Stefan Monnier João Távora wrote: > 4. Pcase integration is a "nice to have". In the provided tests, the > new extension is only tested as a destructuring aid, so I cannot tell > very well how it fares int the matching aspect of pcase. For example > I did this experiment: > > (pcase (list 42 41 :c 42) > ((cl-arglist (42 42 &key c)) > (list c)) > ((cl-arglist (42 b &rest more)) > (list b more))) > ;; => (42 2) > This matches the second case, which is good and returns (41 (:c 42)) > > But how do I construct a case that matches only if the provided > value to c is 42, if this is at all possible? It is possible. You can give a pattern instead of a symbol for the variable, but you have to use a version of `&key` variables in which the pattern can't be confused for the normal `((KEY VAR) DEFAULT SUPPLIED)` form. Please try the following: ;; => (42 2) (pcase (list :c 42) ((cl-arglist (&key ((:c (and 43 c))))) (list c 1)) ((cl-arglist (&key ((:c (and 42 c))))) (list c 2))) ;; => (42 2) (pcase (list :c 42) ((cl-arglist (&key ((:c (and 43 c))))) (list c 1)) ((cl-arglist (&key ((:c (and (pred (equal 42)) c))))) (list c 2)) ((cl-arglist (&key ((:c (and 44 c))))) (list c 3))) ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-11 22:46 ` João Távora 2024-01-12 0:55 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-13 6:38 ` Stefan Kangas 1 sibling, 0 replies; 25+ messages in thread From: Stefan Kangas @ 2024-01-13 6:38 UTC (permalink / raw) To: João Távora; +Cc: Okamsn, 67611, Stefan Monnier João Távora <joaotavora@gmail.com> writes: > I think it makes sense, but I don't know how to do that. Just write > reopen 67611/thanks to this tracker? Yes, on two separate lines to the control@ address. ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-11 21:56 ` João Távora 2024-01-11 22:13 ` Stefan Kangas @ 2024-01-12 3:04 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-12 10:46 ` João Távora 1 sibling, 1 reply; 25+ messages in thread From: Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-12 3:04 UTC (permalink / raw) To: João Távora; +Cc: Okamsn, 67611, Stefan Kangas >> Thanks for the patch. I can only echo the sentiment already given here, >> that making `pcase' more complex won't do much for its popularity. > This sentiment is not unanimous. If pcase is naturally extensible, > using that ability is not making it more complex. That'd be akin > to saying "defun" is made more complex because too many functions > are popping up. Agreed. > Just wanted register this position. Though I don't know for sure if > the patch is simply adding a new extension to pcase or changing > its core structure. It's a pure extension. The question is not whether the patch is good or bad or whether it makes the existing infrastructure too complex. It's rather where should such a thing live. I don't think there's a clear enough need for it right now in Emacs core to motivate its integration in Emacs proper. Also, because several people have expressed an opinion that leans towards recommending that Emacs's own code should probably better avoid using this functionality. I'd be quite happy to include such a think in GNU ELPA, OTOH. Stefan ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-12 3:04 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-12 10:46 ` João Távora 2024-01-12 15:38 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 0 siblings, 1 reply; 25+ messages in thread From: João Távora @ 2024-01-12 10:46 UTC (permalink / raw) To: Stefan Monnier; +Cc: Okamsn, 67611, Stefan Kangas [-- Attachment #1: Type: text/plain, Size: 2140 bytes --] On Fri, Jan 12, 2024 at 3:05 AM Stefan Monnier <monnier@iro.umontreal.ca> wrote: > I don't think there's a clear enough need for it right now in Emacs core > to motivate its integration in Emacs proper. Also, because several > people have expressed an opinion that leans towards recommending that > Emacs's own code should probably better avoid using this functionality. Those people are trying to come up with alternative pattern-matching libraries which we start to see are not simpler or as powerful as pcase. But sure, other pattern-matching libraries exist out there. See CL's optima/trivia [1/2] for some very good ones. Emacs just happens to have pcase readily available. > I'd be quite happy to include such a think in GNU ELPA, OTOH. Could be, but why really? Why are CL things which rest on such high-quality well-known designs, older than many things Emacs, relegated to a place where they're less discoverable? Here, I think at least the new fresh implementation of lambda-list parsing (which is the meat-and-bones of this patch) is worth taking a look at. It's the function 'cl--pcase-cl-lambda-var-groups'. I would definitely consider grooming this function, renaming it, and keeping it in core, exposing to general Elisp usage in cl-macs.el (or cl-lambdalist.el, cl-ll.el), even if a new pcase pattern that uses it goes to ELPA (but why, really?) That util could help us write other lambda-list destructuring alternatives that understand &optional, &rest. Because with or without it, we already use a lot of the &optional, &rest explicitly in Emacs. And we also use &key and &allow-other-keys in many other places, though sometimes in ad-hoc lets-not-call-this-bull-by-its-name fashion. IOW there is no general purpose-util like Alexandria's 'parse-ordinary-lambda-list', and this could be it. It could not only be used to simplify and add coherence to many of these existing compile-time structures, for example helping simplify things and address FIXMEs in cl-lib.el. João [1] https://github.com/m2ym/optima [2] https://github.com/guicho271828/trivia [-- Attachment #2: Type: text/html, Size: 2723 bytes --] ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-12 10:46 ` João Távora @ 2024-01-12 15:38 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-12 16:56 ` João Távora 2024-01-14 3:08 ` Richard Stallman 0 siblings, 2 replies; 25+ messages in thread From: Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-12 15:38 UTC (permalink / raw) To: João Távora; +Cc: Okamsn, 67611, Stefan Kangas >> I don't think there's a clear enough need for it right now in Emacs core >> to motivate its integration in Emacs proper. Also, because several >> people have expressed an opinion that leans towards recommending that >> Emacs's own code should probably better avoid using this functionality. > Those people are trying to come up with alternative pattern-matching > libraries which we start to see are not simpler or as powerful > as pcase. Only some of them are. Others are perfectly happy with using `pcase` but still aren't super happy about combining the complexity of `pcase` with that of CL destructuring syntax. Personally I'm rather put off by the difficulty of figuring out which part is using CL syntax and which part is using Pcase: the transition from Pcase to CL is fairly clear (marked by `cl-arglist` or somesuch), but the other is much less so. I'd be happier with a `cl-arglist` which cannot contain nested Pcase patterns (i.e. a one-way street from Pcase to CL) with `cl-destructuring-bind` reimplemented on top of it. I'd also be interested in a new Pcase pattern that provides the part of `cl-arglist` functionality that's missing from current Pcase patterns (like "optional" elements in a list), but with a syntax that blends better in Pcase patterns. > IOW there is no general purpose-util like Alexandria's > 'parse-ordinary-lambda-list', and this could be it. It could > not only be used to simplify and add coherence to many of these > existing compile-time structures, for example helping simplify > things and address FIXMEs in cl-lib.el. That's a different question: improving up cl-lib's implementation would be welcome, yes. That's not what the current patch does, tho. Stefan ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-12 15:38 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2024-01-12 16:56 ` João Távora 2024-01-13 6:58 ` Stefan Kangas 2024-01-14 3:08 ` Richard Stallman 1 sibling, 1 reply; 25+ messages in thread From: João Távora @ 2024-01-12 16:56 UTC (permalink / raw) To: Stefan Monnier; +Cc: Okamsn, 67611, Stefan Kangas reopen 67611 thanks On Fri, Jan 12, 2024 at 3:38 PM Stefan Monnier <monnier@iro.umontreal.ca> wrote: > > >> I don't think there's a clear enough need for it right now in Emacs core > >> to motivate its integration in Emacs proper. Also, because several > >> people have expressed an opinion that leans towards recommending that > >> Emacs's own code should probably better avoid using this functionality. > > Those people are trying to come up with alternative pattern-matching > > libraries which we start to see are not simpler or as powerful > > as pcase. > > Only some of them are. Others are perfectly happy with using `pcase` > but still aren't super happy about combining the complexity of `pcase` > with that of CL destructuring syntax. > > Personally I'm rather put off by the difficulty of figuring out which > part is using CL syntax and which part is using Pcase: the transition > from Pcase to CL is fairly clear (marked by `cl-arglist` or somesuch), > but the other is much less so. > I'd be happier with a `cl-arglist` which cannot contain nested Pcase > patterns (i.e. a one-way street from Pcase to CL) with > `cl-destructuring-bind` reimplemented on top of it. Can a pcase extension even be a one-way street? And if so, isn't that contrary to the whole purpose of pcase itself? Why have this ban specifically on a CL pattern (should really be called "lambda-list" by the way) when we have a cl library in core and so many uses of CL things that use CL-style lambda lists, with or without cl-*.el. We have so many other less commonly used extensions, some of them subtle performance problems, like seq extensions that rely on generic functions. Pcase is complicated and hard-to-follow yes. Becasue complex pattern matching is a complicated thing to express, just as regular expressions are such a thing (I for one do not think 'rx' makes things particularly simpler). If you ask me, we'd be better off designing an "explain pcase" utility or designing font-lock rules that helps explain it. The byte-compiler is already traversing that anyway and flagging unused variables and stuff. Can't we use this to mark what is a lexical variable and what is a literal symbol, for example? Can't we have a very clear highlighting of the pcase extension being used, like highlighting the '`' or the 'cl-arglist' or the 'seq'. > I'd also be interested in a new Pcase pattern that provides the part of > `cl-arglist` functionality that's missing from current Pcase patterns > (like "optional" elements in a list), but with a syntax that blends > better in Pcase patterns. I'd rather not reinvent half-baked CL things, as it's all too common to discover later we should have gone full-baked and we have digressed for no good reason. > > IOW there is no general purpose-util like Alexandria's > > 'parse-ordinary-lambda-list', and this could be it. It could > > not only be used to simplify and add coherence to many of these > > existing compile-time structures, for example helping simplify > > things and address FIXMEs in cl-lib.el. > > That's a different question: improving up cl-lib's implementation would > be welcome, yes. That's not what the current patch does, tho. It provides a tool to help do that, of course. Anyway if there's some common ground here, let's not throw the entire baby out with the bathwater. Maybe Okamsn can repurpose the helper function he created to parse lambda lists to be akin to Alexandria's parse-simple-lambda-list. It seems it already is fairly close (the alist retun type in Elisp is natural as we don't have multiple values). Also the function's implementaion should be changed to rely on as little as possible of existing cl-macs (cl-copy-list and cl-flet can maybe be skipped -- and maybe added back again later). Shoulnd't be a very hard job (I might be wrong). Then we can consider merging that including figuring out where to merge it. And then we can continue discussing about the usefulness the pcase patterns that can be built with it, sure. I've reopened the bug. João ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-12 16:56 ` João Távora @ 2024-01-13 6:58 ` Stefan Kangas 0 siblings, 0 replies; 25+ messages in thread From: Stefan Kangas @ 2024-01-13 6:58 UTC (permalink / raw) To: João Távora, Stefan Monnier; +Cc: Okamsn, 67611 João Távora <joaotavora@gmail.com> writes: > Pcase is complicated and hard-to-follow yes. Becasue complex pattern > matching is a complicated thing to express, just as regular expressions > are such a thing Pretty much, yes. We could improve its documentation though. We could add a tutorial to the ELisp manual, for example (probably not included in the printed version). > If you ask me, we'd be better off designing an "explain pcase" > utility or designing font-lock rules that helps explain it. > > The byte-compiler is already traversing that anyway and flagging > unused variables and stuff. Can't we use this to mark what is a > lexical variable and what is a literal symbol, for example? Can't > we have a very clear highlighting of the pcase extension being > used, like highlighting the '`' or the 'cl-arglist' or the 'seq'. That would be very useful to explore, I think. ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-12 15:38 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-12 16:56 ` João Távora @ 2024-01-14 3:08 ` Richard Stallman 2024-01-14 3:12 ` João Távora 1 sibling, 1 reply; 25+ messages in thread From: Richard Stallman @ 2024-01-14 3:08 UTC (permalink / raw) To: Stefan Monnier; +Cc: okamsn, 67611, joaotavora, stefankangas [[[ To any NSA and FBI agents reading my email: please consider ]]] [[[ whether defending the US Constitution against all enemies, ]]] [[[ foreign or domestic, requires you to follow Snowden's example. ]]] Would someone please tell me what syntax is being proposed here, and show me an example, saying what it would mean? I would like to try to adapt it it to cond*. Maybe I could make it simple enough for people to like it. -- Dr Richard Stallman (https://stallman.org) Chief GNUisance of the GNU Project (https://gnu.org) Founder, Free Software Foundation (https://fsf.org) Internet Hall-of-Famer (https://internethalloffame.org) ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-14 3:08 ` Richard Stallman @ 2024-01-14 3:12 ` João Távora 2024-01-17 3:29 ` Richard Stallman 0 siblings, 1 reply; 25+ messages in thread From: João Távora @ 2024-01-14 3:12 UTC (permalink / raw) To: Richard Stallman; +Cc: okamsn, 67611, Stefan Monnier, stefankangas Richard Stallman <rms@gnu.org> writes: > Would someone please tell me what syntax is being proposed here, > and show me an example, saying what it would mean? Common-lisp style lambda lists. The ones containing the &key and &optional with more features. It'd make it possible to use pcase for things similar to cl-destructuring-bind, which I suppose you know. ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-14 3:12 ` João Távora @ 2024-01-17 3:29 ` Richard Stallman 2024-01-17 9:12 ` João Távora 0 siblings, 1 reply; 25+ messages in thread From: Richard Stallman @ 2024-01-17 3:29 UTC (permalink / raw) To: João Távora; +Cc: 67611 [[[ To any NSA and FBI agents reading my email: please consider ]]] [[[ whether defending the US Constitution against all enemies, ]]] [[[ foreign or domestic, requires you to follow Snowden's example. ]]] > > Would someone please tell me what syntax is being proposed here, > > and show me an example, saying what it would mean? > Common-lisp style lambda lists. The ones containing the &key and > &optional with more features. Thanks for answering, but its meaning is not concretely clear to me. Could you tell me more concretely what this proposed feature would look like in use? Perhaps with an example including context? pcase does not use lambda lists, and neither does cond*. They are based on the backquote construct, which does not use &-keywords. I see a danger of conceptual incoherence here. If we want to extend the kinds of constructs for destructuring lists, we should extend the features of backquote. That would give a more coherent interface. We could define ,? to specify an element that might br missing, and ,& to specify a keyword argument. These could work in backquote for constructing lists as well as in destructiring. (let ((x 9) (y 10) (z nil) (u 11) (v nil) (w '(12 13))) `(a ,x ,?y ,?z ,&(foo u) ,&(bar v) . ,w)) => (a 9 10 foo 11 12 13) That is my first stab at the design. I think it is better, for this purpose, than using parmlist keywords. But maybe with more thinking we can find improvements. -- Dr Richard Stallman (https://stallman.org) Chief GNUisance of the GNU Project (https://gnu.org) Founder, Free Software Foundation (https://fsf.org) Internet Hall-of-Famer (https://internethalloffame.org) ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-17 3:29 ` Richard Stallman @ 2024-01-17 9:12 ` João Távora 2024-02-08 3:49 ` Richard Stallman 0 siblings, 1 reply; 25+ messages in thread From: João Távora @ 2024-01-17 9:12 UTC (permalink / raw) To: rms; +Cc: 67611 On Wed, Jan 17, 2024 at 3:29 AM Richard Stallman <rms@gnu.org> wrote: > Could you tell me more concretely what this proposed feature would > look like in use? Perhaps with an example including context? Many examples in the patch, have you looked? > pcase does not use lambda lists, and neither does cond*. Pcase it extensible for any object structure the user may think of you can think of. This proposal is an extension. Here's an example (pcase some-mistery-object ((cl-arglist (42 &key a b c)) ; this proposal (message "Oh, it starts it 42 and has c=%s" c)) (`(,_ ,x ,_) (message "Boring three-element list with middle %s" x)) (`[,_ ,x ,_] (message "Fancy vector with middle %s" x)) ((franklinboing (nixneez)) ; my data-structure (message "This franklinboing has some nice nixneez %s=" nizneez))) João ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-01-17 9:12 ` João Távora @ 2024-02-08 3:49 ` Richard Stallman 2024-02-08 13:41 ` João Távora 0 siblings, 1 reply; 25+ messages in thread From: Richard Stallman @ 2024-02-08 3:49 UTC (permalink / raw) To: João Távora; +Cc: 67611 [[[ To any NSA and FBI agents reading my email: please consider ]]] [[[ whether defending the US Constitution against all enemies, ]]] [[[ foreign or domestic, requires you to follow Snowden's example. ]]] > > Could you tell me more concretely what this proposed feature would > > look like in use? Perhaps with an example including context? > Many examples in the patch, have you looked? I would not think of looking at a patch to code I don't understand. To try to read and understand such a patch would be doing it the hard way, and not wise. Instead I asked you to send me examples so I could get that information the easy way. The examples in your patch could have done it if you had send me those examples separatrly. It's far more helpful to send an example than to say, "Look through the patch for some." > (pcase some-mistery-object > ((cl-arglist (42 &key a b c)) ; this proposal > (message "Oh, it starts it 42 and has c=%s" c)) > (`(,_ ,x ,_) > (message "Boring three-element list with middle %s" x)) > (`[,_ ,x ,_] > (message "Fancy vector with middle %s" x)) > ((franklinboing (nixneez)) ; my data-structure > (message "This franklinboing has some nice nixneez %s=" nizneez))) Thanks. Now I understand what your extension would be. -- Dr Richard Stallman (https://stallman.org) Chief GNUisance of the GNU Project (https://gnu.org) Founder, Free Software Foundation (https://fsf.org) Internet Hall-of-Famer (https://internethalloffame.org) ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-02-08 3:49 ` Richard Stallman @ 2024-02-08 13:41 ` João Távora 2024-02-11 3:28 ` Richard Stallman 0 siblings, 1 reply; 25+ messages in thread From: João Távora @ 2024-02-08 13:41 UTC (permalink / raw) To: rms; +Cc: 67611 On Thu, Feb 8, 2024 at 3:49 AM Richard Stallman <rms@gnu.org> wrote: > > [[[ To any NSA and FBI agents reading my email: please consider ]]] > [[[ whether defending the US Constitution against all enemies, ]]] > [[[ foreign or domestic, requires you to follow Snowden's example. ]]] > > > > Could you tell me more concretely what this proposed feature would > > > look like in use? Perhaps with an example including context? > examples separatrly. It's far more helpful to send an example than to > say, "Look through the patch for some." You do this very often where you ask someone to summarize or explain context just for you. That's perfectly fine, you're polite and not generally imposing. But since we're all busy individuals, I also think it's fine to point out that what you're looking for is close by. > > (pcase some-mistery-object > > ((cl-arglist (42 &key a b c)) ; this proposal > > (message "Oh, it starts it 42 and has c=%s" c)) > > (`(,_ ,x ,_) > > (message "Boring three-element list with middle %s" x)) > > (`[,_ ,x ,_] > > (message "Fancy vector with middle %s" x)) > > ((franklinboing (nixneez)) ; my data-structure > > (message "This franklinboing has some nice nixneez %s=" nizneez))) > > Thanks. Now I understand what your extension would be. This is very similar from what you find in the patch in the form of ert tests. Also it's not my extension. Thanks, João ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-02-08 13:41 ` João Távora @ 2024-02-11 3:28 ` Richard Stallman 2024-02-12 15:25 ` João Távora 0 siblings, 1 reply; 25+ messages in thread From: Richard Stallman @ 2024-02-11 3:28 UTC (permalink / raw) To: João Távora; +Cc: 67611 [[[ To any NSA and FBI agents reading my email: please consider ]]] [[[ whether defending the US Constitution against all enemies, ]]] [[[ foreign or domestic, requires you to follow Snowden's example. ]]] > But since we're all busy individuals, I also think > it's fine to point out that what you're looking for is close by. Thousands of incoming messages are close by in that same sense. 26 of them have this same Subject line. To find a specific one, not by a string that uniquiely identifies it but by understanding what each one says, would take a long time. Then I would have to look through the patch for examples. That would be easy if the patch is short, but I don't know how long it is. If I made a habit of searching for everything myself rather than asking for help from people who might find it quickly, I would fall even more behind. Thank you for helping me keep up. > Also it's not my extension. I did not know who had wrote it, and I didn't intend the request to be only to you. -- Dr Richard Stallman (https://stallman.org) Chief GNUisance of the GNU Project (https://gnu.org) Founder, Free Software Foundation (https://fsf.org) Internet Hall-of-Famer (https://internethalloffame.org) ^ permalink raw reply [flat|nested] 25+ messages in thread
* bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` 2024-02-11 3:28 ` Richard Stallman @ 2024-02-12 15:25 ` João Távora 0 siblings, 0 replies; 25+ messages in thread From: João Távora @ 2024-02-12 15:25 UTC (permalink / raw) To: rms; +Cc: 67611 [-- Attachment #1: Type: text/plain, Size: 780 bytes --] On Sun, Feb 11, 2024 at 3:28 AM Richard Stallman <rms@gnu.org> wrote: > If I made a habit of searching for everything myself rather than > asking for help from people who might find it quickly, I would fall > even more behind. I think your stance makes sense in an employer-employee relationship. Personally, I don't search for "everything", just "some of it". It's a balance worth honing. As I wrote, asking is fine, so is replying that the answer is nearby. Sometimes I ask (in fact I did here, if you care to look up), sometimes the answer really is nearby and it's just a question of using a MUA to read up-thread. You're free to ignore this advice, of course, I'm just supplying it since you took issue with my "examples are in the patch". João [-- Attachment #2: Type: text/html, Size: 1156 bytes --] ^ permalink raw reply [flat|nested] 25+ messages in thread
end of thread, other threads:[~2024-02-12 15:25 UTC | newest] Thread overview: 25+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2023-12-03 20:33 bug#67611: [PATCH] Add a Pcase pattern `cl-lambda` equivalent to `cl-destructuring-bind` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-04 19:08 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 2:42 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2023-12-05 9:26 ` João Távora 2023-12-05 9:21 ` João Távora 2023-12-25 21:30 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-11 21:12 ` Stefan Kangas 2024-01-11 21:56 ` João Távora 2024-01-11 22:13 ` Stefan Kangas 2024-01-11 22:46 ` João Távora 2024-01-12 0:55 ` Okamsn via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-13 6:38 ` Stefan Kangas 2024-01-12 3:04 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-12 10:46 ` João Távora 2024-01-12 15:38 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors 2024-01-12 16:56 ` João Távora 2024-01-13 6:58 ` Stefan Kangas 2024-01-14 3:08 ` Richard Stallman 2024-01-14 3:12 ` João Távora 2024-01-17 3:29 ` Richard Stallman 2024-01-17 9:12 ` João Távora 2024-02-08 3:49 ` Richard Stallman 2024-02-08 13:41 ` João Távora 2024-02-11 3:28 ` Richard Stallman 2024-02-12 15:25 ` João Távora
Code repositories for project(s) associated with this public inbox https://git.savannah.gnu.org/cgit/emacs.git This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).