Why does it not compile?

src/modules/package/builder.rs

@@ -0,0 +1,103 @@
+use super::{PackageArgs, IntoPackageList, PackageList, PackageState, PackageModule, PackageStatus, PackageError, SpecificPackageManager};
+use super::apt::DebianPackageManager;
+use super::pacman::ArchlinuxPackageManager;
+use std::boxed::Box;
+
+use crate::Module;
+
+pub struct PackageArgsBuilder<Packages, State, Manager> {
+    name: Packages,
+    state: State,
+    manager: Manager,
+}
+
+pub struct NoPackage;
+pub struct NoState;
+pub struct NoManager;
+
+impl PackageArgsBuilder<NoPackage, NoState, NoManager> {
+    pub fn new() -> PackageArgsBuilder<NoPackage, NoState, NoManager> {
+        PackageArgsBuilder {
+            name: NoPackage,
+            state: NoState,
+            manager: NoManager,
+        }
+    }
+}
+
+impl<State, Manager> PackageArgsBuilder<NoPackage, State, Manager> {
+    pub fn name<T: IntoPackageList>(self, list: T) -> PackageArgsBuilder<PackageList, State, Manager> {
+        let Self { state, manager, .. } = self;
+
+        PackageArgsBuilder {
+            name: list.into_package_list(),
+            state,
+            manager,
+        }
+    }
+}
+
+impl<Packages, Manager> PackageArgsBuilder<Packages, NoState, Manager> {
+    pub fn state(self, state: PackageState) -> PackageArgsBuilder<Packages, PackageState, Manager> {
+        let Self { name, manager, .. } = self;
+
+        PackageArgsBuilder {
+            name,
+            state,
+            manager,
+        }
+    }
+}
+
+impl<Packages, State> PackageArgsBuilder<Packages, State, NoManager> {
+    pub fn with(self, manager: impl SpecificPackageManager + 'static) -> PackageArgsBuilder<Packages, State, Box<dyn SpecificPackageManager>> {
+        let Self { name, state, .. } = self;
+
+        PackageArgsBuilder {
+            name,
+            state,
+            manager: Box::new(manager),
+        }
+    }
+
+    pub fn with_apt(self) -> PackageArgsBuilder<Packages, State, Box<dyn SpecificPackageManager>> {
+        let Self { name, state, .. } = self;
+        PackageArgsBuilder {
+            name,
+            state,
+            manager: Box::new(DebianPackageManager),
+        }
+    }
+
+    pub fn with_pacman(self) -> PackageArgsBuilder<Packages, State, Box<dyn SpecificPackageManager>> {
+        let Self { name, state, .. } = self;
+        PackageArgsBuilder {
+            name,
+            state,
+            manager: Box::new(ArchlinuxPackageManager),
+        }
+    }
+}
+    
+
+// We can only RUN the args when a package manager has been set. Alternatively,
+// when called inside a playbook, the package manager can be populated automatically from facts.
+impl PackageArgsBuilder<PackageList, PackageState, Box<dyn SpecificPackageManager>> {
+    pub fn run(self) -> Result<PackageStatus, PackageError> {
+        self.build().run()
+    }
+}
+
+impl PackageArgsBuilder<PackageList, PackageState, Box<dyn SpecificPackageManager>> {
+    pub fn build(self) -> PackageModule<Box<dyn SpecificPackageManager>> {
+        let Self { name, state, manager, .. } = self;
+
+        PackageModule {
+            args: PackageArgs {
+                name,
+                state,
+            },
+            manager,
+        }
+    }
+}