Crate reliakit_validate 

Composable validation traits and error types for Rust structs and values.

reliakit-validate provides a small, focused toolkit for expressing validation rules as types. The core pieces are:

• Validate — a trait that types implement to describe their validity rules.
• Valid<T> — a zero-cost wrapper that carries proof of successful validation in the type system.
• ValidationError — an error type that collects one or more Violations, useful for validating multiple fields at once and returning all failures together.

Examples

Single-field validation

use reliakit_validate::{Validate, Valid, ValidationError};

struct Username(String);

impl Validate for Username {
    type Error = ValidationError;

    fn validate(&self) -> Result<(), Self::Error> {
        if self.0.is_empty() {
            return Err(ValidationError::new("username must not be empty"));
        }
        if self.0.len() > 32 {
            return Err(ValidationError::new("username must not exceed 32 characters"));
        }
        Ok(())
    }
}

let user = Valid::new(Username("alice".into())).unwrap();
assert_eq!(user.0, "alice");

Multi-field struct validation

use reliakit_validate::{Validate, ValidationError, Violation};

struct CreateUser {
    name: String,
    age: u8,
}

impl Validate for CreateUser {
    type Error = ValidationError;

    fn validate(&self) -> Result<(), Self::Error> {
        let mut errors = ValidationError::empty();

        if self.name.is_empty() {
            errors.push(Violation::with_field("name", "must not be empty"));
        }
        if self.age < 18 {
            errors.push(Violation::with_field("age", "must be at least 18"));
        }

        if errors.is_empty() { Ok(()) } else { Err(errors) }
    }
}

let result = CreateUser { name: String::new(), age: 15 }.validate();
assert!(result.is_err());
assert_eq!(result.unwrap_err().len(), 2);

Structs

Valid

A value that has been successfully validated.

ValidationError

One or more validation failures collected during validation.

Violation

A single failed constraint, optionally associated with a named field.

Traits

Validate

A type that can validate itself.

Type Aliases

ValidateResult

Result alias for validation operations.