Trait std::iter::FromIterator

pub trait FromIterator<A> {
    fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item=A>;
}

Conversion from an Iterator.

By implementing FromIterator for a type, you define how it will be created from an iterator. This is common for types which describe a collection of some kind.

FromIterator's from_iter() is rarely called explicitly, and is instead used through Iterator's collect() method. See collect()'s documentation for more examples.

See also: IntoIterator.

Examples

Basic usage:

use std::iter::FromIterator;

let five_fives = std::iter::repeat(5).take(5);

let v = Vec::from_iter(five_fives);

assert_eq!(v, vec![5, 5, 5, 5, 5]);

Using collect() to implicitly use FromIterator:

let five_fives = std::iter::repeat(5).take(5);

let v: Vec<i32> = five_fives.collect();

assert_eq!(v, vec![5, 5, 5, 5, 5]);

Implementing FromIterator for your type:

use std::iter::FromIterator;

// A sample collection, that's just a wrapper over Vec<T>
#[derive(Debug)]
struct MyCollection(Vec<i32>);

// Let's give it some methods so we can create one and add things
// to it.
impl MyCollection {
    fn new() -> MyCollection {
        MyCollection(Vec::new())
    }

    fn add(&mut self, elem: i32) {
        self.0.push(elem);
    }
}

// and we'll implement FromIterator
impl FromIterator<i32> for MyCollection {
    fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {
        let mut c = MyCollection::new();

        for i in iter {
            c.add(i);
        }

        c
    }
}

// Now we can make a new iterator...
let iter = (0..5).into_iter();

// ... and make a MyCollection out of it
let c = MyCollection::from_iter(iter);

assert_eq!(c.0, vec![0, 1, 2, 3, 4]);

// collect works too!

let iter = (0..5).into_iter();
let c: MyCollection = iter.collect();

assert_eq!(c.0, vec![0, 1, 2, 3, 4]);

Required Methods

use std::iter::FromIterator;

let five_fives = std::iter::repeat(5).take(5);

let v = Vec::from_iter(five_fives);

assert_eq!(v, vec![5, 5, 5, 5, 5]);

Implementors

• impl<T> FromIterator<T> for BinaryHeap<T> where T: Ord
• impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V> where K: Ord
• impl<T> FromIterator<T> for BTreeSet<T> where T: Ord
• impl<E> FromIterator<E> for EnumSet<E> where E: CLike
• impl<T> FromIterator<T> for LinkedList<T>
• impl FromIterator<char> for std::string::String
• impl<'a> FromIterator<&'a str> for std::string::String
• impl FromIterator<String> for std::string::String
• impl<'a> FromIterator<char> for std::borrow::Cow<'a, str>
• impl<'a, 'b> FromIterator<&'b str> for std::borrow::Cow<'a, str>
• impl<'a> FromIterator<String> for std::borrow::Cow<'a, str>
• impl<T> FromIterator<T> for Vec<T>
• impl<'a, T> FromIterator<T> for std::borrow::Cow<'a, [T]> where T: Clone
• impl<A> FromIterator<A> for VecDeque<A>
• impl<A, V> FromIterator<Option<A>> for Option<V> where V: FromIterator<A>
• impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E> where V: FromIterator<A>
• impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where K: Eq + Hash,
        S: BuildHasher + Default
• impl<T, S> FromIterator<T> for HashSet<T, S> where T: Eq + Hash,
        S: BuildHasher + Default
• impl<P: AsRef<Path>> FromIterator<P> for PathBuf