Solution

  1. #[derive(Debug)]
  2. enum Language {
  3.     Rust,
  4.     Java,
  5.     Perl,
  6. }
  8. #[derive(Clone, Debug)]
  9. struct Dependency {
  10.     name: String,
  11.     version_expression: String,
  12. }
  14. /// A representation of a software package.
  15. #[derive(Debug)]
  16. struct Package {
  17.     name: String,
  18.     version: String,
  19.     authors: Vec<String>,
  20.     dependencies: Vec<Dependency>,
  21.     language: Option<Language>,
  22. }
  24. impl Package {
  25.     /// Return a representation of this package as a dependency, for use in
  26.     /// building other packages.
  27.     fn as_dependency(&self) -> Dependency {
  28.         Dependency {
  29.             name: self.name.clone(),
  30.             version_expression: self.version.clone(),
  31.         }
  32.     }
  33. }
  35. /// A builder for a Package. Use `build()` to create the `Package` itself.
  36. struct PackageBuilder(Package);
  38. impl PackageBuilder {
  39.     fn new(name: impl Into<String>) -> Self {
  40.         Self(Package {
  41.             name: name.into(),
  42.             version: "0.1".into(),
  43.             authors: vec![],
  44.             dependencies: vec![],
  45.             language: None,
  46.         })
  47.     }
  49.     /// Set the package version.
  50.     fn version(mut self, version: impl Into<String>) -> Self {
  51.         self.0.version = version.into();
  52.         self
  53.     }
  55.     /// Set the package authors.
  56.     fn authors(mut self, authors: Vec<String>) -> Self {
  57.         self.0.authors = authors;
  58.         self
  59.     }
  61.     /// Add an additional dependency.
  62.     fn dependency(mut self, dependency: Dependency) -> Self {
  63.         self.0.dependencies.push(dependency);
  64.         self
  65.     }
  67.     /// Set the language. If not set, language defaults to None.
  68.     fn language(mut self, language: Language) -> Self {
  69.         self.0.language = Some(language);
  70.         self
  71.     }
  73.     fn build(self) -> Package {
  74.         self.0
  75.     }
  76. }
  78. fn main() {
  79.     let base64 = PackageBuilder::new("base64").version("0.13").build();
  80.     println!("base64: {base64:?}");
  81.     let log =
  82.         PackageBuilder::new("log").version("0.4").language(Language::Rust).build();
  83.     println!("log: {log:?}");
  84.     let serde = PackageBuilder::new("serde")
  85.         .authors(vec!["djmitche".into()])
  86.         .version(String::from("4.0"))
  87.         .dependency(base64.as_dependency())
  88.         .dependency(log.as_dependency())
  89.         .build();
  90.     println!("serde: {serde:?}");
  91. }