TypeForm: Spelling for a type annotation object at runtime

[davidfstr (David Foster)]

@erictraut

I like this idea. It requires that we standardize the type of special forms when they appear in value expressions.

Aye. I can enumerate in the next PEP draft rules for parsing each kind of type expression in a value expression context.

@erictraut

I’m not sure what we’d do with special forms that are not valid TypeForms, like Union (with no type arguments) or Required or ClassVar. Do we leave those undefined? Or should we take this opportunity to specify how all special forms should be evaluated by a type checker when used in a value expression?

It would be useful to define that incomplete type expressions (like Union, Optional, Annotated - with no type arguments) should have type object. That would guarantee that you’d get a reasonable error message if you spelled something that is close to valid. Currently you see errors that look like:

def identity_type(t: type[T]) -> type[T]:
    return t

identity_type(Literal)
  # pyright: Argument of type "type[Literal]" cannot be assigned to parameter "t" of type "type[T@identity_type]"
  # mypy: Argument 1 to "identity_type" has incompatible type "<typing special form>"

Ideally annotation expressions which aren’t type expressions (like Required[...], Final, etc) should also be defined to have type object. I don’t think there’d be too many additional cases to write out so I think it would be OK to enumerate them.

There’s a corner case for Annotated[...] because it sometimes is a type expression and sometimes is an annotation expression:

• Proposal: If x has type type[t] then Annotated[x, ...] has type type[t]
• Proposal: If x has type TypeForm[t] then Annotated[x, ...] has type TypeForm[t]
• Proposal: Otherwise Annotated[x, ...] has type object

@erictraut

The only part of your proposal that I find problematic is “Otherwise x | y has type UnionType”.

Ah yes. I think I meant here to write something like “Otherwise x | y has the type implied by the binary-or bitwise-or of x and y”. For example the type of 5 | 2 would be int.

I agree that I don’t think there’s a case where you’d end up with UnionType here if the type and TypeForm cases were already checked.

@erictraut

unions distribute across type. That is, type[A] | type[B] is equivalent to type[A | B].

@erictraut

We should document this special case. I mention this in the context of this PEP because we may want to document that TypeForm has this same property.

Agreed. I’ll add a mention to the next PEP draft.