[patagonia]

ELI5: The difficulty and resources involved in adding explicit types to the language aside, besides a little more typing, what added burden is placed on the developer? It seems to me that the improvements to performance, code correctness, and code readability farrrr outweigh the cost of the added keystrokes.

[Myrmornis]

I like typed Python, but it's not as simple as just adding types with a few keystrokes. It is a rabbit hole: if you're typing simple types, you will eventually want to type more complex types: functions, iterables, generators, use type variables, etc (Remember what the difference is between an iterable and an iterator? You'll need to.) And Python's type system is its own thing, with its own idiosyncracies. Furthermore, invoking the typechecker itself has complexities: are you doing it in an IDE, or as part of a pre-commit hook, or CI test? The default mypy options aren't great; there's one called `--check-untyped-defs` that IMO you should usually use. Anyway, I am not an expert and not currently using it professionally, but my point is it's much more complex than you're suggesting.

[Hasnep]

I've had lots of success using pyright [1] for Python projects, it has sensible defaults and can be configured with a pyproject.toml file so everyone's using the same settings. I use the Pylance VSCode extension to catch errors earlier, but I also put it in pre-commit and as a CI check, so all contributors are committing the same quality of typed code.

With more complex types, I've found it isn't necessary to do anything more complex than specifying the element type of a list or dict most of the time. I have typehinted lambda function arguments before, but just using the plain Callable typehint is usually enough. When I forget if I need to use an Iterator or an Iterable (which is every time), then I just try one and run the type checker and change it to the other if i guessed incorrectly.

Type checking Python can become complex if you expect to be able to express everything in the typehints, but Python's type system isn't powerful enough for that. I feel its strength is that it lets you add as much detail to the types as is convenient.

[1] https://github.com/microsoft/pyright

[Bedon292]

I have had times where I have had to spend a great deal of effort to make the type checker happy. Finding exactly where to import the correct type from the library you are interacting with can be quite annoying at points. And it can be painful making sure everything lines up perfectly so the code (which is already well tested and functionally correct) can make it through the type checker without having to just `# type: ignore` or use `Any`. I have had a few times where it took significantly longer to get the types working than the actual code.