Add clarification for overloading example #3369
Conversation
docs/source/function_overloading.rst
Outdated
| overloaded definition, and ignores the type annotations on the | ||
| implementation of ``__getitem__``. The code in the body of the | ||
| definition of ``__getitem__`` is checked against the annotations on | ||
| the last function declaration. In this case the body is checked with |
There was a problem hiding this comment.
the last function declaration -> the corresponding declaration.
docs/source/function_overloading.rst
Outdated
| the last function declaration. In this case the body is checked with | ||
| ``index: Union[int, slice]`` and a return type | ||
| ``Union[T, Sequence[T]]``. If there are no annotations on the last | ||
| definition, then code in the function body is not type checked. The |
There was a problem hiding this comment.
I'd start a new paragraph at "The annotations ..."
docs/source/function_overloading.rst
Outdated
| definition, then code in the function body is not type checked. The | ||
| annotations on the function body must be compatible with the types | ||
| given for the overloaded variants listed above it. The type checker | ||
| will ensure that all the types listed for parameters and the return |
There was a problem hiding this comment.
ensure -> verify
(It can't ensure anything, it has no powers except for pointing out errors. :-)
docs/source/function_overloading.rst
Outdated
| annotations on the function body must be compatible with the types | ||
| given for the overloaded variants listed above it. The type checker | ||
| will ensure that all the types listed for parameters and the return | ||
| type in the overloaded variants can inhabit the type given for the |
There was a problem hiding this comment.
Can you use a different word than "inhabit"? It's not used nor explained anywhere else in the mypy docs, and as far as I can tell from your example it just means "to be compatible with", right? (That's our term for "is a subtype module Any".)
Also IIRC the actual rules are more complicated -- I think it's something like each overload variant must be compatible with the implementation? @sixolet can explain it better than I can.
There was a problem hiding this comment.
Hmmm. I don't think I really understand. It makes sense that you would need to check full signatures together to make sure generics are resolved correctly. To prevent this sort of thing:
from typing import List, Any, Union, Tuple, TypeVar, overload
A = TypeVar("A")
B = TypeVar("B")
@overload
def first(xs: List[A]) -> A: ...
@overload
def first(xs: Tuple[A, Any]) -> A: ...
def first(xs: Union[List[A], Tuple[B, Any]]) -> A:
return xs[0]Tuple[A, Any] -> A should not be compatible with Union[List[A], Tuple[B, Any]] -> A
But I ran that example and mypy didn't complain. Is there a different reason?
|
I think that should incorporate your suggestions, except for maybe the last one. |
Fix for #3360