Trait nom::lib::std::iter::FromIterator1.0.0[−][src]

pub trait FromIterator<A> {
    pub 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::from_iter() is rarely called explicitly, and is instead used through Iterator::collect() method. See Iterator::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 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]);

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

pub fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = A>, [src][−]

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 FromIterator<()> for ()1.23.0[src][+]

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

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E> where
    V: FromIterator<A>, [src][+]

pub fn from_iter<I>(iter: I) -> Result<V, E> where
    I: IntoIterator<Item = Result<A, E>>, [src][−]

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_eq!(res, Ok(vec![2, 3]));

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

let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));

Here is a variation on the previous example, showing that no further elements are taken from iter after the first Err.

let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);

Since the third element caused an underflow, no further elements were taken, so the final value of shared is 6 (= 3 + 2 + 1), not 16.

impl<A, V> FromIterator<Option<A>> for Option<V> where
    V: FromIterator<A>, [src][+]

pub fn from_iter<I>(iter: I) -> Option<V> where
    I: IntoIterator<Item = Option<A>>, [src][−]

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 of add that returns None 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.

Here is a variation on the previous example, showing that no further elements are taken from iter after the first None.

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

let mut shared = 0;

let res: Option<Vec<u16>> = items
    .iter()
    .map(|x| { shared += x; x.checked_sub(2) })
    .collect();

assert_eq!(res, None);
assert_eq!(shared, 6);

Since the third element caused an underflow, no further elements were taken, so the final value of shared is 6 (= 3 + 2 + 1), not 16.

impl FromIterator<Sides> for Sides

impl<T> FromIterator<Steal<T>> for Steal<T>

impl FromIterator<ColorMask> for ColorMask

impl FromIterator<Mirror> for Mirror

impl FromIterator<Access> for Access

impl FromIterator<Bind> for Bind

impl FromIterator<Usage> for Usage

impl FromIterator<DepthStencilFlags> for DepthStencilFlags

impl FromIterator<ModifierKey> for ModifierKey

impl FromIterator<AtFlags> for AtFlags

impl FromIterator<OFlag> for OFlag

impl FromIterator<SealFlag> for SealFlag

impl FromIterator<FdFlag> for FdFlag

impl FromIterator<SpliceFFlags> for SpliceFFlags

impl FromIterator<FallocateFlags> for FallocateFlags

impl FromIterator<ModuleInitFlags> for ModuleInitFlags

impl FromIterator<DeleteModuleFlags> for DeleteModuleFlags

impl FromIterator<MsFlags> for MsFlags

impl FromIterator<MntFlags> for MntFlags

impl FromIterator<MQ_OFlag> for MQ_OFlag

impl FromIterator<FdFlag> for FdFlag

impl FromIterator<InterfaceFlags> for InterfaceFlags

impl FromIterator<PollFlags> for PollFlags

impl FromIterator<CloneFlags> for CloneFlags

impl FromIterator<EpollFlags> for EpollFlags

impl FromIterator<EpollCreateFlags> for EpollCreateFlags

impl FromIterator<EfdFlags> for EfdFlags

impl FromIterator<MemFdCreateFlag> for MemFdCreateFlag

impl FromIterator<ProtFlags> for ProtFlags

impl FromIterator<MapFlags> for MapFlags

impl FromIterator<MRemapFlags> for MRemapFlags

impl FromIterator<MsFlags> for MsFlags

impl FromIterator<MlockAllFlags> for MlockAllFlags

impl FromIterator<Persona> for Persona

impl FromIterator<Options> for Options

impl FromIterator<QuotaValidFlags> for QuotaValidFlags

impl FromIterator<SaFlags> for SaFlags

impl FromIterator<SfdFlags> for SfdFlags

impl FromIterator<SockFlag> for SockFlag

impl FromIterator<MsgFlags> for MsgFlags

impl FromIterator<SFlag> for SFlag

impl FromIterator<Mode> for Mode

impl FromIterator<FsFlags> for FsFlags

impl FromIterator<InputFlags> for InputFlags

impl FromIterator<OutputFlags> for OutputFlags

impl FromIterator<ControlFlags> for ControlFlags

impl FromIterator<LocalFlags> for LocalFlags

impl FromIterator<WaitPidFlag> for WaitPidFlag

impl FromIterator<AddWatchFlags> for AddWatchFlags

impl FromIterator<InitFlags> for InitFlags

impl FromIterator<TimerFlags> for TimerFlags

impl FromIterator<TimerSetTimeFlags> for TimerSetTimeFlags

impl FromIterator<AccessFlags> for AccessFlags

impl FromIterator<Transformations> for Transformations

impl FromIterator<TokenTree> for TokenStream

impl FromIterator<TokenStream> for TokenStream

impl<A: Array> FromIterator<<A as Array>::Item> for SmallVec<A>

impl<T, P> FromIterator<T> for Punctuated<T, P> where
    P: Default, 

impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P>

impl FromIterator<DndAction> for DndAction

impl FromIterator<Resize> for Resize

impl FromIterator<Transient> for Transient

impl FromIterator<Capability> for Capability

impl FromIterator<Mode> for Mode

impl FromIterator<ContentHint> for ContentHint

impl FromIterator<Anchor> for Anchor

impl FromIterator<Gravity> for Gravity

impl FromIterator<ConstraintAdjustment> for ConstraintAdjustment

impl FromIterator<Anchor> for Anchor

impl FromIterator<Flags> for Flags

impl FromIterator<Kind> for Kind

impl FromIterator<ConstraintAdjustment> for ConstraintAdjustment

impl FromIterator<ModifiersState> for ModifiersState