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. ```
    }
    ```