Struct Range

pub struct Range<'id, I: Idx = u32, Emptiness = Unknown> { /* private fields */ }

A branded range.

Range<'id> only indexes the container instantiated with the exact same lifetime for the parameter 'id created by the scope function.

The range may carry a proof of non-emptiness (Emptiness), which enables further operations.

Implementations

impl<'id, I: Idx> Range<'id, I, Unknown>

pub fn from<P, Q>(start: Index<'id, I, P>, end: Index<'id, I, Q>) -> Self

Construct a range from two trusted indices.

impl<'id, I: Idx, Emptiness> Range<'id, I, Emptiness>

pub fn untrusted(&self) -> Range<I>

This range without the branding.

pub fn erased(&self) -> Range<'id, I, Unknown>

This range without the emptiness proof.

pub fn len(&self) -> I

The length of the range.

pub fn is_empty(&self) -> bool

true if the range is empty.

pub fn nonempty(&self) -> Option<Range<'id, I, NonEmpty>>

Try to create a proof that the range is nonempty.

pub fn start(&self) -> Index<'id, I, Emptiness>

The starting index. (Accessible if the range is NonEmpty.)

pub fn end(&self) -> Index<'id, I, Unknown>

The ending index.

pub fn split_at<E>( &self, index: Index<'id, I, E>, ) -> Option<(Range<'id, I>, Range<'id, I>)>

Split around the middle index if it is in this range.

pub fn contains_in<Array: TrustedContainer>( &self, index: I, container: &Container<'id, Array>, ) -> Option<Index<'id, I, NonEmpty>>

If the index is a valid absolute index within this range.

pub fn contains<P>( &self, index: Index<'id, I, P>, ) -> Option<Index<'id, I, NonEmpty>>

If the index is within this range. Provides a nonempty proof.

pub fn join<Q>( &self, other: Range<'id, I, Q>, ) -> Option<Range<'id, I, <(Emptiness, Q) as ProofAdd>::Sum>>

where (Emptiness, Q): ProofAdd,

Join together two adjacent ranges. (They must be exactly touching, non-overlapping, and in order.)

pub fn join_cover<Q>( &self, other: Range<'id, I, Q>, ) -> Range<'id, I, <(Emptiness, Q) as ProofAdd>::Sum>

where (Emptiness, Q): ProofAdd,

Extend the range to cover all of other, including any space between.

pub fn frontiers(&self) -> (Range<'id, I, Unknown>, Range<'id, I, Unknown>)

Create two empty ranges, at the front and the back of this range.

impl<'id, I: Idx> Range<'id, I, NonEmpty>

pub fn advance_in<Array: TrustedContainer>( &mut self, container: &Container<'id, Array>, ) -> bool

Increase the range’s start, if the result is still a non-empty range.

true if stepped successfully, false if the range would be empty.

Trait Implementations

impl<'id, I: Idx, Emptiness> Clone for Range<'id, I, Emptiness>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'id, I: Idx, Emptiness> Debug for Range<'id, I, Emptiness>

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

Formats the value using the given formatter.

impl<'id, I: Idx, Emptiness> From<Range<Index<'id, I, Emptiness>>> for Range<'id, I, Unknown>

Note

In order to use this impl, you’ll likely need to erase the emptiness proof from the indices to create the range. This doesn’t lose any Range proof.

fn from(r: Range<Index<'id, I, Emptiness>>) -> Self

Converts to this type from the input type.

impl<'id, I: Idx, Emptiness> Hash for Range<'id, I, Emptiness>

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<'id, Array: TrustedContainer + ?Sized, I: Idx, P> Index<Range<'id, I, P>> for Container<'id, Array>

type Output = <Array as TrustedContainer>::Slice

The returned type after indexing.

fn index(&self, r: Range<'id, I, P>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'id, I: Idx, P, Q> PartialEq<Range<'id, I, Q>> for Range<'id, I, P>

fn eq(&self, other: &Range<'id, I, Q>) -> 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<'id, I: Idx, Emptiness> Copy for Range<'id, I, Emptiness>

impl<'id, I: Idx, Emptiness> Eq for Range<'id, I, Emptiness>