Struct Refinement

pub struct Refinement<T, P: Predicate<T>>(/* private fields */);

A refinement of a type T certifying that the Predicate P holds.

Trait Implementations

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN + B::UMIN }>, LessThan<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN + B::UMIN }>, LessThan<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN + B::UMIN }>, LessThanEqual<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN + B::UMIN }>, LessThanEqual<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN + B::UMIN }>, LessThan<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN + B::UMIN }>, LessThan<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN + B::UMIN }>, LessThanEqual<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN + B::UMIN }>, LessThanEqual<{ MAX + B::UMAX }>>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMin<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, GreaterThan<A>>

where Refinement<Type, GreaterThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThan<{ A + B::UMIN }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMin<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, GreaterThan<A>>

where Refinement<Type, GreaterThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThan<{ A + B::UMIN }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMin<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, GreaterThanEqual<A>>

where Refinement<Type, GreaterThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThanEqual<{ A + B::UMIN }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMin<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, GreaterThanEqual<A>>

where Refinement<Type, GreaterThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThanEqual<{ A + B::UMIN }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, LessThan<A>>

where Refinement<Type, LessThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThan<{ A + B::UMAX }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, LessThan<A>>

where Refinement<Type, LessThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThan<{ A + B::UMAX }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: usize, Type: UnsignedBoundable + Add<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, LessThanEqual<A>>

where Refinement<Type, LessThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThanEqual<{ A + B::UMAX }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<const A: isize, Type: SignedBoundable + Add<Output = Type>, B: SignedMax<Type> + Predicate<Type>> Add<Refinement<Type, B>> for Refinement<Type, LessThanEqual<A>>

where Refinement<Type, LessThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThanEqual<{ A + B::UMAX }>>

The resulting type after applying the + operator.

fn add(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the + operation.

impl<T: Clone, P: Clone + Predicate<T>> Clone for Refinement<T, P>

fn clone(&self) -> Refinement<T, P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, P: Debug + Predicate<T>> Debug for Refinement<T, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, P: Default + Predicate<T>> Default for Refinement<T, P>

fn default() -> Refinement<T, P>

Returns the “default value” for a type.

impl<T, P: Predicate<T>> Deref for Refinement<T, P>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, T: Deserialize<'de>, P: Predicate<T>> Deserialize<'de> for Refinement<T, P>

Available on crate features serde and alloc only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display, P: Predicate<T>> Display for Refinement<T, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ (MIN + 1) / B::UMAX - 1 }>, LessThan<{ (MAX - 1) / B::UMIN + 1 }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Div<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ min_div(MIN + 1, MAX - 1, B::UMIN, B::UMAX) - 1 }>, LessThan<{ max_div(MIN + 1, MAX - 1, B::UMIN, B::UMAX) + 1 }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ (MIN + 1) / B::UMAX - 1 }>, LessThanEqual<{ MAX / B::UMIN }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Div<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ min_div(MIN + 1, MAX, B::UMIN, B::UMAX) - 1 }>, LessThanEqual<{ max_div(MIN + 1, MAX, B::UMIN, B::UMAX) }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN / B::UMAX }>, LessThan<{ (MAX - 1) / B::UMIN + 1 }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Div<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ min_div(MIN, MAX - 1, B::UMIN, B::UMAX) }>, LessThan<{ max_div(MIN, MAX - 1, B::UMIN, B::UMAX) + 1 }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN / B::UMAX }>, LessThanEqual<{ MAX / B::UMIN }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Div<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ min_div(MIN, MAX, B::UMIN, B::UMAX) }>, LessThanEqual<{ max_div(MIN, MAX, B::UMIN, B::UMAX) }>>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const A: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMin<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, GreaterThan<A>>

where Refinement<Type, GreaterThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThan<{ A / B::UMIN }>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const A: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMin<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, GreaterThanEqual<A>>

where Refinement<Type, GreaterThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThanEqual<{ A / B::UMIN }>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const A: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, LessThan<A>>

where Refinement<Type, LessThan<A>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThan<A>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<const A: usize, Type: UnsignedBoundable + Div<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Div<Refinement<Type, B>> for Refinement<Type, LessThanEqual<A>>

where Refinement<Type, LessThanEqual<A>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThanEqual<A>>

The resulting type after applying the / operator.

fn div(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the / operation.

impl<T, P: Predicate<T>> From<Refinement<T, P>> for Refined<T>

fn from(value: Refinement<T, P>) -> Self

Converts to this type from the input type.

impl<T: Hash, P: Hash + Predicate<T>> Hash for Refinement<T, P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F, T, Type> Implies<Refinement<Type, T>> for Refinement<Type, F>

where F: Predicate<Type> + Implies<T>, T: Predicate<Type>,

Available on crate feature implication only.

fn imply(self) -> Refinement<Type, T>

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ (MIN + 1) * B::UMIN - 1 }>, LessThan<{ (MAX - 1) * B::UMAX + 1 }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Mul<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ min_mul(MIN + 1, MAX - 1, B::UMIN, B::UMAX) - 1 }>, LessThan<{ max_mul(MIN + 1, MAX - 1, B::UMIN, B::UMAX) + 1 }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ (MIN + 1) * B::UMIN - 1 }>, LessThanEqual<{ MAX * B::UMAX }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Mul<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ min_mul(MIN + 1, MAX, B::UMIN, B::UMAX) - 1 }>, LessThanEqual<{ max_mul(MIN + 1, MAX, B::UMIN, B::UMAX) }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN * B::UMIN }>, LessThan<{ (MAX - 1) * B::UMAX + 1 }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Mul<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ min_mul(MIN, MAX - 1, B::UMIN, B::UMAX) }>, LessThan<{ max_mul(MIN, MAX - 1, B::UMIN, B::UMAX) + 1 }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN * B::UMIN }>, LessThanEqual<{ MAX * B::UMAX }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Mul<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ min_mul(MIN, MAX, B::UMIN, B::UMAX) }>, LessThanEqual<{ max_mul(MIN, MAX, B::UMIN, B::UMAX) }>>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const A: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMin<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, GreaterThan<A>>

where Refinement<Type, GreaterThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThan<{ (A + 1) * B::UMIN - 1 }>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const A: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMin<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, GreaterThanEqual<A>>

where Refinement<Type, GreaterThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThanEqual<{ A * B::UMIN }>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const A: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, LessThan<A>>

where Refinement<Type, LessThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThan<{ (A - 1) * B::UMAX + 1 }>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<const A: usize, Type: UnsignedBoundable + Mul<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Mul<Refinement<Type, B>> for Refinement<Type, LessThanEqual<A>>

where Refinement<Type, LessThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, LessThanEqual<{ A * B::UMAX }>>

The resulting type after applying the * operator.

fn mul(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the * operation.

impl<T: Ord, P: Ord + Predicate<T>> Ord for Refinement<T, P>

fn cmp(&self, other: &Refinement<T, P>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, P: PartialEq + Predicate<T>> PartialEq for Refinement<T, P>

fn eq(&self, other: &Refinement<T, P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, P: PartialOrd + Predicate<T>> PartialOrd for Refinement<T, P>

fn partial_cmp(&self, other: &Refinement<T, P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, P: Predicate<T>> RefinementOps for Refinement<T, P>

type T = T

fn take(self) -> T

Destructively removes the refined value from the Refinement wrapper.

fn extract(self) -> T

👎Deprecated since 0.0.4: use the more idiomatic ‘take’ function instead

Destructively removes the refined value from the Refinement wrapper.

fn refine(value: Self::T) -> Result<Self, RefinementError>

Attempts to refine a runtime value with the type’s imbued predicate.

fn modify<F>(self, fun: F) -> Result<Self, RefinementError>

where F: FnOnce(Self::T) -> Self::T,

Attempts a modification of a refined value, re-certifying that the predicate still holds after the modification is complete.

fn replace(self, value: Self::T) -> Result<Self, RefinementError>

Attempts a replacement of a refined value, re-certifying that the predicate holds for the new value.

impl<T: Serialize, P: Predicate<T>> Serialize for Refinement<T, P>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, P: StatefulPredicate<T>> StatefulRefinementOps<T, P> for Refinement<T, P>

fn refine_with_state(predicate: &P, value: T) -> Result<Self, RefinementError>

Attempts to refine a runtime value with the type’s imbued predicate, statefully.

fn modify_with_state<F>( self, predicate: &P, fun: F, ) -> Result<Self, RefinementError>

where F: FnOnce(<Self as RefinementOps>::T) -> <Self as RefinementOps>::T,

Attempts a modification of a refined value, re-certifying that the stateful predicate still holds after the modification is complete.

fn replace_with_state( self, predicate: &P, value: <Self as RefinementOps>::T, ) -> Result<Self, RefinementError>

Attempts a replacement of a refined value, re-certifying that the stateful predicate holds for the new value.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Sub<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN - B::UMAX }>, LessThan<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Sub<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, OpenInterval<MIN, MAX>>

where Refinement<Type, OpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN - B::UMAX }>, LessThan<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Sub<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN - B::UMAX }>, LessThanEqual<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Sub<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, OpenClosedInterval<MIN, MAX>>

where Refinement<Type, OpenClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThan<{ MIN - B::UMAX }>, LessThanEqual<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Sub<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN - B::UMAX }>, LessThan<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Sub<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, ClosedOpenInterval<MIN, MAX>>

where Refinement<Type, ClosedOpenInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN - B::UMAX }>, LessThan<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: usize, const MAX: usize, Type: UnsignedBoundable + Sub<Output = Type>, B: UnsignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN - B::UMAX }>, LessThanEqual<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: isize, const MAX: isize, Type: SignedBoundable + Sub<Output = Type>, B: SignedMinMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, ClosedInterval<MIN, MAX>>

where Refinement<Type, ClosedInterval<{ _ }, { _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, And<GreaterThanEqual<{ MIN - B::UMAX }>, LessThanEqual<{ MAX - B::UMIN }>>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: usize, Type: UnsignedBoundable + Sub<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, GreaterThan<MIN>>

where Refinement<Type, GreaterThan<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThan<{ MIN - B::UMAX }>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<const MIN: usize, Type: UnsignedBoundable + Sub<Output = Type>, B: UnsignedMax<Type> + Predicate<Type>> Sub<Refinement<Type, B>> for Refinement<Type, GreaterThanEqual<MIN>>

where Refinement<Type, GreaterThanEqual<{ _ }>>: Sized,

Available on crate features arithmetic and implication only.

type Output = Refinement<Type, GreaterThanEqual<{ MIN - B::UMAX }>>

The resulting type after applying the - operator.

fn sub(self, rhs: Refinement<Type, B>) -> Self::Output

Performs the - operation.

impl<T, P: Predicate<T>> TryFrom<Refined<T>> for Refinement<T, P>

type Error = RefinementError

The type returned in the event of a conversion error.

fn try_from(value: Refined<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Copy, P: Copy + Predicate<T>> Copy for Refinement<T, P>

impl<T: Eq, P: Eq + Predicate<T>> Eq for Refinement<T, P>

impl<T, P: Predicate<T>> StructuralPartialEq for Refinement<T, P>