FromIterator in core::iter - Rust
Description: Conversion from an `Iterator`.

# Trait FromIterator

1.6.0 · Source

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

Expand description

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.

If you want to create a collection from the contents of an iterator, the `Iterator::collect()` method is preferred. However, when you need to specify the container type, `FromIterator::from_iter()` can be more readable than using a turbofish (e.g. `::<Vec<_>>()`). See the `Iterator::collect()` documentation for more examples of its use.

See also: `IntoIterator`.

## §Examples

Basic usage:

    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 `Iterator::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]);

Using `FromIterator::from_iter()` as a more readable alternative to `Iterator::collect()`:

    use std::collections::VecDeque;
    let first = (0..10).collect::<VecDeque<i32>>();
    let second = VecDeque::from_iter(0..10);

    assert_eq!(first, second);

Implementing `FromIterator` for your type:

    // 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§

1.0.0 · Source

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

Creates a value from an iterator.

See the module-level documentation for more.

##### §Examples

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

## 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.

## Implementors§

1.23.0 · Source§

### 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());

1.0.0 · Source§

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

1.79.0 · Source§

### impl<A, EA> FromIterator<(EA₁, EA₂, …, EAₙ)> for (A₁, A₂, …, Aₙ)
where A: Default + Extend<EA>,

This implementation turns an iterator of tuples into a tuple of types which implement `Default` and `Extend`.

This is similar to `Iterator::unzip`, but is also composable with other `FromIterator` implementations:

    let string = "1,2,123,4";

    // Example given for a 2-tuple, but 1- through 12-tuples are supported
    let (numbers, lengths): (Vec<_>, Vec<_>) = string
        .split(',')
        .map(|s| s.parse().map(|n: u32| (n, s.len())))
        .collect::<Result<_, _>>()?;

    assert_eq!(numbers, [1, 2, 123, 4]);
    assert_eq!(lengths, [1, 1, 3, 1]);

This trait is implemented for tuples up to twelve items long. The `impl`s for 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.

1.0.0 · Source§

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