Struct nunny::NonEmpty

pub struct NonEmpty<T: ?Sized> { /* private fields */ }

A wrapper struct around non-empty slices/arrays/vectors.

You may wish to use the following type aliases instead:

• Slice.
• Vec.
• Array.

See also crate documentation

Implementations

impl<const N: usize, T> NonEmpty<[T; N]>

Array methods

pub const fn new_ref(src: &[T; N]) -> Option<&Self>

Returns a NonEmpty array.

Returns None if src is empty.

pub fn new_mut(src: &mut [T; N]) -> Option<&mut Self>

Returns a NonEmpty array.

Returns None if src is empty.

pub fn new(src: [T; N]) -> Option<Self>

Returns a NonEmpty array.

Returns None if src is empty.

pub const unsafe fn new_ref_unchecked(src: &[T; N]) -> &Self

Create a NonEmpty array.

Safety

• src must not be empty

pub unsafe fn new_mut_unchecked(src: &mut [T; N]) -> &mut Self

Create a NonEmpty array.

Safety

• src must not be empty

pub const unsafe fn new_unchecked(src: [T; N]) -> Self

Create a NonEmpty array.

Safety

• src must not be empty

pub fn each_ref(&self) -> Array<&T, N>

Borrows each element and returns a NonEmpty array of references with the same size as self.

pub fn each_mut(&mut self) -> Array<&mut T, N>

Borrows each element mutably and returns a NonEmpty array of mutable references with the same size as self.

pub fn each_map<F, U>(self, f: F) -> Array<U, N>

where F: FnMut(T) -> U,

Returns a NonEmpty array of the same size as self, with function f applied to each element in order.

pub const fn as_slice_ne(&self) -> &Slice<T>

Returns a NonEmpty slice.

pub fn as_mut_slice_ne(&mut self) -> &mut Slice<T>

Returns a NonEmpty slice.

pub const fn as_array(&self) -> &[T; N]

Returns a primitive array.

pub fn as_mut_array(&mut self) -> &mut [T; N]

Returns a primitive array.

pub fn into_array(self) -> [T; N]

Returns a primitive array.

impl<T, const N: usize> NonEmpty<[T; N]>

Known non-empty iterator for Array.

pub fn into_iter_ne(self) -> NonEmpty<IntoIter<T, N>>

impl<T> NonEmpty<[T; 1]>

Special case for Arrays of length one

pub const fn of(item: T) -> Self

Create a NonEmpty array of a single element

pub fn of_mut(item: &mut T) -> &mut Self

Create a NonEmpty array of a single mutable reference

pub const fn of_ref(item: &T) -> &Self

Create a NonEmpty array of a single reference

impl<I> NonEmpty<I>

where I: Iterator,

Methods on Iterators with a non-empty invariant.

See Self::relax to access the normal iterator inside.

pub fn first(self) -> I::Item

NonEmpty version of Iterator::next.

let v = vec![1, 2, 3];
let _: Option<&u8> = v.iter().next();
    // ^ normally you have to handle the empty case
let _: &u8 = v.iter_ne().first();
    // ^ but we know there is at least one element

pub fn last(self) -> I::Item

NonEmpty version of Iterator::last.

let v = vec![1, 2, 3];
let _: Option<&u8> = v.iter().last();
    // ^ normally you have to handle the empty case
let _: &u8 = v.iter_ne().last();
    // ^ but we know there is at least one element

pub fn map<B, F>(self, f: F) -> NonEmpty<Map<I, F>>

where F: FnMut(I::Item) -> B,

NonEmpty version of Iterator::map.

let iter = slice![1, 2, 3].iter_ne();
assert_eq!(
    iter.map(|it| *it * 2).last(),
                        // ^ the invariant is maintained
                        //   so we _know_ there's a last element
    6
);

pub fn chain<U>( self, other: U, ) -> NonEmpty<Chain<I, <U as IntoIterator>::IntoIter>>

where U: IntoIterator<Item = I::Item>,

NonEmpty version of Iterator::chain.

let iter = slice![1, 2].iter_ne();
assert_eq!(
    iter.chain(&[3]).last(),
                  // ^ the invariant is maintained
                  //   so we _know_ there's a last element
    &3
);

pub fn enumerate(self) -> NonEmpty<Enumerate<I>>

NonEmpty version of Iterator::enumerate.

let iter = slice!['a', 'b'].iter_ne();
assert_eq!(
    iter.enumerate().last(),
                 // ^ the invariant is maintained
                 //   so we _know_ there's a last element
    (1, &'b')
);

pub fn peekable(self) -> NonEmpty<Peekable<I>>

NonEmpty version of Iterator::peekable, allowing you to use Self::peek and Self::peek_mut

let mut peek_me = vec!['a', 'b'].into_iter_ne().peekable();
assert_eq!(
    *peek_me.peek(),
    'a'
);
*peek_me.peek_mut() = 'b';
assert_eq!(
    peek_me.collect_vec(),
    ['b', 'b']
);

pub fn take(self, n: NonZeroUsize) -> NonEmpty<Take<I>>

NonEmpty version of Iterator::take.

Note that n cannot be zero, to maintain the NonEmpty invariant.

let iter = slice!['a', 'b'].iter_ne();
assert_eq!(
    iter.take(nonzero!(1)).last(),
           // ^ compile time checked
    &'a'
)

pub fn flatten<II, T>(self) -> NonEmpty<FlatMap<I, II, fn(_: I::Item) -> II>>

where I: Iterator<Item = NonEmpty<II>>, II: IntoIterator<Item = T>,

NonEmpty version of Iterator::flatten.

Note that the inner items must also be NonEmpty, to maintain the invariant.

use nunny::{vec};
let nested = vec![vec![1], vec![2, 3]];
assert_eq!(
    nested.into_iter_ne().flatten().collect_vec(),
    [1, 2, 3],
);

pub fn fuse(self) -> NonEmpty<Fuse<I>>

NonEmpty version of Iterator::fuse.

pub fn inspect<F>(self, f: F) -> NonEmpty<Inspect<I, F>>

where F: FnMut(&I::Item),

NonEmpty version of Iterator::inspect.

pub fn reduce<F>(self, f: F) -> I::Item

where F: FnMut(I::Item, I::Item) -> I::Item,

NonEmpty version of Iterator::reduce.

let v = vec![1, 2, 3];
let _: Option<&u8> = v.iter().reduce(min);
    // ^ normally you have to handle the empty case
let _: &u8 = v.iter_ne().reduce(min);
    // ^ but we know there is at least one element

pub fn max(self) -> I::Item

where I::Item: Ord,

NonEmpty version of Iterator::max.

let v = vec![1, 2, 3];
let _: Option<&u8> = v.iter().max();
    // ^ normally you have to handle the empty case
let _: &u8 = v.iter_ne().max();
    // ^ but we know there is at least one element

pub fn min(self) -> I::Item

where I::Item: Ord,

NonEmpty version of Iterator::min.

let v = vec![1, 2, 3];
let _: Option<&u8> = v.iter().min();
    // ^ normally you have to handle the empty case
let _: &u8 = v.iter_ne().min();
    // ^ but we know there is at least one element

pub fn max_by_key<B, F>(self, f: F) -> I::Item

where B: Ord, F: FnMut(&I::Item) -> B,

NonEmpty version of Iterator::max_by_key.

pub fn max_by<F>(self, compare: F) -> I::Item

where F: FnMut(&I::Item, &I::Item) -> Ordering,

NonEmpty version of Iterator::max_by.

pub fn min_by_key<B, F>(self, f: F) -> I::Item

where B: Ord, F: FnMut(&I::Item) -> B,

NonEmpty version of Iterator::min_by_key.

pub fn min_by<F>(self, compare: F) -> I::Item

where F: FnMut(&I::Item, &I::Item) -> Ordering,

NonEmpty version of Iterator::min_by.

pub fn rev(self) -> NonEmpty<Rev<I>>

where I: DoubleEndedIterator,

NonEmpty version of Iterator::rev.

pub fn unzip_vec<A, B>(self) -> (Vec<A>, Vec<B>)

where I: Iterator<Item = (A, B)>,

NonEmpty version of Iterator::unzip.

pub fn copied<'a, T>(self) -> NonEmpty<Copied<I>>

where T: 'a + Copy, I: Iterator<Item = &'a T>,

NonEmpty version of Iterator::copied.

pub fn cloned<'a, T>(self) -> NonEmpty<Cloned<I>>

where T: 'a + Clone, I: Iterator<Item = &'a T>,

NonEmpty version of Iterator::cloned.

pub fn cycle(self) -> NonEmpty<Cycle<I>>

where I: Clone,

NonEmpty version of Iterator::cycle.

pub fn relax(self) -> I

Remove the NonEmpty wrapper, allowing you to access normal iterator methods like Iterator::filter.

pub fn collect_vec(self) -> Vec<I::Item>

Collect this iterator into a NonEmpty<Vec>.

pub fn try_collect_vec<T, E>(self) -> Result<Vec<T>, E>

where I: Iterator<Item = Result<T, E>>,

Collect Ok items into a NonEmpty<Vec>, short-circuiting on Err.

impl<I> NonEmpty<Peekable<I>>

where I: Iterator,

pub fn peek(&mut self) -> &I::Item

Peek this NonEmpty iterator, without advancing it.

See Self::peekable.

pub fn peek_mut(&mut self) -> &mut I::Item

Peek and modify this NonEmpty iterator, without advancing it.

See Self::peekable.

impl<T> NonEmpty<[T]>

Slice methods

pub const fn new(src: &[T]) -> Option<&Self>

Create a new NonEmpty slice

Returns None if src is empty.

pub fn new_mut(src: &mut [T]) -> Option<&mut Self>

Create a new NonEmpty slice

Returns None if src is empty.

pub const unsafe fn new_unchecked(src: &[T]) -> &Self

Create a new NonEmpty slice

Safety

• src must not be empty

pub unsafe fn new_mut_unchecked(src: &mut [T]) -> &mut Self

Create a new NonEmpty slice

Safety

• src must not be empty

pub const fn of(item: &T) -> &Self

Create a NonEmpty slice of a single element

pub fn of_mut(item: &mut T) -> &mut Self

Create a NonEmpty slice of a single element

pub const fn as_slice(&self) -> &[T]

Returns a primitive slice.

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

Returns a primitive slice.

pub const fn len_ne(&self) -> NonZeroUsize

Returns the known non-zero length.

pub const fn first(&self) -> &T

Returns the first element, guaranteed.

pub const fn split_first(&self) -> (&T, &[T])

Returns the first element, guaranteed, and the rest of the elements.

pub const fn split_last(&self) -> (&T, &[T])

Returns the last element, guaranteed, and the rest of the elements.

pub const fn last(&self) -> &T

Returns the last element, guaranteed.

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

Returns the first element, guaranteed.

pub fn split_first_mut(&mut self) -> (&mut T, &mut [T])

Returns the first element, guaranteed, and the rest of the elements.

pub fn split_last_mut(&mut self) -> (&mut T, &mut [T])

Returns the last element, guaranteed, and the rest of the elements.

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

Returns the last element, guaranteed.

impl<T> NonEmpty<[T]>

Known non-empty iterators for Slice.

pub fn iter_ne(&self) -> NonEmpty<Iter<'_, T>>

pub fn iter_mut_ne(&mut self) -> NonEmpty<IterMut<'_, T>>

pub fn into_iter_ne(self: Box<Self>) -> NonEmpty<IntoIter<T>>

impl<T> NonEmpty<Vec<T>>

Vec methods

pub fn new_ref(src: &Vec<T>) -> Option<&Self>

Create a new NonEmpty heap-allocated vec

Returns None if src is empty.

pub fn new_mut(src: &mut Vec<T>) -> Option<&mut Self>

Create a new NonEmpty heap-allocated vec

Returns None if src is empty.

pub unsafe fn new_unchecked(src: Vec<T>) -> Self

Create a new NonEmpty heap-allocated vec

Safety

• src must not be empty

pub unsafe fn new_ref_unchecked(src: &Vec<T>) -> &Self

Create a new NonEmpty heap-allocated vec

Safety

• src must not be empty

pub unsafe fn new_mut_unchecked(src: &mut Vec<T>) -> &mut Self

Create a new NonEmpty heap-allocated vec

Safety

• src must not be empty

pub fn new(src: Vec<T>) -> Result<Self, Vec<T>>

Create a new NonEmpty heap-allocated vec, returning the original allocation if it was empty.

pub fn of(item: T) -> Self

Create a NonEmpty heap-allocated vec, of a single element.

pub fn of_with_capacity(item: T, capacity: usize) -> Self

Create a NonEmpty heap-allocated vec, of a single element, with capacity for capacity elements without (re)-allocating.

pub fn of_extending<A>(first: T, rest: impl IntoIterator<Item = A>) -> Self

where Self: Extend<A>,

Creating a NonEmpty heap-allocated vec where the first element is known.

This is an convenience method, equivalent to

let mut it = nunny::vec!["first"];
it.extend(["this", "is", "the", "rest"]);

pub fn filled(value: T, len: NonZeroUsize) -> Self

where T: Clone,

Create a NonEmpty heap-allocated vec with len items, filled with Clones of the given value.

See also Self::filled_with.

pub fn filled_with<F>(f: F, len: NonZeroUsize) -> Self

where F: FnMut() -> T,

Create a NonEmpty heap-allocated vec with len items, filled with values returned from repeating the closure f.

See also Self::filled.

pub fn as_vec(&self) -> &Vec<T>

Returns a std::vec::Vec.

pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<T>

Returns a std::vec::Vec.

Safety

• returned vec must not be emptied through this reference

pub fn into_vec(self) -> Vec<T>

Returns a std::vec::Vec.

pub fn as_slice_ne(&self) -> &Slice<T>

Returns a NonEmpty slice.

pub fn as_mut_slice_ne(&mut self) -> &mut Slice<T>

Returns a NonEmpty slice.

pub fn capacity(&self) -> NonZeroUsize

Returns the known non-zero length.

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

See reserve.

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

See reserve_exact.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

See try_reserve.

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

See try_reserve_exact.

pub fn shrink_to_fit(&mut self)

See shrink_to_fit.

pub fn shrink_to(&mut self, min_capacity: usize)

See shrink_to.

pub fn into_boxed_slice(self) -> Box<Slice<T>>

Return a NonEmpty boxed slice.

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

Shortens the vector to a guaranteed-nonzero length

See truncate.

pub unsafe fn set_len(&mut self, new_len: NonZeroUsize)

Safety

• See set_len.

pub fn insert(&mut self, index: usize, element: T)

See insert.

pub fn dedup_by_key<F, K>(&mut self, key: F)

where F: FnMut(&mut T) -> K, K: PartialEq,

See dedup_by_key.

pub fn dedup_by<F>(&mut self, same_bucket: F)

where F: FnMut(&mut T, &mut T) -> bool,

See dedup_by.

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

See push.

pub fn append(&mut self, other: &mut Vec<T>)

See append.

pub fn resize_with<F>(&mut self, new_len: NonZeroUsize, f: F)

where F: FnMut() -> T,

See resize_with.

pub fn leak<'a>(self) -> &'a mut Slice<T>

Returns a NonEmpty slice.

See leak.

pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]

See spare_capacity_mut.

impl<T> NonEmpty<Vec<T>>

Known non-empty iterator for Vec.

pub fn into_iter_ne(self) -> NonEmpty<IntoIter<T>>

Trait Implementations

impl<T> AsMut<NonEmpty<[T]>> for Slice<T>

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, const N: usize> AsMut<NonEmpty<[T]>> for Array<T, N>

fn as_mut(&mut self) -> &mut Slice<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsMut<NonEmpty<[T]>> for Vec<T>

fn as_mut(&mut self) -> &mut Slice<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, const N: usize> AsMut<NonEmpty<[T; N]>> for Array<T, N>

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsMut<NonEmpty<Vec<T>>> for Vec<T>

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<NonEmpty<[T]>> for Slice<T>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, const N: usize> AsRef<NonEmpty<[T]>> for Array<T, N>

fn as_ref(&self) -> &Slice<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<NonEmpty<[T]>> for Vec<T>

fn as_ref(&self) -> &Slice<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, const N: usize> AsRef<NonEmpty<[T; N]>> for Array<T, N>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<NonEmpty<Vec<T>>> for Vec<T>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, const N: usize> Borrow<NonEmpty<[T]>> for Array<T, N>

fn borrow(&self) -> &Slice<T>

Immutably borrows from an owned value.

impl<T> Borrow<NonEmpty<[T]>> for Vec<T>

fn borrow(&self) -> &Slice<T>

Immutably borrows from an owned value.

impl<T, const N: usize> BorrowMut<NonEmpty<[T]>> for Array<T, N>

fn borrow_mut(&mut self) -> &mut Slice<T>

Mutably borrows from an owned value.

impl<T> BorrowMut<NonEmpty<[T]>> for Vec<T>

fn borrow_mut(&mut self) -> &mut Slice<T>

Mutably borrows from an owned value.

impl<T: Clone + ?Sized> Clone for NonEmpty<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for NonEmpty<T>

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

Formats the value using the given formatter.

impl<'a, T> From<&'a NonEmpty<[T]>> for &'a [T]

fn from(value: &'a Slice<T>) -> Self

Converts to this type from the input type.

impl<T> From<&NonEmpty<[T]>> for Arc<Slice<T>>

where T: Clone,

fn from(value: &Slice<T>) -> Self

Converts to this type from the input type.

impl<T> From<&NonEmpty<[T]>> for Box<Slice<T>>

where T: Clone,

fn from(value: &Slice<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a NonEmpty<[T]>> for Cow<'a, Slice<T>>

where T: Clone,

fn from(value: &'a Slice<T>) -> Self

Converts to this type from the input type.

impl<T> From<&NonEmpty<[T]>> for Vec<T>

where T: Clone,

fn from(value: &Slice<T>) -> Self

Converts to this type from the input type.

impl<T> From<&NonEmpty<[T]>> for Rc<Slice<T>>

where T: Clone,

fn from(value: &Slice<T>) -> Self

Converts to this type from the input type.

impl<'a, T, const N: usize> From<&'a NonEmpty<[T; N]>> for &'a [T; N]

fn from(value: &'a Array<T, N>) -> Self

Converts to this type from the input type.

impl<'a, const N: usize, T> From<&'a NonEmpty<[T; N]>> for Cow<'a, Slice<T>>

where T: Clone,

fn from(value: &'a Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<&NonEmpty<[T; N]>> for Vec<T>

where T: Clone,

fn from(value: &Array<T, N>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a NonEmpty<Vec<T>>> for &'a Vec<T>

fn from(value: &'a Vec<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a NonEmpty<Vec<T>>> for Cow<'a, Slice<T>>

where T: Clone,

fn from(value: &'a Vec<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a mut NonEmpty<[T]>> for &'a mut [T]

fn from(value: &'a mut Slice<T>) -> Self

Converts to this type from the input type.

impl<T> From<&mut NonEmpty<[T]>> for Vec<T>

where T: Clone,

fn from(value: &mut Slice<T>) -> Self

Converts to this type from the input type.

impl<'a, T, const N: usize> From<&'a mut NonEmpty<[T; N]>> for &'a mut [T; N]

fn from(value: &'a mut Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<&mut NonEmpty<[T; N]>> for Vec<T>

where T: Clone,

fn from(value: &mut Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, K, V> From<NonEmpty<[(K, V); N]>> for BTreeMap<K, V>

where K: Ord,

fn from(value: Array<(K, V), N>) -> Self

Converts to this type from the input type.

impl<const N: usize, K, V> From<NonEmpty<[(K, V); N]>> for HashMap<K, V, RandomState>

where K: Eq + Hash,

fn from(value: Array<(K, V), N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<NonEmpty<[T; N]>> for [T; N]

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for Arc<Slice<T>>

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for BTreeSet<T>

where T: Ord,

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for BinaryHeap<T>

where T: Ord,

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for Box<Slice<T>>

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for HashSet<T, RandomState>

where T: Eq + Hash,

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for LinkedList<T>

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for Vec<T>

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for Rc<Slice<T>>

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<const N: usize, T> From<NonEmpty<[T; N]>> for VecDeque<T>

fn from(value: Array<T, N>) -> Self

Converts to this type from the input type.

impl<T> From<NonEmpty<Vec<T>>> for Arc<Slice<T>>

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

Converts to this type from the input type.

impl<T> From<NonEmpty<Vec<T>>> for Box<Slice<T>>

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

Converts to this type from the input type.

impl<'a, T> From<NonEmpty<Vec<T>>> for Cow<'a, Slice<T>>

where T: Clone,

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

Converts to this type from the input type.

impl<T> From<NonEmpty<Vec<T>>> for Rc<Slice<T>>

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

Converts to this type from the input type.

impl<T> From<NonEmpty<Vec<T>>> for Vec<T>

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

Converts to this type from the input type.

impl<T: Hash + ?Sized> Hash for NonEmpty<T>

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

Feeds this value into the given Hasher.

impl<A, B, const N: usize> PartialEq<&NonEmpty<[B]>> for Array<A, N>

where A: PartialEq<B>,

fn eq(&self, other: &&Slice<B>) -> bool

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

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

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

impl<T, U> PartialEq<&NonEmpty<[U]>> for Cow<'_, Slice<T>>

where T: PartialEq<U> + Clone,

fn eq(&self, other: &&Slice<U>) -> bool

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

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

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

impl<T, U> PartialEq<&NonEmpty<[U]>> for Vec<T>

where T: PartialEq<U>,

fn eq(&self, other: &&Slice<U>) -> bool

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

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

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

impl<T, U> PartialEq<&NonEmpty<[U]>> for VecDeque<T>

where T: PartialEq<U>,

fn eq(&self, other: &&Slice<U>) -> bool

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

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

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

impl<T, U, const N: usize> PartialEq<&NonEmpty<[U; N]>> for Vec<T>

where T: PartialEq<U>,

fn eq(&self, other: &&Array<U, N>) -> bool

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

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

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

impl<T, U, const N: usize> PartialEq<&NonEmpty<[U; N]>> for VecDeque<T>

where T: PartialEq<U>,

fn eq(&self, other: &&Array<U, N>) -> bool

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

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

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

impl<A, B, const N: usize> PartialEq<&mut NonEmpty<[B]>> for Array<A, N>

where A: PartialEq<B>,

fn eq(&self, other: &&mut Slice<B>) -> bool

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

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

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

impl<T, U> PartialEq<&mut NonEmpty<[U]>> for Cow<'_, Slice<T>>

where T: PartialEq<U> + Clone,

fn eq(&self, other: &&mut Slice<U>) -> bool

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

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

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

impl<T, U> PartialEq<&mut NonEmpty<[U]>> for Vec<T>

where T: PartialEq<U>,

fn eq(&self, other: &&mut Slice<U>) -> bool

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

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

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

impl<T, U> PartialEq<&mut NonEmpty<[U]>> for VecDeque<T>

where T: PartialEq<U>,

fn eq(&self, other: &&mut Slice<U>) -> bool

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

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

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

impl<T, U, const N: usize> PartialEq<&mut NonEmpty<[U; N]>> for VecDeque<T>

where T: PartialEq<U>,

fn eq(&self, other: &&mut Array<U, N>) -> bool

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

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

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

impl<A, B, const N: usize> PartialEq<NonEmpty<[A; N]>> for &Slice<B>

where B: PartialEq<A>,

fn eq(&self, other: &Array<A, N>) -> bool

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

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

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

impl<A, B, const N: usize> PartialEq<NonEmpty<[A; N]>> for &mut Slice<B>

where B: PartialEq<A>,

fn eq(&self, other: &Array<A, N>) -> bool

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

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

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

impl<A, B, const N: usize> PartialEq<NonEmpty<[A; N]>> for Slice<B>

where B: PartialEq<A>,

fn eq(&self, other: &Array<A, N>) -> bool

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

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

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

impl<A, B> PartialEq<NonEmpty<[B]>> for Slice<A>

where A: PartialEq<B>,

fn eq(&self, other: &Slice<B>) -> bool

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

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

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

impl<A, B, const N: usize> PartialEq<NonEmpty<[B]>> for Array<A, N>

where A: PartialEq<B>,

fn eq(&self, other: &Slice<B>) -> bool

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

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

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

impl<A, B, const N: usize> PartialEq<NonEmpty<[B; N]>> for Array<A, N>

where A: PartialEq<B>,

fn eq(&self, other: &Array<B, N>) -> bool

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

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

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

impl<T, U> PartialEq<NonEmpty<[T]>> for [U]

where U: PartialEq<T>,

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

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<[T]>> for [U; N]

where U: PartialEq<T>,

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

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

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

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

impl<T, U> PartialEq<NonEmpty<[T]>> for Vec<U>

where U: PartialEq<T>,

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

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<[T; N]>> for [U]

where U: PartialEq<T>,

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

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<[T; N]>> for [U; N]

where U: PartialEq<T>,

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

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<[T; N]>> for Vec<U>

where U: PartialEq<T>,

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

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

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

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

impl<T, U> PartialEq<NonEmpty<[U]>> for Vec<T>

where T: PartialEq<U>,

fn eq(&self, other: &Slice<U>) -> bool

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<[U; N]>> for Vec<T>

where T: PartialEq<U>,

fn eq(&self, other: &Array<U, N>) -> bool

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<[U; N]>> for VecDeque<T>

where T: PartialEq<U>,

fn eq(&self, other: &Array<U, N>) -> bool

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<T>>> for [U]

where U: PartialEq<T>,

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

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

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

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

impl<T, U, const N: usize> PartialEq<NonEmpty<Vec<T>>> for [U; N]

where U: PartialEq<T>,

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

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<T>>> for Vec<U>

where U: PartialEq<T>,

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

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<U>>> for &Slice<T>

where T: PartialEq<U>,

fn eq(&self, other: &Vec<U>) -> bool

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<U>>> for &mut Slice<T>

where T: PartialEq<U>,

fn eq(&self, other: &Vec<U>) -> bool

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<U>>> for Cow<'_, Slice<T>>

where T: PartialEq<U> + Clone,

fn eq(&self, other: &Vec<U>) -> bool

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<U>>> for Slice<T>

where T: PartialEq<U>,

fn eq(&self, other: &Vec<U>) -> bool

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

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

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

impl<T, U> PartialEq<NonEmpty<Vec<U>>> for Vec<T>

where T: PartialEq<U>,

fn eq(&self, other: &Vec<U>) -> bool

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

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

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

impl<T> PartialOrd<NonEmpty<[T]>> for [T]

where T: PartialOrd,

fn partial_cmp(&self, other: &Slice<T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, const N: usize> PartialOrd<NonEmpty<[T]>> for [T; N]

where T: PartialOrd,

fn partial_cmp(&self, other: &Slice<T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T> PartialOrd<NonEmpty<[T]>> for Vec<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Slice<T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, const N: usize> PartialOrd<NonEmpty<[T; N]>> for [T]

where T: PartialOrd,

fn partial_cmp(&self, other: &Array<T, N>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, const N: usize> PartialOrd<NonEmpty<[T; N]>> for [T; N]

where T: PartialOrd,

fn partial_cmp(&self, other: &Array<T, N>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, const N: usize> PartialOrd<NonEmpty<[T; N]>> for Vec<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Array<T, N>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T> PartialOrd<NonEmpty<Vec<T>>> for [T]

where T: PartialOrd,

fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, const N: usize> PartialOrd<NonEmpty<Vec<T>>> for [T; N]

where T: PartialOrd,

fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T> PartialOrd<NonEmpty<Vec<T>>> for Vec<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<'a, T, const N: usize> TryFrom<&'a NonEmpty<[T]>> for &'a Array<T, N>

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(value: &'a Slice<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, const N: usize> TryFrom<&NonEmpty<[T]>> for Array<T, N>

where T: Copy,

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(value: &Slice<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, T, const N: usize> TryFrom<&'a mut NonEmpty<[T]>> for &'a mut Array<T, N>

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(value: &'a mut Slice<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, const N: usize> TryFrom<&mut NonEmpty<[T]>> for Array<T, N>

where T: Copy,

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(value: &mut Slice<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, const N: usize> TryFrom<NonEmpty<Vec<T>>> for Box<Array<T, N>>

type Error = NonEmpty<Vec<T>>

The type returned in the event of a conversion error.

fn try_from(value: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, const N: usize> TryFrom<NonEmpty<Vec<T>>> for Array<T, N>

type Error = NonEmpty<Vec<T>>

The type returned in the event of a conversion error.

fn try_from(value: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Copy + ?Sized> Copy for NonEmpty<T>

impl<T> Eq for NonEmpty<[T]>

where T: Eq,

impl<T, const N: usize> Eq for NonEmpty<[T; N]>

where T: Eq,

impl<T> Eq for NonEmpty<Vec<T>>

where T: Eq,