Struct NonEmptyVec 

pub struct NonEmptyVec<T> {
    pub head: T,
    pub tail: Vec<T>,
}

A Non-empty growable vector.

Non-emptiness can be a powerful guarantee. If your main use of Vec is as an Iterator, then you may not need to distinguish on emptiness. But there are indeed times when the Vec you receive as as function argument needs to be non-empty or your function can’t proceed. Similarly, there are times when the Vec you return to a calling user needs to promise it actually contains something.

With NonEmptyVec, you’re freed from the boilerplate of constantly needing to check is_empty() or pattern matching before proceeding, or erroring if you can’t. So overall, code, type signatures, and logic become cleaner.

Consider that unlike Vec, NonEmptyVec::first and NonEmptyVec::last don’t return in Option, they always succeed.

Examples

The simplest way to construct a NonEmptyVec is via the non_empty_vec macro:

use rama_utils::collections::{NonEmptyVec, non_empty_vec};

let l: NonEmptyVec<u32> = non_empty_vec![1, 2, 3];
assert_eq!(l.head, 1);

Unlike the familiar vec! macro, non_empty_vec! requires at least one element:

use rama_utils::collections::non_empty_vec;

let l = non_empty_vec![1];

// Doesn't compile!
// let l = non_empty_vec![];

Like Vec, you can also construct a NonEmptyVec the old fashioned way with NonEmptyVec::new.

Caveats

Since NonEmptyVec must have a least one element, it is not possible to implement the FromIterator trait for it. We can’t know, in general, if any given Iterator actually contains something.

Fields

head: T

tail: Vec<T>

Implementations

impl<T> NonEmptyVec<T>

pub const fn new(e: T) -> NonEmptyVec<T>

Available on crate features grpc and http and std only.

Alias for NonEmptyVec::singleton.

pub fn to_ref(&self) -> NonEmptyVec<&T>

Available on crate features grpc and http and std only.

Converts from &NonEmptyVec<T> to NonEmptyVec<&T>, allocating a new tail of borrows. Named to_ (not as_) because it is not a free view.

pub fn collect<I>(iter: I) -> Option<NonEmptyVec<T>>

where I: IntoIterator<Item = T>,

Available on crate features grpc and http and std only.

Attempt to convert an iterator into a NonEmptyVec vector. Returns None if the iterator was empty.

pub const fn singleton(head: T) -> NonEmptyVec<T>

Available on crate features grpc and http and std only.

Create a new non-empty list with an initial element.

pub const fn is_empty(&self) -> bool

Available on crate features grpc and http and std only.

Always returns false.

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

Available on crate features grpc and http and std only.

Get the first element. Never fails.

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

Available on crate features grpc and http and std only.

Get the mutable reference to the first element. Never fails.

Examples

use rama_utils::collections::NonEmptyVec;

let mut non_empty = NonEmptyVec::new(42);
let head = non_empty.first_mut();
*head += 1;
assert_eq!(non_empty.first(), &43);

let mut non_empty = NonEmptyVec::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]

Available on crate features grpc and http and std only.

Get the possibly-empty tail of the list.

use rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new(42);
assert_eq!(non_empty.tail(), &[]);

let non_empty = NonEmptyVec::from((1, vec![4, 2, 3]));
assert_eq!(non_empty.tail(), &[4, 2, 3]);

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

Available on crate features grpc and http and std only.

Push an element to the end of the list.

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

Available on crate features grpc and http and std only.

Pop an element from the end of the list.

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

Available on crate features grpc and http and std only.

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

Panics

Panics if index > len.

Examples

use rama_utils::collections::NonEmptyVec;

let mut non_empty = NonEmptyVec::from((1, vec![2, 3]));
non_empty.insert(1, 4);
assert_eq!(non_empty, NonEmptyVec::from((1, vec![4, 2, 3])));
non_empty.insert(4, 5);
assert_eq!(non_empty, NonEmptyVec::from((1, vec![4, 2, 3, 5])));
non_empty.insert(0, 42);
assert_eq!(non_empty, NonEmptyVec::from((42, vec![1, 4, 2, 3, 5])));

pub fn len(&self) -> usize

Available on crate features grpc and http and std only.

Get the length of the list.

pub fn len_nonzero(&self) -> NonZero<usize>

Available on crate features grpc and http and std only.

Gets the length of the list as a NonZeroUsize.

pub fn capacity(&self) -> NonZero<usize>

Available on crate features grpc and http and std only.

Get the capacity of the list.

pub fn last(&self) -> &T

Available on crate features grpc and http and std only.

Get the last element. Never fails.

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

Available on crate features grpc and http and std only.

Get the last element mutably.

pub fn contains(&self, x: &T) -> bool

where T: PartialEq,

Available on crate features grpc and http and std only.

Check whether an element is contained in the list.

use rama_utils::collections::NonEmptyVec;

let mut l = NonEmptyVec::from((42, vec![36, 58]));

assert!(l.contains(&42));
assert!(!l.contains(&101));

pub fn get(&self, index: usize) -> Option<&T>

Available on crate features grpc and http and std only.

Get an element by index.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Available on crate features grpc and http and std only.

Get an element by index, mutably.

pub fn truncate(&mut self, len: NonZero<usize>)

Available on crate features grpc and http and std only.

Truncate the list to a certain size. Must be greater than 0.

pub fn iter(&self) -> NonEmptyVecIter<'_, T>

Available on crate features grpc and http and std only.

use rama_utils::collections::NonEmptyVec;

let mut l = NonEmptyVec::from((42, vec![36, 58]));

let mut l_iter = l.iter();

assert_eq!(l_iter.len(), 3);
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(&mut self) -> impl DoubleEndedIterator

Available on crate features grpc and http and std only.

use rama_utils::collections::NonEmptyVec;

let mut l = NonEmptyVec::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<NonEmptyVec<T>>

where T: Clone,

Available on crate features grpc and http and std only.

Often we have a Vec (or slice &[T]) but want to ensure that it is NonEmptyVec before proceeding with a computation. Using from_slice will give us a proof that we have a NonEmptyVec in the Some branch, otherwise it allows the caller to handle the None case.

Example Use

use rama_utils::collections::NonEmptyVec;

let non_empty_vec = NonEmptyVec::from_slice(&[1, 2, 3, 4, 5]);
assert_eq!(non_empty_vec, Some(NonEmptyVec::from((1, vec![2, 3, 4, 5]))));

let empty_vec: Option<NonEmptyVec<&u32>> = NonEmptyVec::from_slice(&[]);
assert!(empty_vec.is_none());

pub fn from_vec(vec: Vec<T>) -> Option<NonEmptyVec<T>>

Available on crate features grpc and http and std only.

Often we have a Vec (or slice &[T]) but want to ensure that it is NonEmptyVec before proceeding with a computation. Using from_vec will give us a proof that we have a NonEmptyVec 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 NonEmptyVec::from_slice.

Example Use

use rama_utils::collections::NonEmptyVec;

let non_empty_vec = NonEmptyVec::from_vec(vec![1, 2, 3, 4, 5]);
assert_eq!(non_empty_vec, Some(NonEmptyVec::from((1, vec![2, 3, 4, 5]))));

let empty_vec: Option<NonEmptyVec<&u32>> = NonEmptyVec::from_vec(vec![]);
assert!(empty_vec.is_none());

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

Available on crate features grpc and http and std only.

Deconstruct a NonEmptyVec into its head and tail. This operation never fails since we are guaranteed to have a head element.

Example Use

use rama_utils::collections::NonEmptyVec;

let mut non_empty = NonEmptyVec::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 = NonEmptyVec::new(1);

// Guaranteed to have the head element.
assert_eq!(non_empty.split_first(), (&1, &[][..]));

pub fn split(&self) -> (&T, &[T], Option<&T>)

Available on crate features grpc and http and std only.

Deconstruct a NonEmptyVec into its first, last, and middle elements, in that order.

If there is only one element then last is None.

Example Use

use rama_utils::collections::NonEmptyVec;

let mut non_empty = NonEmptyVec::from((1, vec![2, 3, 4, 5]));

// When there are two or more elements, the last element is represented
// as a `Some`. Elements preceding it, except for the first, are returned
// in the middle.
assert_eq!(non_empty.split(), (&1, &[2, 3, 4][..], Some(&5)));

let non_empty = NonEmptyVec::new(1);

// The last element is `None` when there's only one element.
assert_eq!(non_empty.split(), (&1, &[][..], None));

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

Available on crate features grpc and http and std only.

Append a Vec to the tail of the NonEmptyVec.

Example Use

use rama_utils::collections::NonEmptyVec;

let mut non_empty = NonEmptyVec::new(1);
let mut vec = vec![2, 3, 4, 5];
non_empty.append(&mut vec);

let mut expected = NonEmptyVec::from((1, vec![2, 3, 4, 5]));

assert_eq!(non_empty, expected);

pub fn map<U, F>(self, f: F) -> NonEmptyVec<U>

where F: FnMut(T) -> U,

Available on crate features grpc and http and std only.

A structure preserving map. This is useful for when we wish to keep the NonEmptyVec structure guaranteeing that there is at least one element. Otherwise, we can use non_empty_vec.iter().map(f).

Examples

use rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::from((1, vec![2, 3, 4, 5]));

let squares = non_empty.map(|i| i * i);

let expected = NonEmptyVec::from((1, vec![4, 9, 16, 25]));

assert_eq!(squares, expected);

pub fn try_map<E, U, F>(self, f: F) -> Result<NonEmptyVec<U>, E>

where F: FnMut(T) -> Result<U, E>,

Available on crate features grpc and http and std only.

A structure preserving, fallible mapping function.

pub fn flat_map<U, F>(self, f: F) -> NonEmptyVec<U>

where F: FnMut(T) -> NonEmptyVec<U>,

Available on crate features grpc and http and std only.

When we have a function that goes from some T to a NonEmptyVec<U>, we may want to apply it to a NonEmptyVec<T> but keep the structure flat. This is where flat_map shines.

Examples

use rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::from((1, vec![2, 3, 4, 5]));

let windows = non_empty.flat_map(|i| {
    let mut next = NonEmptyVec::new(i + 5);
    next.push(i + 6);
    next
});

let expected = NonEmptyVec::from((6, vec![7, 7, 8, 8, 9, 9, 10, 10, 11]));

assert_eq!(windows, expected);

pub fn flatten(full: NonEmptyVec<NonEmptyVec<T>>) -> NonEmptyVec<T>

Available on crate features grpc and http and std only.

Flatten nested NonEmptyVecs into a single one.

Examples

use rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::from((
    NonEmptyVec::from((1, vec![2, 3])),
    vec![NonEmptyVec::from((4, vec![5]))],
));

let expected = NonEmptyVec::from((1, vec![2, 3, 4, 5]));

assert_eq!(NonEmptyVec::flatten(non_empty), expected);

pub fn binary_search(&self, x: &T) -> Result<usize, usize>

where T: Ord,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::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 rama_utils::collections::NonEmptyVec;

let mut non_empty = NonEmptyVec::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, NonEmptyVec::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,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::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,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::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,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new(42);
assert_eq!(non_empty.maximum(), &42);

let non_empty = NonEmptyVec::from((1, vec![-34, 42, 76, 4, 5]));
assert_eq!(non_empty.maximum(), &76);

pub fn minimum(&self) -> &T

where T: Ord,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new(42);
assert_eq!(non_empty.minimum(), &42);

let non_empty = NonEmptyVec::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: FnMut(&T, &T) -> Ordering,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new((0, 42));
assert_eq!(non_empty.maximum_by(|(k, _), (l, _)| k.cmp(l)), &(0, 42));

let non_empty = NonEmptyVec::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: FnMut(&T, &T) -> Ordering,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new((0, 42));
assert_eq!(non_empty.minimum_by(|(k, _), (l, _)| k.cmp(l)), &(0, 42));

let non_empty = NonEmptyVec::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: FnMut(&T) -> U,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new((0, 42));
assert_eq!(non_empty.maximum_by_key(|(k, _)| *k), &(0, 42));

let non_empty = NonEmptyVec::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));
assert_eq!(non_empty.maximum_by_key(|(k, _)| -k), &(0, 76));

pub fn minimum_by_key<U, F>(&self, f: F) -> &T

where U: Ord, F: FnMut(&T) -> U,

Available on crate features grpc and http and std only.

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 rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::new((0, 42));
assert_eq!(non_empty.minimum_by_key(|(k, _)| *k), &(0, 42));

let non_empty = NonEmptyVec::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));
assert_eq!(non_empty.minimum_by_key(|(k, _)| -k), &(4, 42));

pub fn sort(&mut self)

where T: Ord,

Available on crate features grpc and http and std only.

Sorts the NonEmptyVec.

The implementation uses slice::sort for the tail and then checks where the head belongs. If the head is already the smallest element, this should be as fast as sorting a slice. However, if the head needs to be inserted, then it incurs extra cost for removing the new head from the tail and adding the old head at the correct index.

Examples

use rama_utils::collections::non_empty_vec;

let mut non_empty = non_empty_vec![-5, 4, 1, -3, 2];

non_empty.sort();
assert!(non_empty == non_empty_vec![-5, -3, 1, 2, 4]);

pub fn sort_by<F>(&mut self, compare: F)

where F: FnMut(&T, &T) -> Ordering,

Available on crate features grpc and http and std only.

Sorts the NonEmptyVec with a comparator function.

The implementation uses slice::sort_by for the tail and then checks where the head belongs. If the head is already the smallest element, this should be as fast as sorting a slice. However, if the head needs to be inserted, then it incurs extra cost for removing the new head from the tail and adding the old head at the correct index.

Examples

use rama_utils::collections::non_empty_vec;

let mut non_empty = non_empty_vec![-5, 4, 1, -3, 2];

non_empty.sort_by(|a, b| a.cmp(b));
assert!(non_empty == non_empty_vec![-5, -3, 1, 2, 4]);

pub fn sort_by_key<K, F>(&mut self, f: F)

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

Available on crate features grpc and http and std only.

Sorts the NonEmptyVec with a key extraction function.

Examples

use rama_utils::collections::non_empty_vec;

let mut non_empty = non_empty_vec!["bbb", "a", "cccc"];

non_empty.sort_by_key(|s| s.len());
assert!(non_empty == non_empty_vec!["a", "bbb", "cccc"]);

pub fn sort_by_cached_key<K, F>(&mut self, f: F)

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

Available on crate features grpc and http and std only.

Sorts the NonEmptyVec with a key extraction function, caching the keys.

The implementation uses slice::sort_by_cached_key for the tail and then determines where the head belongs using the cached head key.

Examples

use rama_utils::collections::non_empty_vec;

let mut non_empty = non_empty_vec!["bbb", "a", "cccc"];

non_empty.sort_by_cached_key(|s| s.len());
assert!(non_empty == non_empty_vec!["a", "bbb", "cccc"]);

Trait Implementations

impl<T> Clone for NonEmptyVec<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for NonEmptyVec<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for NonEmptyVec<T>

where T: Default,

fn default() -> NonEmptyVec<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for NonEmptyVec<T>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<NonEmptyVec<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> DnsAddressResolver for NonEmptyVec<R>

where R: DnsAddressResolver,

type Error = OpaqueError

Error returned by the DnsAddressResolver

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <NonEmptyVec<R> as DnsAddressResolver>::Error>> + Send

Resolve the ‘A’ records accessible by this resolver for the given Domain into Ipv4Addresses.

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <NonEmptyVec<R> as DnsAddressResolver>::Error>>

Resolve the first ‘A’ record found for the resolver.

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <NonEmptyVec<R> as DnsAddressResolver>::Error>>

Resolve to a pseudo-random ‘A’ record found for the resolver.

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <NonEmptyVec<R> as DnsAddressResolver>::Error>> + Send

Resolve the ‘AAAA’ records accessible by this resolver for the given Domain into Ipv6Addresses.

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <NonEmptyVec<R> as DnsAddressResolver>::Error>>

Resolve the first ‘AAAA’ record found for the resolver.

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <NonEmptyVec<R> as DnsAddressResolver>::Error>>

Resolve to a pseudo-random ‘AAAA’ record found for the resolver.

fn into_box_dns_address_resolver(self) -> BoxDnsAddressResolver

Box this resolver to allow for dynamic dispatch.

impl<R> DnsResolver for NonEmptyVec<R>

where R: DnsResolver,

fn into_box_dns_resolver(self) -> BoxDnsResolver

where Self: Sized,

impl<R> DnsTxtResolver for NonEmptyVec<R>

where R: DnsTxtResolver,

type Error = OpaqueError

Error returned by the DnsTxtResolver

fn lookup_txt( &self, domain: Domain, ) -> impl Stream<Item = Result<Bytes, <NonEmptyVec<R> as DnsTxtResolver>::Error>> + Send

Resolve the ‘TXT’ records accessible by this resolver for the given Domain into Bytes.

fn into_box_dns_txt_resolver(self) -> BoxDnsTxtResolver

Box this resolver to allow for dynamic dispatch.

impl<T> Eq for NonEmptyVec<T>

where T: Eq,

impl<A> Extend<A> for NonEmptyVec<A>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

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<T> From<(T, Vec<T>)> for NonEmptyVec<T>

fn from(_: (T, Vec<T>)) -> NonEmptyVec<T>

Turns a pair of an element and a Vec into a NonEmptyVec.

impl<T> From<NonEmptyVec<T>> for Vec<T>

fn from(non_empty_vec: NonEmptyVec<T>) -> Vec<T>

Turns a non-empty list into a Vec.

impl<T> From<NonEmptyVec<T>> for (T, Vec<T>)

fn from(non_empty_vec: NonEmptyVec<T>) -> (T, Vec<T>)

Turns a non-empty list into a Vec.

impl<T> Hash for NonEmptyVec<T>

where T: Hash,

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

where __H: Hasher,

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<T> Index<usize> for NonEmptyVec<T>

fn index(&self, index: usize) -> &T

use rama_utils::collections::NonEmptyVec;

let non_empty = NonEmptyVec::from((1, vec![2, 3, 4, 5]));

assert_eq!(non_empty[0], 1);
assert_eq!(non_empty[1], 2);
assert_eq!(non_empty[3], 4);

type Output = T

The returned type after indexing.

impl<T> IndexMut<usize> for NonEmptyVec<T>

fn index_mut(&mut self, index: usize) -> &mut T

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

impl<T> IntoIterator for NonEmptyVec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = Chain<Once<T>, IntoIter<<NonEmptyVec<T> as IntoIterator>::Item>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <NonEmptyVec<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a NonEmptyVec<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Chain<Once<&'a T>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a NonEmptyVec<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> Ord for NonEmptyVec<T>

where T: Ord,

fn cmp(&self, other: &NonEmptyVec<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for NonEmptyVec<T>

where T: PartialEq,

fn eq(&self, other: &NonEmptyVec<T>) -> 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<T> PartialOrd for NonEmptyVec<T>

where T: PartialOrd,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T> Serialize for NonEmptyVec<T>

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for NonEmptyVec<T>

where T: PartialEq,

impl<T> TryFrom<Vec<T>> for NonEmptyVec<T>

type Error = NonEmptyVecEmptyError

The type returned in the event of a conversion error.

fn try_from( vec: Vec<T>, ) -> Result<NonEmptyVec<T>, <NonEmptyVec<T> as TryFrom<Vec<T>>>::Error>

Performs the conversion.