Trait Test

pub trait Test<Input, const ARITY: usize = 1> {
    type Error<'i>: Display
       where Input: 'i;

    const ADJECTIVE: &str;

    // Required method
    fn test(input: [&Input; ARITY]) -> Result<(), Self::Error<'_>>;
}

Function-like type that checks an invariant and optionally provides an error message.

Takes an arity parameter useful e.g. for comparing pairs, since you want to take references for each element of the pair, but the pair itself has to be a temporary value.

Required Associated Constants

const ADJECTIVE: &str

Adjective to describe this test: for example, if we’re testing A, then this is B in “A is not B.”

Required Associated Types

type Error<'i>: Display where Input: 'i

An error implementing ::core::fmt::Display. If no error is ever provided, please use ::core::convert::Infallible.

Required Methods

fn test(input: [&Input; ARITY]) -> Result<(), Self::Error<'_>>

Check whether a given term satisfies this invariant.

Errors

If it doesn’t.

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<Input: Debug + PartialOrd + Zero> Test<Input> for NonNegativeInvariant<Input>

const ADJECTIVE: &str = "non-negative"

type Error<'i> = Negative<'i, Input> where Input: 'i

impl<Input: Debug + PartialOrd + Zero> Test<Input> for PositiveInvariant<Input>

const ADJECTIVE: &str = "positive"

type Error<'i> = NonPositive<'i, Input> where Input: 'i

impl<Input: One + PartialOrd + Zero + Debug, const INCLUSIVE_AT_ZERO: bool, const INCLUSIVE_AT_ONE: bool> Test<Input> for OnUnitInvariant<Input, INCLUSIVE_AT_ZERO, INCLUSIVE_AT_ONE>

const ADJECTIVE: &str = "on the unit interval"

type Error<'i> = NotOnUnit<'i, Input, INCLUSIVE_AT_ZERO, INCLUSIVE_AT_ONE> where Input: 'i

impl<Invariant: Test<Input::Item, 1>, Input: IntoIterator + Debug> Test<Input> for All<Invariant, Input>

where Input::Item: Debug, for<'i> &'i Input: IntoIterator<Item = &'i Input::Item>,

const ADJECTIVE: &str = "all valid"

type Error<'i> = NotAll<'i, <Input as IntoIterator>::Item, Invariant> where Input: 'i

impl<Invariant: Test<Input::Item, 2>, Input: IntoIterator + Debug> Test<Input> for AllPairs<Invariant, Input>

where Input::Item: Debug, for<'i> &'i Input: IntoIterator<Item = &'i Input::Item>,

const ADJECTIVE: &str = "all pairwise valid"

type Error<'i> = NotAllPairs<'i, <Input as IntoIterator>::Item, Invariant> where Input: 'i

impl<const ALLOW_DUPLICATES: bool, Input: PartialOrd> Test<Input, 2> for SortedPair<ALLOW_DUPLICATES>

const ADJECTIVE: &str = "sorted"

type Error<'i> = OutOfOrder where Input: 'i