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

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = A>, 

Creates a value from an iterator.

See the module-level documentation for more.

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]);

Loading content...

Implementors

impl FromIterator<char> for String

fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = char>, 

impl FromIterator<()> for ()

Collapses all unit items from an iterator into one.

This is more useful when combined with higher-level abstractions, like collecting to a Result<(), E> where you only care about errors:

use std::io::*;
let data = vec![1, 2, 3, 4, 5];
let res: Result<()> = data.iter()
    .map(|x| writeln!(stdout(), "{}", x))
    .collect();
assert!(res.is_ok());

fn from_iter<I>(iter: I) where
    I: IntoIterator<Item = ()>, 

impl FromIterator<String> for String

fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = String>, 

impl<'a> FromIterator<&'a char> for String

fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = &'a char>, 

impl<'a> FromIterator<&'a str> for String

fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = &'a str>, 

impl<'a> FromIterator<Cow<'a, str>> for String

fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = Cow<'a, str>>, 

impl<'a> FromIterator<char> for Cow<'a, str>

fn from_iter<I>(it: I) -> Cow<'a, str> where
    I: IntoIterator<Item = char>, 

impl<'a> FromIterator<String> for Cow<'a, str>

fn from_iter<I>(it: I) -> Cow<'a, str> where
    I: IntoIterator<Item = String>, 

impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

fn from_iter<I>(it: I) -> Cow<'a, str> where
    I: IntoIterator<Item = &'b str>, 

impl<'a, T> FromIterator<T> for Cow<'a, [T]> where
    T: Clone, 

fn from_iter<I>(it: I) -> Cow<'a, [T]> where
    I: IntoIterator<Item = T>, 

impl<A> FromIterator<A> for Box<[A]>

Important traits for Box<I>

impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<F> Future for Box<F> where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>

fn from_iter<T>(iter: T) -> Box<[A]> where
    T: IntoIterator<Item = A>, 

impl<A> FromIterator<A> for VecDeque<A>

fn from_iter<T>(iter: T) -> VecDeque<A> where
    T: IntoIterator<Item = A>, 

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E> where
    V: FromIterator<A>, 

fn from_iter<I>(iter: I) -> Result<V, E> where
    I: IntoIterator<Item = Result<A, E>>, 

Takes each element in the Iterator: if it is an Err, no further elements are taken, and the Err is returned. Should no Err occur, a container with the values of each Result is returned.

Here is an example which increments every integer in a vector, checking for overflow:

let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert!(res == Ok(vec![2, 3]));

impl<A, V> FromIterator<Option<A>> for Option<V> where
    V: FromIterator<A>, 

fn from_iter<I>(iter: I) -> Option<V> where
    I: IntoIterator<Item = Option<A>>, 

Takes each element in the Iterator: if it is None, no further elements are taken, and the None is returned. Should no None occur, a container with the values of each Option is returned.

Examples

Here is an example which increments every integer in a vector. We use the checked variant ofaddthat returnsNone` when the calculation would result in an overflow.

let items = vec![0_u16, 1, 2];

let res: Option<Vec<u16>> = items
    .iter()
    .map(|x| x.checked_add(1))
    .collect();

assert_eq!(res, Some(vec![1, 2, 3]));

As you can see, this will return the expected, valid items.

Here is another example that tries to subtract one from another list of integers, this time checking for underflow:

let items = vec![2_u16, 1, 0];

let res: Option<Vec<u16>> = items
    .iter()
    .map(|x| x.checked_sub(1))
    .collect();

assert_eq!(res, None);

Since the last element is zero, it would underflow. Thus, the resulting value is None.

impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V> where
    K: Ord, 

fn from_iter<T>(iter: T) -> BTreeMap<K, V> where
    T: IntoIterator<Item = (K, V)>, 

impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher + Default, 

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> HashMap<K, V, S>

impl<P: AsRef<Path>> FromIterator<P> for PathBuf

fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf

impl<T> FromIterator<T> for BinaryHeap<T> where
    T: Ord, 

fn from_iter<I>(iter: I) -> BinaryHeap<T> where
    I: IntoIterator<Item = T>, 

impl<T> FromIterator<T> for BTreeSet<T> where
    T: Ord, 

fn from_iter<I>(iter: I) -> BTreeSet<T> where
    I: IntoIterator<Item = T>, 

impl<T> FromIterator<T> for LinkedList<T>

fn from_iter<I>(iter: I) -> LinkedList<T> where
    I: IntoIterator<Item = T>, 

impl<T> FromIterator<T> for Vec<T>

Important traits for Vec<u8>

impl Write for Vec<u8>

fn from_iter<I>(iter: I) -> Vec<T> where
    I: IntoIterator<Item = T>, 

impl<T, S> FromIterator<T> for HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher + Default, 

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> HashSet<T, S>

Loading content...