Is it possible to implement an order-preserving Union?

[tobyp]

I would like to use type annotations (especially Annotated) to add information to class members for some parsing code to use at runtime (via get_type_hints).
When some element can have multiple types, they must usually be tried in a specific order; if the order is unstable, the parser becomes non-deterministic.
Unfortunately, the typing docs state that get_args does not necessarily preserve order of Union members, due to type caching[1].

As a concrete example, I have a field annotated MyIntEnum | int, for which the parser reads a number from its input stream, and then return an instance of MyIntEnum if possible, or just a plain int if not.
If this union gets re-ordered with int first, the parser will never even try to return an instance of MyIntEnum.

I can understand that caching is very important for type checking, which is a much more important use case for type annotations than mine, so I'm thinking more in the direction of working around this limitation somehow.
I could easily implement some kind of OrderedUnion[...] that would work for my parser, but I don't see how it would be possible to get a type checker to interpret such a thing correctly -- and I would lose the | syntax sugar.
I'm assuming it's not possible to monkey patch Union, as I remember from my last trip through cpython that Union is implemented pretty low-level.

Does the "Type School" have any ideas or advice?

[JelleZijlstra]

Order appears to be preserved in practice in 3.13 and 3.14. I don't recall whether we changed that recently, but I'd be open to changing the docs to make that guarantee for Union.

[tobyp]

Thanks for the reply; I was happy to read this, and started doing some tests to see how this behaves in more complex scenarios like nested unions, or with things like type Flip[T, U] = U | T. Unfortunately it looks like there's still some caching behavior somewhere, because this snippet fails in my Python 3.13.1 REPL:

import typing
annotation_a = typing.Annotated[typing.Union[str, int], "a"]
annotation_b = typing.Annotated[typing.Union[int, str], "a"]
assert typing.get_args(typing.get_args(annotation_a)[0]) != typing.get_args(typing.get_args(annotation_b)[0])

A quick look at the source doesn't make it look like get_args itself is doing any caching. Some more assert experiments make me think it isn't the Union, either - which is probably what you were thinking of when you said the order should be preserved? That would leave Annotated itself, and the underlying _GenericAlias infrastructure, but that's a bit heavy for Sunday night. I hope I can pick this up again next week.

[JelleZijlstra]

I believe it's the _tp_cache decorator on Annotated.