mypy is unhappy with repeated use of `_` as a throw-away variable

[ddfisher]

_ is commonly used as a throw-away variable in list unpacking, but this will make mypy unhappy if two lists with different types are unpacked in the same function. For example

x, _ = ["foo", "bar"]
n, _ = [1, 2]

results in:

test.py:2: error: Incompatible types in assignment (expression has type "int", variable has type "str")

To support this pattern, we may want to consider special-casing _ and not generating this sort of type error if the variable is never read.

[gvanrossum]

A complication is that _ is also commonly used as an alias for gettext. When we see an import like from ... import gettext as _ we should not special-case it (and probably complain extra loudly if _ is redefined locally).

[JukkaL]

In the gettext use case _ it will be accessed within the module. As @ddfisher suggested, perhaps we should only special case _ if it's never read.

[dmoisset]

In my opinion, any variable (no matter its name) which is used only write only can be safely typed to Any (or to object), given that this can never be an unsafe operation, so it's sound and cover this pattern well (and some alternative things like using __ as placeholder)

[JukkaL]

At module and class top levels we can't determine whether a variable will be read outside the module/class, so at least here a naming convention helps.

[dmoisset]

Yes, my comment was made thinking about locals

[dmoisset]

A note that may help clean up the issue tracker: this seems to be the same issue as #465 and #1649, they can probably be unified

[ddfisher]

Instead of special casing write-only variables to have the Any type, we could also just be willing to infer Union types for things. E.g.:

_ = 1
_ = "foo"
# _ now has type Union[int, str]

Come to think of it, this would likely also solve the "variable must only have a single type" problem (provided that is something we want to solve) because of the way we already understand assignments to Union types.

[gvanrossum]

Isn't the problem with union types that next you will have to use isinstance() before using it?

[ddfisher]

Not necessarily! We add more specific types to the binder on assignment, so e.g.:

from typing import Union

x = 0  # type: Union[str, int]
x = "foo"
reveal_type(x)  # Revealed type is 'builtins.str'
x = 0
reveal_type(x)  # Revealed type is 'builtins.int'

[JukkaL]

Closing this as a duplicate of #465.