from typing import TypeVar, List

# 定義一個(gè)類型變量 T
# 習(xí)慣上變量名和字符串參數(shù)保持一致
T = TypeVar('T')

from typing import TypeVar, List

T = TypeVar('T')

def get_first(items: List[T]) -> T:
    """返回列表的第一個(gè)元素，類型與列表元素類型一致"""
    return items[0]

# 使用示例
n: int = get_first([1, 2, 3])      # T 被推斷為 int
s: str = get_first(["a", "b"])     # T 被推斷為 str

# IDE 會(huì)報(bào)錯(cuò)的例子:
# x: str = get_first([1, 2, 3])    # 錯(cuò)誤: 期望返回 int，但標(biāo)記為 str

from typing import TypeVar, Generic

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()

# 具體化使用
int_stack = Stack[int]()
int_stack.push(1)
# int_stack.push("a")  # 類型檢查錯(cuò)誤: 期望 int

str_stack = Stack[str]()
str_stack.push("hello")

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

class KeyValuePair(Generic[K, V]):
    def __init__(self, key: K, value: V):
        self.key = key
        self.value = value

pair = KeyValuePair[str, int]("age", 25)

class Animal:
    def speak(self): pass

class Dog(Animal): ...
class Cat(Animal): ...

# T 必須是 Animal 或其子類
A = TypeVar('A', bound=Animal)

def make_noise(animal: A) -> None:
    animal.speak()

make_noise(Dog()) # OK
# make_noise("hello") # Error: str 不是 Animal 的子類

// Java 不需要提前定義 T
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 使用
Box<String> box = new Box<>();
box.set("hello");

from typing import TypeVar, Generic

# Python 必須先定義 T
T = TypeVar('T') 

class Box(Generic[T]):
    def __init__(self) -> None:
        self.content: T = None
        
    def set(self, content: T) -> None:
        self.content = content
        
    def get(self) -> T:
        return self.content

# 使用
box = Box[str]()
box.set("hello")

// T 必須是 Animal 或其子類
public class Zoo<T extends Animal> {
    private T animal;
    
    public void set(T animal) {
        // 可以安全調(diào)用 Animal 的方法
        animal.speak();
    }
}

# T 必須是 Animal 或其子類
T = TypeVar('T', bound='Animal')

class Zoo(Generic[T]):
    def __init__(self, animal: T):
        self.animal = animal
        
    def set(self, animal: T) -> None:
        # 可以安全調(diào)用 Animal 的方法
        self.animal.speak()

from typing import TypeVar, Generic, List, Optional
from dataclasses import dataclass

# 假設(shè)有兩個(gè)實(shí)體模型
@dataclass
class User:
    id: int
    name: str

@dataclass
class Document:
    id: int
    content: str

# 定義泛型 T，約束為必須有 id 屬性 (這里用 Protocol 更高級(jí)，但簡(jiǎn)化演示用)
T = TypeVar('T')

class BaseRepository(Generic[T]):
    def __init__(self):
        self.db: dict[int, T] = {}

    def save(self, entity: T) -> None:
        # 假設(shè)實(shí)體都有 id 屬性
        self.db[entity.id] = entity

    def get(self, id: int) -> Optional[T]:
        return self.db.get(id)

    def find_all(self) -> List[T]:
        return list(self.db.values())

# 具體實(shí)現(xiàn)
class UserRepository(BaseRepository[User]):
    def find_by_name(self, name: str) -> Optional[User]:
        for user in self.db.values():
            if user.name == name:
                return user
        return None

# 使用
user_repo = UserRepository()
user_repo.save(User(1, "Alice"))
user = user_repo.get(1) # 類型自動(dòng)推斷為 User

from typing import Protocol, TypeVar

T = TypeVar('T')

class Reader(Protocol[T]):
    def read(self) -> T:
        ...

def process_data(reader: Reader[str]) -> None:
    print(reader.read())

class FileReader:
    def read(self) -> str:
        return "file content"

# FileReader 沒(méi)有繼承 Reader，但符合結(jié)構(gòu)，可以通過(guò)檢查
process_data(FileReader())