Struct indexing::Range

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

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.

Methods

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> Copy for Range<'id, I, Emptiness>

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

Performs the conversion.

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, P, Q> PartialEq<Range<'id, I, Q>> for Range<'id, I, P>

fn eq(&self, other: &Range<'id, I, Q>) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

impl<'id, Array: TrustedContainer + ?Sized, I: Idx, P> Index<Range<'id, I, P>> for Container<'id, Array>

type Output = Array::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, 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, 

Feeds a slice of this type into the given [Hasher].