Struct Constrained

pub struct Constrained<T, C: Constraint<T>> { /* private fields */ }

A wrapper enforcing a numeric constraint at construction time.

Combine this with one of the provided marker types (such as NonNegative) or your own Constraint<T> implementation.

See the module documentation for details and usage patterns.

Example

use twine_core::constraint::{Constrained, StrictlyPositive};

let n = Constrained::<_, StrictlyPositive>::new(42).unwrap();
assert_eq!(n.into_inner(), 42);

Implementations

impl<T, C: Constraint<T>> Constrained<T, C>

pub fn new(value: T) -> Result<Self, ConstraintError>

Constructs a new constrained value.

Errors

Returns an error if the value does not satisfy the constraint.

pub fn into_inner(self) -> T

Consumes the wrapper and returns the inner value.

Trait Implementations

impl<T> Add for Constrained<T, NonNegative>

where T: Add<Output = T> + PartialOrd + Zero,

Adds two Constrained<T, NonNegative> values.

Assumes that summing two non-negative values yields a non-negative result. This holds for most numeric types (i32, f64, uom::Quantity, etc.), but may not for all possible T. The invariant is checked in debug builds.

Panics

Panics in debug builds if the sum is unexpectedly negative.

type Output = Constrained<T, NonNegative>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T> Add for Constrained<T, NonPositive>

where T: Add<Output = T> + PartialOrd + Zero,

Adds two Constrained<T, NonPositive> values.

Assumes that summing two non-positive values yields a non-positive result. This holds for most numeric types (i32, f64, uom::Quantity, etc.), but may not for all possible T. The invariant is checked in debug builds.

Panics

Panics in debug builds if the sum is unexpectedly positive.

type Output = Constrained<T, NonPositive>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T> Add for Constrained<T, StrictlyNegative>

where T: Add<Output = T> + PartialOrd + Zero,

Adds two Constrained<T, StrictlyNegative> values.

Assumes that summing two negative values yields a negative result. This holds for most numeric types (i32, f64, uom::Quantity, etc.), but may not for all possible T. The invariant is checked in debug builds.

Panics

Panics in debug builds if the sum is unexpectedly non-negative.

type Output = Constrained<T, StrictlyNegative>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T> Add for Constrained<T, StrictlyPositive>

where T: Add<Output = T> + PartialOrd + Zero,

Adds two Constrained<T, StrictlyPositive> values.

Assumes that summing two positive values yields a positive result. This holds for most numeric types (i32, f64, uom::Quantity, etc.), but may not for all possible T. The invariant is checked in debug builds.

Panics

Panics in debug builds if the sum is unexpectedly non-positive.

type Output = Constrained<T, StrictlyPositive>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T, C: Constraint<T>> AsRef<T> for Constrained<T, C>

Returns a reference to the inner unconstrained value.

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone, C: Clone + Constraint<T>> Clone for Constrained<T, C>

fn clone(&self) -> Constrained<T, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, C: Debug + Constraint<T>> Debug for Constrained<T, C>

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

Formats the value using the given formatter.

impl<T: Default, C: Default + Constraint<T>> Default for Constrained<T, C>

fn default() -> Constrained<T, C>

Returns the “default value” for a type.

impl<T: Ord, C: Ord + Constraint<T>> Ord for Constrained<T, C>

fn cmp(&self, other: &Constrained<T, C>) -> 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, C: PartialEq + Constraint<T>> PartialEq for Constrained<T, C>

fn eq(&self, other: &Constrained<T, C>) -> 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, C: PartialOrd + Constraint<T>> PartialOrd for Constrained<T, C>

fn partial_cmp(&self, other: &Constrained<T, C>) -> 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, C> Sum for Constrained<T, C>

where C: Constraint<T>, Constrained<T, C>: Add<Output = Self> + Zero,

Sums constrained values for which addition is valid.

Applies to all constraints that are preserved under addition.

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Zero for Constrained<T, NonNegative>

where T: PartialOrd + Zero,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T> Zero for Constrained<T, NonPositive>

where T: PartialOrd + Zero,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Copy, C: Copy + Constraint<T>> Copy for Constrained<T, C>

impl<T: Eq, C: Eq + Constraint<T>> Eq for Constrained<T, C>

impl<T, C: Constraint<T>> StructuralPartialEq for Constrained<T, C>