Enum WillowRange 

pub enum WillowRange<T> {
    Closed(Range<T>),
    Open(RangeFrom<T>),
}

A continuous subset of a type implementing Ord.

It is either a closed range consisting of an inclusive start value and an exclusive end value, or an open range consisting only of an inclusive start value.

use std::ops::RangeBounds;
use willow_data_model::prelude::*;

assert!(WillowRange::<u8>::from(4..9).contains(&6));
assert!(!WillowRange::<u8>::from(4..9).contains(&12));

// You can create `WillowRanges` from arbitrary Rust ranges.
assert!(WillowRange::<u8>::from(4..=8) == WillowRange::<u8>::from(4..9));

Variants

Closed(Range<T>)

A closed range with an inclusive start value and an exclusive end value.

Open(RangeFrom<T>)

An open range with an inclusive start value.

Implementations

impl<T> WillowRange<T>

where T: Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

pub fn includes_range<R: RangeBounds<T>>(&self, other: &R) -> bool

Returns whether every possible item that is included in other is also included in self.

If other is a WillowRange, you can equivalently check self >= other.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(4..9).includes_range(&(5..7)), true);
assert_eq!(WillowRange::<u8>::from(4..9).includes_range(&(5..11)), false);
assert_eq!(WillowRange::<u8>::from(4..9).includes_range(&(2..7)), false);
assert_eq!(WillowRange::<u8>::from(4..9).includes_range(&(4..9)), true);

pub fn strictly_includes_range<R: RangeBounds<T>>(&self, other: &R) -> bool

Returns whether every possible item that is included in other is also included in self and there exists at least one item included in self but not included in other.

If other is a WillowRange, you can equivalently check self > other.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(4..9).strictly_includes_range(&(5..7)), true);
assert_eq!(WillowRange::<u8>::from(4..9).strictly_includes_range(&(5..11)), false);
assert_eq!(WillowRange::<u8>::from(4..9).strictly_includes_range(&(2..7)), false);
assert_eq!(WillowRange::<u8>::from(4..9).strictly_includes_range(&(4..9)), false);
assert_eq!(WillowRange::<u8>::from(4..9).strictly_includes_range(&(5..9)), true);
assert_eq!(WillowRange::<u8>::from(4..9).strictly_includes_range(&(4..8)), true);

pub fn does_intersection_include_value<R: RangeBounds<T>>( &self, other: &R, value: &T, ) -> bool

Returns whether the intersection of self and other includes the given value.

More efficient than actually creating the intersection and then calling includes.

use willow_data_model::prelude::*;

assert!(WillowRange::<u8>::from(4..9).does_intersection_include_value(&(5..7), &6));
assert!(!WillowRange::<u8>::from(4..9).does_intersection_include_value(&(5..7), &4));
assert!(!WillowRange::<u8>::from(4..9).does_intersection_include_value(&(5..7), &8));
assert!(!WillowRange::<u8>::from(4..9).does_intersection_include_value(&(5..7), &99));

impl<T> WillowRange<T>

where T: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

pub fn from_bounds<R>(bounds: &R) -> Self

where R: RangeBounds<T>,

Converts any value which implements RangeBounds<T> into a WillowRange<T> containing the same values.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from_bounds(&(..)), (..).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(0..)), (0..).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(..254)), (..254).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(..255)), (..255).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(..=254)), (..=254).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(..=255)), (..=255).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(4..8)), (4..8).into());
assert_eq!(WillowRange::<u8>::from_bounds(&(4..=8)), (4..=8).into());

pub fn intersection<R: RangeBounds<T>>(&self, other: &R) -> Self

Returns the intersection of self and other, i.e., the WillowRange which includes exactly those values included in both self and other.

If you want to check whether some value is included in the intersecion of two ranges, prefer WillowRange::does_intersection_include_value over explicitly constructing the intersection.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(4..9).intersection(&(5..7)), (5..7).into());
assert_eq!(WillowRange::<u8>::from(4..9).intersection(&(5..11)), (5..9).into());
assert_eq!(WillowRange::<u8>::from(4..9).intersection(&(2..7)), (4..7).into());
assert!(WillowRange::<u8>::from(4..9).intersection(&(11..14)).is_empty());
assert!(WillowRange::<u8>::from(4..9).intersection(&(6..6)).is_empty());

impl<T> WillowRange<T>

pub fn is_closed(&self) -> bool

Returns whether self is a closed range.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(3..8).is_closed(), true);
assert_eq!(WillowRange::<u8>::from(3..255).is_closed(), true);
assert_eq!(WillowRange::<u8>::from(3..=255).is_closed(), false);
assert_eq!(WillowRange::<u8>::from(3..).is_closed(), false);

pub fn is_open(&self) -> bool

Returns whether self is an open range.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(3..8).is_open(), false);
assert_eq!(WillowRange::<u8>::from(3..255).is_open(), false);
assert_eq!(WillowRange::<u8>::from(3..=255).is_open(), true);
assert_eq!(WillowRange::<u8>::from(3..).is_open(), true);

pub fn start(&self) -> &T

Returns a reference to the start value of self.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(3..8).start(), &3);
assert_eq!(WillowRange::<u8>::from(..8).start(), &0);

pub fn start_mut(&mut self) -> &mut T

Returns a mutable reference to the start value of self.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(3..8).start_mut(), &mut 3);
assert_eq!(WillowRange::<u8>::from(..8).start_mut(), &mut 0);

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

Returns a reference to the end value of self, or None if the range is open.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(3..8).end(), Some(&8));
assert_eq!(WillowRange::<u8>::from(3..=8).end(), Some(&9));
assert_eq!(WillowRange::<u8>::from(3..).end(), None);

pub fn end_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the end value of self, or None if the range is open.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(3..8).end_mut(), Some(&mut 8));
assert_eq!(WillowRange::<u8>::from(3..=8).end_mut(), Some(&mut 9));
assert_eq!(WillowRange::<u8>::from(3..).end_mut(), None);

pub fn map<U, F>(self, f: F) -> WillowRange<U>

where F: FnMut(T) -> U,

Converts this range into a different range by applying a function to all endpoints.

use willow_data_model::prelude::*;

assert_eq!(
    WillowRange::<u8>::from(3..8).map(|x| (x + 1) as u16),
    WillowRange::<u16>::from(4..9),
);

pub unsafe fn cast<U>(&self) -> &WillowRange<U>

Unsafely reinterprets a reference to a range as a reference to a range of a different type of boundaries.

Safety

This is safe only if &T and &U have an identical layout in memory.

impl<T> WillowRange<T>

where T: Ord,

pub fn is_empty(&self) -> bool

Returns whether self is empty, i.e., whether it includes no values.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::from(4..5).is_empty(), false);
assert_eq!(WillowRange::<u8>::from(255..).is_empty(), false);
assert_eq!(WillowRange::<u8>::from(4..4).is_empty(), true);
assert_eq!(WillowRange::<u8>::from(4..3).is_empty(), true);

impl<T> WillowRange<T>

where T: SuccessorExceptForGreatest,

pub fn singleton(t: T) -> Self

Returns the WillowRange which includes t but no other value.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::singleton(5), (5..6).into());
assert_eq!(WillowRange::<u8>::singleton(255), (255..).into());

impl<T> WillowRange<T>

where T: LeastElement,

pub fn full() -> Self

Returns the WillowRange which includes every value of type T.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::full(), (..).into());

pub fn is_full(&self) -> bool

Returns whether self is the full range, i.e., the range which includes every value of type T.

use willow_data_model::prelude::*;

assert_eq!(WillowRange::<u8>::full().is_full(), true);
assert_eq!(WillowRange::<u8>::from(1..).is_full(), false);
assert_eq!(WillowRange::<u8>::from(0..255).is_full(), false);

Trait Implementations

impl<'a, T: Arbitrary<'a>> Arbitrary<'a> for WillowRange<T>

Available on crate feature dev only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T: Clone> Clone for WillowRange<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for WillowRange<T>

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

Formats the value using the given formatter.

impl<T> From<Range<T>> for WillowRange<T>

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

Converts to this type from the input type.

impl<T> From<RangeFrom<T>> for WillowRange<T>

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

Converts to this type from the input type.

impl<T> From<RangeFull> for WillowRange<T>

where T: LeastElement,

fn from(_value: RangeFull) -> Self

Converts to this type from the input type.

impl<T> From<RangeInclusive<T>> for WillowRange<T>

where T: SuccessorExceptForGreatest,

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

Converts to this type from the input type.

impl<T> From<RangeTo<T>> for WillowRange<T>

where T: LeastElement,

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

Converts to this type from the input type.

impl<T> From<RangeToInclusive<T>> for WillowRange<T>

where T: LeastElement + SuccessorExceptForGreatest,

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

Converts to this type from the input type.

impl<T> GreatestElement for WillowRange<T>

where T: Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn greatest() -> Self

Returns the unique greatest element.

fn is_greatest(&self) -> bool

Returns true if and only if self is the greatest element.

impl<T> Hash for WillowRange<T>

where T: Hash + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

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> LeastElement for WillowRange<T>

where T: Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn least() -> Self

Returns the unique least element.

fn is_least(&self) -> bool

Returns true if and only if self is the least element.

impl<T> LowerSemilattice for WillowRange<T>

where T: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn greatest_lower_bound(&self, other: &Self) -> Self

Returns the greatest lower bound of self and other, i.e., the unique greatest element in the type which is less than or equal to both self and other.

impl<T> PartialEq for WillowRange<T>

where T: Ord + SuccessorExceptForGreatest + PredecessorExceptForLeast,

Two WillowRanges are equal iff they contain the same values.

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

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

fn ne(&self, other: &WillowRange<T>) -> bool

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

impl<T> PartialOrd for WillowRange<T>

where T: Ord + SuccessorExceptForGreatest + PredecessorExceptForLeast,

A range is less than another iff all values contained in the first are also contained in the other.

fn partial_cmp(&self, other: &WillowRange<T>) -> 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 WillowRange<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.

fn is_empty(&self) -> bool

where T: PartialOrd,

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

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl<T> UpperSemilattice for WillowRange<T>

where T: Clone + Ord + PredecessorExceptForLeast + SuccessorExceptForGreatest,

fn least_upper_bound(&self, other: &Self) -> Self

Returns the least upper bound of self and other, i.e., the unique least element in the type which is greater than or equal to both self and other.

impl<T> Eq for WillowRange<T>

where T: Ord + SuccessorExceptForGreatest + PredecessorExceptForLeast + Eq,