undefined | Better HN

0 pointspansa21y ago0 comments

> So don't do this then?

Don't do what?

- Don't write unsound code? There's no way to know until you run the program and find out your `int` is actually a `list`.

- Don't assume type annotations are correct? Then what's the point of all the extra code to appease the type checker if it doesn't provide any guarantees?

0 comments

3 comments · 1 top-level

_dain_1y ago· 2 in thread

Don't do this stupid party trick with `global`.

You may as well argue that unit tests are pointless because you could cheat by making the implementations return just the hardcoded values from the test cases.

pansa2OP1y ago

This isn't a "party trick" with `global`, it's a fundamental hole in the type system:

    class C:
        def __init__(self) -> None:
            self.i : int | list[int] = 0

        def foo(self) -> None:
            self.i = []
        
        def bar(self) -> int:
            if isinstance(self.i, int):
                self.foo()
                return self.i
            return 0

    print(type(C().bar()))

maleldil1y ago

This seems to work in TypeScript too:

    class C {
        i: number | number[];

        constructor() {
            this.i = 0;
        }

        foo(): void {
            this.i = [];
        }

        bar(): number {
            if (typeof this.i === 'number') {
                this.foo();
                return this.i;
            }
            return 0;
        }
    }

    console.log(typeof new C().bar());

It seems to be a problem with "naked" type unions in general. It's unfortunate.

1 more reply

j / k navigate · click thread line to collapse