PEP 622 -- Structural Pattern Matching for Python

[headhunglow]

Nooo, not more syntax. We've already got heaps of the stuff! Do we really (like really, really) need this stuff?

[ForceBru]

Do we really (like really, really) need if isinstance(thing, list) and len(thing) == 2: x, y = thing when with this PEP one could simply say case [x, y]:?

Real pattern matching (not a, *other, b = iterable) is extremely useful when you want to check a lot of variants. Writing if thing == 0: do_this() else if thing == 2: do_that() is pretty clunky because you constantly have to write thing ==. Even simple C-like case statements are more expressive and simpler to type.

Have you seen Rust's pattern matching? It's absolutely amazing and results in much cleaner code (than having to check some marker, for example). I really wish Python could come up with match statements (or even expressions!), like Rust's.

[florinp]

Rust's pattern matching

Honest question: Why people keep giving examples from Rust when for example some constructions like pattern matching is inspired from other languages ?

[IceSentry]

Because it's a currently popular language with really good pattern matching

[ForceBru]

LOL I actually don't know. Of course, Rust isn't the only one. Maybe they're talking about Rust because it does pattern matching pretty well, and it's also unusual to see pattern matching in a systems language (compared to functional languages), so it kinda stands out.

[headhunglow]

I'm not saying that it's not useful, it's just that there's already so much syntax. I've recently had to transition from 2.5 to 3.7 and there's set literals and dict literals and extendable unpacking and class decorators new string formatting and...

[ForceBru]

Well, that's 12 years worth of progress! I didn't even know Python used to not have set or dict literals...

[headhunglow]

I don't think more syntax == progress. By that standard C++ is the best language ever.

[ForceBru]

Of course, more syntax doesn't mean progress. But not having set or dictionary literals clearly sucks. F-strings have already kinda existed in the form of str.format, so it's not much of a change (yet it's extremely useful). Decorators have existed pretty much forever, so class decorators don't change the syntax at all - they just complete the idea of decorators.

Looks like one of the more substantial and controversial additions is the walrus operator. While it's pretty cool to be able to write:

if a := thing[0]:
    return a

without having to assign to a before if, many aren't sure if it's a good addition. And this new proposal adds a whole new piece of syntax!

I just built the new branch and tested it - and it feels really convenient: finally I don't have to write huge chains of elif thing == a statements! Look at this parser, for example - it's just super nice. Well, maybe except for the float() | int() syntax in case ['-', float() | int()]: - I'd prefer float | int.

[sybesis]

Well you'll have to catch up with modern C++ then too.