Struct Interval

pub struct Interval<T> {
    pub lower: Bound<T>,
    pub upper: Bound<T>,
}

Represents an interval with a lower and an upper bound.

The Interval type allows modeling ranges of values with optional inclusion or exclusion at each bound. This is useful for mathematical operations, range checks, and interval arithmetic.

Fields

lower: Bound<T>

The lower bound (also known as the start bound, or the left bound).

upper: Bound<T>

The upper bound (also known as the end, bound or the right bound).

Implementations

impl<T> Interval<T>

Methodical constructors

pub const fn closed(lower: T, upper: T) -> Self

Creates a closed interval $[l, u]$ lower..=upper RangeInclusive.

pub const fn closed_open(lower: T, upper: T) -> Self

Creates a half-open interval $[l, u)$ lower..upper Range.

pub const fn closed_unbounded(lower: T) -> Self

Creates an interval $[l, ∞)$ lower.. RangeFrom.

pub const fn open(lower: T, upper: T) -> Self

Creates an open interval $(l, u)$.

pub const fn open_closed(lower: T, upper: T) -> Self

Creates a half-open interval $(a, b]$.

pub const fn open_unbounded(lower: T) -> Self

Creates an interval $(l, ∞)$.

pub const fn unbounded() -> Self

Creates an unbounded interval $(-∞, ∞)$ .. RangeFull.

pub const fn unbounded_closed(upper: T) -> Self

Creates an interval $(-∞, u]$ ..upper RangeTo.

pub const fn unbounded_open(upper: T) -> Self

Creates an interval $(-∞, u)$ ..=upper RangeToInclusive.

impl<T> Interval<T>

Additional constructors

pub const fn new(lower: Bound<T>, upper: Bound<T>) -> Self

Creates a new interval with the given lower and upper bounds.

pub fn point(value: T) -> Self

where T: Clone,

Creates a single-point interval, equivalent to closed(value, value).

pub fn empty() -> Self

where T: Default,

Creates a canonical empty interval, equivalent to open(T::default(), T::default()).

pub const fn empty_const() -> Self

where T: ConstDefault,

Creates a canonical empty interval, equivalent to open(T::default(), T::default()).

pub fn empty_with(value: T) -> Self

where T: Clone,

Creates a canonical empty interval, equivalent to open(value, value).

impl<T: Copy> Interval<T>

pub const fn to_tuple(self) -> (Bound<T>, Bound<T>)

Returns a copy of both bounds as a tuple (lower, upper).

Example

let r = Interval::from(1..3usize);
assert_eq!("bc", &"abcd"[r.to_tuple()]);

impl<T> Interval<T>

pub fn into_tuple(self) -> (Bound<T>, Bound<T>)

Returns both bounds as a tuple (lower, upper).

pub fn to_tuple_ref(&self) -> (Bound<&T>, Bound<&T>)

Returns a reference to both bounds as a tuple (&lower, &upper).

pub fn lower_ref(&self) -> Bound<&T>

Returns a reference to the lower bound.

pub fn upper_ref(&self) -> Bound<&T>

Returns a reference to the upper bound.

pub const fn is_bounded(&self) -> bool

Checks if the interval is both lower and upper bounded.

pub const fn is_lower_bounded(&self) -> bool

Checks if the lower bound is bounded.

pub const fn is_upper_bounded(&self) -> bool

Checks if the upper bound is bounded.

pub const fn is_lower_open(&self) -> bool

Checks if the lower bound is open (excluded).

pub const fn is_lower_closed(&self) -> bool

Checks if the lower bound is closed (included).

pub const fn is_upper_open(&self) -> bool

Checks if the upper bound is open (excluded).

pub const fn is_upper_closed(&self) -> bool

Checks if the upper bound is closed (included).

impl<T: PartialOrd> Interval<T>

pub fn is_empty(&self) -> bool

Checks if the interval is empty (contains no values).

An interval is empty if:

• The bounds exclude each other, such as (x, x), [x, x), or (x, x].
• The lower bound is strictly greater than the upper bound.

Unbounded intervals are never empty.

pub fn is_well_ordered(&self) -> bool

Validates that the interval bounds are ordered correctly.

Returns true if the lower bound is less than or equal to the upper bound. Unbounded intervals are always considered well ordered.

pub fn contains(&self, value: &T) -> bool

Checks if the interval contains the given value.

let interval = Interval::closed(1, 5);
assert!(interval.contains(&3));
assert!(!interval.contains(&6));

pub fn size(&self) -> Option<T>

where T: Clone + Sub<Output = T>,

Returns the size of the interval, if finite.

Trait Implementations

impl<T: Clone> Clone for Interval<T>

fn clone(&self) -> Interval<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> ConstDefault for Interval<T>

Provides a const default value for Interval, the unbounded interval $(-\infty, \infty)$.

See the Default implementation for more information.

See Default for more information.

const DEFAULT: Self

Returns the compile-time “default value” for a type.

impl<T: Debug> Debug for Interval<T>

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

Formats the value using the given formatter.

impl<T> Default for Interval<T>

Provides a default value for Interval, the unbounded interval $(-\infty, \infty)$.

This choice emphasizes neutrality and generality, where the interval encompasses all possible values of T. It:

• Represents a neutral and maximal range for generic use cases.
• Avoids reliance on Default for T, making it applicable to all types.
• Aligns with mathematical conventions, where unbounded intervals are a natural default.

fn default() -> Self

Returns the “default value” for a type.

impl<T: Display> Display for Interval<T>

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

Formats the interval as a human-readable string.

Examples:

• (-∞, 5] for an unbounded lower bound and inclusive upper bound.
• [1, 3) for a closed lower bound and open upper bound.

impl<T> From<Range<T>> for Interval<T>

fn from(r: Range<T>) -> Self

Converts to this type from the input type.

impl<T> From<RangeFrom<T>> for Interval<T>

fn from(r: RangeFrom<T>) -> Self

Converts to this type from the input type.

impl<T> From<RangeFull> for Interval<T>

fn from(_: RangeFull) -> Self

Converts to this type from the input type.

impl<T> From<RangeInclusive<T>> for Interval<T>

fn from(r: RangeInclusive<T>) -> Self

Converts to this type from the input type.

impl<T> From<RangeTo<T>> for Interval<T>

fn from(r: RangeTo<T>) -> Self

Converts to this type from the input type.

impl<T> From<RangeToInclusive<T>> for Interval<T>

fn from(r: RangeToInclusive<T>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Interval<T>

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<T: Ord> Ord for Interval<T>

Comparison Logic:

• We compare the lower bounds first.
• If the lower bounds are equal, we compare the upper bounds.
• We define Unbounded as less than any bounded value.
• We define that Included(a) < Excluded(a) at same point a.

fn cmp(&self, other: &Self) -> 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> PartialEq for Interval<T>

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

Comparison Logic:

• We compare the lower bounds first.
• If the lower bounds are equal, we compare the upper bounds.
• We define Unbounded as less than any bounded value.
• We define that Included(a) < Excluded(a) at same point a.

fn partial_cmp(&self, other: &Self) -> 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> RangeBounds<T> for Interval<T>

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

impl<T> TryFrom<Interval<T>> for Range<T>

Errors

Returns IncompatibleBounds if the bounds are not compatible.

type Error = NumError

The type returned in the event of a conversion error.

fn try_from(interval: Interval<T>) -> NumResult<Self>

Performs the conversion.

impl<T> TryFrom<Interval<T>> for RangeFrom<T>

Errors

Returns IncompatibleBounds if the bounds are not compatible.

type Error = NumError

The type returned in the event of a conversion error.

fn try_from(interval: Interval<T>) -> NumResult<Self>

Performs the conversion.

impl<T> TryFrom<Interval<T>> for RangeFull

Errors

Returns IncompatibleBounds if the bounds are not compatible.

type Error = NumError

The type returned in the event of a conversion error.

fn try_from(interval: Interval<T>) -> NumResult<Self>

Performs the conversion.

impl<T> TryFrom<Interval<T>> for RangeInclusive<T>

Errors

Returns IncompatibleBounds if the bounds are not compatible.

type Error = NumError

The type returned in the event of a conversion error.

fn try_from(interval: Interval<T>) -> NumResult<Self>

Performs the conversion.

impl<T> TryFrom<Interval<T>> for RangeTo<T>

Errors

Returns IncompatibleBounds if the bounds are not compatible.

type Error = NumError

The type returned in the event of a conversion error.

fn try_from(interval: Interval<T>) -> NumResult<Self>

Performs the conversion.

impl<T> TryFrom<Interval<T>> for RangeToInclusive<T>

Errors

Returns IncompatibleBounds if the bounds are not compatible.

type Error = NumError

The type returned in the event of a conversion error.

fn try_from(interval: Interval<T>) -> NumResult<Self>

Performs the conversion.

impl<T: Copy> Copy for Interval<T>

impl<T: Eq> Eq for Interval<T>

impl<T> StructuralPartialEq for Interval<T>