[−][src]Struct nonempty::NonEmpty
Fields
head: T
tail: Vec<T>
Implementations
impl<T> NonEmpty<T>
[src]
pub const fn new(e: T) -> Self
[src]
Alias for NonEmpty::singleton
.
pub const fn singleton(head: T) -> Self
[src]
Create a new non-empty list with an initial element.
pub const fn is_empty(&self) -> bool
[src]
Always returns false.
pub const fn first(&self) -> &T
[src]
Get the first element. Never fails.
pub fn first_mut(&mut self) -> &mut T
[src]
Get the mutable reference to the first element. Never fails.
Examples
use nonempty::NonEmpty; let mut non_empty = NonEmpty::new(42); let head = non_empty.first_mut(); *head += 1; assert_eq!(non_empty.first(), &43); let mut non_empty = NonEmpty::from((1, vec![4, 2, 3])); let head = non_empty.first_mut(); *head *= 42; assert_eq!(non_empty.first(), &42);
pub fn tail(&self) -> &[T]
[src]
Get the possibly-empty tail of the list.
use nonempty::NonEmpty; let non_empty = NonEmpty::new(42); assert_eq!(non_empty.tail(), &[]); let non_empty = NonEmpty::from((1, vec![4, 2, 3])); assert_eq!(non_empty.tail(), &[4, 2, 3]);
pub fn push(&mut self, e: T)
[src]
Push an element to the end of the list.
pub fn pop(&mut self) -> Option<T>
[src]
Pop an element from the end of the list.
pub fn insert(&mut self, index: usize, element: T)
[src]
Inserts an element at position index within the vector, shifting all elements after it to the right.
Panics
Panics if index > len.
Examples
use nonempty::NonEmpty; let mut non_empty = NonEmpty::from((1, vec![2, 3])); non_empty.insert(1, 4); assert_eq!(non_empty, NonEmpty::from((1, vec![4, 2, 3]))); non_empty.insert(4, 5); assert_eq!(non_empty, NonEmpty::from((1, vec![4, 2, 3, 5]))); non_empty.insert(0, 42); assert_eq!(non_empty, NonEmpty::from((42, vec![1, 4, 2, 3, 5])));
pub fn len(&self) -> usize
[src]
Get the length of the list.
pub fn last(&self) -> &T
[src]
Get the last element. Never fails.
pub fn last_mut(&mut self) -> &mut T
[src]
Get the last element mutably.
pub fn contains(&self, x: &T) -> bool where
T: PartialEq,
[src]
T: PartialEq,
Check whether an element is contained in the list.
use nonempty::NonEmpty; let mut l = NonEmpty::from((42, vec![36, 58])); assert!(l.contains(&42)); assert!(!l.contains(&101));
pub fn get(&self, index: usize) -> Option<&T>
[src]
Get an element by index.
pub fn get_mut(&mut self, index: usize) -> Option<&mut T>
[src]
Get an element by index, mutably.
pub fn truncate(&mut self, len: usize)
[src]
Truncate the list to a certain size. Must be greater than 0
.
pub fn iter<'a>(&'a self) -> impl Iterator<Item = &T> + 'a
[src]
use nonempty::NonEmpty; let mut l = NonEmpty::from((42, vec![36, 58])); let mut l_iter = l.iter(); assert_eq!(l_iter.next(), Some(&42)); assert_eq!(l_iter.next(), Some(&36)); assert_eq!(l_iter.next(), Some(&58)); assert_eq!(l_iter.next(), None);
pub fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &mut T> + 'a
[src]
use nonempty::NonEmpty; let mut l = NonEmpty::new(42); l.push(36); l.push(58); for i in l.iter_mut() { *i *= 10; } let mut l_iter = l.iter(); assert_eq!(l_iter.next(), Some(&420)); assert_eq!(l_iter.next(), Some(&360)); assert_eq!(l_iter.next(), Some(&580)); assert_eq!(l_iter.next(), None);
pub fn from_slice(slice: &[T]) -> Option<NonEmpty<T>> where
T: Clone,
[src]
T: Clone,
Often we have a Vec
(or slice &[T]
) but want to ensure that it is NonEmpty
before
proceeding with a computation. Using from_slice
will give us a proof
that we have a NonEmpty
in the Some
branch, otherwise it allows
the caller to handle the None
case.
Example Use
use nonempty::NonEmpty; let non_empty_vec = NonEmpty::from_slice(&[1, 2, 3, 4, 5]); assert_eq!(non_empty_vec, Some(NonEmpty::from((1, vec![2, 3, 4, 5])))); let empty_vec: Option<NonEmpty<&u32>> = NonEmpty::from_slice(&[]); assert!(empty_vec.is_none());
pub fn from_vec(vec: Vec<T>) -> Option<NonEmpty<T>>
[src]
Often we have a Vec
(or slice &[T]
) but want to ensure that it is NonEmpty
before
proceeding with a computation. Using from_vec
will give us a proof
that we have a NonEmpty
in the Some
branch, otherwise it allows
the caller to handle the None
case.
This version will consume the Vec
you pass in. If you would rather pass the data as a
slice then use NonEmpty::from_slice
.
Example Use
use nonempty::NonEmpty; let non_empty_vec = NonEmpty::from_vec(vec![1, 2, 3, 4, 5]); assert_eq!(non_empty_vec, Some(NonEmpty::from((1, vec![2, 3, 4, 5])))); let empty_vec: Option<NonEmpty<&u32>> = NonEmpty::from_vec(vec![]); assert!(empty_vec.is_none());
pub fn split_first(&self) -> (&T, &[T])
[src]
Deconstruct a NonEmpty
into its head and tail.
This operation never fails since we are guranteed
to have a head element.
Example Use
use nonempty::NonEmpty; let mut non_empty = NonEmpty::from((1, vec![2, 3, 4, 5])); // Guaranteed to have the head and we also get the tail. assert_eq!(non_empty.split_first(), (&1, &[2, 3, 4, 5][..])); let non_empty = NonEmpty::new(1); // Guaranteed to have the head element. assert_eq!(non_empty.split_first(), (&1, &[][..]));
pub fn split(&self) -> (&T, &[T], &T)
[src]
Deconstruct a NonEmpty
into its first, last, and
middle elements, in that order.
If there is only one element then first == last.
Example Use
use nonempty::NonEmpty; let mut non_empty = NonEmpty::from((1, vec![2, 3, 4, 5])); // Guaranteed to have the last element and the elements // preceding it. assert_eq!(non_empty.split(), (&1, &[2, 3, 4][..], &5)); let non_empty = NonEmpty::new(1); // Guaranteed to have the last element. assert_eq!(non_empty.split(), (&1, &[][..], &1));
pub fn append(&mut self, other: &mut Vec<T>)
[src]
Append a Vec
to the tail of the NonEmpty
.
Example Use
use nonempty::NonEmpty; let mut non_empty = NonEmpty::new(1); let mut vec = vec![2, 3, 4, 5]; non_empty.append(&mut vec); let mut expected = NonEmpty::from((1, vec![2, 3, 4, 5])); assert_eq!(non_empty, expected);
pub fn map<U, F>(self, f: F) -> NonEmpty<U> where
F: FnMut(T) -> U,
[src]
F: FnMut(T) -> U,
A structure preserving map
. This is useful for when
we wish to keep the NonEmpty
structure guaranteeing
that there is at least one element. Otherwise, we can
use nonempty.iter().map(f)
.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::from((1, vec![2, 3, 4, 5])); let squares = non_empty.map(|i| i * i); let expected = NonEmpty::from((1, vec![4, 9, 16, 25])); assert_eq!(squares, expected);
pub fn flat_map<U, F>(self, f: F) -> NonEmpty<U> where
F: FnMut(T) -> NonEmpty<U>,
[src]
F: FnMut(T) -> NonEmpty<U>,
When we have a function that goes from some T
to a NonEmpty<U>
,
we may want to apply it to a NonEmpty<T>
but keep the structure flat.
This is where flat_map
shines.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::from((1, vec![2, 3, 4, 5])); let windows = non_empty.flat_map(|i| { let mut next = NonEmpty::new(i + 5); next.push(i + 6); next }); let expected = NonEmpty::from((6, vec![7, 7, 8, 8, 9, 9, 10, 10, 11])); assert_eq!(windows, expected);
pub fn flatten(full: NonEmpty<NonEmpty<T>>) -> Self
[src]
Flatten nested NonEmpty
s into a single one.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::from(( NonEmpty::from((1, vec![2, 3])), vec![NonEmpty::from((4, vec![5]))], )); let expected = NonEmpty::from((1, vec![2, 3, 4, 5])); assert_eq!(NonEmpty::flatten(non_empty), expected);
pub fn binary_search(&self, x: &T) -> Result<usize, usize> where
T: Ord,
[src]
T: Ord,
Binary searches this sorted non-empty vector for a given element.
If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned.
If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::from((0, vec![1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55])); assert_eq!(non_empty.binary_search(&0), Ok(0)); assert_eq!(non_empty.binary_search(&13), Ok(9)); assert_eq!(non_empty.binary_search(&4), Err(7)); assert_eq!(non_empty.binary_search(&100), Err(13)); let r = non_empty.binary_search(&1); assert!(match r { Ok(1..=4) => true, _ => false, });
If you want to insert an item to a sorted non-empty vector, while maintaining sort order:
use nonempty::NonEmpty; let mut non_empty = NonEmpty::from((0, vec![1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55])); let num = 42; let idx = non_empty.binary_search(&num).unwrap_or_else(|x| x); non_empty.insert(idx, num); assert_eq!(non_empty, NonEmpty::from((0, vec![1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55])));
pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize> where
F: FnMut(&'a T) -> Ordering,
[src]
F: FnMut(&'a T) -> Ordering,
Binary searches this sorted non-empty with a comparator function.
The comparator function should implement an order consistent with the sort order of the underlying slice, returning an order code that indicates whether its argument is Less, Equal or Greater the desired target.
If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1,4].
use nonempty::NonEmpty; let non_empty = NonEmpty::from((0, vec![1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55])); let seek = 0; assert_eq!(non_empty.binary_search_by(|probe| probe.cmp(&seek)), Ok(0)); let seek = 13; assert_eq!(non_empty.binary_search_by(|probe| probe.cmp(&seek)), Ok(9)); let seek = 4; assert_eq!(non_empty.binary_search_by(|probe| probe.cmp(&seek)), Err(7)); let seek = 100; assert_eq!(non_empty.binary_search_by(|probe| probe.cmp(&seek)), Err(13)); let seek = 1; let r = non_empty.binary_search_by(|probe| probe.cmp(&seek)); assert!(match r { Ok(1..=4) => true, _ => false, });
pub fn binary_search_by_key<'a, B, F>(
&'a self,
b: &B,
f: F
) -> Result<usize, usize> where
B: Ord,
F: FnMut(&'a T) -> B,
[src]
&'a self,
b: &B,
f: F
) -> Result<usize, usize> where
B: Ord,
F: FnMut(&'a T) -> B,
Binary searches this sorted non-empty vector with a key extraction function.
Assumes that the vector is sorted by the key.
If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements in a non-empty vector of pairs sorted by their second elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].
use nonempty::NonEmpty; let non_empty = NonEmpty::from(( (0, 0), vec![(2, 1), (4, 1), (5, 1), (3, 1), (1, 2), (2, 3), (4, 5), (5, 8), (3, 13), (1, 21), (2, 34), (4, 55)] )); assert_eq!(non_empty.binary_search_by_key(&0, |&(a,b)| b), Ok(0)); assert_eq!(non_empty.binary_search_by_key(&13, |&(a,b)| b), Ok(9)); assert_eq!(non_empty.binary_search_by_key(&4, |&(a,b)| b), Err(7)); assert_eq!(non_empty.binary_search_by_key(&100, |&(a,b)| b), Err(13)); let r = non_empty.binary_search_by_key(&1, |&(a,b)| b); assert!(match r { Ok(1..=4) => true, _ => false, });
pub fn maximum(&self) -> &T where
T: Ord,
[src]
T: Ord,
Returns the maximum element in the non-empty vector.
This will return the first item in the vector if the tail is empty.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::new(42); assert_eq!(non_empty.maximum(), &42); let non_empty = NonEmpty::from((1, vec![-34, 42, 76, 4, 5])); assert_eq!(non_empty.maximum(), &76);
pub fn minimum(&self) -> &T where
T: Ord,
[src]
T: Ord,
Returns the minimum element in the non-empty vector.
This will return the first item in the vector if the tail is empty.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::new(42); assert_eq!(non_empty.minimum(), &42); let non_empty = NonEmpty::from((1, vec![-34, 42, 76, 4, 5])); assert_eq!(non_empty.minimum(), &-34);
pub fn maximum_by<F>(&self, compare: F) -> &T where
F: Fn(&T, &T) -> Ordering,
[src]
F: Fn(&T, &T) -> Ordering,
Returns the element that gives the maximum value with respect to the specified comparison function.
This will return the first item in the vector if the tail is empty.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::new((0, 42)); assert_eq!(non_empty.maximum_by(|(k, _), (l, _)| k.cmp(l)), &(0, 42)); let non_empty = NonEmpty::from(((2, 1), vec![(2, -34), (4, 42), (0, 76), (1, 4), (3, 5)])); assert_eq!(non_empty.maximum_by(|(k, _), (l, _)| k.cmp(l)), &(4, 42));
pub fn minimum_by<F>(&self, compare: F) -> &T where
F: Fn(&T, &T) -> Ordering,
[src]
F: Fn(&T, &T) -> Ordering,
Returns the element that gives the minimum value with respect to the specified comparison function.
This will return the first item in the vector if the tail is empty.
use nonempty::NonEmpty; let non_empty = NonEmpty::new((0, 42)); assert_eq!(non_empty.minimum_by(|(k, _), (l, _)| k.cmp(l)), &(0, 42)); let non_empty = NonEmpty::from(((2, 1), vec![(2, -34), (4, 42), (0, 76), (1, 4), (3, 5)])); assert_eq!(non_empty.minimum_by(|(k, _), (l, _)| k.cmp(l)), &(0, 76));
pub fn maximum_by_key<U, F>(&self, f: F) -> &T where
U: Ord,
F: Fn(&T) -> &U,
[src]
U: Ord,
F: Fn(&T) -> &U,
Returns the element that gives the maximum value with respect to the specified function.
This will return the first item in the vector if the tail is empty.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::new((0, 42)); assert_eq!(non_empty.maximum_by_key(|(k, _)| k), &(0, 42)); let non_empty = NonEmpty::from(((2, 1), vec![(2, -34), (4, 42), (0, 76), (1, 4), (3, 5)])); assert_eq!(non_empty.maximum_by_key(|(k, _)| k), &(4, 42));
pub fn minimum_by_key<U, F>(&self, f: F) -> &T where
U: Ord,
F: Fn(&T) -> &U,
[src]
U: Ord,
F: Fn(&T) -> &U,
Returns the element that gives the minimum value with respect to the specified function.
This will return the first item in the vector if the tail is empty.
Examples
use nonempty::NonEmpty; let non_empty = NonEmpty::new((0, 42)); assert_eq!(non_empty.minimum_by_key(|(k, _)| k), &(0, 42)); let non_empty = NonEmpty::from(((2, 1), vec![(2, -34), (4, 42), (0, 76), (1, 4), (3, 5)])); assert_eq!(non_empty.minimum_by_key(|(k, _)| k), &(0, 76));
Trait Implementations
impl<T: Clone> Clone for NonEmpty<T>
[src]
impl<T: Debug> Debug for NonEmpty<T>
[src]
impl<T: Eq> Eq for NonEmpty<T>
[src]
impl<T> From<(T, Vec<T>)> for NonEmpty<T>
[src]
fn from((head, tail): (T, Vec<T>)) -> Self
[src]
Turns a pair of an element and a Vec into a NonEmpty.
impl<T> From<NonEmpty<T>> for Vec<T>
[src]
impl<T> From<NonEmpty<T>> for (T, Vec<T>)
[src]
impl<T: Hash> Hash for NonEmpty<T>
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T> IntoIterator for NonEmpty<T>
[src]
type Item = T
The type of the elements being iterated over.
type IntoIter = Chain<Once<T>, IntoIter<Self::Item>>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<T: Ord> Ord for NonEmpty<T>
[src]
fn cmp(&self, other: &NonEmpty<T>) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T: PartialEq> PartialEq<NonEmpty<T>> for NonEmpty<T>
[src]
impl<T: PartialOrd> PartialOrd<NonEmpty<T>> for NonEmpty<T>
[src]
fn partial_cmp(&self, other: &NonEmpty<T>) -> Option<Ordering>
[src]
fn lt(&self, other: &NonEmpty<T>) -> bool
[src]
fn le(&self, other: &NonEmpty<T>) -> bool
[src]
fn gt(&self, other: &NonEmpty<T>) -> bool
[src]
fn ge(&self, other: &NonEmpty<T>) -> bool
[src]
impl<T> StructuralEq for NonEmpty<T>
[src]
impl<T> StructuralPartialEq for NonEmpty<T>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for NonEmpty<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for NonEmpty<T> where
T: Send,
T: Send,
impl<T> Sync for NonEmpty<T> where
T: Sync,
T: Sync,
impl<T> Unpin for NonEmpty<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for NonEmpty<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,