Trait otter_api_tests::iter::FromIterator

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>, 

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

Loading content...

Implementations on Foreign Types

impl<'a> FromIterator<Cow<'a, OsStr>> for OsString

pub fn from_iter<I>(iter: I) -> OsString where
    I: IntoIterator<Item = Cow<'a, OsStr>>, 

impl FromIterator<OsString> for OsString

pub fn from_iter<I>(iter: I) -> OsString where
    I: IntoIterator<Item = OsString>, 

impl<'a> FromIterator<&'a OsStr> for OsString

pub fn from_iter<I>(iter: I) -> OsString where
    I: IntoIterator<Item = &'a OsStr>, 

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

pub fn from_iter<I>(iter: I) where
    I: IntoIterator<Item = ()>, 

impl<'a> FromIterator<&'a char> for String

pub fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = &'a char>, 

impl<'a> FromIterator<Cow<'a, str>> for String

pub fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = Cow<'a, str>>, 

impl FromIterator<char> for String

pub fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = char>, 

impl<I> FromIterator<I> for Box<[I], Global>

pub fn from_iter<T>(iter: T) -> Box<[I], Global> where
    T: IntoIterator<Item = I>, 

impl<T> FromIterator<T> for Rc<[T]>

pub fn from_iter<I>(iter: I) -> Rc<[T]> where
    I: IntoIterator<Item = T>, 

Takes each element in the Iterator and collects it into an Rc<[T]>.

Performance characteristics

The general case

In the general case, collecting into Rc<[T]> is done by first collecting into a Vec<T>. That is, when writing the following:

let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect();

this behaves as if we wrote:

let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0)
    .collect::<Vec<_>>() // The first set of allocations happens here.
    .into(); // A second allocation for `Rc<[T]>` happens here.

This will allocate as many times as needed for constructing the Vec<T> and then it will allocate once for turning the Vec<T> into the Rc<[T]>.

Iterators of known length

When your Iterator implements TrustedLen and is of an exact size, a single allocation will be made for the Rc<[T]>. For example:

let evens: Rc<[u8]> = (0..10).collect(); // Just a single allocation happens here.

impl<T> FromIterator<T> for Vec<T, Global>

pub fn from_iter<I>(iter: I) -> Vec<T, Global> where
    I: IntoIterator<Item = T>, 

impl<T> FromIterator<T> for LinkedList<T>

pub fn from_iter<I>(iter: I) -> LinkedList<T> where
    I: IntoIterator<Item = T>, 

impl<T> FromIterator<T> for BinaryHeap<T> where
    T: Ord, 

pub fn from_iter<I>(iter: I) -> BinaryHeap<T> where
    I: IntoIterator<Item = T>, 

impl FromIterator<Box<str, Global>> for String

pub fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = Box<str, Global>>, 

impl<'a> FromIterator<&'a str> for String

pub fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = &'a str>, 

impl FromIterator<String> for String

pub fn from_iter<I>(iter: I) -> String where
    I: IntoIterator<Item = String>, 

impl FromIterator<Op> for Op

pub fn from_iter<T>(iterator: T) -> Op where
    T: IntoIterator<Item = Op>, 

impl FromIterator<WatchMask> for WatchMask

pub fn from_iter<T>(iterator: T) -> WatchMask where
    T: IntoIterator<Item = WatchMask>, 

impl FromIterator<EventMask> for EventMask

pub fn from_iter<T>(iterator: T) -> EventMask where
    T: IntoIterator<Item = EventMask>, 

impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
    I: Idx, 

pub fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>, Global> where
    T: IntoIterator<Item = A>, 

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

pub fn from_iter<I>(iterable: I) -> SmallVec<A> where
    I: IntoIterator<Item = <A as Array>::Item>, 

impl<A> FromIterator<<A as Array>::Item> for ArrayVec<A> where
    A: Array, 

#[must_use]

pub fn from_iter<T>(iter: T) -> ArrayVec<A> where
    T: IntoIterator<Item = <A as Array>::Item>, 

impl<A> FromIterator<<A as Array>::Item> for TinyVec<A> where
    A: Array, 

#[must_use]

pub fn from_iter<T>(iter: T) -> TinyVec<A> where
    T: IntoIterator<Item = <A as Array>::Item>, 

impl<V> FromIterator<(usize, V)> for VecMap<V>

pub fn from_iter<I>(iter: I) -> VecMap<V> where
    I: IntoIterator<Item = (usize, V)>, 

Loading content...

Implementors

impl FromIterator<(String, Value)> for otter_api_tests::imports::toml::value::Map<String, Value>

pub fn from_iter<T>(iter: T) -> Map<String, Value> where
    T: IntoIterator<Item = (String, Value)>, 

impl FromIterator<(String, Value)> for otter_api_tests::serde_json::Map<String, Value>

pub fn from_iter<T>(iter: T) -> Map<String, Value> where
    T: IntoIterator<Item = (String, Value)>, 

impl FromIterator<AtFlags> for AtFlags

pub fn from_iter<T>(iterator: T) -> AtFlags where
    T: IntoIterator<Item = AtFlags>, 

impl FromIterator<FallocateFlags> for FallocateFlags

pub fn from_iter<T>(iterator: T) -> FallocateFlags where
    T: IntoIterator<Item = FallocateFlags>, 

impl FromIterator<FdFlag> for otter_api_tests::imports::nix::fcntl::FdFlag

pub fn from_iter<T>(iterator: T) -> FdFlag where
    T: IntoIterator<Item = FdFlag>, 

impl FromIterator<OFlag> for OFlag

pub fn from_iter<T>(iterator: T) -> OFlag where
    T: IntoIterator<Item = OFlag>, 

impl FromIterator<SealFlag> for SealFlag

pub fn from_iter<T>(iterator: T) -> SealFlag where
    T: IntoIterator<Item = SealFlag>, 

impl FromIterator<SpliceFFlags> for SpliceFFlags

pub fn from_iter<T>(iterator: T) -> SpliceFFlags where
    T: IntoIterator<Item = SpliceFFlags>, 

impl FromIterator<DeleteModuleFlags> for DeleteModuleFlags

pub fn from_iter<T>(iterator: T) -> DeleteModuleFlags where
    T: IntoIterator<Item = DeleteModuleFlags>, 

impl FromIterator<ModuleInitFlags> for ModuleInitFlags

pub fn from_iter<T>(iterator: T) -> ModuleInitFlags where
    T: IntoIterator<Item = ModuleInitFlags>, 

impl FromIterator<MntFlags> for MntFlags

pub fn from_iter<T>(iterator: T) -> MntFlags where
    T: IntoIterator<Item = MntFlags>, 

impl FromIterator<MsFlags> for otter_api_tests::imports::nix::mount::MsFlags

pub fn from_iter<T>(iterator: T) -> MsFlags where
    T: IntoIterator<Item = MsFlags>, 

impl FromIterator<FdFlag> for otter_api_tests::imports::nix::mqueue::FdFlag

pub fn from_iter<T>(iterator: T) -> FdFlag where
    T: IntoIterator<Item = FdFlag>, 

impl FromIterator<MQ_OFlag> for MQ_OFlag

pub fn from_iter<T>(iterator: T) -> MQ_OFlag where
    T: IntoIterator<Item = MQ_OFlag>, 

impl FromIterator<InterfaceFlags> for InterfaceFlags

pub fn from_iter<T>(iterator: T) -> InterfaceFlags where
    T: IntoIterator<Item = InterfaceFlags>, 

impl FromIterator<PollFlags> for PollFlags

pub fn from_iter<T>(iterator: T) -> PollFlags where
    T: IntoIterator<Item = PollFlags>, 

impl FromIterator<CloneFlags> for CloneFlags

pub fn from_iter<T>(iterator: T) -> CloneFlags where
    T: IntoIterator<Item = CloneFlags>, 

impl FromIterator<EpollCreateFlags> for EpollCreateFlags

pub fn from_iter<T>(iterator: T) -> EpollCreateFlags where
    T: IntoIterator<Item = EpollCreateFlags>, 

impl FromIterator<EpollFlags> for EpollFlags

pub fn from_iter<T>(iterator: T) -> EpollFlags where
    T: IntoIterator<Item = EpollFlags>, 

impl FromIterator<EfdFlags> for EfdFlags

pub fn from_iter<T>(iterator: T) -> EfdFlags where
    T: IntoIterator<Item = EfdFlags>, 

impl FromIterator<AddWatchFlags> for AddWatchFlags

pub fn from_iter<T>(iterator: T) -> AddWatchFlags where
    T: IntoIterator<Item = AddWatchFlags>, 

impl FromIterator<InitFlags> for InitFlags

pub fn from_iter<T>(iterator: T) -> InitFlags where
    T: IntoIterator<Item = InitFlags>, 

impl FromIterator<MemFdCreateFlag> for MemFdCreateFlag

pub fn from_iter<T>(iterator: T) -> MemFdCreateFlag where
    T: IntoIterator<Item = MemFdCreateFlag>, 

impl FromIterator<MRemapFlags> for MRemapFlags

pub fn from_iter<T>(iterator: T) -> MRemapFlags where
    T: IntoIterator<Item = MRemapFlags>, 

impl FromIterator<MapFlags> for MapFlags

pub fn from_iter<T>(iterator: T) -> MapFlags where
    T: IntoIterator<Item = MapFlags>, 

impl FromIterator<MlockAllFlags> for MlockAllFlags

pub fn from_iter<T>(iterator: T) -> MlockAllFlags where
    T: IntoIterator<Item = MlockAllFlags>, 

impl FromIterator<MsFlags> for otter_api_tests::imports::nix::sys::mman::MsFlags

pub fn from_iter<T>(iterator: T) -> MsFlags where
    T: IntoIterator<Item = MsFlags>, 

impl FromIterator<ProtFlags> for ProtFlags

pub fn from_iter<T>(iterator: T) -> ProtFlags where
    T: IntoIterator<Item = ProtFlags>, 

impl FromIterator<Persona> for Persona

pub fn from_iter<T>(iterator: T) -> Persona where
    T: IntoIterator<Item = Persona>, 

impl FromIterator<Options> for Options

pub fn from_iter<T>(iterator: T) -> Options where
    T: IntoIterator<Item = Options>, 

impl FromIterator<QuotaValidFlags> for QuotaValidFlags

pub fn from_iter<T>(iterator: T) -> QuotaValidFlags where
    T: IntoIterator<Item = QuotaValidFlags>, 

impl FromIterator<SaFlags> for SaFlags

pub fn from_iter<T>(iterator: T) -> SaFlags where
    T: IntoIterator<Item = SaFlags>, 

impl FromIterator<SfdFlags> for SfdFlags

pub fn from_iter<T>(iterator: T) -> SfdFlags where
    T: IntoIterator<Item = SfdFlags>, 

impl FromIterator<MsgFlags> for MsgFlags

pub fn from_iter<T>(iterator: T) -> MsgFlags where
    T: IntoIterator<Item = MsgFlags>, 

impl FromIterator<SockFlag> for SockFlag

pub fn from_iter<T>(iterator: T) -> SockFlag where
    T: IntoIterator<Item = SockFlag>, 

impl FromIterator<Mode> for Mode

pub fn from_iter<T>(iterator: T) -> Mode where
    T: IntoIterator<Item = Mode>, 

impl FromIterator<SFlag> for SFlag

pub fn from_iter<T>(iterator: T) -> SFlag where
    T: IntoIterator<Item = SFlag>, 

impl FromIterator<FsFlags> for FsFlags

pub fn from_iter<T>(iterator: T) -> FsFlags where
    T: IntoIterator<Item = FsFlags>, 

impl FromIterator<ControlFlags> for ControlFlags

pub fn from_iter<T>(iterator: T) -> ControlFlags where
    T: IntoIterator<Item = ControlFlags>, 

impl FromIterator<InputFlags> for InputFlags

pub fn from_iter<T>(iterator: T) -> InputFlags where
    T: IntoIterator<Item = InputFlags>, 

impl FromIterator<LocalFlags> for LocalFlags

pub fn from_iter<T>(iterator: T) -> LocalFlags where
    T: IntoIterator<Item = LocalFlags>, 

impl FromIterator<OutputFlags> for OutputFlags

pub fn from_iter<T>(iterator: T) -> OutputFlags where
    T: IntoIterator<Item = OutputFlags>, 

impl FromIterator<TimerFlags> for TimerFlags

pub fn from_iter<T>(iterator: T) -> TimerFlags where
    T: IntoIterator<Item = TimerFlags>, 

impl FromIterator<TimerSetTimeFlags> for TimerSetTimeFlags

pub fn from_iter<T>(iterator: T) -> TimerSetTimeFlags where
    T: IntoIterator<Item = TimerSetTimeFlags>, 

impl FromIterator<WaitPidFlag> for WaitPidFlag

pub fn from_iter<T>(iterator: T) -> WaitPidFlag where
    T: IntoIterator<Item = WaitPidFlag>, 

impl FromIterator<AccessFlags> for AccessFlags

pub fn from_iter<T>(iterator: T) -> AccessFlags where
    T: IntoIterator<Item = AccessFlags>, 

impl<'a> FromIterator<char> for Cow<'a, str>

pub fn from_iter<I>(it: I) -> Cow<'a, str> where
    I: IntoIterator<Item = char>, 

impl<'a> FromIterator<String> for Cow<'a, str>

pub fn from_iter<I>(it: I) -> Cow<'a, str> where
    I: IntoIterator<Item = String>, 

impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

pub fn from_iter<I>(it: I) -> Cow<'a, str> where
    I: IntoIterator<Item = &'b str>, 

impl<'a, T> FromIterator<T> for Cow<'a, [T]> where
    T: Clone, 

pub fn from_iter<I>(it: I) -> Cow<'a, [T]> where
    I: IntoIterator<Item = T>, 

impl<A> FromIterator<<A as Array>::Item> for otter_api_tests::shapelib::ArrayVec<A> where
    A: Array, 

Create an ArrayVec from an iterator.

Does not extract more items than there is space for. No error occurs if there are more iterator elements.

pub fn from_iter<T>(iter: T) -> ArrayVec<A> where
    T: IntoIterator<Item = <A as Array>::Item>, 

impl<A> FromIterator<A> for VecDeque<A>

pub fn from_iter<T>(iter: T) -> VecDeque<A> where
    T: IntoIterator<Item = A>, 

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

pub fn from_iter<I>(iter: I) -> Result<V, E> where
    I: IntoIterator<Item = Result<A, 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_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>, 

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

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<I, T> FromIterator<T> for IndexVec<I, T> where
    I: Idx, 

pub fn from_iter<J>(iter: J) -> IndexVec<I, T> where
    J: IntoIterator<Item = T>, 

impl<K, V> FromIterator<(K, V)> for Value where
    K: Into<String>,
    V: Into<Value>, 

pub fn from_iter<I>(iter: I) -> Value where
    I: IntoIterator<Item = (K, V)>, 

Convert an iteratable type to a Value

Examples

use serde_json::Value;

let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];
let x: Value = v.into_iter().collect();

impl<K, V> FromIterator<(K, V)> for SecondaryMap<K, V> where
    K: Key, 

pub fn from_iter<I>(iter: I) -> SecondaryMap<K, V> where
    I: IntoIterator<Item = (K, V)>, 

impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V> where
    K: Ord, 

pub fn from_iter<T>(iter: T) -> BTreeMap<K, V> where
    T: IntoIterator<Item = (K, V)>, 

impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
    S: BuildHasher + Default,
    K: Eq + Hash, 

pub fn from_iter<T>(iter: T) -> HashMap<K, V, S> where
    T: IntoIterator<Item = (K, V)>, 

impl<K, V, S> FromIterator<(K, V)> for SparseSecondaryMap<K, V, S> where
    S: BuildHasher + Default,
    K: Key, 

pub fn from_iter<I>(iter: I) -> SparseSecondaryMap<K, V, S> where
    I: IntoIterator<Item = (K, V)>, 

impl<P> FromIterator<P> for PathBuf where
    P: AsRef<Path>, 

pub fn from_iter<I>(iter: I) -> PathBuf where
    I: IntoIterator<Item = P>, 

impl<T> FromIterator<T> for Value where
    T: Into<Value>, 

pub fn from_iter<I>(iter: I) -> Value where
    I: IntoIterator<Item = T>, 

Convert an iteratable type to a Value

Examples

use serde_json::Value;

let v = std::iter::repeat(42).take(5);
let x: Value = v.collect();

use serde_json::Value;

let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
let x: Value = v.into_iter().collect();

use std::iter::FromIterator;
use serde_json::Value;

let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);

impl<T> FromIterator<T> for Arc<[T]>

pub fn from_iter<I>(iter: I) -> Arc<[T]> where
    I: IntoIterator<Item = T>, 

Takes each element in the Iterator and collects it into an Arc<[T]>.

Performance characteristics

The general case

In the general case, collecting into Arc<[T]> is done by first collecting into a Vec<T>. That is, when writing the following:

let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect();

this behaves as if we wrote:

let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0)
    .collect::<Vec<_>>() // The first set of allocations happens here.
    .into(); // A second allocation for `Arc<[T]>` happens here.

This will allocate as many times as needed for constructing the Vec<T> and then it will allocate once for turning the Vec<T> into the Arc<[T]>.

Iterators of known length

When your Iterator implements TrustedLen and is of an exact size, a single allocation will be made for the Arc<[T]>. For example:

let evens: Arc<[u8]> = (0..10).collect(); // Just a single allocation happens here.

impl<T> FromIterator<T> for BTreeSet<T> where
    T: Ord, 

pub fn from_iter<I>(iter: I) -> BTreeSet<T> where
    I: IntoIterator<Item = T>, 

impl<T, S> FromIterator<T> for HashSet<T, S> where
    S: BuildHasher + Default,
    T: Eq + Hash, 

pub fn from_iter<I>(iter: I) -> HashSet<T, S> where
    I: IntoIterator<Item = T>, 

Loading content...