Applying Rust‑Inspired Type Safety and Design Patterns to Python

After years of using Rust, the author reflects on how its rigorous type system changed the way they write Python code, shifting from loosely‑typed, dictionary‑heavy functions to more explicit, type‑annotated interfaces.

Key practices include:

Using def find_item(records: List[Item], check: Callable[[Item], bool]) -> Optional[Item]: to make function contracts clear.

Replacing ambiguous tuples or dictionaries with @dataclass structures, e.g., @dataclass class City: name: str zip_code: int @dataclass class Person: name: str city: City age: int def find_person(...) -> Person:

Modeling sum types with typing.Union (or the | operator in Python 3.10) to emulate Rust’s algebraic data types: Packet = Header | Payload | Trailer

Using NewType to create distinct identifier types and catch swapped arguments at type‑checking time: CarId = NewType("CarId", int) DriverId = NewType("DriverId", int)

Applying the typestate pattern by splitting object states into separate classes, e.g., a ConnectedClient returned from a connect function and an AuthenticatedClient returned from authenticate .

Designing safer mutexes by embedding the protected value inside a generic Mutex class and exposing a context‑manager lock method: class Mutex(Generic[T]): def __init__(self, value: T): self.__value = value self.__lock = Lock() @contextlib.contextmanager def lock(self) -> ContextManager[T]: self.__lock.acquire() try: yield self.__value finally: self.__lock.release()

These techniques collectively make Python code more robust by preventing invalid states, improving IDE assistance, and enabling compile‑time‑like checks through static type analysis.