Subclasses vs union of types vs TypeVar

[hunterhogan]

I think I have major flaws in my understanding of subclasses of a type (e.g., ast.AST and ast.Module), a union of types (e.g., type hasDOTarg = ast.arg | ast.keyword), and TypeVar (e.g., kuo = typing_TypeVar('kuo', bound=ast.stmt, covariant=True). I don't have an intelligent question, though. I suspect one of my following beliefs is wrong or at least incomplete.

Given

def ImaFunction(goat: ImaType):
    pass

• If the type is ast.AST, I think ast.Module will match.
• If the type is hasDOTarg, I think ast.keyword will match.
• If the type is kuo, I think ast.Assign will match because it is a subclass of ast.stmt.

But, this system of using TypeAlias, union, and subclasses, for example, doesn't always work when I expect it to work.

type hasDOTtarget_expr = ast.AsyncFor | ast.comprehension | ast.For
type hasDOTtarget_Name = ast.NamedExpr
type hasDOTtarget_NameOrAttributeOrSubscript = ast.AnnAssign | ast.AugAssign
type hasDOTtarget = hasDOTtarget_expr | hasDOTtarget_Name | hasDOTtarget_NameOrAttributeOrSubscript

...

class DOT:
    @staticmethod
    @overload
    def target(node: hasDOTtarget_expr) -> ast.expr:
        ...

    @staticmethod
    @overload
    def target(node: hasDOTtarget_Name) -> ast.Name:
        ...

    @staticmethod
    @overload
    def target(node: hasDOTtarget_NameOrAttributeOrSubscript) -> ast.Name | ast.Attribute | ast.Subscript:
        ...

    @staticmethod
    def target(node: hasDOTtarget) -> ast.expr | ast.Name | (ast.Name | ast.Attribute | ast.Subscript):
        return node.target

As I said, I don't have an intelligent question. I know my mental model is wrong, but I'm lost.

[srittau]

Maybe this will help a bit:

• If the type is ast.AST, I think ast.Module will match.
• If the type is hasDOTarg, I think ast.keyword will match.
• If the type is kuo, I think ast.Assign will match because it is a subclass of ast.stmt.

Unless I've overlooked something, this is correct, although I'd like to point out that a type var should always be used at least twice in a context to make sense. I.e.:

def ImaFunction(goat: kuo):
    pass

Using kuo here has no benefit and you could just use ast.stmt directly instead.

But, this system of using TypeAlias, union, and subclasses, for example, doesn't always work when I expect it to work.

[...]

    @staticmethod
    def target(node: hasDOTtarget) -> ast.expr | ast.Name | (ast.Name | ast.Attribute | ast.Subscript):
        return node.target

I don't have much to add here. The overloads make sense to me. Although there is currently some discussion about overload behavior, the overloads here seem to be non-overlapping. The only thing that stood out to me was using parentheses in the return type annotation of the implementation. To my knowledge, the meaning of grouping parentheses is currently not defined in the typing spec, so this could have unforeseen effects.

[hunterhogan]

a type var should always be used at least twice in a context to make sense.

I have "reactions", but I still don't have a good question, per se.

    @staticmethod
    def target[个: hasDOTtarget, 归个: ast.expr | ast.Name | ast.Attribute | ast.Subscript](node: 个) -> 归个:
        return node.target

Analytically, this makes sense, but as you pointed out, it needs to make sense within the specification. I think that this does not work because, in part, neither TypeVar ("ge" and "guige") is used more than once.

    @staticmethod
    def target[个: hasDOTtarget, 归个: ast.expr | ast.Name | ast.Attribute | ast.Subscript](node: 个) -> 归个:
        return cast(归个, node.target)

I don't think the cast is valid because I don't feel that the symbol is defined in the scope. But I don't know what scope the definition has: just the signature?

I think the overload definitions have the desired effect of type narrowing, so I think the above TypeVar would be redundant anyway.

"used twice", TypeAlias, and TypeVar

This statement is triggering my spidey sense--about a union of types:

a type var should always be used at least twice in a context to make sense.

For example, take:

工 = typing_TypeVar('工', bound=ast.expr, covariant=True) # "gong"

...

class Grab:
    @staticmethod
    def targetAttribute(action: Callable[[ast.Name], ast.Name] \
        | Callable[[ast.Name | ast.Attribute | ast.Subscript], ast.Name | ast.Attribute | ast.Subscript] \
        | Callable[[工], 工]) -> Callable[[hasDOTtarget], hasDOTtarget]:

        def workhorse(node: hasDOTtarget) -> hasDOTtarget:
            setattr(node, 'target', action(getattr(node, 'target')))
            return node
        return workhorse

I switched some annotations to TypeVar recently, and I'm not sure of their impact yet, but I am pretty sure it is not helping in this context. Because of what you wrote, I wonder if hasDOTtarget is effectively acting as a type "widener" and saying the return is always a union of types. Until now, I guess I believed that if the "input" type were ast.Name and the annotation was Callable[[hasDOTtarget], hasDOTtarget], then the type checker would treat the return as ast.Name.

class Then:
    @staticmethod
    def replaceWith(this: 归个) -> Callable[[Any], 归个]:
        return lambda _replaceMe: this

The above might be working: as in, the type checkers are using this annotation to "transitively define" the type. "Transitive:" I have no idea what the correct term is, so I mean A = B, B = C, -> A = C.

Parentheses

the meaning of grouping parentheses is currently not defined in the typing spec

I hadn't considered that. I'll change that. Thank you.

[srittau]

I don't think the cast is valid because I don't feel that the symbol is defined in the scope. But I don't know what scope the definition has: just the signature?

Just one quick point: The scope of the type var is the whole function, but when I said "a type var should always be used at least twice in a context" I should have said "a type var should always be used at least twice in a signature" (which for classes includes the signature of its methods and attributes).

So the cast is not necessarily "wrong", but the type var is kind of redundant, because the following definition would basically be equivalent:

    @staticmethod
    def target(node: Any) -> ast.expr | ast.Name | ast.Attribute | ast.Subscript:
        return cast(ast.expr | ast.Name | ast.Attribute | ast.Subscript, node.target)