[Python-ideas] Match statement brainstorm

[Sven R. Kunze]

On 26.05.2016 19:11, Paul Moore wrote:
> On 26 May 2016 at 17:21, Sven R. Kunze <srkunze at mail.de> wrote:
>> I think "test one thing against multiple conditions" is a quite abstract thing to do.
>>
>> I would like to see some real-world use-case for this kind of syntax
> Today, I was parsing a job output file. For each line in the file, I
> tested it against various patterns/conditions to see what type of line
> it was. Depending on the type of line, I did something different. I
> used a chain of if/elif statements, because that's what Python
> currently (3.5) provides, but it would have been an obvious case for a
> match/switch statement. If the important thing here is *structural*
> matching then what I actually did was call split() on the line to get
> a list of elements, then wanted some to be constants, and I picked
> data out of others. Something like
>
>      match line_parts:
>          case _, 'Job', 'Start', start_time: do_something1(start_time)
>          case _, 'Job', 'End', end_time: do_something2(end_time)
>          case view, 'size', 'is', kb, 'KB': do_something3(view, kb)
>
> Is that the type of example you had in mind?
> Paul

Interesting to see that you chose chains of if-elses.

I wouldn't.

Especially because our guidelines tells us to avoid *elses* and *ifs* if 
possible. But here, it's also my personal preference of avoiding a 
switch-case-like mess.

So, in this particular case, I would have used a datastructure for 
describing how to work with the incoming data. That gives me three 
advantages over a syntax-using solution:

1) a datastructure (like a dict) would be first-class and I could move 
it around, manipulate it etc for whatever reason
2) I am able to run separate tests for the matching algorithm (aka 
finding the right mapping) without applying mocks for *all* possible 
match-cases
3) no monolithic code block that tends to grow


It is also interesting to see that it worked for you. I can remember a 
similar task quite some time ago. However, there, I needed regular 
expressions to solve the issue at hand. So, a simple structural 
unpacking didn't suffice. However, a loop over a list of (regex, 
action)s with a single check made it work for me.

Btw. Django uses this way of matching for the URLs system. And because 
it needs to be modular (different apps can contribute to it), it would 
be pointless to have a syntax for it. Even dynamic changes would not be 
possible with syntax which we do in various places because of, well 
let's call it, our customer requirements. ;-)


My point here is not that not somebody could make use of it (apparently 
it would for you). However, the absence of it forces people to invent 
other more flexible mechanisms and I'd actually like it this way.


This said, I could rather imagine a new function introduced to functools 
which provides some sort of match-and-dispatch functionality which you 
actually do above. Not sure if somebody already suggested this on this 
thread.


Best,
Sven
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20160526/53271cc2/attachment.html>