Struct coca::vec::Vec

pub struct Vec<Element, Buf, Idx = usize> where
    Buf: ContiguousStorage<Element>,
    Idx: Capacity,  { /* fields omitted */ }

A contiguous growable array type with constant capacity.

Generic over the storage buffer type Buf and the index type Idx.

See the module-level documentation for more.

Implementations

impl<E, B, I> Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn into_raw_parts(self) -> (B, I)

Decomposes a Vec<E, B, I> into its raw parts.

Returns the raw storage type and the length of the vector in elements. These are the same arguments in the same order as the arguments to from_raw_parts.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 5];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.extend(&[1, 2, 3]);

let (slice, len) = vec.into_raw_parts();
unsafe {
    assert_eq!(slice[0].assume_init(), 1);
    assert_eq!(slice[1].assume_init(), 2);
    assert_eq!(slice[2].assume_init(), 3);
    // other elements are uninitialized
}

pub unsafe fn from_raw_parts(buf: B, length: I) -> Self

Creates a Vec<E, B, I> directly from its raw parts.

Safety

Callers must ensure that values stored in buf at all positions less than length are initialized, and that length is less than or equal to buf.capacity().

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 5];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.extend(&[1, 2, 3]);

let (buf, length) = vec.into_raw_parts();
let vec = unsafe { coca::SliceVec::<u32>::from_raw_parts(buf, length) };
assert_eq!(vec.as_slice(), &[1, 2, 3]);

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hold.

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its 'length'.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn is_full(&self) -> bool

Returns true if the vector contains the maximum number of elements.

pub fn pop(&mut self) -> Option<E>

Removes the last element from the vector and returns it, or None if it is empty.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 3];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3);
assert_eq!(vec.pop(), Some(3));
assert_eq!(vec, &[1, 2][..]);

pub fn as_slice(&self) -> &[E]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [E]

Extracts a mutable slice of the entire vector.

Equivalent to &mut s[..].

pub fn get(&self, index: I) -> Option<&E>

Returns a reference to the element at the specified index, or None if the index is out of bounds.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 3];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3);
assert_eq!(vec.get(1), Some(&2));
assert_eq!(vec.get(3), None);

pub fn get_mut(&mut self, index: I) -> Option<&mut E>

Returns a mutable reference to the element at the specified index, or None if the index is out of bounds.

pub fn try_push(&mut self, value: E) -> Result<(), E>

Appends an element to the back of the vector, returning Err(value) if it is already at capacity.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 3];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
assert!(vec.try_push(1).is_ok());
assert!(vec.try_push(2).is_ok());
assert!(vec.try_push(3).is_ok());
assert_eq!(vec.try_push(4), Err(4));

pub fn push(&mut self, value: E)

Appends an element to the back of the vector.

Panics

Panics if the vector is already at capacity. See try_push for a checked version that never panics.

pub fn truncate(&mut self, len: I)

Shortens the vector, keeping the first len elements and dropping the rest.

If len is greater than the vector's current length, this has no effect.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3); vec.push(4);

vec.truncate(6);
assert_eq!(vec, &[1, 2, 3, 4][..]);

vec.truncate(2);
assert_eq!(vec, &[1, 2][..]);

pub fn clear(&mut self)

Clears the vector, dropping all values.

Equivalent to s.truncate(0).

pub fn swap(&mut self, fst: I, snd: I)

Swaps two elements in the vector.

Panics

Pancis if either argument is out of bounds.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3); vec.push(4);

vec.swap(0, 2);
assert_eq!(vec, &[3, 2, 1, 4][..]);

pub fn swap_remove(&mut self, index: I) -> E

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector. This does not preserve ordering, but it is O(1).

Panics

Panics if index is out of bounds.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3); vec.push(4);

vec.swap_remove(1);
assert_eq!(vec, &[1, 4, 3][..]);

pub fn insert(&mut self, index: I, element: E)

Inserts an element at position index within the vector, shifting all elements after it to the right.

Panics

Panics if the vector is already full, or if index is out of bounds. See try_insert for a checked version.

pub fn try_insert(&mut self, index: I, element: E) -> Result<(), E>

Inserts an element at position index within the vector, shifting all elements after it to the right.

Returns back Err(element) if the vector is already at capacity.

Panics

Panics if index is out of bounds.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3);

assert!(vec.try_insert(3, 4).is_ok());
assert!(vec.try_insert(4, 5).is_err());
assert_eq!(vec, &[1, 2, 3, 4][..]);

pub fn replace(&mut self, index: I, element: E) -> E

Places an element at position index within the vector, returning the element previously stored there.

Panics

Panics if index is out of bounds.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3);

assert_eq!(vec.replace(1, 4), 2);
assert_eq!(vec, &[1, 4, 3][..]);

pub fn remove(&mut self, index: I) -> E

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

Panics

Panics if index is out of bounds.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3);
vec.remove(0);

assert_eq!(vec, &[2, 3][..]);

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&E) -> bool, 

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place, visiting each element exactly once in the original order, and preserves the order of the retained elements.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3); vec.push(4);
vec.retain(|&x| x % 2 == 0);

assert_eq!(vec, &[2, 4][..]);

The exact order may be useful for tracking external state, like an index.

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 4];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3); vec.push(4);
let keep = [false, true, true, false];
let mut i = 0;
vec.retain(|_| (keep[i], i += 1).0);

assert_eq!(vec, &[2, 3][..]);

pub fn drain<R: RangeBounds<I>>(&mut self, range: R) -> Drain<'_, E, B, I>

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

When the iterator is dropped, all elements in the range are removed from the vector, even if the iterator was not fully consumed. If the iterator is not dropped (with core::mem::forget for example), it is unspecified how many elements are removed.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

Examples

let mut backing_region = [core::mem::MaybeUninit::<u32>::uninit(); 5];
let mut vec = coca::SliceVec::<u32>::from(&mut backing_region[..]);
vec.push(1); vec.push(2); vec.push(3); vec.push(4); vec.push(5);
let mut iter = vec.drain(1..3);
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), None);
drop(iter);
assert_eq!(vec, &[1, 4, 5][..]);

impl<E, I> Vec<E, Box<[MaybeUninit<E>], Global>, I> where
    E: Copy,
    I: Capacity, 

pub fn with_capacity(capacity: I) -> Self

This is supported on crate feature alloc only.

Constructs a new, empty AllocVec<E, I> with the specified capacity.

Panics

Panics if the specified capacity cannot be represented by a usize.

impl<E, I, const C: usize> Vec<E, [MaybeUninit<E>; C], I> where
    I: Capacity, 

pub fn new() -> Self

This is supported on crate feature nightly only.

Constructs a new, empty Vec backed by an inline array.

Panics

Panics if C cannot be represented as a value of type I.

Examples

let vec = coca::ArrayVec::<u32, 6>::new();
assert_eq!(vec.capacity(), 6);
assert_eq!(vec.len(), 0);

Trait Implementations

impl<E, B, I> AsMut<[E]> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn as_mut(&mut self) -> &mut [E]

Performs the conversion.

impl<E, B, I> AsRef<[E]> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn as_ref(&self) -> &[E]

Performs the conversion.

impl<E, I, const C: usize> Clone for Vec<E, [MaybeUninit<E>; C], I> where
    E: Clone,
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E, B, I> Debug for Vec<E, B, I> where
    E: Debug,
    B: ContiguousStorage<E>,
    I: Capacity, 

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

Formats the value using the given formatter.

impl<E, I, const C: usize> Default for Vec<E, [MaybeUninit<E>; C], I> where
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn default() -> Self

Returns the "default value" for a type.

impl<E, B, I> Deref for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

type Target = [E]

The resulting type after dereferencing.

pub fn deref(&self) -> &[E]

Dereferences the value.

impl<E, B, I> DerefMut for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn deref_mut(&mut self) -> &mut [E]

Mutably dereferences the value.

impl<E, B, I> Drop for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn drop(&mut self)

Executes the destructor for this type.

impl<E, B, I> Eq for Vec<E, B, I> where
    E: Eq,
    B: ContiguousStorage<E>,
    I: Capacity, 

impl<'a, E, B, Idx> Extend<&'a E> for Vec<E, B, Idx> where
    E: 'a + Clone,
    B: ContiguousStorage<E>,
    Idx: Capacity, 

pub fn extend<I: IntoIterator<Item = &'a E>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<E, B, Idx> Extend<E> for Vec<E, B, Idx> where
    B: ContiguousStorage<E>,
    Idx: Capacity, 

pub fn extend<I: IntoIterator<Item = E>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<E, I, const C: usize> From<&'_ [E]> for Vec<E, [MaybeUninit<E>; C], I> where
    E: Clone,
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn from(source: &[E]) -> Self

Performs the conversion.

impl<E, I, const C: usize> From<&'_ mut [E]> for Vec<E, [MaybeUninit<E>; C], I> where
    E: Clone,
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn from(source: &mut [E]) -> Self

Performs the conversion.

impl<E, B, I> From<B> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn from(buf: B) -> Self

Converts a contiguous block of memory into an empty vector.

Panics

This may panic if the index type I cannot represent buf.capacity().

impl<E, B, I> From<Vec<E, B, I>> for BinaryHeap<E, B, I> where
    E: Ord,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn from(vec: Vec<E, B, I>) -> Self

Converts a Vec into a binary heap.

This conversion happens in-place, and has O(n) time complexity.

impl<E, B: ContiguousStorage<E>, I: Capacity> From<Vec<E, B, I>> for Deque<E, B, I>

pub fn from(vec: Vec<E, B, I>) -> Self

Performs the conversion.

impl<E, I, const N: usize> FromIterator<E> for Vec<E, [MaybeUninit<E>; N], I> where
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn from_iter<It: IntoIterator<Item = E>>(iter: It) -> Self

Creates a vector backed by an inline array from an iterator.

Panics

Panics if the iterator yields more than N elements.

impl<E, B, I> Hash for Vec<E, B, I> where
    E: Hash,
    B: ContiguousStorage<E>,
    I: Capacity, 

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<E, B, I> Index<I> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

type Output = E

The returned type after indexing.

pub fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> Index<Range<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

type Output = [E]

The returned type after indexing.

pub fn index(&self, index: Range<I>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> Index<RangeFrom<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

type Output = [E]

The returned type after indexing.

pub fn index(&self, index: RangeFrom<I>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> Index<RangeFull> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

type Output = [E]

The returned type after indexing.

pub fn index(&self, index: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> Index<RangeInclusive<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

type Output = [E]

The returned type after indexing.

pub fn index(&self, index: RangeInclusive<I>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> Index<RangeTo<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

type Output = [E]

The returned type after indexing.

pub fn index(&self, index: RangeTo<I>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> Index<RangeToInclusive<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

type Output = [E]

The returned type after indexing.

pub fn index(&self, index: RangeToInclusive<I>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E, B, I> IndexMut<I> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IndexMut<Range<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

pub fn index_mut(&mut self, index: Range<I>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IndexMut<RangeFrom<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

pub fn index_mut(&mut self, index: RangeFrom<I>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IndexMut<RangeFull> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

pub fn index_mut(&mut self, index: RangeFull) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IndexMut<RangeInclusive<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

pub fn index_mut(&mut self, index: RangeInclusive<I>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IndexMut<RangeTo<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

pub fn index_mut(&mut self, index: RangeTo<I>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IndexMut<RangeToInclusive<I>> for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity + PartialOrd, 

pub fn index_mut(&mut self, index: RangeToInclusive<I>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<E, B, I> IntoIterator for Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

type Item = E

The type of the elements being iterated over.

type IntoIter = IntoIterator<E, B, I>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<'a, E, B, I> IntoIterator for &'a Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

type Item = &'a E

The type of the elements being iterated over.

type IntoIter = Iter<'a, E>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<'a, E, B, I> IntoIterator for &'a mut Vec<E, B, I> where
    B: ContiguousStorage<E>,
    I: Capacity, 

type Item = &'a mut E

The type of the elements being iterated over.

type IntoIter = IterMut<'a, E>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<E, B, I> Ord for Vec<E, B, I> where
    E: Ord,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<V, E, B, I> PartialEq<&'_ [V]> for Vec<E, B, I> where
    E: PartialEq<V>,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn eq(&self, other: &&[V]) -> 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<V, E, B, I> PartialEq<&'_ mut [V]> for Vec<E, B, I> where
    E: PartialEq<V>,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn eq(&self, other: &&mut [V]) -> 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<V, E, B, I, const N: usize> PartialEq<[V; N]> for Vec<E, B, I> where
    E: PartialEq<V>,
    B: ContiguousStorage<E>,
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn eq(&self, other: &[V; N]) -> 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<AE, AB, AI, BE, BB, BI> PartialEq<Vec<BE, BB, BI>> for Vec<AE, AB, AI> where
    AE: PartialEq<BE>,
    AB: ContiguousStorage<AE>,
    BB: ContiguousStorage<BE>,
    AI: Capacity,
    BI: Capacity, 

pub fn eq(&self, other: &Vec<BE, BB, BI>) -> 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<V, E, B, I> PartialEq<Vec<E, B, I>> for &[V] where
    V: PartialEq<E>,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn eq(&self, other: &Vec<E, B, I>) -> 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<V, E, B, I> PartialEq<Vec<E, B, I>> for &mut [V] where
    V: PartialEq<E>,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn eq(&self, other: &Vec<E, B, I>) -> 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<V, E, B, I, const N: usize> PartialEq<Vec<E, B, I>> for [V; N] where
    V: PartialEq<E>,
    B: ContiguousStorage<E>,
    I: Capacity, 

This is supported on crate feature nightly only.

pub fn eq(&self, other: &Vec<E, B, I>) -> 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<E, B, I> PartialOrd<Vec<E, B, I>> for Vec<E, B, I> where
    E: PartialOrd,
    B: ContiguousStorage<E>,
    I: Capacity, 

pub fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.