type_flow_macros/

lib.rs

#[allow(unused_imports)]
use type_flow_traits::{
    Processor,
    InPlaceProcessor,
    TransformProcessor,
    StatefulProcessor,
    InPlaceStatefulProcessor,
};
/*macro_rules! count_tts {
    () => { 0 };
    ($odd:tt $($a:tt $b:tt)*) => { (count_tts!($($a)*) << 1) | 1 };
    ($($a:tt $even:tt)*) => { count_tts!($($a)*) << 1 };
}*/

#[macro_export]
macro_rules! processor {
    ($struct_name:ident, $type:ty, $process_fn:expr) => {
        pub struct $struct_name;
        impl Processor<$type> for $struct_name {
            fn process(data: $type) -> $type {
                ($process_fn)(data)
            }
        }
    };
}

#[macro_export]
macro_rules! processor_pipeline {
    ($struct_name:ident, $type:ty, $($processor:ty),+) => {
        pub struct $struct_name;
        impl Processor<$type> for $struct_name {
            fn process(data: $type) -> $type {
                let result = data;
                $(
                    let result = <$processor>::process(result);
                )*
                result
            }
        }
    }
}

#[macro_export]
macro_rules! type_flow_processor_pipeline {
    ($struct_name:ident, $processor_type:ty, $($type_param:ident),+) => {
        pub struct $struct_name<$($type_param: Processor<$processor_type>),*> {
            _marker: std::marker::PhantomData<($($type_param),*)>,
        }
        impl<$($type_param: Processor<$processor_type>),*> Processor<$processor_type> for $struct_name<$($type_param),*> {
            fn process(data: $processor_type) -> $processor_type{
                let result = data;
                $(
                    let result = $type_param::process(result);
                )*
                result
            }
        }
    };
}

#[macro_export]
macro_rules! inplace_processor {
    ($struct_name:ident, $type:ty, $error_type:ty, $process_fn:expr) => {
        pub struct $struct_name;
        impl InPlaceProcessor<$type, $error_type> for $struct_name {
            fn process(data: &mut $type) -> Result<(), $error_type> {
                ($process_fn)(data)
            }
        }
    };
}

#[macro_export]
macro_rules! inplace_processor_pipeline {
    ($struct_name:ident, $type:ty, $error_type:ty, $($processor:ty),+) => {
        pub struct $struct_name;
        impl InPlaceProcessor<$type, $error_type> for $struct_name {
            fn process(data: &mut $type) -> Result<(), $error_type> {
                $(
                    <$processor>::process(data)?;
                )*
                Ok(())
            }
        }
    }
}
#[macro_export]
macro_rules! type_flow_inplace_processor_pipeline {
    ($struct_name:ident, $processor_type:ty, $processor_error_type:ty, $($type_param:ident),+) => {
        pub struct $struct_name<$($type_param: InPlaceProcessor<$processor_type, $processor_error_type>),*> {
            _marker: std::marker::PhantomData<($($type_param),*)>,
        }
        impl<$($type_param: InPlaceProcessor<$processor_type, $processor_error_type>),*> InPlaceProcessor<$processor_type, $processor_error_type> for $struct_name<$($type_param),*> {
            fn process(data: &mut $processor_type) -> Result<(), $processor_error_type> {
                $(
                    $type_param::process(data)?;
                )*
                Ok(())
            }
        }
    };
}

#[macro_export]
macro_rules! transform_processor {
    ($struct_name:ident, $input_type:ty, $output_type:ty, $process_fn:expr) => {
        pub struct $struct_name;
        impl TransformProcessor<$input_type, $output_type> for $struct_name {
            fn process(data: $input_type) -> $output_type {
                ($process_fn)(data)
            }
        }
    };
}

#[macro_export]
macro_rules! stateful_processor {
    // Original version with constructor
    ($struct_name:ident, $state_type:ty, $type:ty, $process_fn:expr) => {
        pub struct $struct_name {
            state: $state_type
        }
        impl $struct_name {
            pub fn new(state: $state_type) -> Self {
                Self {
                    state
                }
            }
        }

        impl StatefulProcessor<$type> for $struct_name {
            fn process(&mut self, data: $type) -> $type {
                let state = &mut self.state;
                ($process_fn)(state, data)
            }
        }
    };

    // Version with direct state value
    ($struct_name:ident, $state_type:ty, $state_value:expr, $type:ty, $process_fn:expr) => {
        pub struct $struct_name {
            state: $state_type
        }

        impl $struct_name {
            pub fn new() -> Self {
                Self {
                    state: $state_value
                }
            }
            pub fn instance() -> Self {
                Self::new()
            }
        }
        impl StatefulProcessor<$type> for $struct_name {
            fn process(&mut self, data: $type) -> $type {
                let state = &mut self.state;
                ($process_fn)(state, data)
            }
        }
    };
}

#[macro_export]
macro_rules! stateful_processor_pipeline {
    ($pipeline_name:ident, $data_type:ty, $($processor_field:ident: $processor_type:ty),+) => {
        pub struct $pipeline_name {
            $(
                $processor_field: $processor_type,
            )+
        }

        impl $pipeline_name {
            pub fn new($($processor_field: $processor_type),+) -> Self {
                Self {
                    $(
                        $processor_field,
                    )+
                }
            }
        }

        impl StatefulProcessor<$data_type> for $pipeline_name {
            fn process(&mut self, mut data: $data_type) -> $data_type {
                $(
                    data = self.$processor_field.process(data);
                )*
                data
            }
        }
    };
    
    ($pipeline_name:ident, $data_type:ty, $($processor_type:ty),+) => {
        type_flow_proc_macros::stateful_processor_pipeline_with_index!($pipeline_name, $data_type, $($processor_type),+);
    };
}

#[macro_export]
macro_rules! inplace_stateful_processor {
    ($struct_name:ident, $state_type:ty, $type:ty, $error_type:ty, $process_fn:expr) => {
        pub struct $struct_name {
            state: $state_type
        }
        impl $struct_name {
            pub fn new(state: $state_type) -> Self {
                Self {
                    state
                }
            }
        }
        impl InPlaceStatefulProcessor<$type, $error_type> for $struct_name {
            fn process(&mut self, data: &mut $type) -> Result<(), $error_type> {
                let state = &mut self.state;
                ($process_fn)(state, data)
            }
        }
    };
    ($struct_name:ident, $state_type:ty, $state_value:expr, $type:ty, $error_type:ty, $process_fn:expr) => {
        pub struct $struct_name {
            state: $state_type
        }
        impl $struct_name {
            pub fn new() -> Self {
                Self {
                    state: $state_value
                }
            }
            pub fn instance() -> Self {
                Self::new()
            }
        }
        impl InPlaceStatefulProcessor<$type, $error_type> for $struct_name {
            fn process(&mut self, data: &mut $type) -> Result<(), $error_type> {
                let state = &mut self.state;
                ($process_fn)(state, data)
            }
        }
    };
}

#[macro_export]
macro_rules! inplace_stateful_processor_pipeline {
    ($pipeline_name:ident, $data_type:ty, $error_type:ty, $($processor_field:ident: $processor_type:ty),+) => {
        pub struct $pipeline_name {
            $(
                $processor_field: $processor_type,
            )+
        }
        impl $pipeline_name {
            pub fn new($($processor_field: $processor_type),+) -> Self {
                Self {
                    $(
                        $processor_field,
                    )+
                }
            }
        }
        impl InPlaceStatefulProcessor<$data_type, $error_type> for $pipeline_name {
            fn process(&mut self, data: &mut $data_type) -> Result<(), $error_type> {
                $(
                    self.$processor_field.process(data)?;
                )*
                Ok(())
            }
        }
    };
    ($pipeline_name:ident, $data_type:ty, $error_type:ty, $($processor_type:ty),+) => {
        type_flow_proc_macros::inplace_stateful_processor_pipeline_with_index!($pipeline_name, $data_type, $error_type, $($processor_type),+);
    };
}

#[macro_export]
macro_rules! impl_shift_left {
    // Case for a single type parameter / field
    ($struct_name:ident, ($type_param:ident), ($field_name:ident), $processor_common_type:ty, $processor_error_type:ty) => {
        impl<$type_param: InPlaceStatefulProcessor<$processor_common_type, $processor_error_type>> type_flow_traits::ShiftLeft for $struct_name<$type_param> {
            type Output = $struct_name<$type_param>;
            fn shift_left(self) -> Self::Output {
                Self::Output {
                    _marker: std::marker::PhantomData,
                    $field_name: self.$field_name
                }
            }
        }
    };
    // Case 2: Multiple elements (at least two) - Entry point for recursion
    // This arm matches when there's a first type/field and at least one more type/field in $rest_t/$rest_f.
    ($struct_name:ident, ($first_t:ident, $($rest_t:ident),+), ($first_f:ident, $($rest_f:ident),+), $proc_ty:ty, $proc_err_ty:ty) => {
        impl_shift_left!(@internal_shift_left
            $struct_name; $proc_ty; $proc_err_ty;  // Fixed parameters passed along
            $first_t; $first_f;                    // Original first type ($orig_first_t) and field ($orig_first_f)
            // Lists of remaining types and fields to process to find middle and last elements:
            @process_types $($rest_t),+; @process_fields $($rest_f),+;
            // Accumulators for middle types and fields, initially empty:
            @middle_types ; @middle_fields ;
        );
    };
    // Internal rule: Recursive step
    // This rule is matched when there are two or more elements remaining in the @process_types/@process_fields lists.
    // It takes the 'current' element, adds it to the 'middle' accumulator, and recurses on the 'tail'.
    (@internal_shift_left
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty; // Fixed parameters
        $orig_first_t:ident; $orig_first_f:ident;         // Original first type and field
        // Types/fields to process: current one, followed by one or more in the tail
        @process_types $current_t:ident, $($tail_t:ident),+; @process_fields $current_f:ident, $($tail_f:ident),+;
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*; // Accumulated middle types/fields so far
    ) => {
        impl_shift_left!(@internal_shift_left
            $struct_name; $proc_ty; $proc_err_ty;
            $orig_first_t; $orig_first_f;
            // Continue processing with the tail of the lists:
            @process_types $($tail_t),+; @process_fields $($tail_f),+;
            // Add the 'current' type and field to their respective accumulators for middle elements:
            @middle_types $($middle_t_acc,)* $current_t;
            @middle_fields $($middle_f_acc,)* $current_f;
        );
    };
    // Internal rule: Base case for recursion
    // This rule is matched when exactly one element remains in the @process_types/@process_fields lists.
    // This single remaining element is the 'last' element of the original list.
    (@internal_shift_left
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty; // Fixed parameters
        $first_t:ident; $first_f:ident;                   // Original first type ($orig_first_t) and field ($orig_first_f)
        // The last type and field from the original lists:
        @process_types $last_t:ident; @process_fields $last_f:ident;
        // All accumulated middle types and fields:
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*;
    ) => {
        impl_shift_left!(@internal_shift_left
            $struct_name; $proc_ty; $proc_err_ty; // Fixed parameters
            $first_t; $first_f;                   // Original first type ($orig_first_t) and field ($orig_first_f)
            // The last type and field from the original lists:
            @process_types $last_t; @process_fields $last_f;
            // All accumulated middle types and fields:
            @middle_types $($middle_t_acc),*; @middle_fields $($middle_f_acc),*;
            @original_order_field_names $first_f, $($middle_f_acc,)* $last_f;
            @new_order_field_names $($middle_f_acc,)* $last_f, $first_f;
        );
    };

    (@internal_shift_left
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty;
        $first_t:ident; $first_f:ident;  @process_types $last_t:ident; @process_fields $last_f:ident;
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*;
        @original_order_field_names $($original_order_field_name:ident),*; @new_order_field_names $($new_order_field_name:ident),*;
    ) => {
        impl<
            $first_t: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>,
            $($middle_t_acc: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>,)*
            $last_t: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>
        > type_flow_traits::ShiftLeft for $struct_name<$first_t, $($middle_t_acc,)* $last_t> {
            // The type of this struct is shifted to the left fo the original
            type ShiftedLeft = $struct_name<$($middle_t_acc,)* $last_t, $first_t>;
            fn shift_left(self) -> Self::ShiftedLeft {
                Self::ShiftedLeft {
                    _marker: std::marker::PhantomData,
                    $($original_order_field_name: self.$new_order_field_name),*
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_shift_right {
    // Case for a single type parameter / field
    ($struct_name:ident, ($type_param:ident), ($field_name:ident), $processor_common_type:ty, $processor_error_type:ty) => {
        impl<$type_param: InPlaceStatefulProcessor<$processor_common_type, $processor_error_type>> type_flow_traits::ShiftRight for $struct_name<$type_param> {
            type Output = $struct_name<$type_param>;
            fn shift_right(self) -> Self::Output {
                Self::Output {
                    _marker: std::marker::PhantomData,
                    $field_name: self.$field_name
                }
            }
        }
    };
    // Case 2: Multiple elements (at least two) - Entry point for recursion
    // This arm matches when there's a first type/field and at least one more type/field in $rest_t/$rest_f.
    ($struct_name:ident, ($first_t:ident, $($rest_t:ident),+), ($first_f:ident, $($rest_f:ident),+), $proc_ty:ty, $proc_err_ty:ty) => {
        impl_shift_right!(@internal_shift_right
            $struct_name; $proc_ty; $proc_err_ty;  // Fixed parameters passed along
            $first_t; $first_f;                    // Original first type ($orig_first_t) and field ($orig_first_f)
            // Lists of remaining types and fields to process to find middle and last elements:
            @process_types $($rest_t),+; @process_fields $($rest_f),+;
            // Accumulators for middle types and fields, initially empty:
            @middle_types ; @middle_fields ;
        );
    };
    // Internal rule: Recursive step
    // This rule is matched when there are two or more elements remaining in the @process_types/@process_fields lists.
    // It takes the 'current' element, adds it to the 'middle' accumulator, and recurses on the 'tail'.
    (@internal_shift_right
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty; // Fixed parameters
        $orig_first_t:ident; $orig_first_f:ident;         // Original first type and field
        // Types/fields to process: current one, followed by one or more in the tail
        @process_types $current_t:ident, $($tail_t:ident),+; @process_fields $current_f:ident, $($tail_f:ident),+;
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*; // Accumulated middle types/fields so far
    ) => {
        impl_shift_right!(@internal_shift_right
            $struct_name; $proc_ty; $proc_err_ty;
            $orig_first_t; $orig_first_f;
            // Continue processing with the tail of the lists:
            @process_types $($tail_t),+; @process_fields $($tail_f),+;
            // Add the 'current' type and field to their respective accumulators for middle elements:
            @middle_types $($middle_t_acc,)* $current_t;
            @middle_fields $($middle_f_acc,)* $current_f;
        );
    };
    // Internal rule: Base case for recursion
    // This rule is matched when exactly one element remains in the @process_types/@process_fields lists.
    // This single remaining element is the 'last' element of the original list.
    (@internal_shift_right
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty; // Fixed parameters
        $first_t:ident; $first_f:ident;                   // Original first type ($orig_first_t) and field ($orig_first_f)
        // The last type and field from the original lists:
        @process_types $last_t:ident; @process_fields $last_f:ident;
        // All accumulated middle types and fields:
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*;
    ) => {
        // Generate the trait implementation
        // The generic parameters for the struct are: original first, all middles, original last
        impl_shift_right!(@internal_shift_right
            $struct_name; $proc_ty; $proc_err_ty; // Fixed parameters
            $first_t; $first_f;                   // Original first type ($orig_first_t) and field ($orig_first_f)
            // The last type and field from the original lists:
            @process_types $last_t; @process_fields $last_f;
            // All accumulated middle types and fields:
            @middle_types $($middle_t_acc),*; @middle_fields $($middle_f_acc),*;
            @original_order_field_names $first_f, $($middle_f_acc,)* $last_f;
            @new_order_field_names $last_f, $first_f, $($middle_f_acc),*;
        );
    };
    (@internal_shift_right
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty;
        $first_t:ident; $first_f:ident;  @process_types $last_t:ident; @process_fields $last_f:ident;
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*;
        @original_order_field_names $($original_order_field_name:ident),*; @new_order_field_names $($new_order_field_name:ident),*;
    ) => {
        impl<
            $first_t: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>,
            $($middle_t_acc: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>,)*
            $last_t: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>
        > type_flow_traits::ShiftRight for $struct_name<$first_t, $($middle_t_acc,)* $last_t> {
            // The type of this struct is shifted to the left fo the original
            type ShiftedRight = $struct_name<$last_t, $first_t, $($middle_t_acc),*>;
            fn shift_right(self) -> Self::ShiftedRight {
                Self::ShiftedRight {
                    _marker: std::marker::PhantomData,
                    $($original_order_field_name: self.$new_order_field_name),*
                }
            }
        }
    };
}

#[macro_export]
macro_rules! impl_swap_start_end {
    // Case 1: Single element (no change needed for swap)
    ($struct_name:ident, ($type_p:ident), ($field_n:ident), $processor_common_type:ty, $processor_error_type:ty) => {
        impl<$type_p: InPlaceStatefulProcessor<$processor_common_type, $processor_error_type>> type_flow_traits::SwapStartEnd for $struct_name<$type_p> {
            type Output = $struct_name<$type_p>;
            fn swap(self) -> Self::Output {
                Self::Output { _marker: std::marker::PhantomData, $field_n: self.$field_n }
            }
        }
    };

    // Case 2: Multiple elements (at least two) - Entry point for recursion
    // This arm matches when there's a first type/field and at least one more type/field in $rest_t/$rest_f.
    ($struct_name:ident, ($first_t:ident, $($rest_t:ident),+), ($first_f:ident, $($rest_f:ident),+), $proc_ty:ty, $proc_err_ty:ty) => {
        impl_swap_start_end!(@internal_swap
            $struct_name; $proc_ty; $proc_err_ty; // Fixed parameters passed along
            $first_t; $first_f;                  // The very first type and field from the original list
            // Lists of remaining types and fields to process to find middle and last elements:
            @process_types $($rest_t),+; @process_fields $($rest_f),+;
            // Accumulators for middle types and fields, initially empty:
            @middle_types ; @middle_fields ;
        );
    };

    // Internal rule: Recursive step
    // This rule is matched when there are two or more elements remaining in the @process_types/@process_fields lists.
    // It takes the 'current' element, adds it to the 'middle' accumulator, and recurses on the 'tail'.
    (@internal_swap
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty; // Fixed parameters
        $orig_first_t:ident; $orig_first_f:ident;        // Original first type and field
        // Types/fields to process: current one, followed by one or more in the tail
        @process_types $current_t:ident, $($tail_t:ident),+; @process_fields $current_f:ident, $($tail_f:ident),+;
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*; // Accumulated middle types/fields so far
    ) => {
        impl_swap_start_end!(@internal_swap
            $struct_name; $proc_ty; $proc_err_ty;
            $orig_first_t; $orig_first_f;
            // Continue processing with the tail of the lists:
            @process_types $($tail_t),+; @process_fields $($tail_f),+;
            // Add the 'current' type and field to their respective accumulators for middle elements:
            @middle_types $($middle_t_acc,)* $current_t;
            @middle_fields $($middle_f_acc,)* $current_f;
        );
    };

    // Internal rule: Base case for recursion
    // This rule is matched when exactly one element remains in the @process_types/@process_fields lists.
    // This single remaining element is the 'last' element of the original list.
    (@internal_swap
        $struct_name:ident; $proc_ty:ty; $proc_err_ty:ty; // Fixed parameters
        $first_t:ident; $first_f:ident;                   // Original first type ($orig_first_t) and field ($orig_first_f)
        // The last type and field from the original lists:
        @process_types $last_t:ident; @process_fields $last_f:ident;
        // All accumulated middle types and fields:
        @middle_types $($middle_t_acc:ident),*; @middle_fields $($middle_f_acc:ident),*;
    ) => {
        // Generate the trait implementation
        // The generic parameters for the struct are: original first, all middles, original last
        impl<
            $first_t: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>,
            $($middle_t_acc: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>,)*
            $last_t: InPlaceStatefulProcessor<$proc_ty, $proc_err_ty>
        > type_flow_traits::SwapStartEnd for $struct_name<$first_t, $($middle_t_acc,)* $last_t> {
            // The Output type has the first and last type parameters swapped
            type Output = $struct_name<$last_t, $($middle_t_acc,)* $first_t>;

            fn swap(self) -> Self::Output {
                Self::Output {
                    _marker: std::marker::PhantomData,
                    // Field assignment:
                    // The first field of the output struct (named $first_f, now expecting type $last_t)
                    // gets the value from the original last field (self.$last_f).
                    $first_f: self.$last_f,
                    // Middle fields (named $middle_f_acc, expecting type $middle_t_acc)
                    // get their corresponding original values (self.$middle_f_acc).
                    $($middle_f_acc: self.$middle_f_acc,)*
                    // The last field of the output struct (named $last_f, now expecting type $first_t)
                    // gets the value from the original first field (self.$first_f).
                    $last_f: self.$first_f
                }
            }
        }
    };
    
}

#[macro_export]
macro_rules! type_flow_inplace_stateful_processor_pipeline {
    ($struct_name:ident, $processor_type:ty, $processor_error_type:ty, $($field_name:ident : $type_param:ident),+) => {
        #[implement_processor_swapping] 
        pub struct $struct_name<$($type_param: InPlaceStatefulProcessor<$processor_type, $processor_error_type>),*> {
            _marker: std::marker::PhantomData<($($type_param),*)>,
            $(
                $field_name: $type_param,
            )+
        }
        impl<$($type_param: InPlaceStatefulProcessor<$processor_type, $processor_error_type>),*> $struct_name<$($type_param),*> {
            pub fn new($($field_name: $type_param),+) -> Self {
                Self {
                    _marker: std::marker::PhantomData,
                    $(
                        $field_name,
                    )+
                }
            }
        }
        impl<$($type_param: InPlaceStatefulProcessor<$processor_type, $processor_error_type>),*> InPlaceStatefulProcessor<$processor_type, $processor_error_type> for $struct_name<$($type_param),*> {
            fn process(&mut self, data: &mut $processor_type) -> Result<(), $processor_error_type> {
                $(
                    self.$field_name.process(data)?;
                )*
                Ok(())
            }
        }
        // Added trait implementations
        impl_shift_left!($struct_name, ($($type_param),+), ($($field_name),+), $processor_type, $processor_error_type);
        impl_shift_right!($struct_name, ($($type_param),+), ($($field_name),+), $processor_type, $processor_error_type);
        impl_swap_start_end!($struct_name, ($($type_param),+), ($($field_name),+), $processor_type, $processor_error_type);

    };
    //Version that doesn't require you to name the field and generic type param
    ($struct_name:ident, $processor_common_type:ty, $processor_error_type:ty, $($param_and_field_name:ident),+) => {
        #[allow(non_snake_case)]
        pub struct $struct_name<$($param_and_field_name: InPlaceStatefulProcessor<$processor_common_type, $processor_error_type>),*> {
            _marker: std::marker::PhantomData<($($param_and_field_name),*)>,
            $(
                // Using the same ident for field name and its type (which is the generic param)
                $param_and_field_name: $param_and_field_name,
            )+ 
        }
        impl<$($param_and_field_name: InPlaceStatefulProcessor<$processor_common_type, $processor_error_type>),*> $struct_name<$($param_and_field_name),*> {
            #[allow(non_snake_case)]
            pub fn new($($param_and_field_name: $param_and_field_name),+) -> Self {
                Self { 
                    _marker: std::marker::PhantomData,
                    $(
                        $param_and_field_name,
                    )+ 
                } 
            } 
        }
        impl<$($param_and_field_name: InPlaceStatefulProcessor<$processor_common_type, $processor_error_type>),*> InPlaceStatefulProcessor<$processor_common_type, $processor_error_type> for $struct_name<$($param_and_field_name),*> {
            fn process(&mut self, data: &mut $processor_common_type) -> Result<(), $processor_error_type> {
                $(
                    self.$param_and_field_name.process(data)?;
                )* 
                Ok(()) 
            }
        }
        // Added trait implementations
        //impl_shift_left!($struct_name, ($($param_and_field_name),+), ($($param_and_field_name),+), $processor_common_type, $processor_error_type);
        //impl_shift_right!($struct_name, ($($param_and_field_name),+), ($($param_and_field_name),+), $processor_common_type, $processor_error_type);
        //impl_swap_start_end!($struct_name, ($($param_and_field_name),+), ($($param_and_field_name),+), $processor_common_type, $processor_error_type);

    };
}

#[cfg(test)]
mod tests {
    use type_flow_proc_macros::implement_processor_swapping;
    use type_flow_traits::{ShiftLeft, ShiftRight, SwapStartEnd};
    use super::*;

    processor!(AddFive, String, |s: String| s + "5");

    #[test]
    fn it_works() {
        let result = AddFive::process(String::from("test"));
        assert_eq!(result, "test5");
    }

    inplace_processor!(InplaceAddHash, String, TestError, |s: &mut String| {
        s.push_str("#");
        Ok(())
    });

    inplace_processor!(InplaceAddStar, String, TestError, |s: &mut String| {
        s.push_str("*");
        Ok(())
    });

    inplace_processor_pipeline!(InplacePipeline, String, TestError, InplaceAddHash, InplaceAddStar);

    #[test]
    fn test_inplace_pipeline() {
        let mut test_string = String::from("test");
        InplacePipeline::process(&mut test_string).unwrap();
        assert_eq!(test_string, "test#*");
    }

    inplace_processor!(ErrorProcessor, String, TestError, |_: &mut String| {
        Err(TestError::SomeError)
    });

    inplace_processor_pipeline!(ErrorPipeline, String, TestError, InplaceAddHash, ErrorProcessor, InplaceAddStar);

    #[test]
    fn test_error_pipeline() {
        let mut test_string = String::from("test");
        assert_eq!(ErrorPipeline::process(&mut test_string), Err(TestError::SomeError));
        assert_eq!(test_string, "test#");  // First processor executed before error
    }

    transform_processor!(SafeConvertToInt, String, i32, |s: String| s.parse::<i32>().unwrap_or(0));
    
    #[test]
    fn it_works_2() {
        let result = SafeConvertToInt::process(String::from("123"));
        assert_eq!(result, 123);
    }
    
    stateful_processor!(CountOfInvocations, u32, String, |state: &mut u32, s: String| {
        *state += 1;
        format!("{}: {}", s, state)
    });

    #[test]
    fn it_works_3() {
        let mut processor = CountOfInvocations::new(5);
        let result = processor.process(String::from("Count"));
        assert_eq!(result, "Count: 6"); // The state is incremented, so the expected output should be 6.
    }
    
    stateful_processor!(FixedMultiply, u64, 10, String, |state:&mut u64, s: String| {
        *state *= 3;
        format!("{} fixed: {}", s, state)
    });

    #[test]
    fn it_works_4() {
        let mut processor = FixedMultiply::instance();
        let result = processor.process(String::from("Counter"));
        assert_eq!(result, "Counter fixed: 30");
    }
    
    processor!(Reverse, String, |s: String| s.chars().rev().collect::<String>());
    processor_pipeline!(StatelessPipeline, String, AddFive, Reverse);
    #[test]
    fn it_works_5() {
        let result = StatelessPipeline::process(String::from("test"));
        assert_eq!(result, "5tset");
    }

    processor_pipeline!(DoubleStatelessPipeline, String, StatelessPipeline, StatelessPipeline);
    
    #[test]
    fn it_works_6() {
        let result = DoubleStatelessPipeline::process(String::from("test"));
        assert_eq!(result, "5test5");
    }

    stateful_processor!(LetterAtoZPlacer, char, 'A', String, |state:&mut char, s: String| {
        if *state == 'Z' {
            *state = 'A';
        } else {
            *state = (*state as u8 + 1) as char;
        }
        format!("{}: {}", s, state)
    });
    #[test]
    fn it_works_7() {
        let mut processor = LetterAtoZPlacer::instance();
        let result = processor.process(String::from("A"));
        assert_eq!(result, "A: B");
    }
    
    stateful_processor_pipeline!(WeirdStuff, String, a : LetterAtoZPlacer, b : FixedMultiply);
    
    #[test]
    fn it_works_8() {
        let processor_a = LetterAtoZPlacer::instance();
        let processor_b = FixedMultiply::instance();
        let mut pipeline = WeirdStuff::new(processor_a, processor_b);
        let result = pipeline.process(String::from("B"));
        assert_eq!(result, "B: B fixed: 30");
        let result = pipeline.process(String::from("C"));
        assert_eq!(result, "C: C fixed: 90");
        let result = pipeline.process(String::from("D"));
        assert_eq!(result, "D: D fixed: 270");
        let result = pipeline.process(String::from("E"));
        assert_eq!(result, "E: E fixed: 810");
        let result = pipeline.process(String::from("F"));
        assert_eq!(result, "F: F fixed: 2430");
        let result = pipeline.process(String::from("G"));
        assert_eq!(result, "G: G fixed: 7290");
        let result = pipeline.process(String::from("H"));
        assert_eq!(result, "H: H fixed: 21870");
        let result = pipeline.process(String::from("I"));
        assert_eq!(result, "I: I fixed: 65610");
        let result = pipeline.process(String::from("J"));
        assert_eq!(result, "J: J fixed: 196830");
        let _ = pipeline.process(String::from("K"));
        let _ = pipeline.process(String::from("L"));
        let _ = pipeline.process(String::from("M"));
        let _ = pipeline.process(String::from("N"));
        let _ = pipeline.process(String::from("O"));
        let _ = pipeline.process(String::from("P"));
        let _ = pipeline.process(String::from("Q"));
        let _ = pipeline.process(String::from("R"));
        let _ = pipeline.process(String::from("S"));
        let _ = pipeline.process(String::from("T"));
        let _ = pipeline.process(String::from("U"));    
        let _ = pipeline.process(String::from("V"));
        let _ = pipeline.process(String::from("W"));
        let _ = pipeline.process(String::from("X"));
        let _ = pipeline.process(String::from("Y"));
        let result = pipeline.process(String::from("Z"));
        assert_eq!(result, "Z: Z fixed: 8472886094430");
        let result = pipeline.process(String::from("A"));
        assert_eq!(result, "A: A fixed: 25418658283290");
    }

    type_flow_processor_pipeline!(Test, String, P1, P2, P3);
    #[test]
    fn it_works_9() {
        //let that_thing: Test<AddFive, Reverse> = Test::<AddFive, Reverse> {  };
        let result = Test::<AddFive, Reverse, Test<AddFive, Reverse, AddFive>>::process(String::from("stuff"));
        assert_eq!(result, "5stuff55");
    }

    stateful_processor_pipeline!(SuffWeird, String, WeirdStuff, WeirdStuff);

    #[test]
    fn it_works_10() {
        let mut pipeline = SuffWeird::new(WeirdStuff::new(LetterAtoZPlacer::instance(), FixedMultiply::instance()), WeirdStuff::new(LetterAtoZPlacer::instance(), FixedMultiply::instance()));
        let result = pipeline.process(String::from("stuff"));
        assert_eq!(result, "stuff: B fixed: 30: B fixed: 30");
    }

    #[derive(Debug, PartialEq)]
    pub enum TestError {
        SomeError,
    }

    inplace_processor!(InplaceAddFive, String, TestError, |s: &mut String| {
        s.push_str("5");
        Ok(())
    });

    inplace_processor!(InplaceReverse, String, TestError, |s: &mut String| {
        *s = s.chars().rev().collect::<String>();
        Ok(())
    });

    type_flow_inplace_processor_pipeline!(
        InplaceTestPipeline,
        String,
        TestError,
        P1,
        P2,
        P3
    );

    #[test]
    fn it_works_inplace() {
        let mut data = String::from("stuff");
        let result = InplaceTestPipeline::<InplaceAddFive, InplaceReverse, InplaceAddFive>::process(&mut data);
        assert_eq!(result, Ok(()));
        assert_eq!(data, "5ffuts5");
    }

    inplace_stateful_processor!(CountUp, u32, String, TestError, |state: &mut u32, s: &mut String| {
        *state += 1;
        s.push_str(state.to_string().as_str());
        Ok(())
    });
    inplace_stateful_processor!(ToggleCase, bool, String, TestError, |state: &mut bool, s: &mut String| {
        *state = !*state;
        if *state {
            s.make_ascii_uppercase();
        } else {
            s.make_ascii_lowercase();
        }
        Ok(())
    });
    inplace_stateful_processor_pipeline!(InplaceStatefulProcessorPipeline, String, TestError, CountUp, ToggleCase);
    #[test]
    fn it_works_inplace_stateful_pipeline() {
        let mut pipeline = InplaceStatefulProcessorPipeline::new(CountUp::new(0), ToggleCase::new(false));
        let mut data = String::from("stuff");
        let result = pipeline.process(&mut data);
        assert_eq!(result, Ok(()));
        assert_eq!(data, "STUFF1");
        let result = pipeline.process(&mut data);
        assert_eq!(result, Ok(()));
        assert_eq!(data, "stuff12");
    }

    inplace_stateful_processor!(InplaceAddExclamation, (), String, TestError, |_, s: &mut String| {
        s.push_str("!");
        Ok(())
    });

    inplace_stateful_processor!(InplaceAddQuestion, (), String, TestError, |_, s: &mut String| {
        s.push_str("?");
        Ok(())
    });

    type_flow_inplace_stateful_processor_pipeline!(
        InplaceStatefulTypeFlowPipeline,
        String,
        TestError,
        A,
        B
    );

    #[test]
    fn test_inplace_type_flow_pipeline() {
        let p1 = InplaceAddExclamation::new(());
        let p2 = InplaceAddQuestion::new(());
        let mut pipeline = InplaceStatefulTypeFlowPipeline::<InplaceAddExclamation, InplaceAddQuestion>::new(p1, p2);
        let mut test_string = "Hello".to_string();
        pipeline.process(&mut test_string).unwrap();
        assert_eq!(test_string, "Hello!?");
    }

    inplace_stateful_processor!(LimitedProcessor, u32, 0, String, TestError, |state: &mut u32, s: &mut String| {
        if *state >= 5 {
            Err(TestError::SomeError)
        } else {
            *state += 1;
            s.push_str(&format!(" #{}", state));
            Ok(())
        }
    });

    #[test]
    fn test_limited_processor() {
        let mut processor = LimitedProcessor::instance();
        let mut test_string = String::from("Test");
        for i in 1..=5 {
            processor.process(&mut test_string).unwrap();
            assert_eq!(test_string, format!("Test #{}", (1..=i).map(|num| num.to_string()).collect::<Vec<String>>().join(" #")));
        }
        assert_eq!(processor.process(&mut test_string), Err(TestError::SomeError));
    }

    
    type_flow_inplace_stateful_processor_pipeline!(WhyNotNow, String, TestError, a : A, b : B, c : C);

    #[test]
    fn test_type_flow_inplace_stateful_processor_pipeline() {
        let mut go_with_the_flow = WhyNotNow::<ToggleCase, InplaceAddExclamation, LimitedProcessor>::new(ToggleCase::new(false), InplaceAddExclamation::new(()), LimitedProcessor::instance());
        let mut test_string = String::from("Test");
        go_with_the_flow.process(&mut test_string).unwrap();
        assert_eq!(test_string, "TEST! #1");
        let mut swapped = go_with_the_flow.swap();
        swapped.process(&mut test_string).unwrap();
        assert_eq!(test_string, "test! #1 #2!");
        let mut shifted_left = swapped.shift_left();
        shifted_left.process(&mut test_string).unwrap();
        assert_eq!(test_string, "TEST! #1 #2!! #3");
        let mut shifted_right = shifted_left.shift_right();
        let _ = shifted_right.process(&mut test_string);
        let _ = shifted_right.process(&mut test_string);
        assert_eq!(shifted_right.process(&mut test_string), Err(TestError::SomeError));
        let mut something = <WhyNotNow<LimitedProcessor, InplaceAddExclamation, ToggleCase> as SwapArbitraryProcessors<0, 1>>::swap_processors(shifted_right);
        assert_eq!(something.process(&mut test_string), Err(TestError::SomeError));
    }
}