Struct ranges::GenericRange

pub struct GenericRange<T> { /* fields omitted */ }

A generic analog to core/std ranges.

Because this type allows more range types, it comes with the cost of a few guarantees that need to be uphold.

First of all, start is always less than or equal to end. Secondly, both bounds are in the Domain that is implemented for T. In case the constructor encounters a value outside of the domain, the value is clamped to the full domain range.

Note

The notation of (-inf and +inf) is used as an equivalent to the domain minimum and maximum, even if the implementing domain may not be unbound or excluding in either direction.

Implementations

impl<T: PartialOrd> GenericRange<T>

#[must_use]pub fn contains(&self, item: &T) -> bool

Returns true if the given item is contained in the range.

Example

 use ranges::GenericRange;

 let range = GenericRange::from(1..=5);
 assert!(range.contains(&3));

impl<T: Domain> GenericRange<T>

pub fn difference(self, other: Self) -> OperationResult<T>

Returns the difference of two ranges.

Examples

 use ranges::{GenericRange, OperationResult};

 let range = GenericRange::from(1..=5);
 let range2 = range;
 assert_eq!(range - range2, OperationResult::Empty);

 use ranges::{GenericRange, OperationResult};

 let range = GenericRange::from(1..=5);
 let range2 = 1..3;
 assert_eq!(range - range2, OperationResult::Single((3..=5).into()));

 use ranges::{GenericRange, OperationResult};

 let range = GenericRange::from(1..=10);
 let range2 = 3..5;
 assert_eq!(range - range2, OperationResult::Double((1..3).into(), (5..=10).into()));

impl<T: Domain> GenericRange<T>

#[must_use]pub fn is_empty(&self) -> bool

Returns true if the range is empty.

Examples

use ranges::GenericRange;

assert!(GenericRange::from(1..1).is_empty());
assert!(!GenericRange::from(1..=1).is_empty());
assert!(!GenericRange::from(1..2).is_empty());

impl<T: Domain> GenericRange<T>

pub fn intersect(self, other: Self) -> OperationResult<T>

Results in either a single or, if the inputs are disjoint, empty range.

Note

The OperationResult::Double discriminant can safely be marked unreachable!() when matching the output of this method.

Examples

use ranges::{GenericRange, OperationResult};

let range = GenericRange::new_less_than(5);
let range2 = GenericRange::new_at_least(10);

assert_eq!(range & range2, OperationResult::Empty);

use ranges::{GenericRange, OperationResult};

let range = GenericRange::from(0..10);
let range2 = 5..=15;

assert_eq!(range & range2, OperationResult::Single(GenericRange::from(5..10)));

impl<T> GenericRange<T>

#[must_use]pub fn invert_border(bound: Bound<T>) -> Bound<T>

Inverts a range border, so a start becomes an end and vice versa.

Example

use core::ops::Bound;
use ranges::GenericRange;

assert_eq!(GenericRange::invert_border(Bound::<usize>::Unbounded), Bound::Unbounded);
assert_eq!(GenericRange::invert_border(Bound::Excluded(42)), Bound::Included(42));
assert_eq!(GenericRange::invert_border(Bound::Included(42)), Bound::Excluded(42));

#[must_use]pub fn invert_border_cloned(bound: &Bound<T>) -> Bound<T> where
    T: Clone, 

Inverts a range border, so a start becomes an end and vice versa. Explicitly clones the contents.

pub fn invert(self) -> OperationResult<T> where
    T: Domain, 

Inverts the given range and returns two if no bound is unbounded.

Example

use ranges::{GenericRange, OperationResult};

assert_eq!(!GenericRange::<usize>::full(), OperationResult::Empty);
assert_eq!(
    !GenericRange::new_at_most(5),
    OperationResult::Single(GenericRange::new_greater_than(5))
);
assert_eq!(
    !GenericRange::new_at_least(42),
    OperationResult::Single(GenericRange::new_less_than(42))
);
assert_eq!(
    !GenericRange::from(5..42),
    OperationResult::Double(GenericRange::new_less_than(5), GenericRange::new_at_least(42))
)

impl<T> GenericRange<T>

This is the "core" of this library. Everything basically relies on this one way or another.

Note

If you need to know only one of the possible outcomes it is generally better to use is_*() methods instead of matching on arrangement() or worse relation(). The more specific methods are, as one would expect, only using the bare minimum of information to figure out if the requested arrangement is the case. If, however, a broad knowledge about or even computation with two ranges is required, arrangement() and relation() are the way to go.

#[must_use]pub fn cmp_start_start(start: Bound<&T>, other_start: Bound<&T>) -> Ordering where
    T: Domain, 

Compares a start bound with another.

Note

Because the generic Bound enum is used, it is not verified if the two bounds are actually starts. This responsibility rests on the caller.

#[must_use]pub fn cmp_start_end(start: Bound<&T>, end: Bound<&T>) -> Ordering where
    T: Domain, 

Compares a start bound with an end bound.

Note

Because the generic Bound enum is used, it is not verified if the two bounds are actually start and end. This responsibility rests on the caller.

#[must_use]pub fn cmp_end_start(end: Bound<&T>, start: Bound<&T>) -> Ordering where
    T: Domain, 

Compares an end bound with a start bound.

Note

Because the generic Bound enum is used, it is not verified if the two bounds are actually end and start. This responsibility rests on the caller.

#[must_use]pub fn cmp_end_end(end: Bound<&T>, other_end: Bound<&T>) -> Ordering where
    T: Domain, 

Compares an end bound with another.

Note

Because the generic Bound enum is used, it is not verified if the two bounds are actually ends. This responsibility rests on the caller.

#[must_use]pub fn is_bound_touching(bound: Bound<&T>, other: Bound<&T>) -> bool where
    T: PartialEq, 

Returns true if two bounds are touching.

#[must_use]pub fn is_disjoint(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if two ranges are disjoint.

Note

No information regarding their arrangement is obtained or returned. Please refer to GenericRange::arrangement() or GenericRange::relation() and match the result on their respective Disjoint discriminant.

#[must_use]pub fn is_touching(&self, other: &Self) -> bool where
    T: PartialEq + Domain, 

Returns true if two ranges are touching.

Note

No information regarding their arrangement is obtained or returned. Please refer to GenericRange::arrangement() or GenericRange::relation() and match the result on their respective Touching discriminant.

#[must_use]pub fn is_overlapping(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if two ranges are overlapping.

Note

No information regarding their arrangement is obtained or returned. Please refer to GenericRange::arrangement() or GenericRange::relation() and match the result on their respective Overlapping discriminant.

#[must_use]pub fn is_containing(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if self contains other.

Note

This method and is_contained_by() are the only two that differentiate by arrangement. If knowledge about containment (in either orientation) is the only information you need, it is still generally faster to call these two instead of using GenericRange::arrangement() or GenericRange::relation().

#[must_use]pub fn is_contained_by(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if self is contained in other.

Note

This method and is_containing() are the only two that differentiate by arrangement. If knowledge about containment (in either orientation) is the only information you need, it is still generally faster to call these two instead of using GenericRange::arrangement() or GenericRange::relation().

#[must_use]pub fn is_starting_with(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if two ranges are starting on the same element.

Note

No information regarding their arrangement is obtained or returned. Please refer to GenericRange::arrangement() or GenericRange::relation() and match the result on their respective Starting discriminant.

#[must_use]pub fn is_ending_with(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if two ranges are ending on the same element.

Note

No information regarding their arrangement is obtained or returned. Please refer to GenericRange::arrangement() or GenericRange::relation() and match the result on their respective Ending discriminant.

#[must_use]pub fn is_equal(&self, other: &Self) -> bool where
    T: Domain, 

Returns true if the two ranges are equal.

This method is the basis for the PartialEq and Eq trait implementations.

Note

For discrete types, this may have counter-intuitive results. See examples.

Examples

use ranges::GenericRange;

assert_eq!(GenericRange::from(1..3), (1..=2).into());
assert_eq!(GenericRange::new_open_closed(1, 3), (2..=3).into());
assert_eq!(GenericRange::new_open(0, 5), (1..=4).into());

#[must_use]pub fn relation(self, other: Self) -> Relation<T> where
    T: Clone + Domain, 

Compares this GenericRange<T> with another one. The relation is expressed as an enum containing only the arrangement in form of the discriminant and some additionally obtained information about the original inputs and, if applicable, either one is less, shorter, or a singleton.

In addition to the same data obtained by GenericRange::arrangement(), the original ranges are moved into the struct to allow direct processing.

#[must_use]pub fn arrangement(&self, other: &Self) -> Arrangement where
    T: Domain, 

Compares this GenericRange<T> with another one. The relation is expressed as an enum containing only the arrangement in form of the discriminant and some additionally obtained information about the original inputs and, if applicable, either one is less, shorter, or a singleton.

impl<T: Domain> GenericRange<T>

#[must_use]pub fn singleton(value: T) -> Self where
    T: Clone, 

Constructs a singleton by cloning the input storing it in included bounds for both start and end.

Example

use core::ops::Bound;
use ranges::GenericRange;

assert_eq!(
    GenericRange::singleton(42),
    (Bound::Included(42), Bound::Included(42)).into()
);

#[must_use]pub fn is_singleton(&self) -> bool

Returns true if the range only contains a single item.

Examples

use core::ops::Bound;
use ranges::GenericRange;

assert!(!GenericRange::from(1..1).is_singleton());
assert!(GenericRange::from(1..2).is_singleton());

assert!(GenericRange::from(1..=1).is_singleton());
assert!(!GenericRange::from(1..=2).is_singleton());

assert!(GenericRange::from((Bound::Excluded(1), Bound::Included(2))).is_singleton());

impl<T: Domain> GenericRange<T>

pub fn symmetric_difference(self, other: Self) -> OperationResult<T>

Results in two ranges if the inputs are disjoint or touching. Results in two ranges (the "left" and "right" disjoint parts) if the inputs are overlapping or contain one another. Results in a single range (the disjoint part) if the inputs start or end on the same value. Returns empty if the inputs are equal.

Examples

Disjoint ranges.

use ranges::{GenericRange, OperationResult};

let a = GenericRange::new_less_than(5);
let b = GenericRange::new_at_least(10);

assert_eq!(a ^ b, OperationResult::Double(a, b));

Ranges start with the same element.

use ranges::{GenericRange, OperationResult};

let a = GenericRange::from(0..10);
let b = 0..=8;

assert_eq!(a ^ b, OperationResult::Single(GenericRange::new_open(8, 10)));

Equal ranges.

use ranges::{GenericRange, OperationResult};

let a = GenericRange::from(5..=10);
let b = a; // this works because Copy is implemented for i32.

assert_eq!(a ^ b, OperationResult::Empty);

impl<T: Domain> GenericRange<T>

pub fn union(self, other: Self) -> OperationResult<T>

Results in either a single or, if the inputs are disjoint, two ranges.

Examples

Disjoint ranges.

use ranges::{GenericRange, OperationResult};

let range = GenericRange::new_less_than(5);
let range2 = GenericRange::new_at_least(10);

assert_eq!(range | range2, OperationResult::Double(range, range2));

Overlapping ranges.

use ranges::{GenericRange, OperationResult};

let range = GenericRange::from(0..10);
let range2 = 5..=15;

assert_eq!(range | range2, OperationResult::Single((0..=15).into()));

impl<T: Domain> GenericRange<T>

Constructors and relevant comparison methods.

#[must_use]pub fn full() -> Self

Creates a new GenericRange using the domain minimum and maximum as start and end.

core/std equivalent

RangeFull or ...

Interval notation

(-inf, +inf)

#[must_use]pub fn is_full(&self) -> bool

Returns true if the start is the domain minimum and the end is the domain maximum.

#[must_use]pub fn is_left_open(&self) -> bool

Returns true if the range start is open/excluded.

#[must_use]pub fn is_left_closed(&self) -> bool

Returns true if the range start is closed/included.

#[must_use]pub fn is_left_unbounded(&self) -> bool

Returns true if the range start is unbounded.

#[must_use]pub fn is_right_open(&self) -> bool

Returns true if the range end is open/excluded.

#[must_use]pub fn is_right_closed(&self) -> bool

Returns true if the range end is closed/included.

#[must_use]pub fn is_right_unbounded(&self) -> bool

Returns true if the range end is unbounded.

#[must_use]pub fn new_greater_than(start: T) -> Self

Convenience method calling new_left_open_right_unbounded.

#[must_use]pub fn new_left_open_right_unbounded(start: T) -> Self

Creates a new GenericRange with an open/excluded start and an unbound end. Convenience method equivalent is new_greater_than.

core/std equivalent

There is no equivalent because open/excluded starts are not representable.

Interval notation

(start, +inf)

#[must_use]pub fn is_left_open_right_unbounded(&self) -> bool

Returns true if the range start is open/excluded and the end is unbounded.

#[must_use]pub fn new_at_least(start: T) -> Self

Convenience method calling new_left_closed_right_unbounded.

#[must_use]pub fn new_left_closed_right_unbounded(start: T) -> Self

Creates a new GenericRange with a closed/included start and an unbound end. Convenience method equivalent is new_at_least.

core/std equivalent

RangeFrom or start...

Interval notation

[start, +inf)

#[must_use]pub fn is_left_closed_right_unbounded(&self) -> bool

Returns true if the range start is closed/included and the end is unbounded.

#[must_use]pub fn new_less_than(end: T) -> Self

Convenience method calling new_left_unbounded_right_open.

#[must_use]pub fn new_left_unbounded_right_open(end: T) -> Self

Creates a new GenericRange with an unbounded start and an open/excluded end. Convenience method equivalent is new_less_than.

core/std equivalent

RangeTo or ..end.

Interval notation

(-inf, end)

#[must_use]pub fn is_left_unbounded_right_open(&self) -> bool

Returns true if the range start is unbounded and the end is open/excluded.

#[must_use]pub fn new_at_most(end: T) -> Self

Convenience method calling new_left_unbounded_right_closed.

#[must_use]pub fn new_left_unbounded_right_closed(end: T) -> Self

Creates a new GenericRange with an unbounded start and a closed/included end. Convenience method equivalent is new_at_most.

core/std equivalent

RangeToInclusive or ..=end.

Interval notation

(-inf, end]

#[must_use]pub fn is_left_unbounded_right_closed(&self) -> bool

Returns true if the range start is unbounded and the end is closed/included.

#[must_use]pub fn new_open(start: T, end: T) -> Self

Convenience method calling new_left_open_right_open.

#[must_use]pub fn new_left_open_right_open(start: T, end: T) -> Self

Creates a new GenericRange with an open/excluded start and end. Convenience method equivalent is new_open.

core/std equivalent

There is no equivalent because open/excluded starts are not representable.

Interval notation

(start, end)

#[must_use]pub fn is_left_open_right_open(&self) -> bool

Returns true if the range start and end are open/excluded.

#[must_use]pub fn new_closed(start: T, end: T) -> Self

Convenience method calling new_left_closed_right_closed.

#[must_use]pub fn new_left_closed_right_closed(start: T, end: T) -> Self

Creates a new GenericRange with a closed/included start and end. Convenience method equivalent is new_closed.

core/std equivalent

RangeInclusive or start..=end.

Interval notation

[start, end]

#[must_use]pub fn is_left_closed_right_closed(&self) -> bool

Returns true if the range start and end are closed/included.

#[must_use]pub fn new_closed_open(start: T, end: T) -> Self

Convenience method calling new_left_closed_right_open.

#[must_use]pub fn new_left_closed_right_open(start: T, end: T) -> Self

Creates a new GenericRange with a closed/included start and an open/excluded end. Convenience method equivalent is new_closed_open.

core/std equivalent

Range or start..end.

Interval notation

[start, end)

#[must_use]pub fn is_left_closed_right_open(&self) -> bool

Returns true if the range start is closed/included and the end is open/excluded.

#[must_use]pub fn new_open_closed(start: T, end: T) -> Self

Convenience method calling new_left_open_right_closed.

#[must_use]pub fn new_left_open_right_closed(start: T, end: T) -> Self

Creates a new GenericRange with a closed/included start and an open/excluded end. Convenience method equivalent is new_open_closed.

core/std equivalent

There is no equivalent because open/excluded starts are not representable.

Interval notation

(start, end]

#[must_use]pub fn is_left_open_right_closed(&self) -> bool

Returns true if the range start is open/excluded and the end is closed/included.

#[must_use]pub fn new_with_bounds(start: Bound<T>, end: Bound<T>) -> Self

Custom range from Bounds.

Panics

It is asserted that start <= end.

Trait Implementations

impl<T: Binary + Domain> Binary for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T, I> BitAnd<I> for GenericRange<T> where
    I: Into<GenericRange<T>>,
    T: Domain, 

This calls self.intersect(other).

type Output = OperationResult<T>

The resulting type after applying the & operator.

#[must_use]pub fn bitand(self, rhs: I) -> Self::Output

Performs the & operation.

impl<T, I> BitOr<I> for GenericRange<T> where
    I: Into<GenericRange<T>>,
    T: Domain, 

This calls self.union(other).

type Output = OperationResult<T>

The resulting type after applying the | operator.

#[must_use]pub fn bitor(self, rhs: I) -> Self::Output

Performs the | operation.

impl<T, I> BitXor<I> for GenericRange<T> where
    I: Into<GenericRange<T>>,
    T: Domain, 

This calls self.symmetric_difference(other).

type Output = OperationResult<T>

The resulting type after applying the ^ operator.

#[must_use]pub fn bitxor(self, rhs: I) -> Self::Output

Performs the ^ operation.

impl<T: Clone> Clone for GenericRange<T>

pub fn clone(&self) -> GenericRange<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for GenericRange<T>

impl<T: Debug> Debug for GenericRange<T>

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

Formats the value using the given formatter.

impl<T: Display + Domain> Display for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T: Domain> Eq for GenericRange<T>

impl<T: Domain> From<(Bound<T>, Bound<T>)> for GenericRange<T>

Converts the tuple using Self::with_bounds(tuple.0, tuple.1).

#[must_use]pub fn from(range: (Bound<T>, Bound<T>)) -> Self

Performs the conversion.

impl<T: Domain> From<Range<T>> for GenericRange<T>

Converts the Range using Self::closed_open(range.start, range.end).

#[must_use]pub fn from(range: Range<T>) -> Self

Performs the conversion.

impl<T: Domain> From<RangeFrom<T>> for GenericRange<T>

Converts the RangeFrom using Self::at_least(range.start).

#[must_use]pub fn from(range: RangeFrom<T>) -> Self

Performs the conversion.

impl<T: Domain> From<RangeFull> for GenericRange<T>

Converts the RangeFull using Self::full().

#[must_use]pub fn from(_range: RangeFull) -> Self

Performs the conversion.

impl<T: Domain> From<RangeInclusive<T>> for GenericRange<T>

Converts the RangeInclusive using Self::closed(start, end).

#[must_use]pub fn from(range: RangeInclusive<T>) -> Self

Performs the conversion.

impl<T: Domain> From<RangeTo<T>> for GenericRange<T>

Converts the RangeTo using Self::less_than(range.end).

#[must_use]pub fn from(range: RangeTo<T>) -> Self

Performs the conversion.

impl<T: Domain> From<RangeToInclusive<T>> for GenericRange<T>

Converts the RangeToInclusive using Self::at_most(range.end).

#[must_use]pub fn from(range: RangeToInclusive<T>) -> Self

Performs the conversion.

impl<T: Domain + Clone> From<T> for GenericRange<T>

#[must_use]pub fn from(val: T) -> Self

Performs the conversion.

impl<T: Domain> FromIterator<GenericRange<T>> for Ranges<T>

pub fn from_iter<I: IntoIterator<Item = GenericRange<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Domain + Hash> Hash for GenericRange<T>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T> IntoIterator for GenericRange<T> where
    T: Iterable<Output = T>, 

type Item = T

The type of the elements being iterated over.

type IntoIter = GenericIterator<T>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Panics

This function panics when trying to convert a range with an unbound start, as there is no way to determine where to start iterating at. However, if the domain of T has a minimum, calling this is safe, as it was set as the start when the range was constructed.

impl<T: LowerExp + Domain> LowerExp for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T: LowerHex + Domain> LowerHex for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T: Domain> Not for GenericRange<T>

This calls self.invert().

type Output = OperationResult<T>

The resulting type after applying the ! operator.

#[must_use]pub fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Octal + Domain> Octal for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T: Domain> PartialEq<GenericRange<T>> for GenericRange<T>

pub fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: Pointer + Domain> Pointer for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T> RangeBounds<T> for GenericRange<T>

#[must_use]pub fn start_bound(&self) -> Bound<&T>

Start index bound.

#[must_use]pub fn end_bound(&self) -> Bound<&T>

End index bound.

pub fn assert_len(self, len: usize) -> Range<usize> where
    Self: RangeBounds<usize>, 

🔬 This is a nightly-only experimental API. (range_bounds_assert_len)

Performs bounds-checking of this range.

pub 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, I> Sub<I> for GenericRange<T> where
    I: Into<GenericRange<T>>,
    T: Domain, 

This calls self.difference(other).

type Output = OperationResult<T>

The resulting type after applying the - operator.

#[must_use]pub fn sub(self, rhs: I) -> Self::Output

Performs the - operation.

impl<T: UpperExp + Domain> UpperExp for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.

impl<T: UpperHex + Domain> UpperHex for GenericRange<T>

Non-Debug formatting uses interval notation and formats the bound values according to the given formatting arguments.

Note

Unless disabled by using the - formatting argument, a whitespace will be printed after the bound separator. Because there is currently no use for -, it will have no effect on the underlying bound values. This might change if requested or core/std makes use of it.

Examples

use ranges::GenericRange;

assert_eq!(format!("{}", GenericRange::from(1..2)), "{1}");
assert_eq!(format!("{}", GenericRange::from(1..=2)), "[1, 2]");
assert_eq!(format!("{}", GenericRange::from(42..)), "[42, 2147483647]");
assert_eq!(format!("{:03}", GenericRange::from(1..2)), "{001}");
assert_eq!(format!("{:02X}", GenericRange::from(1..=10)), "[01, 0A]");
assert_eq!(format!("{:-#}", GenericRange::from(42..=100)), "[42,100]");

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

Formats the value using the given formatter.