1.0.0[−][src]Trait core::iter::FromIterator
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]);Run
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]);Run
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]);Run
Required Methods
fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self
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]);Run
Implementors
impl FromIterator<()> for ()[src]
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());Run
fn from_iter<I: IntoIterator<Item = ()>>(iter: I) -> Self[src]
fn from_iter<I: IntoIterator<Item = ()>>(iter: I) -> Selfimpl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E>[src]
impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E>fn from_iter<I: IntoIterator<Item = Result<A, E>>>(iter: I) -> Result<V, E>[src]
fn from_iter<I: IntoIterator<Item = Result<A, E>>>(iter: I) -> Result<V, 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]));Run
impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V>[src]
impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V>fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V>[src]
fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V>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.
Here is an example which increments every integer in a vector, checking for overflow:
use std::u16; let v = vec![1, 2]; let res: Option<Vec<u16>> = v.iter().map(|&x: &u16| if x == u16::MAX { None } else { Some(x + 1) } ).collect(); assert!(res == Some(vec![2, 3]));Run