generic type inference when combining containers with different element types

[bitcleo]

I'm trying to combine two Cache instances with different element types and preserve both types in the result.

class Cache[T]:
    def __init__(self, items: list[T]) -> None:
        self.items = items

def combine[T, U](
    first: Cache[T],
    second: Cache[U],
) -> Cache[T | U]:
    return Cache(first.items + second.items)

Is Cache[T | U] the correct return type here, or is there a better way to type this?

What I'd like to avoid is losing type information or having to use Any or cast.

[Muguett-DBY]

Yes, Cache[T | U] is an appropriate return type here: the new cache can hold values of either input type. The list concatenation creates a new list, so your implementation doesn't need Any or a cast.

For example, a type checker can preserve the union at the call site:

from typing import assert_type

a: Cache[int] = Cache([1])
b: Cache[str] = Cache(["x"])
assert_type(combine(a, b), Cache[int | str])

I checked the example with Python 3.12 and mypy 2.3.1.