Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

A generic function is a function defined with one or more type variables, allowing it to accept arguments of various types while maintaining strict, statically verifiable type relationships between its inputs, outputs, and internal variables. Instead of binding to a specific concrete type (like int or str) or falling back to the untyped Any, a generic function parameterizes the types it operates on, enabling static type checkers to track type flow parametrically based on the call site.

​
Modern Syntax (Python 3.12+)

Python 3.12 (PEP 695) introduced native syntax for type parameters. Type variables are declared in square brackets [] immediately following the function name. 
def identity[T](value: T) -> T:
    return value

def merge_sequences[T, U](seq1: list[T], seq2: list[U]) -> tuple[list[T], list[U]]:
    return (seq1, seq2)
In this syntax, T and U are implicitly scoped to the function. The static type checker infers the concrete type of T based on the argument passed at the call site.

​
Legacy Syntax (Python 3.11 and older)

In older versions of Python, generic functions require explicit instantiation of type variables using typing.TypeVar. 
from typing import TypeVar, List, Tuple

T = TypeVar('T')
U = TypeVar('U')

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

def merge_sequences(seq1: List[T], seq2: List[U]) -> Tuple[List[T], List[U]]:
    return (seq1, seq2)

​
Type Constraints

A type variable can be constrained to a specific, finite set of allowed types. If a constrained generic function is called with an unlisted type, the static type checker will raise an error. Python 3.12+: 
def process_numeric[T: (int, float)](value: T) -> T:
    return value
Legacy: 
from typing import TypeVar

T = TypeVar('T', int, float)

def process_numeric(value: T) -> T:
    return value

​
Type Bounds

Unlike constraints (which require exact type matches from a specific list), bounds restrict a type variable to a specific class or any of its subclasses. This is heavily used with structural typing (Protocols) or nominal inheritance hierarchies. Note: For modern Python, abstract base classes like Sized should be imported from collections.abc, as their typing module equivalents were deprecated in Python 3.9. Python 3.12+: 
from collections.abc import Sized

def get_length[T: Sized](item: T) -> int:
    return len(item)
Legacy: 
from typing import TypeVar
from collections.abc import Sized

T = TypeVar('T', bound=Sized)

def get_length(item: T) -> int:
    return len(item)

​
Runtime Behavior and Type Erasure

Python implements generics via type erasure. The type variables and parameterizations (e.g., list[int]) are not enforced by the Python interpreter at runtime. Generic functions behave exactly like standard functions during execution. The generic signatures exist purely as metadata (accessible via __annotations__ and __type_params__) to be consumed by static analysis tools like mypy, pyright, or IDE language servers.
Master Python with Deep Grasping Methodology!Learn More