Type Narrowing in Closures

[Sora Takemi (TakemiSora)]

class NameHavingClass:  
    __slots__ = ("name",)  
  
    name: str  
 
class NotNamedClass:  
    __slots__ = ("someother",)  
  
class Container:  
    def __init__(self, data: NameHavingClass | NotNamedClass):  
        self.bar: NameHavingClass | NotNamedClass = data  
          
def foo(container: Container):  
    assert isinstance(container.bar, NameHavingClass)  
      
    something = container.bar.name   
    # Pyright sees bar as an instance of NameHavingClass and allows it!  
      
    func = lambda: container.bar.name  
    # Pyright complains that bar isn't narrowed  
    # or still can be an instance of NotNamedClasss

    bar = container.bar
    # However if we assign the narrowed bar to a variable

    func2 = lambda: bar.name
    # Pyright can correctly resolve bar to be an instance of
    # NameHavingClass and does not complain

Error:

Cannot access attribute "name" for class "NotNamedClass"  
  Attribute "name" is unknown

Is this the intended way? container.bar being narrowed to be an instance of NameHavingClass, but losing that captured narrowing inside the lambda? Thanks for the answer in advance!

[Rich Chiodo (rchiodo)]

Yes, this is intended behavior.

Pyright retains narrowing inside a closure only for captured variables (simple names), and only when it can prove the variable isn't reassigned on any code path after the closure is defined. This is documented under Narrowing for Captured Variables.

The reason for the difference you're seeing:

• container.bar.name inside the lambda — container.bar is a member access expression, not a simple captured variable. Narrowing of member expressions is never retained inside closures. A closure can be invoked at any later time, and between the isinstance check and the actual call, anything holding a reference to container could reassign container.bar to a NotNamedClass. Pyright can't prove that won't happen, so inside the lambda it falls back to the declared type NameHavingClass | NotNamedClass, hence the error.

• bar.name inside func2 — bar is a local variable. Pyright can see that bar is assigned exactly once and never modified afterward, so it's safe to retain the narrowed NameHavingClass type within the closure.

So the workaround you already discovered — assigning the narrowed member to a local variable first — is exactly the recommended approach:

def foo(container: Container):
    assert isinstance(container.bar, NameHavingClass)
    bar = container.bar            # narrowed to NameHavingClass, never reassigned
    func = lambda: bar.name        # OK

This same restriction applies to any narrowing of member/index expressions captured by a nested function or lambda, not just isinstance.

[Sora Takemi (TakemiSora)]

Thank you for answering! I get it now.