编程范式游记（2）- 泛型编程 [2026重制版]

// 原文中的C语言实现
int search(void* a, size_t size, void* target,
           size_t elem_size, int(*cmpFn)(void*, void*))
{
    for(int i=0; i<size; i++) {
        if ( cmpFn( a + elem_size * i, target) == 0 ) {
            return i;
        }
    }
    return -1;
}

// 使用泛型和迭代器协议的现代实现
function search<T>(
    iterable: Iterable<T>,
    predicate: (item: T) => boolean
): T | undefined {
    for (const item of iterable) {
        if (predicate(item)) {
            return item;
        }
    }
    return undefined;
}

// 使用示例
interface Employee {
    id: number;
    name: string;
    department: string;
}

const employees: Employee[] = [
    { id: 1, name: "张三", department: "技术部" },
    { id: 2, name: "李四", department: "市场部" },
    { id: 3, name: "王五", department: "技术部" },
];

// 查找技术部的员工
const techEmployee = search(
    employees,
    (emp) => emp.department === "技术部"
);
console.log(techEmployee); // { id: 1, name: "张三", department: "技术部" }

// 支持任何Iterable类型（包括Map、Set、Generator）
const numberSet = new Set([1, 2, 3, 4, 5]);
const found = search(numberSet, (n) => n > 3); // 4

// Rust使用trait bounds和迭代器trait
fn search<'a, T, I>(mut iter: I, predicate: impl FnMut(&T) -> bool) -> Option<&'a T>
where
    I: Iterator<Item = &'a T>,
{
    iter.find(|item| predicate(item))
}

#[derive(Debug)]
struct Employee {
    id: u32,
    name: String,
    department: String,
}

fn main() {
    let employees = vec![
        Employee { id: 1, name: String::from("张三"), department: String::from("技术部") },
        Employee { id: 2, name: String::from("李四"), department: String::from("市场部") },
    ];

    // 使用方法链式调用，编译器自动推断类型
    let tech_emp = employees.iter()
        .find(|emp| emp.department == "技术部");

    match tech_emp {
        Some(emp) => println!("找到: {:?}", emp),
        None => println!("未找到"),
    }
}

package main

import "fmt"

// Go使用接口约束和泛型
func search[T any](items%20[]T,%20predicate%20func(T) bool) (T, bool) {
    var zero T
    for _, item := range items {
        if predicate(item) {
            return item, true
        }
    }
    return zero, false
}

type Employee struct {
    ID         int
    Name       string
    Department string
}

func main() {
    employees := []Employee{
        {ID: 1, Name: "张三", Department: "技术部"},
        {ID: 2, Name: "李四", Department: "市场部"},
    }

    if emp, found := search(employees, func(e Employee) bool {
        return e.Department == "技术部"
    }); found {
        fmt.Printf("找到: %+v\n", emp)
    }
}

template <class Iter, class T, class Op>
T reduce(Iter start, Iter end, T init, Op op) {
    T result = init;
    while (start != end) {
        result = op(result, *start);
        start++;
    }
    return result;
}

// 定义泛型的reduce函数
function reduce<T, U>(
    iterable: Iterable<T>,
    initialValue: U,
    reducer: (acc: U, current: T) => U
): U {
    let acc = initialValue;
    for (const item of iterable) {
        acc = reducer(acc, item);
    }
    return acc;
}

interface Product {
    name: string;
    price: number;
    quantity: number;
    category: string;
}

const products: Product[] = [
    { name: "笔记本电脑", price: 8000, quantity: 2, category: "电子" },
    { name: "机械键盘", price: 500, quantity: 5, category: "电子" },
    { name: "办公椅", price: 1200, quantity: 10, category: "家具" },
];

// 计算总价值
const totalValue = reduce(
    products,
    0,
    (sum, product) => sum + product.price * product.quantity
);

console.log(`总价值: ¥${totalValue.toLocaleString()}`);
// 输出: 总价值: ¥30,500

// 结合filter和管道操作符（Stage 2提案）
// const electronicsTotal = products
//     |> filter($$, p => p.category === "电子")
//     |> reduce($$, 0, (sum, p) => sum + p.price * p.quantity);

from typing import TypeVar, Iterable, Callable, Protocol
from dataclasses import dataclass
from functools import reduce as ft_reduce

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

# PEP 695 新语法：类型参数声明
def my_reduce[
    T, U
](
    items: Iterable[T],
    initial: U,
    reducer: Callable[[U, T], U]
) -> U:
    """类型安全的reduce函数"""
    result = initial
    for item in items:
        result = reducer(result, item)
    return result


@dataclass
class Employee:
    name: str
    salary: float
    department: str


employees = [
    Employee("张三", 15000.0, "技术部"),
    Employee("李四", 12000.0, "市场部"),
    Employee("王五", 18000.0, "技术部"),
]

# 计算技术部总薪资
tech_total = my_reduce(
    (emp for emp in employees if emp.department == "技术部"),
    0.0,
    lambda total, emp: total + emp.salary
)

print(f"技术部总薪资: ¥{tech_total:,.2f}")
# 输出: 技术部总薪资: ¥33,000.00

#[derive(Debug)]
struct Employee {
    name: String,
    salary: f64,
    department: String,
}

fn main() {
    let employees = vec![
        Employee { name: "张三".into(), salary: 15000.0, department: "技术部".into() },
        Employee { name: "李四".into(), salary: 12000.0, department: "市场部".into() },
        Employee { name: "王五".into(), salary: 18000.0, department: "技术部".into() },
    ];

    // Rust的迭代器适配器链：filter -> map -> fold
    let tech_total: f64 = employees
        .iter()
        .filter(|emp| emp.department == "技术部")
        .map(|emp| emp.salary)
        .fold(0.0, |acc, salary| acc + salary);

    println!("技术部总薪资: ¥{:.2}", tech_total);
}

// ❌ 过于宽泛，容易出错
function process<T>(data: T): T { ... }

// ✅ 使用接口约束
interface Processable {
    validate(): boolean;
    transform(): unknown;
}

function process<T extends Processable>(data: T): T {
    if (!data.validate()) {
        throw new Error("验证失败");
    }
    return data.transform() as T;
}

// Go 1.18+ 泛型（注意：Go 目前不支持默认类型参数）
type Stack[T any] struct {
    items []T
}

func NewStack[T any]() *Stack[T] {
    return &Stack[T]{
        items: make([]T, 0),
    }
}

// 显式实例化，或由赋值目标推断类型参数
s := NewStack[string]()

// ❌ 不必要的复杂度
fn complex_operation<
    T: Clone + Debug + Serialize + DeserializeOwned,
    U: IntoIterator<Item = T>,
    V: Fn(T) -> Result<T, Box<dyn Error>>,
>(data: U, processor: V) -> Result<Vec<T>, Box<dyn Error>> { ... }

// ✅ 简洁明了
fn process_items<T: Clone>(items: &[T]) -> Vec<T> {
    items.to_vec()
}

# PEP 695 新语法（Python 3.12+）
def first[T](items:%20list[T]) -> T | None:
    """返回列表第一个元素"""
    return items[0] if items else None

# 自动推导返回类型
result: str | None = first(["hello", "world"])

/**
 * 对可排序数组进行二分查找
 * @template T - 必须实现Comparable接口的类型
 * @param {T[]} sortedArray - 已排序的数组
 * @param {T} target - 要查找的目标值
 * @returns {number} 目标值的索引，未找到返回-1
 */
function binarySearch<T extends Comparable<T>>(
    sortedArray: T[],
    target: T
): number {
    let left = 0;
    let right = sortedArray.length - 1;

    while (left <= right) {
        const mid = Math.floor((left + right) / 2);
        const comparison = sortedArray[mid].compareTo(target);

        if (comparison === 0) return mid;
        else if (comparison < 0) left = mid + 1;
        else right = mid - 1;
    }

    return -1;
}

// ❌ 继承导致耦合
abstract class BaseRepository<T> {
    abstract find(id: string): Promise<T>;
    abstract save(entity: T): Promise<void>;
}

class UserRepository extends BaseRepository<User> { ... }

// ✅ 组合提供灵活性
interface Repository<T> {
    find(id: string): Promise<T>;
    save(entity: T): Promise<void>;
}

// 可以自由混入其他能力
interface Cacheable<T> {
    getFromCache(id: string): Promise<T | null>;
    setToCache(id: string, entity: T): Promise<void>;
}

class CachedUserRepository implements Repository<User>, Cacheable<User> {
    async find(id: string): Promise<User> {
        const cached = await this.getFromCache(id);
        if (cached) return cached;
        const user = await this.dbFind(id);
        await this.setToCache(id, user);
        return user;
    }
}

// Rust: 零成本泛型抽象
#[inline(always)]
fn generic_sum<T: std::ops::Add<Output = T> + Copy>(values: &[T], init: T) -> T {
    values.iter().fold(init, |acc, &v| acc + v)
}

// 编译后等同于手写的具体类型版本
fn concrete_sum(values: &[i32], init: i32) -> i32 {
    values.iter().fold(init, |acc, v| acc + v)
}
// 两者生成的机器码完全相同！