Trait Specification 

pub trait Specification<T>: Send + Sync {
    type Error: Debug + Send;

    // Required method
    fn is_satisfied_by(&self, candidate: &T) -> Result<bool, Self::Error>;

    // Provided methods
    fn and<S>(self, other: S) -> AndSpecification<Self, S, T>
       where Self: Sized,
             S: Specification<T> { ... }
    fn or<S>(self, other: S) -> OrSpecification<Self, S, T>
       where Self: Sized,
             S: Specification<T> { ... }
    fn not(self) -> NotSpecification<Self, T>
       where Self: Sized { ... }
}

Core Specification trait

Specifications encapsulate business rules that can be:

• Combined with AND, OR, NOT operators
• Reused across different parts of the application
• Tested in isolation

Type Parameters

• T: The type of entity being validated

Required Associated Types

type Error: Debug + Send

Error type for validation failures

Required Methods

fn is_satisfied_by(&self, candidate: &T) -> Result<bool, Self::Error>

Check if the candidate satisfies this specification

Provided Methods

fn and<S>(self, other: S) -> AndSpecification<Self, S, T>

where Self: Sized, S: Specification<T>,

Combine with another specification using AND

fn or<S>(self, other: S) -> OrSpecification<Self, S, T>

where Self: Sized, S: Specification<T>,

Combine with another specification using OR

fn not(self) -> NotSpecification<Self, T>

where Self: Sized,

Negate this specification

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<L, R, T> Specification<T> for AndSpecification<L, R, T>

where L: Specification<T>, R: Specification<T>, T: Send + Sync,

type Error = String

impl<L, R, T> Specification<T> for OrSpecification<L, R, T>

where L: Specification<T>, R: Specification<T>, T: Send + Sync,

type Error = String

impl<S, T> Specification<T> for NotSpecification<S, T>

where S: Specification<T>, T: Send + Sync,

type Error = String

impl<T, F> Specification<T> for PredicateSpecification<T, F>

where T: Send + Sync, F: Fn(&T) -> bool + Send + Sync,

type Error = !

impl<T: Send + Sync> Specification<T> for AlwaysFalse<T>

type Error = !

impl<T: Send + Sync> Specification<T> for AlwaysTrue<T>

type Error = !