The problem that arises here is one of pythons scoping and people reading this satire will have a hard time understanding what is happening (if they don't follow the links in the article).

Taking an example from a reddit comment[1] for the actual pattern matching. The command matched on is a list, and the matching condition in this case is the number of elements in the list.

    command = ['cmd', 'somearg']
    match command:
        case [nonargaction]:
            print(f'We got a non-argument command: {nonargaction}')
        case [action, arg]:
            print(f'We got a command with an arg: {action}, {arg}')
        case _:
            print('default, dunno what to do')

    x = 0
    for x in range(5):
        pass
    print(x) # = 4
    m = 5
    match m:
        case x: pass
    print(x) # = 5

[1] https://www.reddit.com/r/programming/comments/lgqhmj/stack_o...

[2] https://www.python.org/dev/peps/pep-0635/

match credulity:

  case woosh:

    print(“We were starting to worry that we would run out of major language changes to confuse new developers. But thanks to pattern matching, we should be set for another 5-7 years! ”)

While I initially thought this was absurd, looking at the intended use case I think this is actually sensible behavior. While I would probably use a word other than case to further distinguish it from the switch statements of other languages, the fact remains it's not a switch statement, and assigning values to variables is the whole point.

In the article's example, copied below, the programmer is confident that the status code fits the format they are looking for but not what status code corresponds to not found

    NOT_FOUND = 404
    match status_code:
        case 200:
            print("OK!")
        case NOT_FOUND:
            print("HTTP Not Found") 

    match ambiguous_response:
        case status_code:
            print("Responded with status code: ",status_code)
        case { "status_code" : status_code , _ }:
            print("Responded with json obj containing status code: ",status_code)

Seriously, who thought such semantics will be useful? What are they smoking?

From what I gather from that article is that pattern matching is the new buzzword for Switch Cases?

If so, expect an influx of applications misusing switches in replacement of if.

Crikey, that's going to be confusing. Why not separate capture variables from comparison variables by using tuple-style brackets?

  RED = "red"
  colour = "green"
  
  match colour:
    case (RED,):
      print(f"The colour is {RED}")
  
  > The colour is green

  match colour:
    case RED:
      print(f"The colour is {RED}")

  > The colour is red

Pretty funny read

Mapping values to functions was the Pythonic thing for this, right? I guess the solution to that had to be just as unintuitive.

Constants getting overwritten is such a footgun.

Hopefully syntax highlighters and linters will mitigate this.

Actually a pretty good introduction