Trait FromNonEmptyIterator

pub trait FromNonEmptyIterator<T>: Sized {
    // Required method
    fn from_nonempty_iter<I>(iter: I) -> Self
       where I: IntoNonEmptyIterator<Item = T>;
}

Conversion from a NonEmptyIterator.

Required Methods

fn from_nonempty_iter<I>(iter: I) -> Self

where I: IntoNonEmptyIterator<Item = T>,

Creates a value from a NonEmptyIterator.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<A, E, V> FromNonEmptyIterator<Result<A, E>> for Result<V, E>

where V: FromNonEmptyIterator<A>,

fn from_nonempty_iter<I>(iter: I) -> Result<V, E>

where I: IntoNonEmptyIterator<Item = Result<A, E>>,

impl<K, V, S> FromNonEmptyIterator<(K, V)> for HashMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Default,

fn from_nonempty_iter<I>(iter: I) -> Self

where I: IntoNonEmptyIterator<Item = (K, V)>,

impl<T> FromNonEmptyIterator<T> for Vec<T>

fn from_nonempty_iter<I>(iter: I) -> Self

where I: IntoNonEmptyIterator<Item = T>,

impl<T, S> FromNonEmptyIterator<T> for HashSet<T, S>

where T: Eq + Hash, S: BuildHasher + Default,

fn from_nonempty_iter<I>(iter: I) -> Self

where I: IntoNonEmptyIterator<Item = T>,

Implementors

impl<K, V, S> FromNonEmptyIterator<(K, V)> for NEIndexMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Default,

use nonempty_collections::*;

let v = nev![('a', 1), ('b', 2), ('c', 3), ('a', 4)];
let m0 = v.into_nonempty_iter().collect::<NEIndexMap<_, _>>();
let m1 = ne_indexmap! {'a' => 4, 'b' => 2, 'c' => 3};
assert_eq!(m0, m1);

impl<K, V, S> FromNonEmptyIterator<(K, V)> for NEMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Default,

use nonempty_collections::*;

let v = nev![('a', 1), ('b', 2), ('c', 3), ('a', 4)];
let m0: NEMap<_, _> = v.into_nonempty_iter().collect();
let m1: NEMap<_, _> = nem!['a' => 4, 'b' => 2, 'c' => 3];
assert_eq!(m0, m1);

impl<T> FromNonEmptyIterator<T> for NEVec<T>

use nonempty_collections::*;

let v0 = nev![1, 2, 3];
let v1: NEVec<_> = v0.nonempty_iter().cloned().collect();
assert_eq!(v0, v1);

impl<T, S> FromNonEmptyIterator<T> for NESet<T, S>

where T: Eq + Hash, S: BuildHasher + Default,

use nonempty_collections::*;

let s0 = nes![1, 2, 3];
let s1: NESet<_> = s0.nonempty_iter().cloned().collect();
assert_eq!(s0, s1);