If you want to define a variable that can accept values of multiple possible types, using typing.Union is one way of doing that:

from typing import Union

U = Union[int, str]

However, there’s another way you can express a similar concept via constrained TypeVar. You’d do so as follows:

from typing import TypeVar

T = TypeVar("T", int, str)

So, what’s the difference between these two and when to use which? The primary difference is:

T’s type needs to be consistent across multiple uses within a given scope, while U’s doesn’t.

With a Union type used as function parameters, the arguments, as well as the return type, can all be different:

# src.py
from typing import Union

U = Union[int, str]

# Native generic tuple requires py3.10 or
# 'from __future__ import annotations' import.
def foo(a: U, b: U) -> tuple[U, ...]:
    return (a, b)

# Use the 'foo' function.
foo("apple", "bazooka")  # This is valid.
foo(1, "apple")  # Mypy won't complain here.
foo("apple", 1)  # Mypy won't complain here as well.

However, the above type definition will be too loose if you need to ensure that all of your function parameters must be of the same type in a single scope. Here’s where constrained TypeVar can come in handy:

# src.py
from typing import TypeVar

T = TypeVar("T", int, str)

def add(a: T, b: T) -> T:
    return a + b

add("hello", "world")  # This is allowed.
add(1, 2)  # This is fine as well.
    "hello", 1
)  # Mypy will complain about this one and it'll fail in runtime.

If you run Mypy against the above snippet, you’ll get this:

$ mypy src.py
src.py:12: error: Value of type variable "T" of "add" cannot be "object"
    add("hello", 1)  # Mypy will complain about this one and it'll fail in runtime.
Found 1 error in 1 file (checked 1 source file)

As the comment implies, this error is coming from the line where I called add("hello", 1). The function add can take parameters of either integer or string type. However, the type of both the parameters needs to be the same. Also, the type of the input parameters will define the type of the output value. So, the types of the input parameters must match, otherwise, Mypy will complain and in this case, the snippet will also raise a TypeError in runtime. Mypy is statically catching a bug that’d otherwise appear in runtime, how convenient!

Recent posts

  • Escaping the template pattern hellscape in Python
  • Finding flow amid chaos
  • The diminishing half-life of knowledge
  • Oh my poor business logic
  • Pesky little scripts
  • Footnotes for the win
  • Dotfile stewardship for the indolent
  • An ode to the neo-grotesque web
  • Self-hosted Google Fonts in Hugo
  • Configuring options in Go