Re: Replace trivial pcase occurrences in the Emacs sources

[Joost Kremers <joostkremers@fastmail.fm>]

On Wed, Oct 24, 2018 at 12:51:35AM -0400, Richard Stallman 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. ]]]
> 
>   > In what sense is the above cl-case more clear than the pcase equivalent?
>   > I'm not saying the pcase version is better in those cases, but I think
>   > the respective advantages and disadvantages pretty much balance out.
> 
> I also wonder.  Is it simply that people find pcase unfamiliar?

Well, I can't speak for others, but personally, though I find pattern matching as a concept straightforward and intuitive, pcase syntax seems unnecessarily complex and unintuitive.

For example, John Wiegley's tutorial on pcase at <http://newartisans.com/2016/01/pattern-matching-with-pcase/> has the following example:

```
(pcase value
  (`(,_ 1 2)
   (message "Matched a list of anything followed by (1 2)")))
```

It is not clear to me why I couldn't simply write:

```
(pcase value
  ((_ 1 2)
   (message "Matched a list of anything followed by (1 2)")))
```

I *can* understand the need to write:

```
(pcase value
  (`(1 2 ,foo 3)
   (message "Matched 1, 2, something now bound to foo, and 3")))
```

Instead of:

```
(pcase value
  ((1 2 foo 3)
   (message "Matched 1, 2, something now bound to foo, and 3")))
```

This is obviously done in order to be able to match against the symbol `foo' while at the same time be able to match anything and bind it to the symbol `foo'. And even though this syntax with backquote and comma looks familiar to anyone who's ever written a macro, their meaning is subtly different from their meaning in macros. In pcase, «,foo» does *not* mean «evaluate `foo'», it means something like «use `foo' as a variable».

So, while I understand the reasoning, it still makes me wonder why I can't write something like this:

```
(pcase value
  ((1 2 % 3)
   (message "Matched 1, 2, something now bound to %, and 3")))
```

That is, use a special symbol (I borrowed % from Clojure's anonymous functions) to indicate that I want to match against any value and at the same time bind that value. Obviously, the following:

```
(pcase value
  ((1 2 % %)
   (message "Matched 1, 2, something now bound to %, and that same something again")))
```

would then match lists of the form (1 2 3 3), not (1 2 3 4). If you need to bind multiple values, I could imagine using something like:

```
(pcase value
  ((1 2 %1 %2)
   (message "Matched 1, 2, something now bound to %1, and something (else) bound to %2")))
```

Also, the use of `pred' and `guard' seem unnecessary. Instead of:

```
(pcase value
  (`(1 2 ,(or 3 4)
     ,(and (pred stringp)
           (pred (string> "aaa"))
           (pred (lambda (x) (> (length x) 10)))))
   (message "Matched 1, 2, 3 or 4, and a long string "
            "that is lexically greater than 'aaa'")))
```

why not write:

```
(pcase value
  ((1 2 (or 3 4)
    (and (stringp %)
         (string> "aaa" %)
         (> (length %) 10)))
   (message "Matched 1, 2, 3 or 4, and a long string "
            "that is lexically greater than 'aaa'")))
```

Similarly, the example:

```
(pcase value
  (`(1 2 ,(and foo (guard (and (not (numberp foo)) (/= foo 10)))) _)
   (message "Matched 1, 2, anything, and then anything again, "
            "but only if the first anything wasn't the number 10"))))
```

uses `(and foo (guard ...))' to bind a value to `foo' and apply a predicate to it. That's a coding pattern that you need to be familiar with in order to understand what it does. (John explains it in his tutorial, but if I had met this in the wild, I'd probably be puzzled by it at first). The % syntax would seem to make this simpler as well:

```
(pcase value
  ((1 2 (and (not (numberp %)) (/= % 10)) _)
   (message "Matched 1, 2, anything, and then anything again, "
            "but only if the first anything wasn't the number 10"))))
```

This example also shows that `and' has a meaning in pcase that is subtly different from its usual meaning in Lisp: `and' in a pcase 'UPattern' (as the manual calls it) is not a logical `and' in the sense that it tests its arguments for truthiness. Rather, it means «both arguments of `and' must apply to the value at this position *regardless of truthiness*». (The `and' inside the guard does have the usual meaning, of course.)

Mind you, I'm not arguing that pcase should be changed or replaced with something that has this more intuitive (to me, anyway) syntax. I'm just trying to explain why I personally find pcase difficult to wrap my head around, and why I think this difficulty has to do with its syntax, which is different in subtle ways, to such an extent that you can't, as an Elisp programmer tackling pcase for the first time, just build on what you already know. You need to actually bend your mind to incorporate the new stuff. Moreover, at first sight, there doesn't seem to be much of an advantage to this syntax, since an alternative syntax that doesn't have the same disadvantage seems feasible.

I say "seems", because it's entirely possible that this particular syntax has capabilities that wouldn't be possible with a simpler syntax. But for a pcase newbie, that's not immediately obvious. The only reason that I can think of why the %-syntax or something similar isn't used is that it's dangerous in an environment that doesn't have lexical scope...

Just my two cents, of course.


-- 
Joost Kremers
Life has its moments