# Trait bitflags::__core::iter::FromIterator [−] [src]

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

## Implementors

- `impl<K, V, S> FromIterator for HashMap<K, V, S> where K: Eq + Hash, S: BuildHasher + Default`
- `impl<T, S> FromIterator for HashSet<T, S> where T: Eq + Hash, S: BuildHasher + Default`
- `impl<A> FromIterator for LinkedList<A>`
- `impl<A> FromIterator for VecDeque<A>`
- `impl<T> FromIterator for BinaryHeap<T> where T: Ord`
- `impl<P> FromIterator for PathBuf where P: AsRef<Path>`
- `impl<T> FromIterator for Vec<T>`
- `impl<'a, T> FromIterator for Cow<'a, [T]> where T: Clone`
- `impl FromIterator for String`
- `impl<'a> FromIterator for String`
- `impl FromIterator for String`
- `impl<A, E, V> FromIterator for Result<V, E> where V: FromIterator<A>`
- `impl<A, V> FromIterator for Option<V> where V: FromIterator<A>`
- `impl<K, V> FromIterator for BTreeMap<K, V> where K: Ord`
- `impl<T> FromIterator for BTreeSet<T> where T: Ord`
- `impl<E> FromIterator for EnumSet<E> where E: CLike`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)