如何以Rust风格通过静态派生地实例化指定类型的具体结构体？

需求：

• 现有GoodBook和BadBook两个结构体，需分别为它们实现专属的GoodBookPrinter和BadBookPrinter，每个打印机仅对应一种书籍类型，无需泛型。
• 实现一个CollectionPrinter，它能接收Vec<GoodBook>或Vec<BadBook>，并生成对应的Vec<GoodBookPrinter>或Vec<BadBookPrinter>。
• 调用者明确指定书籍和对应打印机类型，要求用静态分派实现，避免动态分派开销。

以下是我的尝试代码，但存在编译错误，不知如何用trait和泛型正确组织逻辑：

struct GoodBook {
    id: u32,
}

struct BadBook {
    id: u32,
}

struct GoodBookPrinter<T> {
    // 实际上不需要泛型，我希望这里是：
    // target: GoodBook
    target: T,
}

trait Printer<T> {
    // 所有打印机都应能通过DefaultCollectionPrinter创建
    fn new(target: T) -> Self;
}

impl<T> Printer<T> for GoodBookPrinter<T> {
    // 如果GoodBookPrinter定义为target: GoodBook，编译器会报错，所以我将其设为泛型
    fn new(target: T) -> Self {
        Self {
            target
        }
    }
}

// 该Vec只会存储Printer<GoodBook>或Printer<BadBook>，不会同时存储两者
// T始终是结构体，GoodBook和BadBook除了id字段外无其他共性
struct DefaultCollectionPrinter<T> {
    printers: Vec<T>,
}

// 我尝试用带关联类型的trait实现DefaultCollectionPrinter的功能，但这可能不对，
// 我不知道更好的方式让它存储Vec<GoodBookPrinter<GoodBook>>或Vec<BadBookPrinter<BadBook>>等
 trait CollectionStuff<T> {
    // 应支持GoodBookPrinter<GoodBook>和BadBookPrinter<BadBook>
    type S: Printer<T>;

    // 将每本书封装到对应的打印机中
    fn new(books: Vec<T>) -> DefaultCollectionPrinter<Self::S> {
        let mut printers: Vec<Self::S> = vec![];
        for book in books {
            let printer = Self::S::new(book);
            printers.push(printer);
        }

        DefaultCollectionPrinter::<Self::S> {
            printers
        }
    }
}

// 告知DefaultCollectionPrinter它将处理GoodBookPrinter<GoodBook>，但如何同时支持BadBookPrinter<BadBook>？
impl<T> CollectionStuff<T> for DefaultCollectionPrinter<T> {
    // 错误：trait GoodBookPrinter<GoodBook>: Printer<T>未满足
    type S = GoodBookPrinter<GoodBook>;
}

fn main() {
    // 我希望能实现类似这样的逻辑：创建书籍Vec，让DefaultCollectionPrinter
    // 根据书籍类型生成对应的Vec<GoodBookPrinter<GoodBook>>或Vec<BadBookPrinter<BadBook>>
    let books = vec![GoodBook{ id: 1 }, GoodBook{ id: 2 }];
    let printers = DefaultCollectionPrinter::new(books).printers;
}

解决方案 #

核心思路是通过关联类型的trait绑定书籍类型与对应打印机类型，让编译器在编译时确定类型关系，实现静态分派。

1. 定义专属打印机结构体 #

去掉不必要的泛型，让每个打印机仅持有对应类型的书籍，逻辑更清晰：

struct GoodBook {
    id: u32,
}

struct BadBook {
    id: u32,
}

// 专属GoodBook的打印机，无需泛型
struct GoodBookPrinter {
    target: GoodBook,
}

// 专属BadBook的打印机，无需泛型
struct BadBookPrinter {
    target: BadBook,
}

2. 用关联类型绑定打印机与书籍 #

定义带关联类型的Printer trait，替代原泛型trait，明确每个打印机对应的书籍类型：

trait Printer {
    // 关联类型：当前打印机对应的书籍类型
    type Book;
    // 从书籍创建打印机的方法
    fn new(target: Self::Book) -> Self;
}

// 为GoodBookPrinter实现Printer，绑定书籍类型为GoodBook
impl Printer for GoodBookPrinter {
    type Book = GoodBook;
    fn new(target: GoodBook) -> Self {
        Self { target }
    }
}

// 为BadBookPrinter实现Printer，绑定书籍类型为BadBook
impl Printer for BadBookPrinter {
    type Book = BadBook;
    fn new(target: BadBook) -> Self {
        Self { target }
    }
}

3. 实现CollectionPrinter #

让CollectionPrinter依赖Printer trait，通过关联类型自动推导对应的书籍类型，实现批量转换：

struct CollectionPrinter<P: Printer> {
    printers: Vec<P>,
}

impl<P: Printer> CollectionPrinter<P> {
    // 接收对应书籍类型的Vec，批量生成打印机集合
    fn new(books: Vec<P::Book>) -> Self {
        let printers = books.into_iter()
            .map(P::new)
            .collect();
        Self { printers }
    }
}

完整可运行代码 #

struct GoodBook {
    id: u32,
}

struct BadBook {
    id: u32,
}

struct GoodBookPrinter {
    target: GoodBook,
}

struct BadBookPrinter {
    target: BadBook,
}

trait Printer {
    type Book;
    fn new(target: Self::Book) -> Self;
}

impl Printer for GoodBookPrinter {
    type Book = GoodBook;
    fn new(target: GoodBook) -> Self {
        Self { target }
    }
}

impl Printer for BadBookPrinter {
    type Book = BadBook;
    fn new(target: BadBook) -> Self {
        Self { target }
    }
}

struct CollectionPrinter<P: Printer> {
    printers: Vec<P>,
}

impl<P: Printer> CollectionPrinter<P> {
    fn new(books: Vec<P::Book>) -> Self {
        let printers = books.into_iter()
            .map(P::new)
            .collect();
        Self { printers }
    }
}

fn main() {
    // 处理GoodBook生成GoodBookPrinter集合
    let good_books = vec![GoodBook{ id: 1 }, GoodBook{ id: 2 }];
    let good_printers = CollectionPrinter::<GoodBookPrinter>::new(good_books).printers;
    println!("生成了{}个GoodBookPrinter", good_printers.len());

    // 处理BadBook生成BadBookPrinter集合
    let bad_books = vec![BadBook{ id: 3 }, BadBook{ id: 4 }];
    let bad_printers = CollectionPrinter::<BadBookPrinter>::new(bad_books).printers;
    println!("生成了{}个BadBookPrinter", bad_printers.len());
}

关键说明 #

• 静态分派：编译器在编译时就确定CollectionPrinter使用的是GoodBookPrinter还是BadBookPrinter，所有方法调用静态解析，无运行时开销。
• 类型安全：若尝试用GoodBook创建BadBookPrinter集合，编译器会直接报错，保证类型匹配。
• 无冗余泛型：每个打印机结构体仅持有对应类型的书籍，逻辑简洁易懂。

内容的提问来源于stack exchange，提问作者rust-nub