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) -> Self
impl<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