type hints

type hints are bad.

https://peps.python.org/pep-0484/

Python as a strongly but dynamically language has big advantages of simplicity and flexibility.

Yet type hints were introduced because of ehat i suspect is a sunk cost bias, coupled with some corrupting influence of by employers on member of the python foundation.

Which i would normally decry, but people have bills to pay. So whatever.

epistomologically type hints are an interesting flaw for several reasons

The proposal itself is obviously flawed because it offers no justification. it merely describes that something is being done and assumes obviousness for the usefulness.

Programming in general has several measurable qualities regarding to predictability:

the code can happen to use bad underlying instructions, turning functional code into erroneous code.
the code can have randomness or pseudorandomness baked in as a feature.
the code can be written, and compiled but the reasoning for why it will work is external and the code is not self desceibing. this happens with bad variables and the infamous "GOTO" that has been banished from newer languages.
the code can be slightly less obfuscated and just work, but with minimal type information and no safeties. e.g. in C it is possible to specify in great detail, the type of variables and its memory use. but the disadvantage is that every type conversion has to be or should be explicit. it is not possible to trear integers and floats as numbers.

In regular python, this type information is omitted for the sake of flexibilty and brevity.

A maybe unintended side effect is that the information that allows or forbids actions is not defined at the local level of definition and execution of a function, but the more remote definition of the type. A "add" operation doesnt depend on the function, or the local code, it merely depends on whether the author of either type has foreseen the possibility of the operation.

This means that theoretically, someone can write code to solve a certain general problem and a user in the far future can discover a new use for that code, and doesnt need to change a thing to make it work for their case.

Type hinting strongly implies that there is a correct type and strongly implies that other types are not correct, no discussion allowed.

objective reasons

The syntax is bad. e.g. iso8601 goes `year month day hour minute second` biggest to smallest. C style types go `general_type_name variable_name = variable_value` `int my_int = 1;` general to specific. python type hints go `variable name : variable type = variable value` medium to large to small

They are not actually ensuring anything. The interpreter does nothing with them. It doesn't optimize, it doesn't precompile, etc. You can write

```py
def f( my_variable : int = "hello world"):
    return my_variable
f(f)
```

And that's not even a silent error, it's *not an error*.

I am not convinced that picking `[type hints + type checker + reading the code a lot and taking care]` is superior to just `[reading the code a lot and taking care + maybe testing]` . I have not seen objective measurement that that's the case. I only ever see people who repeat it as a mantra, without any substance to back it up.

They make code harder to read, because there is just more code to read.

To answer your question: Python is the language of "mess around and find out". A well written python module will take any of the things you listed. Just try it. If it doesn't work, the interpreter will tell you immediately and precisely which part didn't work and why. Particularly if it's a type problem. In practical terms, how to use functions should either be obvious, from your context, from the name, or it should be mentioned in docs, tutorials, or example files.

subjective reasons

The biggest problem I have is more of a spiritual one: Python is specifically built to not care about types. For loops will work for all kinds of iterables, generators and then some. There are even magic methods like `__rmul__` that support that even if you didn't want your type to be multiplied with anything, someone else can write the support for it into their class.