Is if list not considered a type guard?

[awgymer]

For the following method, mypy --strict has no complaints but pyright complains that i is possibly unbound.

I am not clear on the circumstances under which the list can be truthy but not have any elements to iterate over, which is presumably the only situation in which i would be unbound?

def list_iter(l: list[int]) -> int | None:
    if not l:
        return None
    for i in l:
        if i > 10:
            break
    return i

[erictraut]

The static type system currently has no way to specify that an iterable is "empty" — i.e. whether it is guaranteed to provide at least one iteration. Pyright assumes conservatively that any iterable may provide zero iterations. This can produce false positives, but it is easy to fix your code to avoid such errors.

If you don't want pyright to report this diagnostic in your code, you can disable the reportPossiblyUnboundVariable check. It is intentionally separated from the reportUnboundVariable check, which is reserved only for cases where a variable is provably unbound.

Mypy only recently added support for unbound variable detection, and it still contains a number of holes. For example, mypy doesn't report an error in this case, which results in a runtime exception:

def func(l: list[int]) -> int:
    for i in l:
        break
    return i

func([])

[awgymer]

So to confirm, there isn't (at least for a base list type) some edge-case I am missing where this could actually be unbound, but rather this is only a limitation of the type-system?

Is there a better way to write the method that would prevent this error?
I considered maybe if len(l) == 0: (which I think would also mean the code worked for generators, but not sure if that's just unnecessary overhead)

Perhaps actually in this particular case

for i in l:
   if thing:
       break
else:
   raise ValueError()
return i

Because actually if it never breaks, something has gone wrong

[erictraut]

In general, it's a bad idea to reference values that are initialized only within a loop outside of that loop. In most programming languages, this wouldn't even be possible because the variable would be scoped to the loop only. Python's scoping rules are pretty archaic since most variables are scoped to a function (although there are exceptions to this rule for comprehensions). My recommendation is to avoid this practice. If you need a variable's value to be accessed after a loop, make sure to assign it a value prior to the loop.

[awgymer]

I guess my issue is, how does one test the case where the variable is never initialised ( and thus you get your default ) if that case can never reasonably exist. I suppose if you decide it's not materially different to a 0-lenght list/sequence then you can set some kind of flag inside the for loop. But I'm not sure

[rayansostenes]

Any reason you could not just iterate over the empty sequence?

def list_iter(l: list[int]) -> int | None:
    for i in l:
        if i > 10:
            return i
    return None