Re: Instead of pcase

["João Távora" <joaotavora@gmail.com>]

On Fri, Dec 1, 2023 at 6:31 AM Eli Zaretskii <eliz@gnu.org> wrote:

> The validity is not the point I wanted to make.  The point I wanted to
> make is that the accepted syntax includes unusual uses of the period
> and other punctuation, some of which have special meaning.  And that
> makes the code harder to read and understand.
>
> Incidentally, the actual code from which this were taken is
>
>       (`(,hookfun . (,start ,end ,collection . ,plist))
>
> Which has _two_ periods, not one, which are AFAIU redundant, as far as
> the Lisp reader is concerned.

They are NOT redundant.  Meaning you can't simply take them out
and have the expression mean the same: that's what "redundant"
means to me, at least.

But like so often in programming, there are different ways to say the same.
In pcase as in normal list-making life, the above form is the same as.

  (`(,hookfun ,start ,end ,collection . plist))

So while it's reasonable to take issue with the author's choice of one
of many equivalent list-representing constructs, I don't think one
should blame their choice of 'pcase' here.

Personally, I don't really fault the author too much in this
case: if the thing to be destructured were an entry of an alist, I
actually like to see things represented in the original alternative.

As you probably know, one as a maintainer often has to work with
data structures that one didn't invent and wishes weren't like
they are.  Very often these structures are contorted, incrementally
evolving lists where certain positional elements mean certain things
for the structure.  One may be completely innocent of inventing
this spaghetti and yet one has to work with it.  This happens very
frequently in Emacs, it certainly happens to me.

> > IMO what's relatively contrived in pcase-- but very well contrived
> > I should add -- is the use of the backtick and comma, whose
> > usual job is output and list construction, to do the reverse,
> > to express input and list destructure.
>
> Again, the point is not that the construct cannot be explained away or
> interpreted correctly given enough time and consulting the docs.

First, I'd like to say that when I first met pcase, I used to share
your views and now I don't.  It's not that I encounter pcase on
constantly these days (I don't), it's just that I quickly changed my
view once someone gave me a piece of insight about it.  That insight
has already surfaced here, but perhaps has not been underlined enough.

So, in these emails, I'm trying to explain to you how to change your
view of these pcase constructs in a constructive way, to help speed
up your understanding of important parts of our code base.  I hope
this message gets across.  If you've already decided you will never
understand 'pcase' and will forever reach for the docs, that's a
legitimate  position, but it also means I can't be much help in
this sub-discussion.

It is _easy_ to explain that "scary" construct _if_ you learn to _lean_
on what should be probably existing knowledge.  No doc-consulting
necessary.

You take a backtick-starting construct with as many scary periods
things as you can find and then, say

`(,foo . (,bar . ,baz))

And then ask yourself: "what kind of list does this build if I just
let-bind foo, bar and baz to 42?". And then you answer yourself
"Why, it's the improper list (42 42 . 42) made up of just two cons
cells and 3 fixnums!".  So _that's_ the kind of list that can be
destructured with the pcase expression.

This solves the reading problem.  Now the writing problem. To author
new pcase patterns one uses more or less the same process.  One again
leans on one's existing knowledge of how the list structure would be
expressed with backtick-and-quote.  So once you know the list
structure in your mind you write it as a backtick-and-quote expression,
just as if you were going to craft that list (though you aren't of
course).  Then once you're happy with your expression, you may take it
and you put it in one of the BINDINGS left-hand part of a 'let'.
Then you rename that 'let' to 'pcase-let' and away you go!

HTH