stillwater 1.0.1

//! Validation type for accumulating errors
//!
//! This module provides the `Validation` type, which is similar to `Result` but designed
//! specifically for validation scenarios where we want to accumulate all errors rather than
//! short-circuiting on the first failure.
//!
//! # Examples
//!
//! ## Basic usage
//!
//! ```
//! use stillwater::Validation;
//!
//! // Create validations
//! let success = Validation::<_, Vec<&str>>::success(42);
//! let failure = Validation::<i32, _>::failure(vec!["error"]);
//!
//! assert!(success.is_success());
//! assert!(failure.is_failure());
//! ```
//!
//! ## Combining validations
//!
//! ```
//! use stillwater::Validation;
//!
//! let v1 = Validation::<_, Vec<&str>>::success(1);
//! let v2 = Validation::<_, Vec<&str>>::success(2);
//! let result = v1.and(v2);
//!
//! assert_eq!(result, Validation::Success((1, 2)));
//! ```
//!
//! ## Accumulating errors
//!
//! ```
//! use stillwater::Validation;
//!
//! let v1 = Validation::<i32, _>::failure(vec!["error1"]);
//! let v2 = Validation::<i32, _>::failure(vec!["error2"]);
//! let result = v1.and(v2);
//!
//! assert_eq!(result, Validation::Failure(vec!["error1", "error2"]));
//! ```
//!
//! ## Validating tuples
//!
//! ```
//! use stillwater::{Validation, validation::ValidateAll};
//!
//! let result = (
//!     Validation::<_, Vec<&str>>::success(1),
//!     Validation::<_, Vec<&str>>::success(2),
//!     Validation::<_, Vec<&str>>::success(3),
//! ).validate_all();
//!
//! assert_eq!(result, Validation::Success((1, 2, 3)));
//! ```
//!
//! ## Try trait support (nightly + feature flag)
//!
//! When the `try_trait` feature is enabled and using nightly Rust, `Validation` supports
//! the `?` operator for ergonomic error propagation:
//!
//! ```ignore
//! #![feature(try_trait_v2)]
//!
//! fn validate_form(data: FormData) -> Validation<User, Vec<ValidationError>> {
//!     let email = validate_email(&data.email)?;
//!     let password = validate_password(&data.password)?;
//!     let age = validate_age(data.age)?;
//!
//!     Validation::success(User { email, password, age })
//! }
//! ```
//!
//! **Important**: Using `?` with `Validation` provides **fail-fast** behavior, not error
//! accumulation. The first validation failure will short-circuit and return immediately.
//! For error accumulation, use `Validation::all()` or tuple validation instead.
//!
//! To enable this feature:
//! 1. Use nightly Rust: `rustup default nightly`
//! 2. Enable the feature in `Cargo.toml`: `features = ["try_trait"]`
//! 3. Add `#![feature(try_trait_v2)]` to your crate root

use crate::either::Either;
use crate::nonempty::NonEmptyVec;
use crate::Semigroup;

/// A validation that either succeeds with a value or fails with accumulated errors
///
/// Unlike `Result`, `Validation` is designed to accumulate multiple errors when combining
/// validations. This makes it ideal for form validation, API input validation, and other
/// scenarios where you want to report all errors at once rather than failing on the first one.
///
/// # Type Parameters
///
/// * `T` - The type of the success value
/// * `E` - The type of the error value (must implement `Semigroup` for accumulation)
///
/// # Examples
///
/// ```
/// use stillwater::{Validation, Semigroup};
///
/// // Simple validation
/// let v = Validation::<_, Vec<&str>>::success(42);
/// assert_eq!(v.into_result(), Ok(42));
///
/// // Error accumulation
/// let v1 = Validation::<i32, _>::failure(vec!["error1"]);
/// let v2 = Validation::<i32, _>::failure(vec!["error2"]);
/// let combined = v1.and(v2);
/// assert_eq!(combined, Validation::Failure(vec!["error1", "error2"]));
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Validation<T, E> {
    /// Successful validation with a value
    Success(T),
    /// Failed validation with accumulated errors
    Failure(E),
}

impl<T, E> Validation<T, E> {
    /// Create a successful validation
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<i32, String>::success(42);
    /// assert!(v.is_success());
    /// ```
    #[inline]
    pub fn success(value: T) -> Self {
        Validation::Success(value)
    }

    /// Create a failed validation
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<i32, Vec<&str>>::failure(vec!["error"]);
    /// assert!(v.is_failure());
    /// ```
    #[inline]
    pub fn failure(error: E) -> Self {
        Validation::Failure(error)
    }

    /// Create a validation from a Result
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::from_result(Ok::<_, String>(42));
    /// assert_eq!(v, Validation::Success(42));
    ///
    /// let v = Validation::from_result(Err::<i32, _>("error".to_string()));
    /// assert_eq!(v, Validation::Failure("error".to_string()));
    /// ```
    #[inline]
    pub fn from_result(result: Result<T, E>) -> Self {
        match result {
            Ok(value) => Validation::Success(value),
            Err(error) => Validation::Failure(error),
        }
    }

    /// Convert this validation to a Result
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(42);
    /// assert_eq!(v.into_result(), Ok(42));
    ///
    /// let v = Validation::<i32, _>::failure("error".to_string());
    /// assert_eq!(v.into_result(), Err("error".to_string()));
    /// ```
    #[inline]
    pub fn into_result(self) -> Result<T, E> {
        match self {
            Validation::Success(value) => Ok(value),
            Validation::Failure(error) => Err(error),
        }
    }

    /// Check if this validation is successful
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(42);
    /// assert!(v.is_success());
    /// ```
    #[inline]
    pub fn is_success(&self) -> bool {
        matches!(self, Validation::Success(_))
    }

    /// Check if this validation failed
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<i32, _>::failure("error".to_string());
    /// assert!(v.is_failure());
    /// ```
    #[inline]
    pub fn is_failure(&self) -> bool {
        matches!(self, Validation::Failure(_))
    }

    /// Transform the success value if present
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(5);
    /// let result = v.map(|x| x * 2);
    /// assert_eq!(result, Validation::Success(10));
    /// ```
    #[inline]
    pub fn map<U, F>(self, f: F) -> Validation<U, E>
    where
        F: FnOnce(T) -> U,
    {
        match self {
            Validation::Success(value) => Validation::Success(f(value)),
            Validation::Failure(error) => Validation::Failure(error),
        }
    }

    /// Transform the error value if present
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<i32, _>::failure(vec!["error"]);
    /// let result = v.map_err(|errors| errors.len());
    /// assert_eq!(result, Validation::Failure(1));
    /// ```
    #[inline]
    pub fn map_err<E2, F>(self, f: F) -> Validation<T, E2>
    where
        F: FnOnce(E) -> E2,
    {
        match self {
            Validation::Success(value) => Validation::Success(value),
            Validation::Failure(error) => Validation::Failure(f(error)),
        }
    }

    /// Convert to Either (Success becomes Right, Failure becomes Left).
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::{Validation, Either};
    ///
    /// let success = Validation::<_, &str>::success(42);
    /// let failure = Validation::<i32, _>::failure("error");
    ///
    /// assert_eq!(success.into_either(), Either::right(42));
    /// assert_eq!(failure.into_either(), Either::left("error"));
    /// ```
    #[inline]
    pub fn into_either(self) -> Either<E, T> {
        match self {
            Validation::Success(value) => Either::Right(value),
            Validation::Failure(error) => Either::Left(error),
        }
    }

    /// Ensure the success value satisfies a predicate from the predicate module.
    ///
    /// If the validation is already a failure, returns the failure unchanged.
    /// If successful but the predicate fails, returns a failure with the given error.
    /// If successful and the predicate passes, returns the success unchanged.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::{Validation, predicate::*};
    ///
    /// let result = Validation::success(String::from("hello"))
    ///     .ensure(len_min(3), "too short");
    /// assert_eq!(result, Validation::Success(String::from("hello")));
    ///
    /// let result = Validation::success(String::from("hi"))
    ///     .ensure(len_min(3), "too short");
    /// assert_eq!(result, Validation::Failure("too short"));
    /// ```
    pub fn ensure<P>(self, predicate: P, error: E) -> Validation<T, E>
    where
        P: crate::predicate::Predicate<T>,
    {
        match self {
            Validation::Success(value) if predicate.check(&value) => Validation::Success(value),
            Validation::Success(_) => Validation::Failure(error),
            Validation::Failure(e) => Validation::Failure(e),
        }
    }

    /// Ensure the success value satisfies a closure predicate.
    ///
    /// This is the closure-based variant of `ensure`. For predicates from the
    /// predicate module, use `ensure` instead.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let result = Validation::success(String::from("hello"))
    ///     .ensure_fn(|s| s.contains('e'), "must contain 'e'");
    /// assert_eq!(result, Validation::Success(String::from("hello")));
    ///
    /// let result = Validation::success(5)
    ///     .ensure_fn(|x| *x > 0, "must be positive");
    /// assert_eq!(result, Validation::Success(5));
    /// ```
    pub fn ensure_fn<F>(self, predicate: F, error: E) -> Validation<T, E>
    where
        F: FnOnce(&T) -> bool,
    {
        match self {
            Validation::Success(value) if predicate(&value) => Validation::Success(value),
            Validation::Success(_) => Validation::Failure(error),
            Validation::Failure(e) => Validation::Failure(e),
        }
    }

    /// Ensure the success value satisfies a predicate, with an error factory.
    ///
    /// Like `ensure`, but takes a closure to generate the error,
    /// allowing access to the value when constructing the error message.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::{Validation, predicate::*};
    ///
    /// let result = Validation::success(String::from("hi"))
    ///     .ensure_with(len_min(3), |s| format!("'{}' too short", s));
    /// assert_eq!(result, Validation::Failure("'hi' too short".to_string()));
    /// ```
    pub fn ensure_with<P, F>(self, predicate: P, error_fn: F) -> Validation<T, E>
    where
        P: crate::predicate::Predicate<T>,
        F: FnOnce(&T) -> E,
    {
        match self {
            Validation::Success(value) => {
                if predicate.check(&value) {
                    Validation::Success(value)
                } else {
                    Validation::Failure(error_fn(&value))
                }
            }
            Validation::Failure(e) => Validation::Failure(e),
        }
    }

    /// Ensure the success value satisfies a closure predicate, with an error factory.
    ///
    /// Like `ensure_fn`, but takes a closure to generate the error.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let result = Validation::success(-5)
    ///     .ensure_fn_with(|x| *x > 0, |x| format!("{} is not positive", x));
    /// assert_eq!(result, Validation::Failure("-5 is not positive".to_string()));
    /// ```
    pub fn ensure_fn_with<P, F>(self, predicate: P, error_fn: F) -> Validation<T, E>
    where
        P: FnOnce(&T) -> bool,
        F: FnOnce(&T) -> E,
    {
        match self {
            Validation::Success(value) => {
                if predicate(&value) {
                    Validation::Success(value)
                } else {
                    Validation::Failure(error_fn(&value))
                }
            }
            Validation::Failure(e) => Validation::Failure(e),
        }
    }

    /// Alias for `ensure_fn` - filter with a fallback error using a closure.
    ///
    /// Named to match common FP convention.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let result = Validation::success(5)
    ///     .filter_or(|x| *x > 0, "must be positive");
    /// assert_eq!(result, Validation::Success(5));
    /// ```
    pub fn filter_or<F>(self, predicate: F, error: E) -> Validation<T, E>
    where
        F: FnOnce(&T) -> bool,
    {
        self.ensure_fn(predicate, error)
    }

    /// Ensure the value does NOT satisfy a closure predicate.
    ///
    /// Inverse of `ensure_fn`: fails if predicate is TRUE.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let result = Validation::success(5)
    ///     .unless(|x| *x < 0, "must not be negative");
    /// assert_eq!(result, Validation::Success(5));
    ///
    /// let result = Validation::success(-5)
    ///     .unless(|x| *x < 0, "must not be negative");
    /// assert_eq!(result, Validation::Failure("must not be negative"));
    /// ```
    pub fn unless<F>(self, predicate: F, error: E) -> Validation<T, E>
    where
        F: FnOnce(&T) -> bool,
    {
        match self {
            Validation::Success(value) if !predicate(&value) => Validation::Success(value),
            Validation::Success(_) => Validation::Failure(error),
            Validation::Failure(e) => Validation::Failure(e),
        }
    }

    // ========== bimap ==========

    /// Transform both variants of this Validation.
    ///
    /// Applies `f` to the error if Failure, or `g` to the value if Success.
    /// This is the Bifunctor `bimap` operation.
    ///
    /// # Bifunctor Laws
    ///
    /// `Validation` satisfies the Bifunctor laws:
    ///
    /// 1. **Identity**: `v.bimap(id, id) == v`
    /// 2. **Composition**: `v.bimap(f1, g1).bimap(f2, g2) == v.bimap(|e| f2(f1(e)), |x| g2(g1(x)))`
    ///
    /// These laws ensure that `bimap` behaves predictably and can be composed.
    ///
    /// # Arguments
    ///
    /// * `f` - Function to transform the error (Failure case)
    /// * `g` - Function to transform the value (Success case)
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let success = Validation::<_, String>::success(5);
    /// let result = success.bimap(|e| e.len(), |x| x * 2);
    /// assert_eq!(result, Validation::Success(10));
    ///
    /// let failure = Validation::<i32, _>::failure("error".to_string());
    /// let result = failure.bimap(|e| e.len(), |x| x * 2);
    /// assert_eq!(result, Validation::Failure(5));
    /// ```
    #[inline]
    pub fn bimap<U, E2, F, G>(self, f: F, g: G) -> Validation<U, E2>
    where
        F: FnOnce(E) -> E2,
        G: FnOnce(T) -> U,
    {
        match self {
            Validation::Success(value) => Validation::Success(g(value)),
            Validation::Failure(error) => Validation::Failure(f(error)),
        }
    }

    /// Transform both variants with success function first.
    ///
    /// This is an alternative to `bimap` with a more intuitive argument order
    /// for those who think "success first".
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(5);
    /// let result = v.bimap_success_first(|x| x * 2, |e| e.len());
    /// assert_eq!(result, Validation::Success(10));
    /// ```
    #[inline]
    pub fn bimap_success_first<U, E2, F, G>(self, f: F, g: G) -> Validation<U, E2>
    where
        F: FnOnce(T) -> U,
        G: FnOnce(E) -> E2,
    {
        self.bimap(g, f)
    }

    /// Apply bimap to references.
    ///
    /// Like `bimap` but works on references without consuming self.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(5);
    /// let result = v.bimap_ref(|e| e.len(), |x| *x * 2);
    /// assert_eq!(result, Validation::Success(10));
    /// // v is still usable
    /// ```
    #[inline]
    pub fn bimap_ref<U, E2, F, G>(&self, f: F, g: G) -> Validation<U, E2>
    where
        F: FnOnce(&E) -> E2,
        G: FnOnce(&T) -> U,
    {
        match self {
            Validation::Success(value) => Validation::Success(g(value)),
            Validation::Failure(error) => Validation::Failure(f(error)),
        }
    }

    // ========== fold ==========

    /// Fold this Validation into a single value.
    ///
    /// Collapses the Validation by applying the appropriate function based
    /// on the variant. This is the catamorphism for Validation.
    ///
    /// # Arguments
    ///
    /// * `on_failure` - Function to handle Failure case
    /// * `on_success` - Function to handle Success case
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let success = Validation::<_, String>::success(5);
    /// let result = success.fold(
    ///     |e| format!("Error: {}", e),
    ///     |x| format!("Value: {}", x)
    /// );
    /// assert_eq!(result, "Value: 5");
    ///
    /// let failure = Validation::<i32, _>::failure("oops".to_string());
    /// let result = failure.fold(
    ///     |e| format!("Error: {}", e),
    ///     |x| format!("Value: {}", x)
    /// );
    /// assert_eq!(result, "Error: oops");
    /// ```
    #[inline]
    pub fn fold<R, F, G>(self, on_failure: F, on_success: G) -> R
    where
        F: FnOnce(E) -> R,
        G: FnOnce(T) -> R,
    {
        match self {
            Validation::Success(value) => on_success(value),
            Validation::Failure(error) => on_failure(error),
        }
    }

    /// Fold with success handler first.
    ///
    /// Alternative argument order for those who prefer success-first thinking.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(5);
    /// let msg = v.fold_success_first(
    ///     |x| format!("Got: {}", x),
    ///     |e| format!("Err: {}", e)
    /// );
    /// assert_eq!(msg, "Got: 5");
    /// ```
    #[inline]
    pub fn fold_success_first<R, F, G>(self, on_success: F, on_failure: G) -> R
    where
        F: FnOnce(T) -> R,
        G: FnOnce(E) -> R,
    {
        self.fold(on_failure, on_success)
    }

    /// Fold references without consuming self.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, String>::success(5);
    /// let result = v.fold_ref(|e| e.len(), |x| *x * 2);
    /// assert_eq!(result, 10);
    /// // v is still usable
    /// ```
    #[inline]
    pub fn fold_ref<R, F, G>(&self, on_failure: F, on_success: G) -> R
    where
        F: FnOnce(&E) -> R,
        G: FnOnce(&T) -> R,
    {
        match self {
            Validation::Success(value) => on_success(value),
            Validation::Failure(error) => on_failure(error),
        }
    }

    /// Fold with an initial accumulator value.
    ///
    /// This is a generalized fold that takes a seed value and combines
    /// it with either the error or success value.
    ///
    /// Named `fold_with_seed` rather than `bifold` to avoid confusion with
    /// category-theoretic bifold, which folds over containers of bifunctors.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let success = Validation::<i32, _>::success(5);
    /// let result = success.fold_with_seed(
    ///     10,
    ///     |acc, e: &str| acc + e.len() as i32,
    ///     |acc, x| acc + x
    /// );
    /// assert_eq!(result, 15); // 10 + 5
    /// ```
    #[inline]
    pub fn fold_with_seed<R, F, G>(self, seed: R, f: F, g: G) -> R
    where
        F: FnOnce(R, E) -> R,
        G: FnOnce(R, T) -> R,
    {
        match self {
            Validation::Success(value) => g(seed, value),
            Validation::Failure(error) => f(seed, error),
        }
    }

    // ========== unwrap variants ==========

    /// Unwrap the success value or compute it from the error.
    ///
    /// If Success, returns the value. If Failure, applies the function
    /// to the error to produce a value.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let success = Validation::<_, String>::success(5);
    /// assert_eq!(success.unwrap_or_else(|e| e.len() as i32), 5);
    ///
    /// let failure = Validation::<i32, _>::failure("error".to_string());
    /// assert_eq!(failure.unwrap_or_else(|e| e.len() as i32), 5);
    /// ```
    #[inline]
    pub fn unwrap_or_else<F>(self, f: F) -> T
    where
        F: FnOnce(E) -> T,
    {
        match self {
            Validation::Success(value) => value,
            Validation::Failure(error) => f(error),
        }
    }

    /// Unwrap the success value or return a default.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let success = Validation::<_, String>::success(5);
    /// assert_eq!(success.unwrap_or(0), 5);
    ///
    /// let failure = Validation::<i32, _>::failure("error".to_string());
    /// assert_eq!(failure.unwrap_or(0), 0);
    /// ```
    #[inline]
    pub fn unwrap_or(self, default: T) -> T {
        match self {
            Validation::Success(value) => value,
            Validation::Failure(_) => default,
        }
    }

    /// Unwrap the success value or compute a default.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let failure = Validation::<i32, _>::failure("error".to_string());
    /// assert_eq!(failure.unwrap_or_default(), 0);
    /// ```
    #[inline]
    pub fn unwrap_or_default(self) -> T
    where
        T: Default,
    {
        match self {
            Validation::Success(value) => value,
            Validation::Failure(_) => T::default(),
        }
    }

    /// Unwrap the error value, panicking if Success.
    ///
    /// # Panics
    ///
    /// Panics if this is a Success variant.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let failure = Validation::<i32, _>::failure("error");
    /// assert_eq!(failure.unwrap_err(), "error");
    /// ```
    #[inline]
    pub fn unwrap_err(self) -> E
    where
        T: std::fmt::Debug,
    {
        match self {
            Validation::Success(value) => panic!(
                "called `Validation::unwrap_err()` on a `Success` value: {:?}",
                value
            ),
            Validation::Failure(error) => error,
        }
    }

    /// Unwrap the error value with a custom panic message.
    #[inline]
    pub fn expect_err(self, msg: &str) -> E
    where
        T: std::fmt::Debug,
    {
        match self {
            Validation::Success(value) => panic!("{}: {:?}", msg, value),
            Validation::Failure(error) => error,
        }
    }
}

// ========== merge for same types ==========

impl<T> Validation<T, T> {
    /// Merge the Validation into its inner value.
    ///
    /// When the success and error types are the same, this extracts
    /// the inner value regardless of which variant it is.
    ///
    /// # Example
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let success: Validation<i32, i32> = Validation::success(5);
    /// assert_eq!(success.merge(), 5);
    ///
    /// let failure: Validation<i32, i32> = Validation::failure(3);
    /// assert_eq!(failure.merge(), 3);
    /// ```
    #[inline]
    pub fn merge(self) -> T {
        match self {
            Validation::Success(value) => value,
            Validation::Failure(error) => error,
        }
    }
}

impl<T, E> Validation<T, NonEmptyVec<E>> {
    /// Create a failure with a single error.
    ///
    /// This is a convenience method for creating validations that fail with a single error,
    /// without needing to construct a NonEmptyVec explicitly.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::{Validation, NonEmptyVec};
    ///
    /// let v = Validation::<i32, NonEmptyVec<&str>>::fail("error");
    /// assert!(v.is_failure());
    /// ```
    pub fn fail(error: E) -> Self {
        Validation::failure(NonEmptyVec::singleton(error))
    }
}

impl<T, E: Semigroup> Validation<T, E> {
    /// Combine two validations, accumulating errors using the Semigroup instance
    ///
    /// If both validations are successful, returns a success with a tuple of both values.
    /// If either or both fail, accumulates the errors using `Semigroup::combine`.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// // Both successful
    /// let v1 = Validation::<_, Vec<&str>>::success(1);
    /// let v2 = Validation::<_, Vec<&str>>::success(2);
    /// assert_eq!(v1.and(v2), Validation::Success((1, 2)));
    ///
    /// // Both failed - errors accumulate
    /// let v1 = Validation::<i32, _>::failure(vec!["error1"]);
    /// let v2 = Validation::<i32, _>::failure(vec!["error2"]);
    /// assert_eq!(v1.and(v2), Validation::Failure(vec!["error1", "error2"]));
    /// ```
    pub fn and<U>(self, other: Validation<U, E>) -> Validation<(T, U), E> {
        match (self, other) {
            (Validation::Success(a), Validation::Success(b)) => Validation::Success((a, b)),
            (Validation::Failure(e1), Validation::Failure(e2)) => {
                Validation::Failure(e1.combine(e2))
            }
            (Validation::Failure(e), _) => Validation::Failure(e),
            (_, Validation::Failure(e)) => Validation::Failure(e),
        }
    }

    /// Chain a dependent validation
    ///
    /// Similar to `Result::and_then`, but for validations. The function is only called
    /// if the current validation is successful.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let v = Validation::<_, Vec<&str>>::success(5);
    /// let result = v.and_then(|x| {
    ///     if x > 0 {
    ///         Validation::success(x * 2)
    ///     } else {
    ///         Validation::failure(vec!["must be positive"])
    ///     }
    /// });
    /// assert_eq!(result, Validation::Success(10));
    /// ```
    #[inline]
    pub fn and_then<U, F>(self, f: F) -> Validation<U, E>
    where
        F: FnOnce(T) -> Validation<U, E>,
    {
        match self {
            Validation::Success(value) => f(value),
            Validation::Failure(error) => Validation::Failure(error),
        }
    }

    /// Combine all validations in a Vec
    ///
    /// Returns a success with a Vec of all success values if all validations succeed.
    /// Otherwise, accumulates all errors using `Semigroup::combine`.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::Validation;
    ///
    /// let validations = vec![
    ///     Validation::<_, Vec<&str>>::success(1),
    ///     Validation::<_, Vec<&str>>::success(2),
    ///     Validation::<_, Vec<&str>>::success(3),
    /// ];
    /// let result = Validation::all_vec(validations);
    /// assert_eq!(result, Validation::Success(vec![1, 2, 3]));
    ///
    /// let validations = vec![
    ///     Validation::<i32, _>::failure(vec!["error1"]),
    ///     Validation::<i32, _>::failure(vec!["error2"]),
    /// ];
    /// let result = Validation::all_vec(validations);
    /// assert_eq!(result, Validation::Failure(vec!["error1", "error2"]));
    /// ```
    pub fn all_vec(validations: Vec<Validation<T, E>>) -> Validation<Vec<T>, E> {
        let mut successes = Vec::new();
        let mut failures = Vec::new();

        for validation in validations {
            match validation {
                Validation::Success(value) => successes.push(value),
                Validation::Failure(error) => failures.push(error),
            }
        }

        if failures.is_empty() {
            Validation::Success(successes)
        } else {
            Validation::Failure(
                failures
                    .into_iter()
                    .reduce(|acc, e| acc.combine(e))
                    .unwrap(),
            )
        }
    }
}

// Free function for combining validations in a tuple
impl<T, E> Validation<T, E> {
    /// Combine all validations in a tuple
    ///
    /// This is a convenience method that delegates to the `ValidateAll` trait.
    /// It works with tuples of validations up to size 12.
    ///
    /// # Examples
    ///
    /// ```
    /// use stillwater::{Validation, validation::ValidateAll};
    ///
    /// let result = (
    ///     Validation::<_, Vec<&str>>::success(1),
    ///     Validation::<_, Vec<&str>>::success(2),
    ///     Validation::<_, Vec<&str>>::success(3),
    /// ).validate_all();
    /// assert_eq!(result, Validation::Success((1, 2, 3)));
    /// ```
    pub fn all<V, E2>(validations: V) -> Validation<V::Output, E2>
    where
        E2: Semigroup,
        V: ValidateAll<E2>,
    {
        validations.validate_all()
    }
}

/// Trait for combining multiple validations in a tuple
///
/// This trait is implemented for tuples of validations, allowing the `Validation::all`
/// method to work with heterogeneous validation types.
pub trait ValidateAll<E: Semigroup> {
    /// The output type when all validations succeed
    type Output;

    /// Combine all validations, accumulating errors
    fn validate_all(self) -> Validation<Self::Output, E>;
}

// Macro to implement ValidateAll for tuples of different sizes
macro_rules! impl_validate_all {
    // Base case: single element
    ($T1:ident) => {
        impl<E: Semigroup, $T1> ValidateAll<E> for (Validation<$T1, E>,) {
            type Output = ($T1,);

            fn validate_all(self) -> Validation<Self::Output, E> {
                self.0.map(|v| (v,))
            }
        }
    };

    // Two elements
    ($T1:ident, $T2:ident) => {
        impl<E: Semigroup, $T1, $T2> ValidateAll<E> for (Validation<$T1, E>, Validation<$T2, E>) {
            type Output = ($T1, $T2);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2) = self;
                $T1.and($T2)
            }
        }
    };

    // Three elements
    ($T1:ident, $T2:ident, $T3:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3> ValidateAll<E>
            for (Validation<$T1, E>, Validation<$T2, E>, Validation<$T3, E>)
        {
            type Output = ($T1, $T2, $T3);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3) = self;
                $T1.and($T2)
                    .map(|(a, b)| (a, b))
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
            }
        }
    };

    // Four elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
            }
        }
    };

    // Five elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
            }
        }
    };

    // Six elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5, $T6);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
            }
        }
    };

    // Seven elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident, $T7:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6, $T7> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
                Validation<$T7, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5, $T6, $T7);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6, $T7) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
                    .and($T7)
                    .map(|((a, b, c, d, e, f), g)| (a, b, c, d, e, f, g))
            }
        }
    };

    // Eight elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident, $T7:ident, $T8:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
                Validation<$T7, E>,
                Validation<$T8, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
                    .and($T7)
                    .map(|((a, b, c, d, e, f), g)| (a, b, c, d, e, f, g))
                    .and($T8)
                    .map(|((a, b, c, d, e, f, g), h)| (a, b, c, d, e, f, g, h))
            }
        }
    };

    // Nine elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident, $T7:ident, $T8:ident, $T9:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
                Validation<$T7, E>,
                Validation<$T8, E>,
                Validation<$T9, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
                    .and($T7)
                    .map(|((a, b, c, d, e, f), g)| (a, b, c, d, e, f, g))
                    .and($T8)
                    .map(|((a, b, c, d, e, f, g), h)| (a, b, c, d, e, f, g, h))
                    .and($T9)
                    .map(|((a, b, c, d, e, f, g, h), i)| (a, b, c, d, e, f, g, h, i))
            }
        }
    };

    // Ten elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident, $T7:ident, $T8:ident, $T9:ident, $T10:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
                Validation<$T7, E>,
                Validation<$T8, E>,
                Validation<$T9, E>,
                Validation<$T10, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
                    .and($T7)
                    .map(|((a, b, c, d, e, f), g)| (a, b, c, d, e, f, g))
                    .and($T8)
                    .map(|((a, b, c, d, e, f, g), h)| (a, b, c, d, e, f, g, h))
                    .and($T9)
                    .map(|((a, b, c, d, e, f, g, h), i)| (a, b, c, d, e, f, g, h, i))
                    .and($T10)
                    .map(|((a, b, c, d, e, f, g, h, i), j)| (a, b, c, d, e, f, g, h, i, j))
            }
        }
    };

    // Eleven elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident, $T7:ident, $T8:ident, $T9:ident, $T10:ident, $T11:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11> ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
                Validation<$T7, E>,
                Validation<$T8, E>,
                Validation<$T9, E>,
                Validation<$T10, E>,
                Validation<$T11, E>,
            )
        {
            type Output = ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11);

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
                    .and($T7)
                    .map(|((a, b, c, d, e, f), g)| (a, b, c, d, e, f, g))
                    .and($T8)
                    .map(|((a, b, c, d, e, f, g), h)| (a, b, c, d, e, f, g, h))
                    .and($T9)
                    .map(|((a, b, c, d, e, f, g, h), i)| (a, b, c, d, e, f, g, h, i))
                    .and($T10)
                    .map(|((a, b, c, d, e, f, g, h, i), j)| (a, b, c, d, e, f, g, h, i, j))
                    .and($T11)
                    .map(|((a, b, c, d, e, f, g, h, i, j), k)| (a, b, c, d, e, f, g, h, i, j, k))
            }
        }
    };

    // Twelve elements
    ($T1:ident, $T2:ident, $T3:ident, $T4:ident, $T5:ident, $T6:ident, $T7:ident, $T8:ident, $T9:ident, $T10:ident, $T11:ident, $T12:ident) => {
        impl<E: Semigroup, $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11, $T12>
            ValidateAll<E>
            for (
                Validation<$T1, E>,
                Validation<$T2, E>,
                Validation<$T3, E>,
                Validation<$T4, E>,
                Validation<$T5, E>,
                Validation<$T6, E>,
                Validation<$T7, E>,
                Validation<$T8, E>,
                Validation<$T9, E>,
                Validation<$T10, E>,
                Validation<$T11, E>,
                Validation<$T12, E>,
            )
        {
            type Output = (
                $T1,
                $T2,
                $T3,
                $T4,
                $T5,
                $T6,
                $T7,
                $T8,
                $T9,
                $T10,
                $T11,
                $T12,
            );

            #[allow(non_snake_case)]
            fn validate_all(self) -> Validation<Self::Output, E> {
                let ($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11, $T12) = self;
                $T1.and($T2)
                    .and($T3)
                    .map(|((a, b), c)| (a, b, c))
                    .and($T4)
                    .map(|((a, b, c), d)| (a, b, c, d))
                    .and($T5)
                    .map(|((a, b, c, d), e)| (a, b, c, d, e))
                    .and($T6)
                    .map(|((a, b, c, d, e), f)| (a, b, c, d, e, f))
                    .and($T7)
                    .map(|((a, b, c, d, e, f), g)| (a, b, c, d, e, f, g))
                    .and($T8)
                    .map(|((a, b, c, d, e, f, g), h)| (a, b, c, d, e, f, g, h))
                    .and($T9)
                    .map(|((a, b, c, d, e, f, g, h), i)| (a, b, c, d, e, f, g, h, i))
                    .and($T10)
                    .map(|((a, b, c, d, e, f, g, h, i), j)| (a, b, c, d, e, f, g, h, i, j))
                    .and($T11)
                    .map(|((a, b, c, d, e, f, g, h, i, j), k)| (a, b, c, d, e, f, g, h, i, j, k))
                    .and($T12)
                    .map(|((a, b, c, d, e, f, g, h, i, j, k), l)| {
                        (a, b, c, d, e, f, g, h, i, j, k, l)
                    })
            }
        }
    };
}

// Generate implementations for tuples of size 1 through 12
impl_validate_all!(T1);
impl_validate_all!(T1, T2);
impl_validate_all!(T1, T2, T3);
impl_validate_all!(T1, T2, T3, T4);
impl_validate_all!(T1, T2, T3, T4, T5);
impl_validate_all!(T1, T2, T3, T4, T5, T6);
impl_validate_all!(T1, T2, T3, T4, T5, T6, T7);
impl_validate_all!(T1, T2, T3, T4, T5, T6, T7, T8);
impl_validate_all!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
impl_validate_all!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
impl_validate_all!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
impl_validate_all!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);

// Try trait support for ? operator (requires nightly + try_trait feature)
//
// This implementation enables using the `?` operator with Validation types,
// providing ergonomic error propagation similar to Result.
//
// IMPORTANT: Using `?` with Validation provides fail-fast behavior, not error
// accumulation. For error accumulation, use `Validation::all()` instead.
#[cfg(feature = "try_trait")]
mod try_impl {
    use super::*;
    use std::convert::Infallible;
    use std::ops::{ControlFlow, FromResidual, Try};

    /// Try trait implementation for Validation
    ///
    /// Enables using the `?` operator for ergonomic error propagation.
    /// Note: This provides fail-fast behavior, stopping at the first error.
    impl<T, E> Try for Validation<T, E> {
        type Output = T;
        type Residual = Validation<Infallible, E>;

        fn from_output(output: Self::Output) -> Self {
            Validation::Success(output)
        }

        fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
            match self {
                Validation::Success(value) => ControlFlow::Continue(value),
                Validation::Failure(error) => ControlFlow::Break(Validation::Failure(error)),
            }
        }
    }

    /// Enables ? operator to propagate Validation failures
    ///
    /// Converts a Validation residual (error) into a Validation of the target type.
    impl<T, E> FromResidual<Validation<Infallible, E>> for Validation<T, E> {
        fn from_residual(residual: Validation<Infallible, E>) -> Self {
            match residual {
                Validation::Failure(error) => Validation::Failure(error),
                Validation::Success(_) => unreachable!(),
            }
        }
    }

    /// Enables ? operator to convert Result errors to Validation
    ///
    /// This allows mixing Result and Validation in the same function with ?.
    /// For example: `let value = some_result?;` will convert Err to Validation::Failure.
    impl<T, E> FromResidual<Result<Infallible, E>> for Validation<T, E> {
        fn from_residual(residual: Result<Infallible, E>) -> Self {
            match residual {
                Err(error) => Validation::Failure(error),
                Ok(_) => unreachable!(),
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // Basic constructor tests
    #[test]
    fn test_success() {
        let v = Validation::<_, Vec<&str>>::success(42);
        assert!(v.is_success());
        assert!(!v.is_failure());
    }

    #[test]
    fn test_failure() {
        let v = Validation::<i32, _>::failure(vec!["error"]);
        assert!(v.is_failure());
        assert!(!v.is_success());
    }

    // Conversion tests
    #[test]
    fn test_from_result_ok() {
        let v = Validation::from_result(Ok::<_, Vec<&str>>(42));
        assert_eq!(v, Validation::Success(42));
    }

    #[test]
    fn test_from_result_err() {
        let v = Validation::from_result(Err::<i32, _>(vec!["error"]));
        assert_eq!(v, Validation::Failure(vec!["error"]));
    }

    #[test]
    fn test_into_result_success() {
        let v = Validation::<_, Vec<&str>>::success(42);
        assert_eq!(v.into_result(), Ok(42));
    }

    #[test]
    fn test_into_result_failure() {
        let v = Validation::<i32, _>::failure(vec!["error"]);
        assert_eq!(v.into_result(), Err(vec!["error"]));
    }

    // map tests
    #[test]
    fn test_map_on_success() {
        let v = Validation::<_, Vec<&str>>::success(5);
        let result = v.map(|x| x * 2);
        assert_eq!(result, Validation::Success(10));
    }

    #[test]
    fn test_map_on_failure() {
        let v = Validation::<i32, _>::failure(vec!["error"]);
        let result = v.map(|x| x * 2);
        assert_eq!(result, Validation::Failure(vec!["error"]));
    }

    #[test]
    fn test_map_err_on_success() {
        let v = Validation::<_, Vec<&str>>::success(42);
        let result = v.map_err(|errors| errors.len());
        assert_eq!(result, Validation::Success(42));
    }

    #[test]
    fn test_map_err_on_failure() {
        let v = Validation::<i32, _>::failure(vec!["error1", "error2"]);
        let result = v.map_err(|errors| errors.len());
        assert_eq!(result, Validation::Failure(2));
    }

    // and tests
    #[test]
    fn test_and_both_success() {
        let v1 = Validation::<_, Vec<&str>>::success(1);
        let v2 = Validation::<_, Vec<&str>>::success(2);
        assert_eq!(v1.and(v2), Validation::Success((1, 2)));
    }

    #[test]
    fn test_and_both_failure() {
        let v1 = Validation::<i32, _>::failure(vec!["error1"]);
        let v2 = Validation::<i32, _>::failure(vec!["error2"]);
        assert_eq!(v1.and(v2), Validation::Failure(vec!["error1", "error2"]));
    }

    #[test]
    fn test_and_first_failure() {
        let v1 = Validation::<i32, _>::failure(vec!["error"]);
        let v2 = Validation::<_, Vec<&str>>::success(2);
        assert_eq!(v1.and(v2), Validation::Failure(vec!["error"]));
    }

    #[test]
    fn test_and_second_failure() {
        let v1 = Validation::<_, Vec<&str>>::success(1);
        let v2 = Validation::<i32, _>::failure(vec!["error"]);
        assert_eq!(v1.and(v2), Validation::Failure(vec!["error"]));
    }

    // and_then tests
    #[test]
    fn test_and_then_success() {
        let v = Validation::<_, Vec<&str>>::success(5);
        let result = v.and_then(|x| Validation::success(x * 2));
        assert_eq!(result, Validation::Success(10));
    }

    #[test]
    fn test_and_then_failure() {
        let v = Validation::<i32, _>::failure(vec!["error"]);
        let result = v.and_then(|x| Validation::success(x * 2));
        assert_eq!(result, Validation::Failure(vec!["error"]));
    }

    #[test]
    fn test_and_then_chain_failure() {
        let v = Validation::<_, Vec<&str>>::success(5);
        let result: Validation<i32, Vec<&str>> =
            v.and_then(|_| Validation::failure(vec!["new error"]));
        assert_eq!(result, Validation::Failure(vec!["new error"]));
    }

    // all tests with tuples
    #[test]
    fn test_all_single_success() {
        use crate::validation::ValidateAll;
        let result = (Validation::<_, Vec<&str>>::success(1),).validate_all();
        assert_eq!(result, Validation::Success((1,)));
    }

    #[test]
    fn test_all_two_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
        )
            .validate_all();
        assert_eq!(result, Validation::Success((1, 2)));
    }

    #[test]
    fn test_all_three_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
        )
            .validate_all();
        assert_eq!(result, Validation::Success((1, 2, 3)));
    }

    #[test]
    fn test_all_with_failures() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<i32, _>::failure(vec!["error1"]),
            Validation::<i32, _>::failure(vec!["error2"]),
            Validation::<i32, _>::failure(vec!["error3"]),
        )
            .validate_all();
        assert_eq!(
            result,
            Validation::Failure(vec!["error1", "error2", "error3"])
        );
    }

    #[test]
    fn test_all_mixed() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<i32, _>::failure(vec!["error1"]),
            Validation::<i32, _>::failure(vec!["error2"]),
        )
            .validate_all();
        assert_eq!(result, Validation::Failure(vec!["error1", "error2"]));
    }

    // all_vec tests
    #[test]
    fn test_all_vec_empty() {
        let validations: Vec<Validation<i32, Vec<&str>>> = vec![];
        let result = Validation::all_vec(validations);
        assert_eq!(result, Validation::Success(vec![]));
    }

    #[test]
    fn test_all_vec_all_success() {
        let validations = vec![
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
        ];
        let result = Validation::all_vec(validations);
        assert_eq!(result, Validation::Success(vec![1, 2, 3]));
    }

    #[test]
    fn test_all_vec_all_failures() {
        let validations = vec![
            Validation::<i32, _>::failure(vec!["error1"]),
            Validation::<i32, _>::failure(vec!["error2"]),
            Validation::<i32, _>::failure(vec!["error3"]),
        ];
        let result = Validation::all_vec(validations);
        assert_eq!(
            result,
            Validation::Failure(vec!["error1", "error2", "error3"])
        );
    }

    #[test]
    fn test_all_vec_mixed() {
        let validations = vec![
            Validation::<_, Vec<&str>>::success(1),
            Validation::failure(vec!["error1"]),
            Validation::<_, Vec<&str>>::success(2),
            Validation::failure(vec!["error2"]),
        ];
        let result = Validation::all_vec(validations);
        assert_eq!(result, Validation::Failure(vec!["error1", "error2"]));
    }

    // NonEmptyVec integration tests
    #[test]
    fn test_fail_with_nonempty() {
        use crate::nonempty::NonEmptyVec;

        let v = Validation::<i32, NonEmptyVec<&str>>::fail("error");
        assert!(v.is_failure());

        match v {
            Validation::Failure(errors) => {
                assert_eq!(errors.len(), 1);
                assert_eq!(errors.head(), &"error");
            }
            _ => panic!("Expected failure"),
        }
    }

    #[test]
    fn test_nonempty_error_accumulation() {
        use crate::nonempty::NonEmptyVec;

        let v1 = Validation::<i32, NonEmptyVec<&str>>::fail("error1");
        let v2 = Validation::<i32, NonEmptyVec<&str>>::fail("error2");
        let result = v1.and(v2);

        match result {
            Validation::Failure(errors) => {
                assert_eq!(errors.len(), 2);
                assert_eq!(errors.into_vec(), vec!["error1", "error2"]);
            }
            _ => panic!("Expected failure"),
        }
    }

    // Integration test: form validation
    #[test]
    fn test_form_validation() {
        #[derive(Debug, PartialEq)]
        enum ValidationError {
            InvalidEmail,
            PasswordTooShort,
            AgeTooYoung,
        }

        fn validate_email(email: &str) -> Validation<String, Vec<ValidationError>> {
            if email.contains('@') {
                Validation::success(email.to_string())
            } else {
                Validation::failure(vec![ValidationError::InvalidEmail])
            }
        }

        fn validate_password(pwd: &str) -> Validation<String, Vec<ValidationError>> {
            if pwd.len() >= 8 {
                Validation::success(pwd.to_string())
            } else {
                Validation::failure(vec![ValidationError::PasswordTooShort])
            }
        }

        fn validate_age(age: u8) -> Validation<u8, Vec<ValidationError>> {
            if age >= 18 {
                Validation::success(age)
            } else {
                Validation::failure(vec![ValidationError::AgeTooYoung])
            }
        }

        // All valid
        use crate::validation::ValidateAll;
        let result = (
            validate_email("test@example.com"),
            validate_password("secure123"),
            validate_age(25),
        )
            .validate_all();
        assert!(result.is_success());

        // All invalid - should accumulate all 3 errors
        let result = (
            validate_email("invalid"),
            validate_password("short"),
            validate_age(15),
        )
            .validate_all();
        assert_eq!(
            result,
            Validation::Failure(vec![
                ValidationError::InvalidEmail,
                ValidationError::PasswordTooShort,
                ValidationError::AgeTooYoung,
            ])
        );

        // Partial failures
        let result = (
            validate_email("test@example.com"),
            validate_password("short"),
            validate_age(15),
        )
            .validate_all();
        assert_eq!(
            result,
            Validation::Failure(vec![
                ValidationError::PasswordTooShort,
                ValidationError::AgeTooYoung,
            ])
        );
    }

    // === 4-tuple tests ===

    #[test]
    fn test_validate_all_4tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success("two"),
            Validation::<_, Vec<&str>>::success(3.0),
            Validation::<_, Vec<&str>>::success(true),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, "two", 3.0, true)));
    }

    #[test]
    fn test_validate_all_4tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
        )
            .validate_all();

        assert_eq!(result, Validation::Failure(vec!["e1", "e2", "e3", "e4"]));
    }

    #[test]
    fn test_validate_all_4tuple_mixed() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32), Vec<&str>> = (
            Validation::Success(1),
            Validation::Failure(vec!["e2"]),
            Validation::Success(3),
            Validation::Failure(vec!["e4"]),
        )
            .validate_all();

        assert_eq!(result, Validation::Failure(vec!["e2", "e4"]));
    }

    // === 5-tuple tests ===

    #[test]
    fn test_validate_all_5tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, 2, 3, 4, 5)));
    }

    #[test]
    fn test_validate_all_5tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec!["e1", "e2", "e3", "e4", "e5"])
        );
    }

    // === 6-tuple tests ===

    #[test]
    fn test_validate_all_6tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, 2, 3, 4, 5, 6)));
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_6tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
            Validation::Failure(vec!["e6"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec!["e1", "e2", "e3", "e4", "e5", "e6"])
        );
    }

    // === 7-tuple tests ===

    #[test]
    fn test_validate_all_7tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
            Validation::<_, Vec<&str>>::success(7),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, 2, 3, 4, 5, 6, 7)));
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_7tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
            Validation::Failure(vec!["e6"]),
            Validation::Failure(vec!["e7"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec!["e1", "e2", "e3", "e4", "e5", "e6", "e7"])
        );
    }

    // === 8-tuple tests ===

    #[test]
    fn test_validate_all_8tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
            Validation::<_, Vec<&str>>::success(7),
            Validation::<_, Vec<&str>>::success(8),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, 2, 3, 4, 5, 6, 7, 8)));
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_8tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
            Validation::Failure(vec!["e6"]),
            Validation::Failure(vec!["e7"]),
            Validation::Failure(vec!["e8"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec!["e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8"])
        );
    }

    // === 9-tuple tests ===

    #[test]
    fn test_validate_all_9tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
            Validation::<_, Vec<&str>>::success(7),
            Validation::<_, Vec<&str>>::success(8),
            Validation::<_, Vec<&str>>::success(9),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, 2, 3, 4, 5, 6, 7, 8, 9)));
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_9tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32, i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
            Validation::Failure(vec!["e6"]),
            Validation::Failure(vec!["e7"]),
            Validation::Failure(vec!["e8"]),
            Validation::Failure(vec!["e9"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec!["e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9"])
        );
    }

    // === 10-tuple tests ===

    #[test]
    fn test_validate_all_10tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
            Validation::<_, Vec<&str>>::success(7),
            Validation::<_, Vec<&str>>::success(8),
            Validation::<_, Vec<&str>>::success(9),
            Validation::<_, Vec<&str>>::success(10),
        )
            .validate_all();

        assert_eq!(result, Validation::Success((1, 2, 3, 4, 5, 6, 7, 8, 9, 10)));
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_10tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), Vec<&str>> = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
            Validation::Failure(vec!["e6"]),
            Validation::Failure(vec!["e7"]),
            Validation::Failure(vec!["e8"]),
            Validation::Failure(vec!["e9"]),
            Validation::Failure(vec!["e10"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec![
                "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "e10"
            ])
        );
    }

    // === 11-tuple tests ===

    #[test]
    fn test_validate_all_11tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
            Validation::<_, Vec<&str>>::success(7),
            Validation::<_, Vec<&str>>::success(8),
            Validation::<_, Vec<&str>>::success(9),
            Validation::<_, Vec<&str>>::success(10),
            Validation::<_, Vec<&str>>::success(11),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Success((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
        );
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_11tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), Vec<&str>> =
            (
                Validation::Failure(vec!["e1"]),
                Validation::Failure(vec!["e2"]),
                Validation::Failure(vec!["e3"]),
                Validation::Failure(vec!["e4"]),
                Validation::Failure(vec!["e5"]),
                Validation::Failure(vec!["e6"]),
                Validation::Failure(vec!["e7"]),
                Validation::Failure(vec!["e8"]),
                Validation::Failure(vec!["e9"]),
                Validation::Failure(vec!["e10"]),
                Validation::Failure(vec!["e11"]),
            )
                .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec![
                "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "e10", "e11"
            ])
        );
    }

    // === 12-tuple tests ===

    #[test]
    fn test_validate_all_12tuple_all_success() {
        use crate::validation::ValidateAll;
        let result = (
            Validation::<_, Vec<&str>>::success(1),
            Validation::<_, Vec<&str>>::success(2),
            Validation::<_, Vec<&str>>::success(3),
            Validation::<_, Vec<&str>>::success(4),
            Validation::<_, Vec<&str>>::success(5),
            Validation::<_, Vec<&str>>::success(6),
            Validation::<_, Vec<&str>>::success(7),
            Validation::<_, Vec<&str>>::success(8),
            Validation::<_, Vec<&str>>::success(9),
            Validation::<_, Vec<&str>>::success(10),
            Validation::<_, Vec<&str>>::success(11),
            Validation::<_, Vec<&str>>::success(12),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Success((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
        );
    }

    #[test]
    #[allow(clippy::type_complexity)]
    fn test_validate_all_12tuple_all_failure() {
        use crate::validation::ValidateAll;
        let result: Validation<
            (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32),
            Vec<&str>,
        > = (
            Validation::Failure(vec!["e1"]),
            Validation::Failure(vec!["e2"]),
            Validation::Failure(vec!["e3"]),
            Validation::Failure(vec!["e4"]),
            Validation::Failure(vec!["e5"]),
            Validation::Failure(vec!["e6"]),
            Validation::Failure(vec!["e7"]),
            Validation::Failure(vec!["e8"]),
            Validation::Failure(vec!["e9"]),
            Validation::Failure(vec!["e10"]),
            Validation::Failure(vec!["e11"]),
            Validation::Failure(vec!["e12"]),
        )
            .validate_all();

        assert_eq!(
            result,
            Validation::Failure(vec![
                "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "e10", "e11", "e12"
            ])
        );
    }

    // ========== bimap tests ==========

    #[test]
    fn test_bimap_on_success() {
        let v = Validation::<_, String>::success(5);
        let result = v.bimap(|e| e.len(), |x| x * 2);
        assert_eq!(result, Validation::Success(10));
    }

    #[test]
    fn test_bimap_on_failure() {
        let v = Validation::<i32, _>::failure("error".to_string());
        let result = v.bimap(|e| e.len(), |x| x * 2);
        assert_eq!(result, Validation::Failure(5));
    }

    #[test]
    fn test_bimap_type_transformation() {
        // Validation<i32, String> -> Validation<f64, usize>
        let v: Validation<i32, String> = Validation::success(5);
        let result: Validation<f64, usize> = v.bimap(|e| e.len(), |x| x as f64 * 2.0);
        assert_eq!(result, Validation::Success(10.0));
    }

    #[test]
    fn test_bimap_success_first() {
        let v = Validation::<_, String>::success(5);
        let result = v.bimap_success_first(|x| x * 2, |e| e.len());
        assert_eq!(result, Validation::Success(10));
    }

    #[test]
    fn test_bimap_ref() {
        let v = Validation::<_, String>::success(5);
        let result = v.bimap_ref(|e| e.len(), |x| *x * 2);
        assert_eq!(result, Validation::Success(10));
        // v is still usable
        assert!(v.is_success());
    }

    // ========== fold tests ==========

    #[test]
    fn test_fold_on_success() {
        let v = Validation::<_, String>::success(5);
        let result = v.fold(|e| format!("Err: {}", e), |x| format!("Val: {}", x));
        assert_eq!(result, "Val: 5");
    }

    #[test]
    fn test_fold_on_failure() {
        let v = Validation::<i32, _>::failure("oops".to_string());
        let result = v.fold(|e| format!("Err: {}", e), |x| format!("Val: {}", x));
        assert_eq!(result, "Err: oops");
    }

    #[test]
    fn test_fold_to_different_type() {
        let v = Validation::<_, String>::success(5);
        let result: i32 = v.fold(|e| e.len() as i32, |x| x * 2);
        assert_eq!(result, 10);
    }

    #[test]
    fn test_fold_success_first() {
        let v = Validation::<_, String>::success(5);
        let result = v.fold_success_first(|x| x * 2, |e| e.len() as i32);
        assert_eq!(result, 10);
    }

    #[test]
    fn test_fold_ref() {
        let v = Validation::<_, String>::success(5);
        let result = v.fold_ref(|e| e.len() as i32, |x| *x * 2);
        assert_eq!(result, 10);
        // v is still usable
        assert!(v.is_success());
    }

    #[test]
    fn test_fold_with_seed() {
        let v = Validation::<_, String>::success(5);
        let result = v.fold_with_seed(10, |acc, e| acc + e.len() as i32, |acc, x| acc + x);
        assert_eq!(result, 15);

        let v = Validation::<i32, _>::failure("err".to_string());
        let result = v.fold_with_seed(10, |acc, e| acc + e.len() as i32, |acc, x| acc + x);
        assert_eq!(result, 13);
    }

    // ========== unwrap tests ==========

    #[test]
    fn test_unwrap_or_else_success() {
        let v = Validation::<_, String>::success(5);
        assert_eq!(v.unwrap_or_else(|e| e.len() as i32), 5);
    }

    #[test]
    fn test_unwrap_or_else_failure() {
        let v = Validation::<i32, _>::failure("error".to_string());
        assert_eq!(v.unwrap_or_else(|e| e.len() as i32), 5);
    }

    #[test]
    fn test_unwrap_or() {
        let success = Validation::<_, String>::success(5);
        assert_eq!(success.unwrap_or(0), 5);

        let failure = Validation::<i32, _>::failure("err".to_string());
        assert_eq!(failure.unwrap_or(0), 0);
    }

    #[test]
    fn test_unwrap_or_default() {
        let failure = Validation::<i32, _>::failure("err".to_string());
        assert_eq!(failure.unwrap_or_default(), 0);
    }

    #[test]
    fn test_unwrap_err() {
        let failure = Validation::<i32, _>::failure("error");
        assert_eq!(failure.unwrap_err(), "error");
    }

    #[test]
    #[should_panic(expected = "called `Validation::unwrap_err()` on a `Success` value")]
    fn test_unwrap_err_panics_on_success() {
        let success = Validation::<_, String>::success(5);
        let _ = success.unwrap_err();
    }

    #[test]
    fn test_expect_err() {
        let failure = Validation::<i32, _>::failure("error");
        assert_eq!(failure.expect_err("should be error"), "error");
    }

    #[test]
    #[should_panic(expected = "expected error")]
    fn test_expect_err_panics_on_success() {
        let success = Validation::<_, String>::success(5);
        let _ = success.expect_err("expected error");
    }

    // ========== merge tests ==========

    #[test]
    fn test_merge_success() {
        let v: Validation<i32, i32> = Validation::success(5);
        assert_eq!(v.merge(), 5);
    }

    #[test]
    fn test_merge_failure() {
        let v: Validation<i32, i32> = Validation::failure(3);
        assert_eq!(v.merge(), 3);
    }

    // ========== Bifunctor law tests ==========

    #[test]
    fn test_bifunctor_identity_law() {
        let v: Validation<i32, String> = Validation::success(5);
        let result = v.clone().bimap(|e| e, |x| x);
        assert_eq!(result, v);

        let v: Validation<i32, String> = Validation::failure("err".to_string());
        let result = v.clone().bimap(|e| e, |x| x);
        assert_eq!(result, v);
    }

    #[test]
    fn test_bifunctor_composition_law() {
        let f1 = |s: String| s.len();
        let f2 = |n: usize| n * 2;
        let g1 = |x: i32| x + 1;
        let g2 = |x: i32| x * 3;

        let v: Validation<i32, String> = Validation::success(5);

        // Two separate bimaps
        let left = v.clone().bimap(f1, g1).bimap(f2, g2);

        // Composed functions
        let right = v.bimap(|e| f2(f1(e)), |x| g2(g1(x)));

        assert_eq!(left, right);
    }

    // ========== integration tests ==========

    #[test]
    fn test_bimap_with_and_then() {
        let v = Validation::<_, Vec<String>>::success(5)
            .and_then(|x| {
                if x > 0 {
                    Validation::success(x * 2)
                } else {
                    Validation::failure(vec!["non-positive".to_string()])
                }
            })
            .bimap(|errs| errs.len(), |x| x + 1);

        assert_eq!(v, Validation::Success(11));
    }

    #[test]
    fn test_fold_as_final_operation() {
        let result = Validation::<_, Vec<String>>::success(5)
            .map(|x| x * 2)
            .fold(
                |errs| format!("{} errors", errs.len()),
                |x| format!("result: {}", x),
            );

        assert_eq!(result, "result: 10");
    }
}