qubit_function/transformers/

stateful_bi_transformer.rs

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026.
 *    Haixing Hu, Qubit Co. Ltd.
 *
 *    All rights reserved.
 *
 ******************************************************************************/
//! # StatefulBiTransformer Types
//!
//! Provides Rust implementations of stateful bi-transformer traits for type
//! conversion and value transformation with two inputs. StatefulBiTransformers
//! consume two input values (taking ownership) and produce an output value.
//!
//! This module provides the `StatefulBiTransformer<T, U, R>` trait and three
//! implementations:
//!
//! - [`BoxStatefulBiTransformer`]: Single ownership, not cloneable
//! - [`ArcStatefulBiTransformer`]: Thread-safe shared ownership, cloneable
//! - [`RcStatefulBiTransformer`]: Single-threaded shared ownership, cloneable
//!
//! # Author
//!
//! Haixing Hu
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;

use parking_lot::Mutex;

use crate::macros::{
    impl_arc_conversions,
    impl_closure_trait,
    impl_rc_conversions,
};
use crate::predicates::bi_predicate::{
    ArcBiPredicate,
    BiPredicate,
    BoxBiPredicate,
    RcBiPredicate,
};
use crate::transformers::{
    bi_transformer_once::BoxBiTransformerOnce,
    macros::{
        impl_box_conditional_transformer,
        impl_box_transformer_methods,
        impl_conditional_transformer_clone,
        impl_conditional_transformer_debug_display,
        impl_shared_conditional_transformer,
        impl_shared_transformer_methods,
        impl_transformer_clone,
        impl_transformer_common_methods,
        impl_transformer_constant_method,
        impl_transformer_debug_display,
    },
    stateful_transformer::StatefulTransformer,
};

// ============================================================================
// Core Trait
// ============================================================================

/// StatefulBiTransformer trait - transforms two values to produce a result
///
/// Defines the behavior of a bi-transformation: converting two values of types
/// `T` and `U` to a value of type `R` by consuming the inputs. This is
/// analogous to `Fn(T, U) -> R` in Rust's standard library.
///
/// # Type Parameters
///
/// * `T` - The type of the first input value (consumed)
/// * `U` - The type of the second input value (consumed)
/// * `R` - The type of the output value
///
/// # Author
///
/// Haixing Hu
pub trait StatefulBiTransformer<T, U, R> {
    /// Transforms two input values to produce an output value
    ///
    /// # Parameters
    ///
    /// * `first` - The first input value to transform (consumed)
    /// * `second` - The second input value to transform (consumed)
    ///
    /// # Returns
    ///
    /// The transformed output value
    fn apply(&mut self, first: T, second: U) -> R;

    /// Converts to BoxStatefulBiTransformer
    ///
    /// **⚠️ Consumes `self`**: The original bi-transformer becomes unavailable
    /// after calling this method.
    ///
    /// # Default Implementation
    ///
    /// The default implementation wraps `self` in a `Box` and creates a
    /// `BoxStatefulBiTransformer`. Types can override this method to provide more
    /// efficient conversions.
    ///
    /// # Returns
    ///
    /// Returns `BoxStatefulBiTransformer<T, U, R>`
    fn into_box(self) -> BoxStatefulBiTransformer<T, U, R>
    where
        Self: Sized + 'static,
    {
        let mut trans = self;
        BoxStatefulBiTransformer::new(move |x, y| trans.apply(x, y))
    }

    /// Converts to RcStatefulBiTransformer
    ///
    /// **⚠️ Consumes `self`**: The original bi-transformer becomes unavailable
    /// after calling this method.
    ///
    /// # Default Implementation
    ///
    /// The default implementation wraps `self` in an `Rc` and creates an
    /// `RcStatefulBiTransformer`. Types can override this method to provide more
    /// efficient conversions.
    ///
    /// # Returns
    ///
    /// Returns `RcStatefulBiTransformer<T, U, R>`
    fn into_rc(self) -> RcStatefulBiTransformer<T, U, R>
    where
        Self: Sized + 'static,
    {
        let mut trans = self;
        RcStatefulBiTransformer::new(move |x, y| trans.apply(x, y))
    }

    /// Converts to ArcStatefulBiTransformer
    ///
    /// **⚠️ Consumes `self`**: The original bi-transformer becomes unavailable
    /// after calling this method.
    ///
    /// # Default Implementation
    ///
    /// The default implementation wraps `self` in an `Arc` and creates an
    /// `ArcStatefulBiTransformer`. Types can override this method to provide more
    /// efficient conversions.
    ///
    /// # Returns
    ///
    /// Returns `ArcStatefulBiTransformer<T, U, R>`
    fn into_arc(self) -> ArcStatefulBiTransformer<T, U, R>
    where
        Self: Sized + Send + 'static,
    {
        let mut trans = self;
        ArcStatefulBiTransformer::new(move |x, y| trans.apply(x, y))
    }

    /// Converts bi-transformer to a closure
    ///
    /// **⚠️ Consumes `self`**: The original bi-transformer becomes unavailable
    /// after calling this method.
    ///
    /// # Default Implementation
    ///
    /// The default implementation creates a closure that captures `self`
    /// and calls its `apply` method. Types can override this method
    /// to provide more efficient conversions.
    ///
    /// # Returns
    ///
    /// Returns a closure that implements `FnMut(T, U) -> R`
    fn into_fn(self) -> impl FnMut(T, U) -> R
    where
        Self: Sized + 'static,
    {
        let mut trans = self;
        move |t, u| trans.apply(t, u)
    }

    /// Converts bi-transformer to a mutable closure (`FnMut`) with an explicit
    /// method name.
    ///
    /// This is a naming alias of [`StatefulBiTransformer::into_fn`] to avoid
    /// confusion with non-stateful `into_fn` methods that typically return `Fn`.
    fn into_mut_fn(self) -> impl FnMut(T, U) -> R
    where
        Self: Sized + 'static,
    {
        self.into_fn()
    }

    /// Converts to BoxBiTransformerOnce
    ///
    /// **⚠️ Consumes `self`**: The original bi-transformer becomes unavailable
    /// after calling this method.
    ///
    /// # Default Implementation
    ///
    /// The default implementation wraps `self` in a `Box` and creates a
    /// `BoxBiTransformerOnce`. Types can override this method to provide more
    /// efficient conversions.
    ///
    /// # Returns
    ///
    /// Returns `BoxBiTransformerOnce<T, U, R>`
    fn into_once(self) -> BoxBiTransformerOnce<T, U, R>
    where
        Self: Sized + 'static,
    {
        let mut trans = self;
        BoxBiTransformerOnce::new(move |t, u| trans.apply(t, u))
    }

    /// Non-consuming conversion to `BoxStatefulBiTransformer` using `&self`.
    ///
    /// Default implementation clones `self` and delegates to `into_box`.
    fn to_box(&self) -> BoxStatefulBiTransformer<T, U, R>
    where
        Self: Sized + Clone + 'static,
    {
        self.clone().into_box()
    }

    /// Non-consuming conversion to `RcStatefulBiTransformer` using `&self`.
    ///
    /// Default implementation clones `self` and delegates to `into_rc`.
    fn to_rc(&self) -> RcStatefulBiTransformer<T, U, R>
    where
        Self: Sized + Clone + 'static,
    {
        self.clone().into_rc()
    }

    /// Non-consuming conversion to `ArcStatefulBiTransformer` using `&self`.
    ///
    /// Default implementation clones `self` and delegates to `into_arc`.
    fn to_arc(&self) -> ArcStatefulBiTransformer<T, U, R>
    where
        Self: Sized + Clone + Send + 'static,
    {
        self.clone().into_arc()
    }

    /// Non-consuming conversion to a boxed function using `&self`.
    ///
    /// Returns a `Box<dyn FnMut(T, U) -> R>` that clones `self` and calls
    /// `apply` inside the boxed closure.
    fn to_fn(&self) -> impl FnMut(T, U) -> R
    where
        Self: Sized + Clone + 'static,
    {
        self.clone().into_fn()
    }

    /// Non-consuming conversion to a mutable closure (`FnMut`) with an explicit
    /// method name.
    ///
    /// This is a naming alias of [`StatefulBiTransformer::to_fn`] and keeps the
    /// same clone-based behavior.
    fn to_mut_fn(&self) -> impl FnMut(T, U) -> R
    where
        Self: Sized + Clone + 'static,
    {
        self.to_fn()
    }

    /// Non-consuming conversion to `BoxBiTransformerOnce` using `&self`.
    ///
    /// Default implementation clones `self` and delegates to `into_once`.
    fn to_once(&self) -> BoxBiTransformerOnce<T, U, R>
    where
        Self: Sized + Clone + 'static,
    {
        self.clone().into_once()
    }
}

// ============================================================================
// BoxStatefulBiTransformer - Box<dyn FnMut(T, U) -> R>
// ============================================================================

/// BoxStatefulBiTransformer - bi-transformer wrapper based on `Box<dyn Fn>`
///
/// A bi-transformer wrapper that provides single ownership with reusable
/// transformation. The bi-transformer consumes both inputs and can be called
/// multiple times.
///
/// # Features
///
/// - **Based on**: `Box<dyn FnMut(T, U) -> R>`
/// - **Ownership**: Single ownership, cannot be cloned
/// - **Reusability**: Can be called multiple times (each call consumes its
///   inputs)
/// - **Thread Safety**: Not thread-safe (no `Send + Sync` requirement)
///
/// # Author
///
/// Haixing Hu
pub struct BoxStatefulBiTransformer<T, U, R> {
    function: Box<dyn FnMut(T, U) -> R>,
    name: Option<String>,
}

impl<T, U, R> BoxStatefulBiTransformer<T, U, R> {
    impl_transformer_common_methods!(
        BoxStatefulBiTransformer<T, U, R>,
        (FnMut(T, U) -> R + 'static),
        |f| Box::new(f)
    );

    impl_box_transformer_methods!(
        BoxStatefulBiTransformer<T, U, R>,
        BoxConditionalStatefulBiTransformer,
        StatefulTransformer
    );
}

// Implement constant method for BoxStatefulBiTransformer
impl_transformer_constant_method!(stateful BoxStatefulBiTransformer<T, U, R>);

// Implement Debug and Display for BoxTransformer
impl_transformer_debug_display!(BoxStatefulBiTransformer<T, U, R>);

impl<T, U, R> StatefulBiTransformer<T, U, R> for BoxStatefulBiTransformer<T, U, R> {
    fn apply(&mut self, first: T, second: U) -> R {
        (self.function)(first, second)
    }

    fn into_box(self) -> BoxStatefulBiTransformer<T, U, R> {
        // Zero-cost: directly return itself
        self
    }

    fn into_rc(self) -> RcStatefulBiTransformer<T, U, R>
    where
        Self: 'static,
    {
        RcStatefulBiTransformer::new(self.function)
    }

    // do NOT override BoxStatefulBiTransformer::into_arc() because BoxStatefulBiTransformer is not Send + Sync
    // and calling BoxStatefulBiTransformer::into_arc() will cause a compile error

    fn into_fn(self) -> impl FnMut(T, U) -> R {
        self.function
    }

    // do NOT override BoxStatefulBiTransformer::to_xxx() because BoxStatefulBiTransformer is not Clone
    // and calling BoxStatefulBiTransformer::to_xxx() will cause a compile error
}

// ============================================================================
// RcStatefulBiTransformer - Rc<dyn FnMut(T, U) -> R>
// ============================================================================

/// RcStatefulBiTransformer - single-threaded bi-transformer wrapper
///
/// A single-threaded, clonable bi-transformer wrapper optimized for scenarios
/// that require sharing without thread-safety overhead.
///
/// # Features
///
/// - **Based on**: `Rc<dyn FnMut(T, U) -> R>`
/// - **Ownership**: Shared ownership via reference counting (non-atomic)
/// - **Reusability**: Can be called multiple times (each call consumes its
///   inputs)
/// - **Thread Safety**: Not thread-safe (no `Send + Sync`)
/// - **Clonable**: Cheap cloning via `Rc::clone`
///
/// # Author
///
/// Haixing Hu
pub struct RcStatefulBiTransformer<T, U, R> {
    function: Rc<RefCell<dyn FnMut(T, U) -> R>>,
    name: Option<String>,
}

impl<T, U, R> RcStatefulBiTransformer<T, U, R> {
    impl_transformer_common_methods!(
        RcStatefulBiTransformer<T, U, R>,
        (FnMut(T, U) -> R + 'static),
        |f| Rc::new(RefCell::new(f))
    );

    impl_shared_transformer_methods!(
        RcStatefulBiTransformer<T, U, R>,
        RcConditionalStatefulBiTransformer,
        into_rc,
        StatefulTransformer,
        'static
    );
}

// Implement constant method for RcStatefulBiTransformer
impl_transformer_constant_method!(stateful RcStatefulBiTransformer<T, U, R>);

// Implement Debug and Display for RcStatefulBiTransformer
impl_transformer_debug_display!(RcStatefulBiTransformer<T, U, R>);

// Implement Clone for RcStatefulBiTransformer
impl_transformer_clone!(RcStatefulBiTransformer<T, U, R>);

// Implement StatefulBiTransformer trait for RcStatefulBiTransformer
impl<T, U, R> StatefulBiTransformer<T, U, R> for RcStatefulBiTransformer<T, U, R> {
    fn apply(&mut self, first: T, second: U) -> R {
        let mut self_fn = self.function.borrow_mut();
        self_fn(first, second)
    }

    // Generate all conversion methods using the unified macro
    impl_rc_conversions!(
        RcStatefulBiTransformer<T, U, R>,
        BoxStatefulBiTransformer,
        BoxBiTransformerOnce,
        FnMut(first: T, second: U) -> R
    );
}

// ============================================================================
// ArcStatefulBiTransformer - Arc<dyn FnMut(T, U) -> R + Send + Sync>
// ============================================================================

/// ArcStatefulBiTransformer - thread-safe bi-transformer wrapper
///
/// A thread-safe, clonable bi-transformer wrapper suitable for multi-threaded
/// scenarios. Can be called multiple times and shared across threads.
///
/// # Features
///
/// - **Based on**: `Arc<dyn FnMut(T, U) -> R + Send + Sync>`
/// - **Ownership**: Shared ownership via reference counting
/// - **Reusability**: Can be called multiple times (each call consumes its
///   inputs)
/// - **Thread Safety**: Thread-safe (`Send + Sync` required)
/// - **Clonable**: Cheap cloning via `Arc::clone`
///
/// # Author
///
/// Haixing Hu
pub struct ArcStatefulBiTransformer<T, U, R> {
    function: Arc<Mutex<dyn FnMut(T, U) -> R + Send>>,
    name: Option<String>,
}

impl<T, U, R> ArcStatefulBiTransformer<T, U, R> {
    impl_transformer_common_methods!(
        ArcStatefulBiTransformer<T, U, R>,
        (FnMut(T, U) -> R + Send + 'static),
        |f| Arc::new(Mutex::new(f))
    );

    impl_shared_transformer_methods!(
        ArcStatefulBiTransformer<T, U, R>,
        ArcConditionalStatefulBiTransformer,
        into_arc,
        StatefulTransformer,
        Send + Sync + 'static
    );
}

// Implement constant method for ArcStatefulBiTransformer
impl_transformer_constant_method!(stateful thread_safe ArcStatefulBiTransformer<T, U, R>);

// Implement Debug and Display for ArcStatefulBiTransformer
impl_transformer_debug_display!(ArcStatefulBiTransformer<T, U, R>);

// Implement Clone for ArcStatefulBiTransformer
impl_transformer_clone!(ArcStatefulBiTransformer<T, U, R>);

// Implement StatefulBiTransformer trait for ArcStatefulBiTransformer
impl<T, U, R> StatefulBiTransformer<T, U, R> for ArcStatefulBiTransformer<T, U, R> {
    fn apply(&mut self, first: T, second: U) -> R {
        let mut func = self.function.lock();
        func(first, second)
    }

    // Use macro to implement conversion methods
    impl_arc_conversions!(
        ArcStatefulBiTransformer<T, U, R>,
        BoxStatefulBiTransformer,
        RcStatefulBiTransformer,
        BoxBiTransformerOnce,
        FnMut(t: T, u: U) -> R
    );
}

// ============================================================================
// Blanket implementation for standard Fn trait
// ============================================================================

// Implement StatefulBiTransformer<T, U, R> for any type that implements FnMut(T, U) -> R
impl_closure_trait!(
    StatefulBiTransformer<T, U, R>,
    apply,
    BoxBiTransformerOnce,
    FnMut(first: T, second: U) -> R
);

// ============================================================================
// FnStatefulBiTransformerOps - Extension trait for FnMut(T, U) -> R bi-transformers
// ============================================================================

/// Extension trait for closures implementing `FnMut(T, U) -> R`
///
/// Provides composition methods (`and_then`, `when`) for bi-transformer
/// closures and function pointers without requiring explicit wrapping in
/// `BoxStatefulBiTransformer`.
///
/// This trait is automatically implemented for all closures and function
/// pointers that implement `FnMut(T, U) -> R`.
///
/// # Design Rationale
///
/// While closures automatically implement `StatefulBiTransformer<T, U, R>` through
/// blanket implementation, they don't have access to instance methods like
/// `and_then` and `when`. This extension trait provides those methods,
/// returning `BoxStatefulBiTransformer` for maximum flexibility.
///
/// # Examples
///
/// ## Chain composition with and_then
///
/// ```rust
/// use std::cell::Cell;
/// use qubit_function::{StatefulBiTransformer, FnStatefulBiTransformerOps};
///
/// let add = |x: i32, y: i32| x + y;
/// let double = |x: i32| x * 2;
///
/// let mut composed = add.and_then(double);
/// assert_eq!(composed.apply(3, 5), 16); // (3 + 5) * 2
/// ```
///
/// ## Conditional execution with when
///
/// ```rust
/// use std::cell::Cell;
/// use qubit_function::{StatefulBiTransformer, FnStatefulBiTransformerOps};
///
/// let add = |x: i32, y: i32| x + y;
/// let multiply = |x: i32, y: i32| x * y;
///
/// let mut conditional = add.when(|x: &i32, y: &i32| *x > 0 && *y > 0).or_else(multiply);
///
/// assert_eq!(conditional.apply(5, 3), 8);   // add
/// assert_eq!(conditional.apply(-5, 3), -15); // multiply
/// ```
///
/// # Author
///
/// Haixing Hu
pub trait FnStatefulBiTransformerOps<T, U, R>: FnMut(T, U) -> R + Sized {
    /// Chain composition - applies self first, then after
    ///
    /// Creates a new bi-transformer that applies this bi-transformer first,
    /// then applies the after transformer to the result. Consumes self and
    /// returns a `BoxStatefulBiTransformer`.
    ///
    /// # Type Parameters
    ///
    /// * `S` - The output type of the after transformer
    /// * `F` - The type of the after transformer (must implement Transformer<R, S>)
    ///
    /// # Parameters
    ///
    /// * `after` - The transformer to apply after self. **Note: This parameter
    ///   is passed by value and will transfer ownership.** If you need to
    ///   preserve the original transformer, clone it first (if it implements
    ///   `Clone`). Can be:
    ///   - A closure: `|x: R| -> S`
    ///   - A function pointer: `fn(R) -> S`
    ///   - A `BoxTransformer<R, S>`
    ///   - An `RcTransformer<R, S>`
    ///   - An `ArcTransformer<R, S>`
    ///   - Any type implementing `Transformer<R, S>`
    ///
    /// # Returns
    ///
    /// A new `BoxStatefulBiTransformer<T, U, S>` representing the composition
    ///
    /// # Examples
    ///
    /// ## Direct value passing (ownership transfer)
    ///
    /// ```rust
    /// use qubit_function::{StatefulBiTransformer, FnStatefulBiTransformerOps};
    ///
    /// let add = |x: i32, y: i32| x + y;
    /// let to_string = |x: i32| x.to_string();
    ///
    /// // to_string is moved here
    /// let mut composed = add.and_then(to_string);
    /// assert_eq!(composed.apply(20, 22), "42");
    /// // to_string(10); // Would not compile - moved
    /// ```
    ///
    /// ## Preserving original with clone
    ///
    /// ```rust
    /// use qubit_function::{StatefulBiTransformer, FnStatefulBiTransformerOps,
    ///     BoxTransformer};
    ///
    /// let add = |x: i32, y: i32| x + y;
    /// let to_string = |x: i32| x.to_string();
    ///
    /// // Clone to preserve original
    /// let mut composed = add.and_then(to_string.clone());
    /// assert_eq!(composed.apply(20, 22), "42");
    ///
    /// // Original still usable
    /// assert_eq!(to_string(10), "10");
    /// ```
    fn and_then<S, F>(self, after: F) -> BoxStatefulBiTransformer<T, U, S>
    where
        Self: 'static,
        S: 'static,
        F: StatefulTransformer<R, S> + 'static,
        T: 'static,
        U: 'static,
        R: 'static,
    {
        BoxStatefulBiTransformer::new(self).and_then(after)
    }

    /// Creates a conditional bi-transformer
    ///
    /// Returns a bi-transformer that only executes when a bi-predicate is
    /// satisfied. You must call `or_else()` to provide an alternative
    /// bi-transformer for when the condition is not satisfied.
    ///
    /// # Parameters
    ///
    /// * `predicate` - The condition to check. **Note: This parameter is passed
    ///   by value and will transfer ownership.** If you need to preserve the
    ///   original bi-predicate, clone it first (if it implements `Clone`).
    ///   Can be:
    ///   - A closure: `|x: &T, y: &U| -> bool`
    ///   - A function pointer: `fn(&T, &U) -> bool`
    ///   - A `BoxBiPredicate<T, U>`
    ///   - An `RcBiPredicate<T, U>`
    ///   - An `ArcBiPredicate<T, U>`
    ///   - Any type implementing `BiPredicate<T, U>`
    ///
    /// # Returns
    ///
    /// Returns `BoxConditionalStatefulBiTransformer<T, U, R>`
    ///
    /// # Examples
    ///
    /// ## Basic usage with or_else
    ///
    /// ```rust
    /// use std::cell::Cell;
    /// use qubit_function::{StatefulBiTransformer, FnStatefulBiTransformerOps};
    ///
    /// let add = |x: i32, y: i32| x + y;
    /// let mut conditional = add.when(|x: &i32, y: &i32| *x > 0)
    ///     .or_else(|x: i32, y: i32| x * y);
    ///
    /// assert_eq!(conditional.apply(5, 3), 8);
    /// assert_eq!(conditional.apply(-5, 3), -15);
    /// ```
    ///
    /// ## Preserving bi-predicate with clone
    ///
    /// ```rust
    /// use qubit_function::{BiPredicate, StatefulBiTransformer, FnStatefulBiTransformerOps,
    ///     RcBiPredicate};
    ///
    /// let add = |x: i32, y: i32| x + y;
    /// let both_positive = RcBiPredicate::new(|x: &i32, y: &i32|
    ///     *x > 0 && *y > 0);
    ///
    /// // Clone to preserve original bi-predicate
    /// let mut conditional = add.when(both_positive.clone())
    ///     .or_else(|x: i32, y: i32| x * y);
    ///
    /// assert_eq!(conditional.apply(5, 3), 8);
    ///
    /// // Original bi-predicate still usable
    /// assert!(both_positive.test(&5, &3));
    /// ```
    fn when<P>(self, predicate: P) -> BoxConditionalStatefulBiTransformer<T, U, R>
    where
        Self: 'static,
        P: BiPredicate<T, U> + 'static,
        T: 'static,
        U: 'static,
        R: 'static,
    {
        BoxStatefulBiTransformer::new(self).when(predicate)
    }

    /// Non-consuming conversion to a function using `&self`.
    ///
    /// Returns a closure that clones `self` and calls the bi-transformer.
    /// This method requires that the bi-transformer implements `Clone`.
    ///
    /// # Type Parameters
    ///
    /// * `F` - The closure type (automatically inferred)
    ///
    /// # Returns
    ///
    /// Returns a closure that implements `FnMut(T, U) -> R`
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::cell::Cell;
    /// use qubit_function::{StatefulBiTransformer, FnStatefulBiTransformerOps};
    ///
    /// let counter = Cell::new(0);
    /// let transformer = move |x: i32, y: i32| {
    ///     let c = counter.get() + 1;
    ///     counter.set(c);
    ///     x + y + c
    /// };
    ///
    /// let mut fn_transformer = FnStatefulBiTransformerOps::to_fn(&transformer);
    /// assert_eq!(fn_transformer(10, 20), 31);
    /// assert_eq!(fn_transformer(10, 20), 32);
    /// ```
    fn to_fn(&self) -> impl FnMut(T, U) -> R
    where
        Self: Clone + 'static,
    {
        let mut cloned = self.clone();
        move |t, u| cloned(t, u)
    }
}

/// Blanket implementation of FnStatefulBiTransformerOps for all closures
///
/// Automatically implements `FnStatefulBiTransformerOps<T, U, R>` for any type that
/// implements `FnMut(T, U) -> R`.
///
/// # Author
///
/// Haixing Hu
impl<T, U, R, F> FnStatefulBiTransformerOps<T, U, R> for F where F: FnMut(T, U) -> R {}

// ============================================================================
// StatefulBinaryOperator Trait - Marker trait for StatefulBiTransformer<T, T, T>
// ============================================================================

/// StatefulBinaryOperator trait - marker trait for stateful binary operators
///
/// A binary operator takes two values of type `T` and produces a value of the
/// same type `T`. This trait extends `StatefulBiTransformer<T, T, T>` to provide
/// semantic clarity for same-type binary operations. Equivalent to Java's
/// `BinaryOperator<T>` which extends `BiFunction<T, T, T>`.
///
/// # Automatic Implementation
///
/// This trait is automatically implemented for all types that implement
/// `StatefulBiTransformer<T, T, T>`, so you don't need to implement it manually.
///
/// # Type Parameters
///
/// * `T` - The type of both input values and the output value
///
/// # Examples
///
/// ## Using in generic constraints
///
/// ```rust
/// use qubit_function::{StatefulBinaryOperator, StatefulBiTransformer};
///
/// fn reduce<T, O>(values: Vec<T>, initial: T, mut op: O) -> T
/// where
///     O: StatefulBinaryOperator<T>,
///     T: Clone,
/// {
///     values.into_iter().fold(initial, |acc, val| op.apply(acc, val))
/// }
///
/// let sum = |a: i32, b: i32| a + b;
/// assert_eq!(reduce(vec![1, 2, 3, 4], 0, sum), 10);
/// ```
///
/// ## With concrete types
///
/// ```rust
/// use qubit_function::{BoxStatefulBinaryOperator, StatefulBiTransformer};
///
/// fn create_adder() -> BoxStatefulBinaryOperator<i32> {
///     BoxStatefulBinaryOperator::new(|x, y| x + y)
/// }
///
/// let mut op = create_adder();
/// assert_eq!(op.apply(20, 22), 42);
/// ```
///
/// # Author
///
/// Haixing Hu
pub trait StatefulBinaryOperator<T>: StatefulBiTransformer<T, T, T> {}

/// Blanket implementation of StatefulBinaryOperator for all StatefulBiTransformer<T, T, T>
///
/// This automatically implements `StatefulBinaryOperator<T>` for any type that
/// implements `StatefulBiTransformer<T, T, T>`.
///
/// # Author
///
/// Haixing Hu
impl<F, T> StatefulBinaryOperator<T> for F
where
    F: StatefulBiTransformer<T, T, T>,
{
    // empty
}

// ============================================================================
// Type Aliases for StatefulBinaryOperator (StatefulBiTransformer<T, T, T>)
// ============================================================================

/// Type alias for `BoxStatefulBiTransformer<T, T, T>`
///
/// Represents a binary operator that takes two values of type `T` and produces
/// a value of the same type `T`, with single ownership semantics. Equivalent to
/// Java's `BinaryOperator<T>`.
///
/// # Examples
///
/// ```rust
/// use qubit_function::{BoxStatefulBinaryOperator, StatefulBiTransformer};
///
/// let add: BoxStatefulBinaryOperator<i32> = BoxStatefulBinaryOperator::new(|x, y| x + y);
/// let mut add = add;
/// assert_eq!(add.apply(20, 22), 42);
/// ```
///
/// # Author
///
/// Haixing Hu
pub type BoxStatefulBinaryOperator<T> = BoxStatefulBiTransformer<T, T, T>;

/// Type alias for `ArcStatefulBiTransformer<T, T, T>`
///
/// Represents a thread-safe binary operator that takes two values of type `T`
/// and produces a value of the same type `T`. Equivalent to Java's
/// `BinaryOperator<T>` with shared, thread-safe ownership.
///
/// # Examples
///
/// ```rust
/// use qubit_function::{ArcStatefulBinaryOperator, StatefulBiTransformer};
///
/// let multiply: ArcStatefulBinaryOperator<i32> = ArcStatefulBinaryOperator::new(|x, y| x * y);
/// let mut multiply_clone = multiply.clone();
/// let mut multiply = multiply;
/// assert_eq!(multiply.apply(6, 7), 42);
/// assert_eq!(multiply_clone.apply(6, 7), 42);
/// ```
///
/// # Author
///
/// Haixing Hu
pub type ArcStatefulBinaryOperator<T> = ArcStatefulBiTransformer<T, T, T>;

/// Type alias for `RcStatefulBiTransformer<T, T, T>`
///
/// Represents a single-threaded binary operator that takes two values of type
/// `T` and produces a value of the same type `T`. Equivalent to Java's
/// `BinaryOperator<T>` with shared, single-threaded ownership.
///
/// # Examples
///
/// ```rust
/// use qubit_function::{RcStatefulBinaryOperator, StatefulBiTransformer};
///
/// let max: RcStatefulBinaryOperator<i32> = RcStatefulBinaryOperator::new(|x, y| if x > y { x } else { y });
/// let mut max_clone = max.clone();
/// let mut max = max;
/// assert_eq!(max.apply(30, 42), 42);
/// assert_eq!(max_clone.apply(30, 42), 42);
/// ```
///
/// # Author
///
/// Haixing Hu
pub type RcStatefulBinaryOperator<T> = RcStatefulBiTransformer<T, T, T>;

// ============================================================================
// BoxConditionalStatefulBiTransformer - Box-based Conditional StatefulBiTransformer
// ============================================================================

/// BoxConditionalStatefulBiTransformer struct
///
/// A conditional bi-transformer that only executes when a bi-predicate is
/// satisfied. Uses `BoxStatefulBiTransformer` and `BoxBiPredicate` for single
/// ownership semantics.
///
/// This type is typically created by calling `BoxStatefulBiTransformer::when()` and is
/// designed to work with the `or_else()` method to create if-then-else logic.
///
/// # Features
///
/// - **Single Ownership**: Not cloneable, consumes `self` on use
/// - **Conditional Execution**: Only transforms when bi-predicate returns `true`
/// - **Chainable**: Can add `or_else` branch to create if-then-else logic
/// - **Implements StatefulBiTransformer**: Can be used anywhere a `StatefulBiTransformer` is expected
///
/// # Examples
///
/// ## With or_else Branch
///
/// ```rust
/// use qubit_function::{StatefulBiTransformer, BoxStatefulBiTransformer};
///
/// let add = BoxStatefulBiTransformer::new(|x: i32, y: i32| x + y);
/// let multiply = BoxStatefulBiTransformer::new(|x: i32, y: i32| x * y);
/// let mut conditional = add.when(|x: &i32, y: &i32| *x > 0).or_else(multiply);
///
/// assert_eq!(conditional.apply(5, 3), 8);  // when branch executed
/// assert_eq!(conditional.apply(-5, 3), -15); // or_else branch executed
/// ```
///
/// # Author
///
/// Haixing Hu
pub struct BoxConditionalStatefulBiTransformer<T, U, R> {
    transformer: BoxStatefulBiTransformer<T, U, R>,
    predicate: BoxBiPredicate<T, U>,
}

// Implement BoxConditionalStatefulBiTransformer
impl_box_conditional_transformer!(
    BoxConditionalStatefulBiTransformer<T, U, R>,
    BoxStatefulBiTransformer,
    StatefulBiTransformer
);

// Implement Debug and Display for BoxConditionalStatefulBiTransformer
impl_conditional_transformer_debug_display!(BoxConditionalStatefulBiTransformer<T, U, R>);

// ============================================================================
// RcConditionalStatefulBiTransformer - Rc-based Conditional StatefulBiTransformer
// ============================================================================

/// RcConditionalStatefulBiTransformer struct
///
/// A single-threaded conditional bi-transformer that only executes when a
/// bi-predicate is satisfied. Uses `RcStatefulBiTransformer` and `RcBiPredicate` for
/// shared ownership within a single thread.
///
/// This type is typically created by calling `RcStatefulBiTransformer::when()` and is
/// designed to work with the `or_else()` method to create if-then-else logic.
///
/// # Features
///
/// - **Shared Ownership**: Cloneable via `Rc`, multiple owners allowed
/// - **Single-Threaded**: Not thread-safe, cannot be sent across threads
/// - **Conditional Execution**: Only transforms when bi-predicate returns `true`
/// - **No Lock Overhead**: More efficient than `ArcConditionalStatefulBiTransformer`
///
/// # Examples
///
/// ```rust
/// use qubit_function::{StatefulBiTransformer, RcStatefulBiTransformer};
///
/// let add = RcStatefulBiTransformer::new(|x: i32, y: i32| x + y);
/// let multiply = RcStatefulBiTransformer::new(|x: i32, y: i32| x * y);
/// let mut conditional = add.when(|x: &i32, y: &i32| *x > 0).or_else(multiply);
///
/// let mut conditional_clone = conditional.clone();
///
/// assert_eq!(conditional.apply(5, 3), 8);
/// assert_eq!(conditional_clone.apply(-5, 3), -15);
/// ```
///
/// # Author
///
/// Haixing Hu
pub struct RcConditionalStatefulBiTransformer<T, U, R> {
    transformer: RcStatefulBiTransformer<T, U, R>,
    predicate: RcBiPredicate<T, U>,
}

// Implement RcConditionalStatefulBiTransformer
impl_shared_conditional_transformer!(
    RcConditionalStatefulBiTransformer<T, U, R>,
    RcStatefulBiTransformer,
    StatefulBiTransformer,
    into_rc,
    'static
);

// Use macro to generate Debug and Display implementations
impl_conditional_transformer_debug_display!(RcConditionalStatefulBiTransformer<T, U, R>);

// Implement Clone for RcConditionalStatefulBiTransformer
impl_conditional_transformer_clone!(RcConditionalStatefulBiTransformer<T, U, R>);

// ============================================================================
// ArcConditionalStatefulBiTransformer - Arc-based Conditional StatefulBiTransformer
// ============================================================================

/// ArcConditionalStatefulBiTransformer struct
///
/// A thread-safe conditional bi-transformer that only executes when a
/// bi-predicate is satisfied. Uses `ArcStatefulBiTransformer` and `ArcBiPredicate` for
/// shared ownership across threads.
///
/// This type is typically created by calling `ArcStatefulBiTransformer::when()` and is
/// designed to work with the `or_else()` method to create if-then-else logic.
///
/// # Features
///
/// - **Shared Ownership**: Cloneable via `Arc`, multiple owners allowed
/// - **Thread-Safe**: Implements `Send + Sync`, safe for concurrent use
/// - **Conditional Execution**: Only transforms when bi-predicate returns `true`
/// - **Chainable**: Can add `or_else` branch to create if-then-else logic
///
/// # Examples
///
/// ```rust
/// use qubit_function::{StatefulBiTransformer, ArcStatefulBiTransformer};
///
/// let add = ArcStatefulBiTransformer::new(|x: i32, y: i32| x + y);
/// let multiply = ArcStatefulBiTransformer::new(|x: i32, y: i32| x * y);
/// let mut conditional = add.when(|x: &i32, y: &i32| *x > 0).or_else(multiply);
///
/// let mut conditional_clone = conditional.clone();
///
/// assert_eq!(conditional.apply(5, 3), 8);
/// assert_eq!(conditional_clone.apply(-5, 3), -15);
/// ```
///
/// # Author
///
/// Haixing Hu
pub struct ArcConditionalStatefulBiTransformer<T, U, R> {
    transformer: ArcStatefulBiTransformer<T, U, R>,
    predicate: ArcBiPredicate<T, U>,
}

impl_shared_conditional_transformer!(
    ArcConditionalStatefulBiTransformer<T, U, R>,
    ArcStatefulBiTransformer,
    StatefulBiTransformer,
    into_arc,
    Send + Sync + 'static
);

// Implement Debug and Display for ArcConditionalStatefulBiTransformer
impl_conditional_transformer_debug_display!(ArcConditionalStatefulBiTransformer<T, U, R>);

// Implement Clone for ArcConditionalStatefulBiTransformer
impl_conditional_transformer_clone!(ArcConditionalStatefulBiTransformer<T, U, R>);