Python 타입 힌트 고급 활용: Generic, Protocol, TypeVar로 타입 안전한 라이브러리 설계하기

from typing import TypeVar

T = TypeVar('T')

def first(items: list[T]) -> T:
    return items[0]

# mypy가 자동으로 타입을 추론합니다
name = first(["Alice", "Bob"])    # str로 추론
count = first([1, 2, 3])          # int로 추론

from typing import TypeVar
from collections.abc import Sized

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

def longest(a: ST, b: ST) -> ST:
    return a if len(a) >= len(b) else b

result = longest([1, 2], [3, 4, 5])   # list[int]
result = longest("hi", "hello")       # str

from typing import TypeVar, Generic
from dataclasses import dataclass

T = TypeVar('T')

@dataclass
class Result(Generic[T]):
    data: T | None
    error: str | None = None

    @property
    def is_ok(self) -> bool:
        return self.error is None

    def unwrap(self) -> T:
        if self.data is None:
            raise ValueError(f"Result has no data: {self.error}")
        return self.data

# 사용 시 타입이 정확하게 추론됩니다
def fetch_user(user_id: int) -> Result[dict]:
    try:
        user = {"id": user_id, "name": "Alice"}
        return Result(data=user)
    except Exception as e:
        return Result(data=None, error=str(e))

result = fetch_user(1)
if result.is_ok:
    user = result.unwrap()  # mypy가 dict 타입으로 인식

K = TypeVar('K')
V = TypeVar('V')

class Registry(Generic[K, V]):
    def __init__(self) -> None:
        self._store: dict[K, V] = {}

    def register(self, key: K, value: V) -> None:
        self._store[key] = value

    def get(self, key: K) -> V | None:
        return self._store.get(key)

# 키는 str, 값은 int로 고정
counter = Registry[str, int]()
counter.register("visits", 42)
counter.register("visits", "많음")  # mypy 에러!

from typing import Protocol, runtime_checkable

@runtime_checkable
class Renderable(Protocol):
    def render(self) -> str: ...

class HtmlWidget:
    def render(self) -> str:
        return "<div>Widget</div>"

class JsonResponse:
    def render(self) -> str:
        return '{"status": "ok"}'

def display(item: Renderable) -> None:
    print(item.render())

# HtmlWidget과 JsonResponse는 Renderable을 상속하지 않았지만
# render() 메서드가 있으므로 타입 체크를 통과합니다
display(HtmlWidget())     # OK
display(JsonResponse())   # OK
display(42)               # mypy 에러!

from typing import TypeVar, Generic, Protocol
from dataclasses import dataclass

# 엔티티가 갖춰야 할 최소 인터페이스
class HasId(Protocol):
    @property
    def id(self) -> int: ...

E = TypeVar('E', bound=HasId)

class Repository(Generic[E]):
    """어떤 엔티티든 저장·조회할 수 있는 제네릭 저장소"""

    def __init__(self) -> None:
        self._items: dict[int, E] = {}

    def save(self, entity: E) -> None:
        self._items[entity.id] = entity

    def find_by_id(self, entity_id: int) -> E | None:
        return self._items.get(entity_id)

    def find_all(self) -> list[E]:
        return list(self._items.values())

# 엔티티 정의 — HasId를 상속하지 않아도 됩니다
@dataclass
class User:
    id: int
    name: str
    email: str

@dataclass
class Product:
    id: int
    title: str
    price: float

# 각각 타입 안전한 저장소
user_repo = Repository[User]()
user_repo.save(User(id=1, name="Alice", email="a@b.com"))

found = user_repo.find_by_id(1)  # User | None으로 추론

product_repo = Repository[Product]()
product_repo.save(Product(id=1, title="키보드", price=89000))

# Python 3.12 이전
T = TypeVar('T')
def first(items: list[T]) -> T: ...

# Python 3.12 이후 — 타입 매개변수 문법
def first[T](items: list[T]) -> T: ...

# 클래스도 마찬가지
class Result[T]:
    data: T | None
    error: str | None = None