I’d like to create new instances of structs based on a type given by the caller.

Given two structs: GoodBook and BadBook, I want to wrap those in a type specific Printer. Each book will have its own printer, ie: GoodBookPrinter or BadBookPrinter. Then I’d like a CollectionPrinter that can accept a Vec<GoodBook> or Vec<BadBook> and create a Vec<GoodBookPrinter<GoodBook>> or Vec<BadBookPrinter<BadBook>>.

The caller to CollectionPrinter will know which type of Printer and Book it needs, but I’m confused on how to implement this with traits/generics.

What is the rust way to do this using static dispatch?

My failed attempt:

struct GoodBook {
    id: u32,
}

struct BadBook {
    id: u32,
}

struct GoodBookPrinter<T> {
    // This doesn't actually need to be generic.
    // I'd like for this to be:
    // target: GoodBook
    target: T,
}

trait Printer<T> {
    // All printers should be new-able from the DefaultCollectionPrinter
    fn new(target: T) -> Self;
}

impl<T> Printer<T> for GoodBookPrinter<T> {
    // Compiler would start to complain here if GoodBookPrinter was defined as:
    // target: GoodBook
    // so I've made it generic.
    fn new(target: T) -> Self {
        Self {
            target
        }
    }
}

// The vec will hold Printer<GoodBook> or Printer<BadBook> but never both.
// T will always be a struct
// GoodBook and BadBook have nothing in common
// except an id field
struct DefaultCollectionPrinter<T> {
    printers: Vec<T>,
}

// I'm using a trait with an associated type to implement the functionality
// of DefaultCollectionPrinter, which must be wrong, but I don't know a better
// way to have DefaultCollectionPrinter store a Vec<GoodBookPrinter<GoodBook>> or
// Vec<BadBookPrinter<BadBook>>, etc...
trait CollectionStuff<T> {
    // Should work with GoodBookPrinter<GoodBook> and GoodBookPrinter<BadBook>
    type S: Printer<T>;

    // Wrap each book in its associated printer
    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
        }
    }
}

// Tell the DefaultCollectionPrinter that it will be working with
// a GoodBookPrinter<GoodBook> ... but how would it also work with
// BadBookPrinter<BadBook>?
impl<T> CollectionStuff<T> for DefaultCollectionPrinter<T> {
    // Error: the trait GoodBookPrinter<GoodBook>: Printer<T> is not satisfied
    type S = GoodBookPrinter<GoodBook>;
}

fn main() {
    // I want to be able to do something like this:
    // create a vec of books and have the DefaultCollectionPrinter
    // create a Vec<GoodBookPrinter<GoodBook>> or Vec<BadBookPrinter<BadBook>>
    // depending on the type of book given.
    let books = vec![GoodBook{ id: 1 }, GoodBook{ id: 2 }];
    let printers = DefaultCollectionPrinter::new(books).printers;
}