What is TypeVar

TypeVar, short for Type Variable, is a powerful feature in Python's typing module that allows you to create more flexible and dynamic type hints. It enables you to create generic functions and classes, making it possible to reuse code while maintaining type safety. TypeVar is especially useful when you want to define a function or class that works with multiple types but still enforce some constraints on those types.

To create a TypeVar, you must first import it from the typing module:

from typing import TypeVar

Then, you can define your TypeVar by providing a unique name:

T = TypeVar("T")

In this example, T represents a generic type that can be replaced by any other type when the TypeVar is used.

TypeVar Constraints and Boundaries

When defining a TypeVar, you can optionally provide constraints or boundaries, which limit the possible types that can be substituted for the TypeVar.

To set constraints, you can pass one or more types to the TypeVar definition:

U = TypeVar("U", int, float)

In this case, U can only be replaced by either int or float.

To set a boundary, use the bound argument:

from typing import List
V = TypeVar("V", bound=List)

Here, V can be any type that is a subclass of List.

Type Hints for Generic Functions

Generic functions are functions that can work with multiple types of arguments while maintaining type safety. To create a generic function, you can use TypeVar to represent the types of the function's arguments and return values.

Let's look at an example of a simple identity function:

def identity(x: T) -> T:
    return x

Here, T is a TypeVar that can represent any type. The identity function takes a single argument x of type T and returns a value of the same type T.

Leveraging TypeVar for Flexible Type Constraints

TypeVar can be used to create more complex and flexible type constraints in generic functions. For instance, consider a function that takes two arguments and returns their sum. This function should work with both integers and floats, but not with mixed types.

from typing import TypeVar, Union

Number = TypeVar("Number", int, float)

def add(x: Number, y: Number) -> Number:
    return x + y

In this example, the TypeVar Number is defined with constraints int and float. The function add takes two arguments of type Number and returns a value of the same type. This ensures that the function works with both integers and floats but not with mixed types.

Practical Examples of TypeVar in Generic Functions

Let's look at some practical examples of using TypeVar in generic functions.

Generic function to find the index of an item in a list

from typing import List, Optional, TypeVar

T = TypeVar("T")

def find_index(items: List[T], target: T) -> Optional[int]:
    for i, item in enumerate(items):
        if item == target:
            return i
    return None

In this example, the find_index function takes a list of items of type T and a target item of the same type T. It returns the index of the target item in the list, or None if the item is not found.

Generic function to merge two dictionaries

from typing import Dict, TypeVar

K = TypeVar("K")
V = TypeVar("V")

def merge_dicts(dict1: Dict[K, V], dict2: Dict[K, V]) -> Dict[K, V]:
    result = dict1.copy()
    result.update(dict2)
    return result

In this example, the merge_dicts function takes two dictionaries with keys of type K and values of type V. It returns a new dictionary that contains the merged key-value pairs from both input dictionaries.

References

https://docs.python.org/3/library/typing.html#typing.TypeVar
https://dev.to/decorator_factory/typevars-explained-hmo