Trait nonempty_collections::iter::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.

Object Safety

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<T> FromNonEmptyIterator<T> for Vec<T>

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

where I: IntoNonEmptyIterator<Item = T>,

impl<T: Eq + Hash> FromNonEmptyIterator<T> for HashSet<T>

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' => 1, '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' => 1, '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.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.iter().cloned().collect();
assert_eq!(s0, s1);