LWN: Comments on "A more generalized switch statement for Python?"

A more generalized switch statement for Python?

flussence — Sun, 10 Jul 2016 20:14:09 +0000

The very least they could do here is learn to not repeat the mistakes Perl 5 did in trying to add a switch construct to the language.

The examples given all look very *pretty*, which is what one would expect Python culture to focus on, but they're harder to *understand*.

A more generalized switch statement for Python?

HIGHGuY — Sun, 10 Jul 2016 18:19:19 +0000

Pattern matching in those languages is great... because of the very strong typing (and automatic type deduction).
Putting this kind of matching with python's duck-typing is like trying to have your cake and eat it too. It's just going to cause even more subtle bugs that are hard to diagnose or find.

A more generalized switch statement for Python?

marcH — Sat, 09 Jul 2016 04:28:59 +0000

Once you've seen in action ML-like pattern matching in some random language (from the ML family or not) and caught actual bugs thanks to it, then people claiming that if/elif/else is "The One Obvious Way to Do It" really sound like they're from the distant past. Maybe still trying to do large-scale development in assembly or something.

Quite surprising from Python: an otherwise fairly high-level language.

A more generalized switch statement for Python?

nybble41 — Fri, 08 Jul 2016 17:47:44 +0000

> The if/elif chain says "try this, then that, now something else". There's no implication that the tests are all looking at the same subject ... With a switch statement, however, the subject is stated once, at the top of the statement. The checks are then listed one after the other, and they are all by definition checks against the subject expression.

This is true of switch statements in C, but not every other language. For example, in Haskell the top-level patterns are all matched against a single value, but you can also add "guards" which add arbitrary conditions and even nested pattern matches:

case x of
(4, y) -> "case 1"
(x, 7) -> "case 2"
(x, y) | x < y -> "case 3"
_ | z == True -> "case 4"
_ | [z, w] <- list -> "case 5"

Haskell also has "view patterns" as a language extension which allow things like matching on dictionaries:

case dict of
(M.lookup "key" -> Just value) -> print value
_ -> putStrLn "No match!"

The left-hand side of the view pattern is an arbitary function which is given the value at that position as a parameter. The right-hand side is a pattern matched against the function's return value. Of course, in this case you could just as easily write `case M.lookup "key" dict of ...`; it becomes more useful when you want to match against multiple keys or use the view pattern in a pattern synonym.

F# has a similar guard syntax as well as "active patterns", which are similar to Haskell's view patterns combined with pattern synonyms.

A more generalized switch statement for Python?

gasche — Fri, 08 Jul 2016 15:44:49 +0000

Algebraic type and pattern-matching were introduced in the 1970s by the functional language Hope, and were quickly adopted by the ML languages (SML, OCaml, Haskell, F#, etc.; with a graceful adaptation to the object-oriented programming as sealed classes in Scala). I find that the discussions related in this article give the impression of the Python community as rather closed-minded as far as language design is concerned. For an interesting take on the form of programming language illiteracy fostered by self-contained one-language communities, see

Why I hate advocacy
Mark-Jason Dominus, 2000
http://www.perl.com/pub/2000/12/advocacy.html