Struct Fusion 

pub struct Fusion<A, E, T>(/* private fields */);

A type that allows chaining multiple validations together while combining their results.

Fusion is particularly useful when you want to accumulate values from multiple successful validations into a single composite value.

Implementations

impl<A, E, T> Fusion<A, E, T>

pub fn fuse<A1>(self, other: Valid<A1, E, T>) -> Fusion<A::Out, E, T>

where A: Append<A1>,

Combines this fusion with another validation, using the Append trait to combine their successful values.

Examples

use tailcall_valid::{Valid, Validator};
let v1: Valid<Vec<i32>, (), ()> = Valid::succeed(vec![1, 2]);
let v2: Valid<Vec<i32>, (), ()> = Valid::succeed(vec![3, 4]);
let fusion = v1.fuse(v2);
let result = fusion.to_result().unwrap();
assert_eq!(result, (vec![1, 2], vec![3, 4]));

Trait Implementations

impl<A, E, T> From<Fusion<A, E, T>> for Valid<A, E, T>

fn from(value: Fusion<A, E, T>) -> Self

Converts a Fusion back into a Valid.

This is typically used at the end of a chain of fuse operations to convert the final result back into a Valid.

Examples

use tailcall_valid::{Valid, Validator};
let v1: Valid<Vec<i32>, (), ()> = Valid::succeed(vec![1]);
let v2: Valid<Vec<i32>, (), ()> = Valid::succeed(vec![2]);
let fusion = v1.fuse(v2);
let result: Valid<(Vec<i32>, Vec<i32>), (), ()> = Valid::from(fusion);
assert!(result.is_succeed());

impl<A, E, T> Validator<A, E, T> for Fusion<A, E, T>

fn to_result(self) -> Result<A, Vec<Cause<E, T>>>

Converts the validation into a Result.

fn is_succeed(&self) -> bool

Returns true if the validation is successful.

fn is_fail(&self) -> bool

Returns true if the validation contains errors.

fn map<A1>(self, f: impl FnOnce(A) -> A1) -> Valid<A1, E, T>

Maps a function over the successful value, transforming it to a new type.

fn foreach(self, f: impl FnMut(A)) -> Valid<A, E, T>

where A: Clone,

Executes a side effect function if the validation is successful. The original value is preserved.

fn and<A1>(self, other: Valid<A1, E, T>) -> Valid<A1, E, T>

Combines two validations, keeping the result of the second one if both succeed. If either validation fails, all errors are collected.

fn zip<A1>(self, other: Valid<A1, E, T>) -> Valid<(A, A1), E, T>

Combines two validations into a tuple of their results. If either validation fails, all errors are collected.

fn fuse<A1>(self, other: Valid<A1, E, T>) -> Fusion<(A, A1), E, T>

Starts a fusion chain of validations. This allows combining multiple validation results using the Append trait.

fn trace(self, trace: impl Into<T> + Clone) -> Valid<A, E, T>

Adds trace context to any errors in the validation. Successful validations are unaffected.

fn fold<A1>( self, ok: impl FnOnce(A) -> Valid<A1, E, T>, err: impl FnOnce() -> Valid<A1, E, T>, ) -> Valid<A1, E, T>

Handles both success and failure cases of a validation.

fn and_then<B>(self, f: impl FnOnce(A) -> Valid<B, E, T>) -> Valid<B, E, T>

Chains a validation operation by applying a function to a successful value. If the original validation failed, the errors are propagated.

fn unit(self) -> Valid<(), E, T>

Converts a successful validation to (). Failed validations retain their errors.

fn some(self) -> Valid<Option<A>, E, T>

Wraps a successful value in Some(_).

fn map_to<B>(self, b: B) -> Valid<B, E, T>

Maps a successful validation to a constant value.

fn when(self, f: impl FnOnce() -> bool) -> Valid<(), E, T>

Conditionally validates based on a predicate. If the predicate returns false, succeeds with ().