News for hackers. Stuff that matters.
Re:Structural pattern matching in Python 3.10 by incrudible on Tuesday September 21, 2021 @07:22AM (#28603920)
Type-safe tagged unions, one of the nicest features of Typescript:

    interface Foo { type: "foo"; name: string; }
    interface Bar { type: "bar"; size: number; }
    type Variant = Foo | Bar;
    
    function tell(x: Variant) {
        switch (x.type) {
            case "foo":
                // x now has type Foo
                console.log(`The name is {x.name}`);
                break;
            case "bar":
                // x now has type Bar
                console.log(`The size is {x.size.toFixed(2)}`);
                break;
            default:
                // statically unreachable
        }
    }
Hope to see this in Python type checkers as well.
Re:Structural pattern matching in Python 3.10 by azkae on Tuesday September 21, 2021 @08:32AM (#28604383)
You can already do this without pattern matching:

  from typing import Union, NoReturn
  
  class Foo:
      name: str
  
  class Bar:
      size: int
 
  Variant = Union[Foo, Bar]       # or `Foo | Bar` in Python 3.10
  
  def assert_never(x: NoReturn) -> NoReturn:
      # runtime error, should not happen
      raise Exception(f'Unhandled value: {x}')
  
  def tell(x: Variant):
      if isinstance(x, Foo):
          print(f'name is {x.name}')
      elif isinstance(x, Bar):
          print(f'name is {x.size}')
      else:
          assert_never(x)
mypy returns an error if you don't handle all cases.
Re:Structural pattern matching in Python 3.10 by incrudible on Tuesday September 21, 2021 @09:29AM (#28604839)
The difference is that in Typescript, this works on any structurally matching object that you may get e.g. through JSON.
Re:Structural pattern matching in Python 3.10 by NoThisIsMe on Tuesday September 21, 2021 @08:30AM (#28604365)
Typescript is so weird. Like this is cool I guess but I'd much rather just match on `Foo` or `Bar` directly. But Typescript doesn't have pattern matching so it compensates with this bizarre paradigm of enforcing dynamic type checks statically.
Re:Structural pattern matching in Python 3.10 by jakear on Tuesday September 21, 2021 @02:04PM (#28607812)
You can check instanceof of course, but the idea behind doing this is that object literals and raw data from JSON/whatever can be treated as a first class entity, rather than mucking around with all the boilerplate dataclass junk a lot of languages get tangled up in.