Remove redundant generic parameter from Program struct

5 files changed, 31 insertions, 46 deletions

diff --git a/mingling_core/src/program/exec.rs b/mingling_core/src/program/exec.rs
index 68a694e..c1eada5 100644
--- a/mingling_core/src/program/exec.rs
+++ b/mingling_core/src/program/exec.rs
@@ -9,11 +9,9 @@ use crate::{
 pub mod error;
 
 #[cfg(feature = "async")]
-pub async fn exec<C, G>(
-    program: &Program<C, G>,
-) -> Result<RenderResult, ProgramInternalExecuteError>
+pub async fn exec<C>(program: &Program<C>) -> Result<RenderResult, ProgramInternalExecuteError>
 where
-    C: ProgramCollect<Enum = G>,
+    C: ProgramCollect<Enum = C>,
 {
     let mut current = dispatch_args_dynamic(program, program.args.clone())?;
     let mut stop_next = false;
@@ -26,7 +24,7 @@ where
             if C::has_chain(&current) {
                 match C::do_chain(current).await {
                     ChainProcess::Ok((any, Next::Renderer)) => {
-                        return Ok(render::<C, G>(program, any));
+                        return Ok(render::<C>(program, any));
                     }
                     ChainProcess::Ok((any, Next::Chain)) => any,
                     ChainProcess::Err(e) => return Err(e.into()),
@@ -34,7 +32,7 @@ where
             }
             // If no chain exists, attempt to render
             else if C::has_renderer(&current) {
-                return Ok(render::<C, G>(program, current));
+                return Ok(render::<C>(program, current));
             }
             // No renderer exists
             else {
@@ -51,9 +49,9 @@ where
 }
 
 #[cfg(not(feature = "async"))]
-pub fn exec<C, G>(program: &Program<C, G>) -> Result<RenderResult, ProgramInternalExecuteError>
+pub fn exec<C>(program: &Program<C>) -> Result<RenderResult, ProgramInternalExecuteError>
 where
-    C: ProgramCollect<Enum = G>,
+    C: ProgramCollect<Enum = C>,
 {
     let mut current = dispatch_args_dynamic(program, program.args.clone())?;
     let mut stop_next = false;
@@ -66,7 +64,7 @@ where
             if C::has_chain(&current) {
                 match C::do_chain(current) {
                     ChainProcess::Ok((any, Next::Renderer)) => {
-                        return Ok(render::<C, G>(program, any));
+                        return Ok(render::<C>(program, any));
                     }
                     ChainProcess::Ok((any, Next::Chain)) => any,
                     ChainProcess::Err(e) => return Err(e.into()),
@@ -74,7 +72,7 @@ where
             }
             // If no chain exists, attempt to render
             else if C::has_renderer(&current) {
-                return Ok(render::<C, G>(program, current));
+                return Ok(render::<C>(program, current));
             }
             // No renderer exists
             else {
@@ -91,12 +89,12 @@ where
 }
 
 /// Dynamically dispatch input arguments to registered entry types
-pub(crate) fn dispatch_args_dynamic<C, G>(
-    program: &Program<C, G>,
+pub(crate) fn dispatch_args_dynamic<C>(
+    program: &Program<C>,
     args: Vec<String>,
-) -> Result<AnyOutput<G>, ProgramInternalExecuteError>
+) -> Result<AnyOutput<C>, ProgramInternalExecuteError>
 where
-    C: ProgramCollect<Enum = G>,
+    C: ProgramCollect<Enum = C>,
 {
     let next = match match_user_input(program, args) {
         Ok((dispatcher, args)) => {
@@ -117,18 +115,18 @@ where
 
 /// Match user input against registered dispatchers and return the matched dispatcher and remaining arguments.
 #[allow(clippy::type_complexity)]
-pub(crate) fn match_user_input<C, G>(
-    program: &Program<C, G>,
+pub(crate) fn match_user_input<C>(
+    program: &Program<C>,
     args: Vec<String>,
-) -> Result<(&(dyn Dispatcher<G> + Send + Sync), Vec<String>), ProgramInternalExecuteError>
+) -> Result<(&(dyn Dispatcher<C> + Send + Sync), Vec<String>), ProgramInternalExecuteError>
 where
-    C: ProgramCollect<Enum = G>,
+    C: ProgramCollect<Enum = C>,
 {
     let nodes = program.get_nodes();
     let command = format!("{} ", args.join(" "));
 
     // Find all nodes that match the command prefix
-    let matching_nodes: Vec<&(String, &(dyn Dispatcher<G> + Send + Sync))> = nodes
+    let matching_nodes: Vec<&(String, &(dyn Dispatcher<C> + Send + Sync))> = nodes
         .iter()
         // Also add a space to the node string to ensure consistent matching logic
         .filter(|(node_str, _)| command.starts_with(&format!("{} ", node_str)))
@@ -162,10 +160,7 @@ where
 
 #[inline(always)]
 #[allow(unused_variables)]
-fn render<C: ProgramCollect<Enum = G>, G>(
-    program: &Program<C, G>,
-    any: AnyOutput<G>,
-) -> RenderResult {
+fn render<C: ProgramCollect<Enum = C>>(program: &Program<C>, any: AnyOutput<C>) -> RenderResult {
     #[cfg(not(feature = "general_renderer"))]
     {
         let mut render_result = RenderResult::default();
diff --git a/mingling_core/src/program/flag.rs b/mingling_core/src/program/flag.rs
index f44cf33..0ab8d1c 100644
--- a/mingling_core/src/program/flag.rs
+++ b/mingling_core/src/program/flag.rs
@@ -1,5 +1,3 @@
-use std::fmt::Display;
-
 use crate::{Program, ProgramCollect};
 
 /// A wrapper for a collection of static string slices representing command-line flags or arguments.
@@ -474,15 +472,14 @@ mod tests {
     }
 }
 
-impl<C, G> Program<C, G>
+impl<C> Program<C>
 where
     C: ProgramCollect,
-    G: Display,
 {
     /// Registers a global argument (with value) and its handler.
     pub fn global_argument<F, A>(&mut self, arguments: A, mut do_fn: F)
     where
-        F: FnMut(&mut Program<C, G>, String),
+        F: FnMut(&mut Program<C>, String),
         A: Into<Flag>,
     {
         let flag = arguments.into();
@@ -498,7 +495,7 @@ where
     /// Registers a global flag (boolean) and its handler.
     pub fn global_flag<F, A>(&mut self, flag: A, mut do_fn: F)
     where
-        F: FnMut(&mut Program<C, G>),
+        F: FnMut(&mut Program<C>),
         A: Into<Flag>,
     {
         let flag = flag.into();
diff --git a/mingling_core/src/program/setup.rs b/mingling_core/src/program/setup.rs
index f095ed3..86228b9 100644
--- a/mingling_core/src/program/setup.rs
+++ b/mingling_core/src/program/setup.rs
@@ -8,19 +8,19 @@ mod general_renderer;
 #[cfg(feature = "general_renderer")]
 pub use general_renderer::*;
 
-pub trait ProgramSetup<C, G>
+pub trait ProgramSetup<C>
 where
     C: ProgramCollect,
 {
-    fn setup(&mut self, program: &mut Program<C, G>);
+    fn setup(&mut self, program: &mut Program<C>);
 }
 
-impl<C, G> Program<C, G>
+impl<C> Program<C>
 where
     C: ProgramCollect,
 {
     /// Load and execute init logic
-    pub fn with_setup<S: ProgramSetup<C, G> + 'static>(&mut self, mut setup: S) -> S {
+    pub fn with_setup<S: ProgramSetup<C> + 'static>(&mut self, mut setup: S) -> S {
         S::setup(&mut setup, self);
         setup
     }
diff --git a/mingling_core/src/program/setup/basic.rs b/mingling_core/src/program/setup/basic.rs
index 8316a33..43c14b9 100644
--- a/mingling_core/src/program/setup/basic.rs
+++ b/mingling_core/src/program/setup/basic.rs
@@ -1,5 +1,3 @@
-use std::fmt::Display;
-
 use crate::{
     ProgramCollect,
     program::{Program, setup::ProgramSetup},
@@ -12,12 +10,11 @@ use crate::{
 /// - Collects `--confirm` flag to skip user confirmation
 pub struct BasicProgramSetup;
 
-impl<C, G> ProgramSetup<C, G> for BasicProgramSetup
+impl<C> ProgramSetup<C> for BasicProgramSetup
 where
     C: ProgramCollect,
-    G: Display,
 {
-    fn setup(&mut self, program: &mut Program<C, G>) {
+    fn setup(&mut self, program: &mut Program<C>) {
         program.global_flag(["--quiet", "-q"], |p| {
             p.stdout_setting.render_output = false;
             p.stdout_setting.error_output = false;
diff --git a/mingling_core/src/program/setup/general_renderer.rs b/mingling_core/src/program/setup/general_renderer.rs
index 035f813..2d2ee79 100644
--- a/mingling_core/src/program/setup/general_renderer.rs
+++ b/mingling_core/src/program/setup/general_renderer.rs
@@ -1,5 +1,3 @@
-use std::fmt::Display;
-
 use crate::{
     ProgramCollect,
     program::{Program, setup::ProgramSetup},
@@ -10,12 +8,11 @@ use crate::{
 /// - Adds a `--renderer` global argument to specify the renderer type
 pub struct GeneralRendererSimpleSetup;
 
-impl<C, G> ProgramSetup<C, G> for GeneralRendererSimpleSetup
+impl<C> ProgramSetup<C> for GeneralRendererSimpleSetup
 where
     C: ProgramCollect,
-    G: Display,
 {
-    fn setup(&mut self, program: &mut Program<C, G>) {
+    fn setup(&mut self, program: &mut Program<C>) {
         program.global_argument("--renderer", |p, renderer| {
             p.general_renderer_name = renderer.into();
         });
@@ -33,12 +30,11 @@ where
 ///   * `--ron-pretty` for pretty-printed RON output
 pub struct GeneralRendererSetup;
 
-impl<C, G> ProgramSetup<C, G> for GeneralRendererSetup
+impl<C> ProgramSetup<C> for GeneralRendererSetup
 where
     C: ProgramCollect,
-    G: Display,
 {
-    fn setup(&mut self, program: &mut Program<C, G>) {
+    fn setup(&mut self, program: &mut Program<C>) {
         program.global_flag("--json", |p| {
             p.general_renderer_name = crate::GeneralRendererSetting::Json
         });