type-flow-macros 0.2.0

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

/// Creates a stateless, data-transforming processor struct.
///
/// This macro generates a struct that implements the `Processor<T>` trait,
/// taking data of a specific type, processing it with a given function,
/// and returning data of the same type.
///
/// # Parameters
/// - `$struct_name`: The name for the new processor struct.
/// - `$type`: The type of data the processor will operate on.
/// - `$process_fn`: A function or closure that takes a value of `$type` and returns a new value of `$type`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::processor;
/// use type_flow_traits::Processor;
///
/// fn to_uppercase(s: String) -> String {
///     s.to_uppercase()
/// }
///
/// processor!(UppercaseProcessor, String, to_uppercase);
///
/// let processed = UppercaseProcessor::process("hello".to_string());
/// assert_eq!(processed, "HELLO");
/// ```
#[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)
            }
        }
    };
}

/// Creates a stateless pipeline of processors.
///
/// This macro generates a struct that chains multiple `Processor` implementations
/// together into a single pipeline. The data flows through each processor in the
/// order they are specified.
///
/// # Parameters
/// - `$struct_name`: The name for the new pipeline struct.
/// - `$type`: The type of data the pipeline will operate on.
/// - `$($processor: ty),+`: A comma-separated list of processor types that implement `Processor<$type>`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{processor, processor_pipeline};
/// use type_flow_traits::Processor;
///
/// processor!(AddOne, i32, |x| x + 1);
/// processor!(MulTwo, i32, |x| x * 2);
///
/// processor_pipeline!(MyPipeline, i32, AddOne, MulTwo);
///
/// let result = MyPipeline::process(10);
/// assert_eq!(result, 22); // (10 + 1) * 2
/// ```
#[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
            }
        }
    }
}

/// Creates a generic, stateless processor pipeline.
///
/// This macro generates a struct that is generic over its processors.
/// It chains them together, and the pipeline itself implements `Processor`.
/// This allows for creating flexible pipelines where the exact processors can
/// be specified at a later time.
///
/// # Parameters
/// - `$struct_name`: The name for the new generic pipeline struct.
/// - `$processor_type`: The data type the pipeline operates on.
/// - `$($type_param:ident),+`: A comma-separated list of generic type parameter identifiers.
///   Each will be constrained to implement `Processor<$processor_type>`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{processor, type_flow_processor_pipeline};
/// use type_flow_traits::Processor;
///
/// processor!(AddTen, i32, |x| x + 10);
/// processor!(DivTwo, i32, |x| x / 2);
///
/// type_flow_processor_pipeline!(GenericPipeline, i32, P1, P2);
///
/// let result = GenericPipeline::<AddTen, DivTwo>::process(20);
/// assert_eq!(result, 15); // (20 + 10) / 2
/// ```
#[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
            }
        }
    };
}

/// Creates a stateless, in-place processor that can return an error.
///
/// This macro generates a struct that implements the `InPlaceProcessor<T, E>` trait.
/// It processes data by mutating it directly and can fail with a specified error type.
///
/// # Parameters
/// - `$struct_name`: The name for the new processor struct.
/// - `$type`: The type of data to be processed (will be passed as `&mut`).
/// - `$error_type`: The error type for the `Result`.
/// - `$process_fn`: A function or closure that takes `&mut $type` and returns a `Result<(), $error_type>`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::inplace_processor;
/// use type_flow_traits::InPlaceProcessor;
///
/// #[derive(Debug)]
/// struct MyError;
///
/// fn increment(data: &mut i32) -> Result<(), MyError> {
///     if *data > 100 {
///         return Err(MyError);
///     }
///     *data += 1;
///     Ok(())
/// }
///
/// inplace_processor!(IncrementProcessor, i32, MyError, increment);
///
/// let mut value = 5;
/// IncrementProcessor::process(&mut value).unwrap();
/// assert_eq!(value, 6);
/// ```
#[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)
            }
        }
    };
}

/// Creates a stateless pipeline of in-place processors.
///
/// This macro generates a struct that chains multiple `InPlaceProcessor` implementations.
/// Data is mutated by each processor in the pipeline sequence. If any processor returns an error,
/// the pipeline stops and forwards the error.
///
/// # Parameters
/// - `$struct_name`: The name for the new pipeline struct.
/// - `$type`: The type of data the pipeline will operate on.
/// - `$error_type`: The common error type for the processors.
/// - `$($processor: ty),+`: A comma-separated list of types that implement `InPlaceProcessor<$type, $error_type>`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{inplace_processor, inplace_processor_pipeline};
/// use type_flow_traits::InPlaceProcessor;
/// #[derive(Debug)]
/// struct MyError;
///
/// inplace_processor!(Add, i32, MyError, |x: &mut i32| { *x += 1; Ok(()) });
/// inplace_processor!(Mul, i32, MyError, |x: &mut i32| { *x *= 2; Ok(()) });
///
/// inplace_processor_pipeline!(MyInPlacePipeline, i32, MyError, Add, Mul);
///
/// let mut value = 10;
/// MyInPlacePipeline::process(&mut value).unwrap();
/// assert_eq!(value, 22); // (10 + 1) * 2
/// ```
#[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(())
            }
        }
    }
}
/// Creates a generic, stateless, in-place processor pipeline.
///
/// This macro generates a struct that is generic over its `InPlaceProcessor`s.
/// This allows for creating flexible in-place pipelines where the exact processors can
/// be specified later.
///
/// # Parameters
/// - `$struct_name`: The name for the new generic pipeline struct.
/// - `$processor_type`: The data type the pipeline operates on.
/// - `$processor_error_type`: The common error type.
/// - `$($type_param:ident),+`: A comma-separated list of generic type parameter identifiers,
///   each constrained to implement `InPlaceProcessor`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{inplace_processor, type_flow_inplace_processor_pipeline};
/// use type_flow_traits::InPlaceProcessor;
/// #[derive(Debug)]
/// struct MyError;
///
/// inplace_processor!(AddTen, i32, MyError, |x: &mut i32| { *x += 10; Ok(()) });
/// inplace_processor!(DivTwo, i32, MyError, |x: &mut i32| { *x /= 2; Ok(()) });
///
/// type_flow_inplace_processor_pipeline!(GenericInPlacePipeline, i32, MyError, P1, P2);
///
/// let mut value = 20;
/// GenericInPlacePipeline::<AddTen, DivTwo>::process(&mut value).unwrap();
/// assert_eq!(value, 15); // (20 + 10) / 2
/// ```
#[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(())
            }
        }
    };
}

/// Creates a stateless processor that transforms data from an input type to an output type.
///
/// This macro generates a struct implementing the `TransformProcessor<I, O>` trait.
///
/// # Parameters
/// - `$struct_name`: The name for the new processor struct.
/// - `$input_type`: The type of the input data.
/// - `$output_type`: The type of the output data.
/// - `$process_fn`: A function or closure that takes `$input_type` and returns `$output_type`.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{transform_processor};
/// use type_flow_traits::TransformProcessor;
///
/// // This processor transforms an i32 to a String.
/// transform_processor!(IntToString, i32, String, |x: i32| x.to_string());
///
/// let result = IntToString::process(123);
/// assert_eq!(result, "123");
/// ```
#[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)
            }
        }
    };
}

/// Creates a stateful processor that maintains its own internal state.
///
/// This macro generates a struct that implements `StatefulProcessor<T>`. The processing logic
/// can read and modify the internal state during its operation.
///
/// Two variants are available:
/// 1. Takes a state type and requires the state to be provided via a `new()` constructor.
/// 2. Takes a state type and an initial value expression, providing a `new()` constructor with no arguments.
///
/// # Arms
///
/// ## 1. With `new(state)` constructor
/// - `$struct_name`: Name of the processor struct.
/// - `$state_type`: Type of the internal state.
/// - `$type`: Type of the data to be processed.
/// - `$process_fn`: A closure `|state, data| -> new_data`.
///
/// ## 2. With `new()` constructor and initial state
/// - `$struct_name`: Name of the processor struct.
/// - `$state_type`: Type of the internal state.
/// - `$state_value`: An expression that evaluates to the initial state.
/// - `$type`: Type of the data to be processed.
/// - `$process_fn`: A closure `|state, data| -> new_data`.
///
/// # Examples
///
/// ### 1. With `new(state)`
/// ```
/// use type_flow_macros::stateful_processor;
/// use type_flow_traits::StatefulProcessor;
///
/// // A processor that adds a configurable number to the input.
/// stateful_processor!(AddN, i32, i32, |state: &mut i32, data: i32| {
///     data + *state
/// });
///
/// let mut processor = AddN::new(5); // State is 5
/// assert_eq!(processor.process(10), 15);
/// assert_eq!(processor.process(20), 25); // State remains 5
/// ```
///
/// ### 2. With initial state value
/// ```
/// use type_flow_macros::stateful_processor;
/// use type_flow_traits::StatefulProcessor;
/// // A processor that accumulates values.
/// stateful_processor!(Accumulator, i32, 0, i32, |state: &mut i32, data: i32| {
///     *state += data;
///     *state // returns the new accumulated value
/// });
///
/// let mut processor = Accumulator::new();
/// assert_eq!(processor.process(5), 5);
/// assert_eq!(processor.process(10), 15);
/// assert_eq!(processor.process(-3), 12);
/// ```
#[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)
            }
        }
    };
}

/// Creates a pipeline of stateful processors.
///
/// This macro generates a struct that holds multiple stateful processors and
/// processes data through them in sequence. Each processor in the pipeline
/// maintains its own state.
///
/// # Arms
///
/// ## 1. With named fields for processors
/// - `$pipeline_name`: Name for the pipeline struct.
/// - `$data_type`: The type of data the pipeline operates on.
/// - `$($processor_field:ident: $processor_type:ty),+`: A comma-separated list of `field: Type` pairs for the processors.
///
/// ## 2. With auto-generated fields (delegates to a proc-macro)
/// - `$pipeline_name`: Name for the pipeline struct.
/// - `$data_type`: The type of data the pipeline operates on.
/// - `$($processor_type:ty),+`: A comma-separated list of processor types.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{stateful_processor, stateful_processor_pipeline};
/// use type_flow_traits::StatefulProcessor;
///
/// // A processor that adds its call count to the data
/// stateful_processor!(CallCountAdder, i32, 0, i32, |state: &mut i32, data: i32| {
///     *state += 1;
///     data + *state
/// });
///
/// // A processor that multiplies data by its call count
/// stateful_processor!(CallCountMultiplier, i32, 0, i32, |state: &mut i32, data: i32| {
///     *state += 1;
///     data * *state
/// });
///
/// // Arm 1: Named fields
/// stateful_processor_pipeline!(MyStatefulPipeline, i32, adder: CallCountAdder, multiplier: CallCountMultiplier);
///
/// let mut pipeline = MyStatefulPipeline::new(CallCountAdder::new(), CallCountMultiplier::new());
/// // First run: process(10) -> adder(state=1) -> 11 -> multiplier(state=1) -> 11
/// assert_eq!(pipeline.process(10), 11);
/// // Second run: process(10) -> adder(state=2) -> 12 -> multiplier(state=2) -> 24
/// assert_eq!(pipeline.process(10), 24);
///
/// // Arm 2: Auto-generated fields
/// stateful_processor_pipeline!(MyAnonPipeline, i32, CallCountMultiplier, CallCountAdder);
/// let mut anon_pipeline = MyAnonPipeline::new(CallCountMultiplier::new(), CallCountAdder::new());
/// assert_eq!(anon_pipeline.process(5), 6); // (5+1)*1
/// assert_eq!(anon_pipeline.process(5), 12); // (5+2)*2
/// ```
#[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),+);
    };
}

/// Creates a stateful, in-place processor that can return an error.
///
/// This macro generates a struct that implements `InPlaceStatefulProcessor<T, E>`,
/// combining state management with in-place mutation and error handling.
///
/// # Arms
///
/// ## 1. With `new(state)` constructor
/// - `$struct_name`: Name of the processor struct.
/// - `$state_type`: Type of the internal state.
/// - `$type`: Type of data to process.
/// - `$error_type`: Error type for the `Result`.
/// - `$process_fn`: A closure `|state, data| -> Result<(), E>`.
///
/// ## 2. With `new()` constructor and initial state
/// - `$struct_name`: Name of the processor struct.
/// - `$state_type`: Type of the internal state.
/// - `$state_value`: An expression for the initial state.
/// - `$type`: Type of data to process.
/// - `$error_type`: Error type for the `Result`.
/// - `$process_fn`: A closure `|state, data| -> Result<(), E>`.
///
/// # Examples
///
/// ### 1. With `new(state)`
/// ```
/// use type_flow_macros::inplace_stateful_processor;
/// use type_flow_traits::InPlaceStatefulProcessor;
/// #[derive(Debug)]
/// struct MyError;
///
/// // Adds a configured value, fails if result exceeds a limit from state.
/// inplace_stateful_processor!(AddNLimited, (i32, i32), i32, MyError, |state: &mut (i32, i32), data: &mut i32| {
///     *data += state.0;
///     if *data > state.1 { Err(MyError) } else { Ok(()) }
/// });
///
/// let mut processor = AddNLimited::new((5, 100)); // Add 5, limit 100
/// let mut value = 10;
/// processor.process(&mut value).unwrap();
/// assert_eq!(value, 15);
/// ```
///
/// ### 2. With initial state
/// ```
/// use type_flow_macros::inplace_stateful_processor;
/// use type_flow_traits::InPlaceStatefulProcessor;
///
/// // Accumulates values in-place.
/// inplace_stateful_processor!(Accumulator, i32, 0, i32, (), |state: &mut i32, data: &mut i32| {
///     *state += *data;
///     *data = *state;
///     Ok(())
/// });
///
/// let mut processor = Accumulator::new();
/// let (mut val1, mut val2) = (5, 10);
/// processor.process(&mut val1).unwrap();
/// assert_eq!(val1, 5);
/// processor.process(&mut val2).unwrap();
/// assert_eq!(val2, 15); // 5 (previous state) + 10
/// ```
#[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)
            }
        }
    };
}

/// Creates a pipeline of stateful, in-place processors.
///
/// Generates a struct that holds multiple `InPlaceStatefulProcessor`s and
/// processes data through them sequentially. Each processor can mutate the data
/// and its own state. The pipeline stops if any processor returns an error.
///
/// # Arms
///
/// ## 1. With named fields
/// - `$pipeline_name`: Name for the pipeline struct.
/// - `$data_type`: The type of data for the pipeline.
/// - `$error_type`: The common error type.
/// - `$($processor_field:ident: $processor_type:ty),+`: A list of `field: Type` pairs.
///
/// ## 2. With auto-generated fields (delegates to a proc-macro)
/// - `$pipeline_name`: Name for the pipeline struct.
/// - `$data_type`: The type of data for the pipeline.
/// - `$error_type`: The common error type.
/// - `$($processor_type:ty),+`: A list of processor types.
///
/// # Examples
///
/// ```
/// use type_flow_macros::{inplace_stateful_processor, inplace_stateful_processor_pipeline};
/// use type_flow_traits::InPlaceStatefulProcessor;
/// use type_flow_proc_macros::inplace_stateful_processor_pipeline_with_index;
/// #[derive(Debug)]
/// struct MyError;
///
/// // Processor that adds its call count to data.
/// inplace_stateful_processor!(CounterAdd, i32, 0, i32, MyError, |state: &mut i32, data: &mut i32| {
///     *state += 1;
///     *data += *state;
///     Ok(())
/// });
///
/// // Processor that multiplies data by its call count.
/// inplace_stateful_processor!(CounterMul, i32, 0, i32, MyError, |state: &mut i32, data: &mut i32| {
///     *state += 1;
///     *data *= *state;
///     Ok(())
/// });
///
/// // Arm 1: Named fields
/// inplace_stateful_processor_pipeline!(MyPipeline, i32, MyError, adder: CounterAdd, multiplier: CounterMul);
///
/// let mut pipeline = MyPipeline::new(CounterAdd::new(), CounterMul::new());
/// let mut value = 10;
///
/// // First run: value=10 -> adder(s=1) -> 11 -> multiplier(s=1) -> 11
/// pipeline.process(&mut value).unwrap();
/// assert_eq!(value, 11);
///
/// // Second run: value=11 -> adder(s=2) -> 13 -> multiplier(s=2) -> 26
/// pipeline.process(&mut value).unwrap();
/// assert_eq!(value, 26);
/// ```
#[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),+);
    };
}

/// Creates a generic, stateful, in-place processor pipeline with type-level permutation capabilities.
///
/// This powerful macro generates a pipeline struct that is generic over its
/// `InPlaceStatefulProcessor`s. It automatically implements traits that allow the
/// order of processors to be rearranged at compile time through type manipulation.
///
/// # Supported Operations
///
/// The generated pipeline supports the following type-level transformations through trait implementations:
///
/// - `Reverse`: Reverses the order of processors in the pipeline
/// - `ShiftLeft`: Rotates all processors one position left
/// - `ShiftRight`: Rotates all processors one position right 
/// - `SwapStartEnd`: Exchanges the first and last processors
/// - `SwapArbitraryProcessors<I, J>`: Swaps processors at any two positions
///
/// # Macro Parameters
///
/// ## Variant 1: With named fields
/// - `$struct_name`: Name for the generated pipeline struct
/// - `$processor_type`: Type of data flowing through the pipeline
/// - `$processor_error_type`: Common error type used by all processors
/// - `$($field_name:ident : $type_param:ident),+`: Field names and corresponding generic type parameters
///
/// ## Variant 2: With processor count
/// - `$struct_name`: Name for the generated pipeline struct
/// - `$processor_type`: Type of data flowing through the pipeline
/// - `$processor_error_type`: Common error type used by all processors
/// - `$number_of_processors`: A literal integer specifying how many processors the pipeline should support
///
/// # Examples
///
/// ```
/// use type_flow_macros::{
///     type_flow_inplace_stateful_processor_pipeline,
///     inplace_stateful_processor
/// };
/// use type_flow_proc_macros::implement_processor_swapping;
/// use type_flow_traits::{InPlaceStatefulProcessor,
///     Reverse, ShiftLeft};
/// #[derive(Debug)]
/// struct MyError;
///
/// // These processors have a state type of `()` and don't use it.
/// inplace_stateful_processor!(AddOne, (), i32, MyError, |_, d: &mut i32| { *d += 1; Ok(()) });
/// inplace_stateful_processor!(MulTwo, (), i32, MyError, |_, d: &mut i32| { *d *= 2; Ok(()) });
/// inplace_stateful_processor!(SubThree, (), i32, MyError, |_, d: &mut i32| { *d -= 3; Ok(()) });
///
/// // Using the variant of the macro that creates field names from type names.
/// type_flow_inplace_stateful_processor_pipeline!(
///     MyPipeline, i32, MyError, a: A, b: B, c: C
/// );
///
/// // Original pipeline
/// let mut pipeline = MyPipeline::new(AddOne::new(()), MulTwo::new(()), SubThree::new(()));
/// let mut value = 10;
/// pipeline.process(&mut value).unwrap();
/// assert_eq!(value, 19); // (10 + 1) * 2 - 3 = 19
///
/// // Reversed pipeline. Note: .reverse() consumes the pipeline and returns a new type.
/// let mut reversed_pipeline = MyPipeline::new(AddOne::new(()), MulTwo::new(()), SubThree::new(()))
///     .reverse();
/// let mut value_rev = 10;
/// reversed_pipeline.process(&mut value_rev).unwrap();
/// assert_eq!(value_rev, 15); // (10 - 3) * 2 + 1 = 15
///
/// // Shifted pipeline
/// let mut shifted_pipeline = MyPipeline::new(AddOne::new(()), MulTwo::new(()), SubThree::new(()))
///     .shift_left();
/// let mut value_shift = 10;
/// shifted_pipeline.process(&mut value_shift).unwrap();
/// assert_eq!(value_shift, 18); // (10 * 2 - 3) + 1 = 18
/// ```
#[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(())
            }
        }
    };
    ($struct_name:ident, $processor_type:ty, $processor_error_type:ty, $number_of_processors:literal) => {
        type_flow_proc_macros::type_flow_inplace_stateful_processor_pipeline_by_count!($struct_name, $processor_type, $processor_error_type, $number_of_processors);
    };
}