How can I avoid a ripple effect from changing a concrete struct to generic?

by

While generic types can seem to “infect” the rest of your code, that’s exactly why they are beneficial! The compiler knowledge about how big and specifically what type is used allow it to make better optimization decisions.

That being said, it can be annoying! If you have a small number of types that implement your trait, you can also construct an enum of those types and delegate to the child implementations:

enum MyBuilders {
    User(FromUser),
    File(FromFile),
}

impl ListBuilder for MyBuilders {
    fn build(&self, list: &mut Vec<String>) {
        use MyBuilders::*;
        match self {
            User(u) => u.build(list),
            File(f) => f.build(list),
        }
    }
}

// Support code

trait ListBuilder {
    fn build(&self, list: &mut Vec<String>);
}

struct FromUser;
impl ListBuilder for FromUser {
    fn build(&self, list: &mut Vec<String>) {}
}

struct FromFile;
impl ListBuilder for FromFile {
    fn build(&self, list: &mut Vec<String>) {}
}

Now the concrete type would be Conf<MyBuilders>, which you can use a type alias to hide.

I’ve used this to good effect when I wanted to be able to inject test implementations into code during testing, but had a fixed set of implementations that were used in the production code.

The enum_dispatch crate helps construct this pattern.

More Related Contents:

  1. “Expected type parameter” error in the constructor of a generic struct
  2. How do I use integer number literals when using generic types?
  3. The trait cannot be made into an object
  4. Conflicting implementations of trait in Rust
  5. Generics Error: expected type parameter, found struct
  6. Why can’t I add a blanket impl on a trait with a type parameter?
  7. Can I avoid eager ambiguity resolution for trait implementations with generics?
  8. What is the cited problem with using generic type parameters in trait objects?
  9. How do I require a generic type implement an operation like Add, Sub, Mul, or Div in a generic function?
  10. How to write a trait bound for adding two references of a generic type?
  11. How do I write the lifetimes for references in a type constraint when one of them is a local reference?
  12. Why does a generic method inside a trait require trait object to be sized?
  13. How do I return a Filter iterator from a function?
  14. Matching a generic parameter to an associated type in an impl
  15. Why can’t I use a key function that returns a reference when sorting a vector with sort_by_key?
  16. Why can’t `&(?Sized + Trait)` be cast to `&dyn Trait`?
  17. What does the question mark mean in a type parameter bound?
  18. What does it mean to instantiate a Rust generic with an underscore?
  19. Writing a generic function that takes an iterable container as parameter in Rust
  20. How do I unwrap an arbitrary number of nested Option types?
  21. Unable to create a polymorphic type because the trait cannot be made into an object
  22. How to clone a struct storing a boxed trait object?
  23. How do I implement a trait I don’t own for a type I don’t own?
  24. What makes something a “trait object”?
  25. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  26. How does the mechanism behind the creation of boxed traits work?
  27. C# Adding two Generic Values
  28. Automatically implement traits of enclosed type for Rust newtypes (tuple structs with one field)
  29. Calling a static method from a generic constraint Dart
  30. Generic extending class AND implements interface in Kotlin

Leave a Comment