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.