Enum Range 

pub enum Range<A = i32> {
    Single(A),
    Bounded(A, A),
    UnboundedL(A),
    UnboundedR(A),
    Unbounded,
}

Variants

Single(A)

Bounded(A, A)

UnboundedL(A)

UnboundedR(A)

Unbounded

Implementations

impl<A> Range<A>

pub fn is_lower_or_upper_bounded(&self) -> bool

Whether the range is bounded on either side. A bounded range may still be infinite. See also: Range::is_finite.

pub fn is_unbounded(&self) -> bool

Whether the range is unbounded on both sides.

pub fn is_finite(&self) -> bool

Whether the range is finite. See also: Range::is_lower_or_upper_bounded.

impl<A: Ord> Range<A>

pub fn contains(&self, val: &A) -> bool

pub fn low(&self) -> Option<&A>

Returns the lower bound of the range, if it has one

pub fn high(&self) -> Option<&A>

Returns the upper bound of the range, if it has one

impl<A: Ord + Clone> Range<A>

pub fn new(lo: Option<A>, hi: Option<A>) -> Range<A>

Create a new range with a lower and upper bound

pub fn spanning(rngs: &[Range<A>]) -> Range<A>

Given a slice of ranges, create a single range that spans from the start of the leftmost range to the end of the rightmost range. An empty slice is considered equivalent to Range::unbounded.

impl<A: Num + Ord + Clone> Range<A>

pub fn length(&self) -> Option<A>

pub fn overlaps(&self, other: &Range<A>) -> bool

Returns true if this interval overlaps another one, i.e. at least one number is part of both self and other E.g:

• [0, 2] overlaps [2, 4]
• [1, 3] overlaps [2, 4]
• [4, 6] overlaps [2, 4]

pub fn touches_left(&self, other: &Range<A>) -> bool

Returns true if this interval touches another one on the left E.g: [1, 2] touches_left [3, 4]

pub fn touches_right(&self, other: &Range<A>) -> bool

Returns true if this interval touches another one on the right E.g: [3, 4] touches_right [1, 2]

pub fn joins(&self, other: &Range<A>) -> bool

Returns true if this interval overlaps or touches another one E.g:

• [1, 3] joins [4, 6]
• [2, 4] joins [4, 6]
• [3, 5] joins [4, 6]
• [6, 8] joins [4, 6]
• [7, 8] joins [4, 6]

pub fn is_before(&self, other: &Range<A>) -> bool

Returns true if this interval is strictly before another one

pub fn is_after(&self, other: &Range<A>) -> bool

Returns true if this interval is strictly after another one

pub fn join(&self, other: &Range<A>) -> Option<Range<A>>

If the two ranges join, return a new range which spans both

pub fn squeeze(rngs: &[Range<A>]) -> Vec<Range<A>>

Merge all joining ranges in the list, and return a new vec of disjoint ranges. E.g:

[(2..3), (4), (..1), (6..8)] -> [(..4), (6..8)]

Performance

Currently uses a naive O(n^2) algorithm. A more optimal approach based on interval trees is planned.

pub fn iter(&self) -> Option<RangeIterator<A>>

If this range is bounded, returns a lazy iterator over all values within the range. Otherwise, returns None.

pub fn values(rngs: &[Range<A>]) -> Option<impl Iterator<Item = A>>

impl Range<IntVal>

pub fn resolve(&self) -> Option<Range<i32>>

Trait Implementations

impl<A: Clone> Clone for Range<A>

fn clone(&self) -> Range<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Range<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for Range<A>

where A: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Display> Display for Range<A>

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

Formats the value using the given formatter.

impl From<Range> for Range<IntVal>

fn from(value: Range<i32>) -> Self

Converts to this type from the input type.

impl<A: Hash> Hash for Range<A>

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<A: PartialEq> PartialEq for Range<A>

fn eq(&self, other: &Range<A>) -> 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<A> Quine for Range<A>

where A: Quine,

fn ctor_tokens(&self) -> TokenStream

impl<A> Serialize for Range<A>

where A: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryInto<Range> for Range<IntVal>

type Error = DomainOpError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Range<i32>, Self::Error>

Performs the conversion.

impl<A: Eq> Eq for Range<A>

impl<A> StructuralPartialEq for Range<A>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.