Why does it not compile?

src/modules/mod.rs

@@ -0,0 +1,132 @@
+//use erased_serde::Serialize;
+use serde::Serialize;
+
+use crate::Facts;
+
+pub mod package;
+pub mod command;
+
+#[derive(Clone, Debug, Serialize)]
+pub struct TaskRun {
+    /// the arguments passed to the module
+    module_args: serde_json::Value,
+    //name: String,
+    /// the name of the module
+    module: String,
+    #[serde(flatten)]
+    /// the status of the task run (ok, skip, fail)
+    status: TaskStatus,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag="status", content = "return")]
+pub enum TaskStatus {
+    #[serde(rename="ok")]
+    Ok(serde_json::Value),
+    #[serde(rename="skip")]
+    Skip(serde_json::Value),
+    #[serde(rename="fail")]
+    Fail(serde_json::Value),
+}
+
+impl TaskStatus {
+    pub fn ok<T: Serialize>(val: T) -> TaskStatus {
+        TaskStatus::Ok(serde_json::to_value(val).unwrap())
+    }
+
+    pub fn skip<T: Serialize>(val: T) -> TaskStatus {
+        TaskStatus::Skip(serde_json::to_value(val).unwrap())
+    }
+
+    pub fn fail<T: Serialize>(val: T) -> TaskStatus {
+        TaskStatus::Fail(serde_json::to_value(val).unwrap())
+    }
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct PlaybookRun {
+    pub facts: Facts,
+    pub steps: Vec<TaskRun>,
+}
+
+impl PlaybookRun {
+    pub fn new() -> PlaybookRun {
+        PlaybookRun {
+            facts: Facts::new(),
+            steps: Vec::new(),
+        }
+    }
+    
+    pub fn add_step(&mut self, step: TaskRun) {
+        self.steps.push(step);
+    }
+
+    pub fn print_json(&self) {
+        println!("{}", serde_json::to_string(&self).unwrap());
+    }
+
+    pub fn print_json_pretty(&self) {
+        println!("{}", serde_json::to_string_pretty(&self).unwrap());
+    }
+
+    pub fn run<MS: ModuleSetup<A, S, E>, A: Serialize, S: Serialize, E: Serialize>(&mut self, cmd: MS) -> Result<S, E> {
+        let module = cmd.with_facts(&self.facts);
+        self.run_inner(module)
+    }
+
+    pub fn run_inner<A: Serialize, S: Serialize, E: Serialize>(&mut self, cmd: Box<dyn Module<A, S, E>>) -> Result<S, E> {
+        // TODO: Check conditions for skip
+
+        let module_name = cmd.module_name().to_string();
+        let args = cmd.serialize_args();
+
+        let res = cmd.run();
+        
+        let status = match &res {
+            Ok(s) => {
+                //self.add_step(s)
+                TaskStatus::ok(s)
+            }, Err(e) => {
+                TaskStatus::fail(e)
+            }
+        };
+
+        let run = TaskRun {
+            module_args: args,
+            module: module_name,
+            status,
+        };
+
+        self.add_step(run);
+
+        res
+    }
+}
+
+// pub trait Loopable {
+//     fn loop_with<T>(self, looped: dyn Fn(Self) -> Self, with: Vec<T>);
+// }
+
+/// A trait for modules to be run in the context of a playbook, by gathering facts
+pub trait ModuleSetup<A, S, E> {
+    // type module: Module<A, S, E>;
+    
+    fn with_facts(self, facts: &Facts) -> Box<dyn Module<A, S, E>>;
+}
+
+/// A Module takes some arguments which can be serialized back to the playbook run, and can be run to produce
+/// a certain result.
+pub trait Module<A: Serialize, S: Serialize, E: Serialize>: Sized {
+    /// Return the module name as string slice
+    fn module_name(&self) -> &'static str;
+
+    /// Clone the arguments to be stored in the playbook's task run
+    fn serialize_args(&self) -> serde_json::Value;
+
+    /// Run the module, producing a result
+    fn run(self) -> Result<S, E>;
+}
+
+/// Declare module types
+pub use command::CommandModule as Command;
+