Quick pcase question

Quick pcase question

[Eric Abrahamsen]

I'm enjoying pcase quite a bit, particular when employed as a kind of
improved destructuring-bind. I think I've got the hang of most of it
(despite the docs being a bit... succinct), but have one leftover
question I keep running into.

What I want to do is: "if this atom matches a predicate, the whole
pattern matches, and also bind the atom to this local variable."

Right now I'm making that work like this:

(setq tst '(symbolla . "I'm the string"))

(pcase tst
  (`(symbolla . ,(and x (pred stringp)))
   (message "cdr is a string: %s" x)))

Is the ",(and x (pred stringp))" part really the simplest way of doing
that? It just seems a little unintuitive.

Thanks,
Eric

Re: Quick pcase question

[Michael Heerdegen]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> (pcase tst
>   (`(symbolla . ,(and x (pred stringp)))
>    (message "cdr is a string: %s" x)))
>
> Is the ",(and x (pred stringp))" part really the simplest way of doing
> that?

Yes, I think so.

How could it be much simpler (there is not much redundancy in that
expression)?


Michael

Re: Quick pcase question

[Eric Abrahamsen]

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> (pcase tst
>>   (`(symbolla . ,(and x (pred stringp)))
>>    (message "cdr is a string: %s" x)))
>>
>> Is the ",(and x (pred stringp))" part really the simplest way of doing
>> that?
>
> Yes, I think so.
>
> How could it be much simpler (there is not much redundancy in that
> expression)?

It's not so much the simplicity, I guess, as the intuitiveness -- "(and x"
looks like a test to me, not an assignment. My brain would prefer:

(,x (pred stringp))

But there's no reason to listen to my brain :)

Thanks,
Eric

Re: Quick pcase question

[Michael Heerdegen]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> It's not so much the simplicity, I guess, as the intuitiveness --
> "(and x" looks like a test to me, not an assignment.

That's a valid point, I think.

Maybe it would be better to avoid reusing names of frequently used
functions.  We could e.g. use "all" or "every" instead of "and", "any"
or "some" instead of "or", and "bind" instead of "let", to avoid
misleading associations in our brains.


Regards,

Michael.

Re: Quick pcase question

[Eric Abrahamsen]

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> It's not so much the simplicity, I guess, as the intuitiveness --
>> "(and x" looks like a test to me, not an assignment.
>
> That's a valid point, I think.
>
> Maybe it would be better to avoid reusing names of frequently used
> functions.  We could e.g. use "all" or "every" instead of "and", "any"
> or "some" instead of "or", and "bind" instead of "let", to avoid
> misleading associations in our brains.

I like the idea of variable assignment being a syntax thing -- it should
be obvious from the position of the symbol within the pcase test that
it's an assignment. Not that I'm really expecting the pcase syntax to
change because of my complaint!

But the fact is that pcase is (very complex and very useful) syntax
sugar. I just wrote a pcase clause that looks like:

`((,(and f-string (pred stringp)) . ,(and class (pred symbolp))) . ,(and regexp (pred stringp)))

And that's kind of awful. The whole point of pcase should be concision,
but that looks pretty terrible.

Anyway, I'm just trying to get used to all the new toys...

E

Re: Quick pcase question

[Michael Heerdegen]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> But the fact is that pcase is (very complex and very useful) syntax
> sugar. I just wrote a pcase clause that looks like:
>
> `((,(and f-string (pred stringp)) . ,(and class (pred symbolp)))
> . ,(and regexp (pred stringp)))
>
> And that's kind of awful. The whole point of pcase should be concision,
> but that looks pretty terrible.

:-P

Maybe separate the testing and the binding operations, like:


#+begin_src emacs-lisp

  (and `((,(pred stringp) . ,(pred symbolp)) . ,(pred stringp))
       `((,f-string       . ,class         ) . ,regexp))

#+end_src


Regards,

Michael.

Re: Quick pcase question

[Phillip Lord]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> I'm enjoying pcase quite a bit, particular when employed as a kind of
> improved destructuring-bind. I think I've got the hang of most of it
> (despite the docs being a bit... succinct)

They are being improved! It might be worth looking at the docs in
the Emacs-25 pre-releases.


> What I want to do is: "if this atom matches a predicate, the whole
> pattern matches, and also bind the atom to this local variable."
>
> Right now I'm making that work like this:
>
> (setq tst '(symbolla . "I'm the string"))
>
> (pcase tst
>   (`(symbolla . ,(and x (pred stringp)))
>    (message "cdr is a string: %s" x)))
>
> Is the ",(and x (pred stringp))" part really the simplest way of doing
> that? It just seems a little unintuitive.


I think that's it I am afraid. Don't trust me though, I am no expert.

Phil

Re: Quick pcase question

[Phillip Lord]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> Michael Heerdegen <michael_heerdegen@web.de> writes:
>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> (pcase tst
>>>   (`(symbolla . ,(and x (pred stringp)))
>>>    (message "cdr is a string: %s" x)))
>>>
>>> Is the ",(and x (pred stringp))" part really the simplest way of doing
>>> that?
>>
>> Yes, I think so.
>>
>> How could it be much simpler (there is not much redundancy in that
>> expression)?
>
> It's not so much the simplicity, I guess, as the intuitiveness -- "(and x"
> looks like a test to me, not an assignment. My brain would prefer:
>
> (,x (pred stringp))

What about?

(guard (stringp ,x))

Phil

Re: Quick pcase question

[Phillip Lord]

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> But the fact is that pcase is (very complex and very useful) syntax
>> sugar. I just wrote a pcase clause that looks like:
>>
>> `((,(and f-string (pred stringp)) . ,(and class (pred symbolp)))
>> . ,(and regexp (pred stringp)))
>>
>> And that's kind of awful. The whole point of pcase should be concision,
>> but that looks pretty terrible.
>
> :-P
>
> Maybe separate the testing and the binding operations, like:

What about this?

(pcase tst
  ((and
    `(symbolla . ,x)
    (guard (stringp x)))
   (message "cdr is a string: %s" x)))

It separates out the list destructure and the guard. It seems cleaner to
be because only the list appears to be backticked and then unquoted.


A nice addition to pcase would perhaps be automatic "and". So having a
list like so

(pcase tst
  (`(symbolla . ,x)
   (guard (stringp x)))
  (message "cdr is a string: %s" x))

would automatically be interpreted as "and". Not sure if this works
syntactically, though.

Phil

Re: Quick pcase question

[Eric Abrahamsen]

phillip.lord@russet.org.uk (Phillip Lord) writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> Michael Heerdegen <michael_heerdegen@web.de> writes:
>>
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> (pcase tst
>>>>   (`(symbolla . ,(and x (pred stringp)))
>>>>    (message "cdr is a string: %s" x)))
>>>>
>>>> Is the ",(and x (pred stringp))" part really the simplest way of doing
>>>> that?
>>>
>>> Yes, I think so.
>>>
>>> How could it be much simpler (there is not much redundancy in that
>>> expression)?
>>
>> It's not so much the simplicity, I guess, as the intuitiveness -- "(and x"
>> looks like a test to me, not an assignment. My brain would prefer:
>>
>> (,x (pred stringp))
>
> What about?
>
> (guard (stringp ,x))

You're suggesting that as a possible alternate syntax, right? (In which
case I like it.) It doesn't actually work now, does it?

Re: Quick pcase question

[Eric Abrahamsen]

phillip.lord@russet.org.uk (Phillip Lord) writes:

> Michael Heerdegen <michael_heerdegen@web.de> writes:
>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> But the fact is that pcase is (very complex and very useful) syntax
>>> sugar. I just wrote a pcase clause that looks like:
>>>
>>> `((,(and f-string (pred stringp)) . ,(and class (pred symbolp)))
>>> . ,(and regexp (pred stringp)))
>>>
>>> And that's kind of awful. The whole point of pcase should be concision,
>>> but that looks pretty terrible.
>>
>> :-P
>>
>> Maybe separate the testing and the binding operations, like:
>
> What about this?
>
> (pcase tst
>   ((and
>     `(symbolla . ,x)
>     (guard (stringp x)))
>    (message "cdr is a string: %s" x)))

That seems quite a bit better -- I really haven't yet wrapped my head
around the possible permutations of upatterns and qpatterns. Still a bit
ungainly when you have multiple clauses, but it does look a little more
intuitive.

Thanks to you both!

E

Re: Quick pcase question

[Stefan Monnier]

>   (`(symbolla . ,x)
>    (guard (stringp x)))
>   (message "cdr is a string: %s" x))

A more promising direction is to change the syntax of `guard` from
(guard EXP) to (guard PAT EXP), which would be equivalent to (and PAT
(guard EXP)).


        Stefan

Re: Quick pcase question

[Phillip Lord]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> phillip.lord@russet.org.uk (Phillip Lord) writes:
>>> It's not so much the simplicity, I guess, as the intuitiveness -- "(and x"
>>> looks like a test to me, not an assignment. My brain would prefer:
>>>
>>> (,x (pred stringp))
>>
>> What about?
>>
>> (guard (stringp ,x))
>
> You're suggesting that as a possible alternate syntax, right? (In which
> case I like it.) It doesn't actually work now, does it?

Yes, apologies, my post wasn't very clear.

Phil