Re: How to extract bindings from `pcase-let*`?

[Stefan Monnier]

>      ;; => ((1 4) (3 6))
>      (loopy (flag pcase)
>             (list elem '((1 (2 3)) (4 (5 6))))
>             (collect `(,a (,_ ,b)) elem))
>
> in which the `collect` expression expands into something like
>
>      (setq a (append a (list some-value-from-elem)))
>      (setq b (append b (list some-other-value-from-elem)))
>
> where `some-value-from-elem` and `some-other-value-from-elem` are
> determined by Pcase, Dash, or other destructuring systems.
>
> Do you think that this is doable using Pcase?

You could do something like:

    (pcase--u `((,(pcase--match INCOMING (pcase--macroexpand PATTERN))
                 ,(lambda (vars)
                    `(progn
                      . ,(mapcar (lambda (v) `(push ,(cadr v) ,(car v)))
                                 vars))))))

where INCOMING is the incoming data (`elem` in your above example).

As the `--` in there suggest, this is digging into pcase's internals.
I think this code will work with Emacs-28 but the `cadr` would need to
be replaced with `cdr` in earlier versions.

Also, this does a `pcase` rather than a `pcase-let` so it will just
silently do nothing if the pattern doesn't match.  You can force the
`pcase-let` semantics with something like:

    (pcase--u `((,(pcase--match INCOMING
                                (pcase--macroexpand
                                 `(or ,PATTERN pcase--dontcare)))
                 ,(lambda (vars)
                    `(progn
                      . ,(mapcar (lambda (v) `(push ,(cadr v) ,(car v)))
                                 vars))))))

See IELM session below.  I suggest you `M-x report-emacs-bug` to request
that this functionality be made accessible without having to rely on
internals (and put me in the `X-Debbugs-Cc` when you do that).


        Stefan


PS: I used `push` rather than your `setq+append+list` since it is
algorithmically much better behaved (linear instead of quadratic
complexity).


ELISP> (pcase--u `((,(pcase--match 'elem
                                   (pcase--macroexpand
                                    '(or `(,a (,_ ,b)) pcase--dontcare)))
                    ,(lambda (vars)
                       `(progn
                         . ,(mapcar (lambda (v) `(push ,(cadr v) ,(car v)))
                                    vars))))))
(progn
  (ignore (consp elem))
  (let* ((x1507 (car-safe elem))
         (x1508 (cdr-safe elem)))
    (progn (ignore (consp x1508))
           (let* ((x1509 (car-safe x1508)))
             (progn (ignore (consp x1509))
                    (let* ((x1511 (cdr-safe x1509)))
                      (progn (ignore (consp x1511))
                             (let* ((x1512 (car-safe x1511))
                                    (x1513 (cdr-safe x1511)))
                               (progn (ignore (null x1513))
                                      (let* ((x1514 (cdr-safe x1508)))
                                        (progn (ignore (null x1514))
                                               (progn (push x1512 b)
                                                      (push x1507 a)))))))))))))

ELISP>