Trait Check 

pub trait Check<T, PreState>
where
    Self: Sized,
{
    type PostState;
    type Error;

    // Required method
    fn check(
        self,
        value: CheckState<T, PreState>,
    ) -> CheckOutcome<T, Self::PostState, Self::Error>;

    // Provided methods
    fn and<B, C>(self, b: B) -> And<Self, B, C>
       where B: Check<T, Self::PostState>,
             C: CombineErrorBuilder<Self::Error, B::Error> { ... }
    fn or<B, C>(self, b: B) -> Or<Self, B, C>
       where B: Check<T, Self::PostState>,
             C: CombineErrorBuilder<Self::Error, B::Error> { ... }
}

Required Associated Types

type PostState

type Error

Required Methods

fn check( self, value: CheckState<T, PreState>, ) -> CheckOutcome<T, Self::PostState, Self::Error>

Provided Methods

fn and<B, C>(self, b: B) -> And<Self, B, C>

where B: Check<T, Self::PostState>, C: CombineErrorBuilder<Self::Error, B::Error>,

fn or<B, C>(self, b: B) -> Or<Self, B, C>

where B: Check<T, Self::PostState>, C: CombineErrorBuilder<Self::Error, B::Error>,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T, PreState, A, B, C> Check<T, PreState> for And<A, B, C>

where A: Check<T, PreState>, B: Check<T, A::PostState>, C: CombineErrorBuilder<A::Error, B::Error>,

type PostState = <B as Check<T, <A as Check<T, PreState>>::PostState>>::PostState

type Error = <<C as CombineErrorBuilder<<A as Check<T, PreState>>::Error, <B as Check<T, <A as Check<T, PreState>>::PostState>>::Error>>::Combiner as CombineError<<A as Check<T, PreState>>::Error, <B as Check<T, <A as Check<T, PreState>>::PostState>>::Error>>::Out

impl<T, PreState, A, B, C> Check<T, PreState> for Or<A, B, C>

where A: Check<T, PreState>, B: Check<T, A::PostState>, C: CombineErrorBuilder<A::Error, B::Error>,

type PostState = <B as Check<T, <A as Check<T, PreState>>::PostState>>::PostState

type Error = <C as CombineErrorBuilder<<A as Check<T, PreState>>::Error, <B as Check<T, <A as Check<T, PreState>>::PostState>>::Error>>::Out

impl<T, PreState, PostState, F, E> Check<T, PreState> for F

where F: Fn(CheckState<T, PreState>) -> CheckOutcome<T, PostState, E>,

type PostState = PostState

type Error = E