Trait FromIterator 

pub trait FromIterator<A>: Sized {
    // Required method
    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.

If you want to create a collection from the contents of an iterator, the Iterator::collect() method is preferred. However, when you need to specify the container type, FromIterator::from_iter() can be more readable than using a turbofish (e.g. ::<Vec<_>>()). See the Iterator::collect() documentation for more examples of its use.

See also: IntoIterator.

Examples

Basic usage:

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

Using FromIterator::from_iter() as a more readable alternative to Iterator::collect():

use std::collections::VecDeque;
let first = (0..10).collect::<VecDeque<i32>>();
let second = VecDeque::from_iter(0..10);

assert_eq!(first, second);

Implementing FromIterator for your type:

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

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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

impl FromIterator<AsciiChar> for String

Available on non-no_global_oom_handling only.

impl FromIterator<Weekday> for WeekdaySet

impl FromIterator<Signal> for SigSet

Available on crate feature signal only.

impl FromIterator<char> for datex_core::stdlib::boxed::Box<str>

Available on non-no_global_oom_handling only.

impl FromIterator<char> for ByteString

impl FromIterator<char> for String

Available on non-no_global_oom_handling only.

impl FromIterator<char> for SmolStr

impl FromIterator<u8> for ByteString

impl FromIterator<u8> for Bytes

impl FromIterator<u8> for BytesMut

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

impl FromIterator<ByteString> for ByteString

impl FromIterator<OsString> for OsString

impl FromIterator<String> for datex_core::stdlib::boxed::Box<str>

Available on non-no_global_oom_handling only.

impl FromIterator<String> for String

Available on non-no_global_oom_handling only.

impl FromIterator<String> for SmolStr

impl FromIterator<WatchKind> for WatchKind

impl FromIterator<AtFlags> for AtFlags

impl FromIterator<FallocateFlags> for FallocateFlags

impl FromIterator<FdFlag> for FdFlag

impl FromIterator<OFlag> for OFlag

impl FromIterator<RenameFlags> for RenameFlags

impl FromIterator<SealFlag> for SealFlag

impl FromIterator<SpliceFFlags> for SpliceFFlags

impl FromIterator<DeleteModuleFlags> for DeleteModuleFlags

impl FromIterator<ModuleInitFlags> for ModuleInitFlags

impl FromIterator<MntFlags> for MntFlags

impl FromIterator<MsFlags> for nix::mount::linux::MsFlags

impl FromIterator<MQ_OFlag> for MQ_OFlag

impl FromIterator<InterfaceFlags> for InterfaceFlags

impl FromIterator<PollFlags> for PollFlags

impl FromIterator<CloneFlags> for CloneFlags

impl FromIterator<EpollCreateFlags> for EpollCreateFlags

impl FromIterator<EpollFlags> for EpollFlags

impl FromIterator<EfdFlags> for EfdFlags

impl FromIterator<AddWatchFlags> for AddWatchFlags

impl FromIterator<InitFlags> for InitFlags

impl FromIterator<MemFdCreateFlag> for MemFdCreateFlag

impl FromIterator<MRemapFlags> for MRemapFlags

impl FromIterator<MapFlags> for MapFlags

impl FromIterator<MlockAllFlags> for MlockAllFlags

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

impl FromIterator<ProtFlags> for ProtFlags

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<MsgFlags> for MsgFlags

impl FromIterator<SockFlag> for SockFlag

impl FromIterator<TimestampingFlag> for TimestampingFlag

impl FromIterator<Mode> for Mode

impl FromIterator<SFlag> for SFlag

impl FromIterator<FsFlags> for FsFlags

impl FromIterator<ControlFlags> for ControlFlags

impl FromIterator<InputFlags> for InputFlags

impl FromIterator<LocalFlags> for LocalFlags

impl FromIterator<OutputFlags> for OutputFlags

impl FromIterator<TimerSetTimeFlags> for TimerSetTimeFlags

impl FromIterator<TimerFlags> for TimerFlags

impl FromIterator<WaitPidFlag> for WaitPidFlag

impl FromIterator<AccessFlags> for AccessFlags

impl FromIterator<CipherCtxFlags> for CipherCtxFlags

impl FromIterator<CMSOptions> for CMSOptions

impl FromIterator<OcspFlag> for OcspFlag

impl FromIterator<Pkcs7Flags> for Pkcs7Flags

impl FromIterator<ExtensionContext> for ExtensionContext

impl FromIterator<ShutdownState> for ShutdownState

impl FromIterator<SslMode> for SslMode

impl FromIterator<SslOptions> for SslOptions

impl FromIterator<SslSessionCacheMode> for SslSessionCacheMode

impl FromIterator<SslVerifyMode> for SslVerifyMode

impl FromIterator<X509CheckFlags> for X509CheckFlags

impl FromIterator<X509VerifyFlags> for X509VerifyFlags

impl FromIterator<Literal> for Seq

impl FromIterator<TrustAnchor<'static>> for RootCertStore

impl FromIterator<FontStyle> for FontStyle

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

Available on non-no_global_oom_handling only.

impl<'a> FromIterator<&'a char> for datex_core::stdlib::boxed::Box<str>

Available on non-no_global_oom_handling only.

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

Available on non-no_global_oom_handling only.

impl<'a> FromIterator<&'a str> for datex_core::stdlib::boxed::Box<str>

Available on non-no_global_oom_handling only.

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

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

Available on non-no_global_oom_handling only.

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

impl<'a> FromIterator<&'a u8> for BytesMut

impl<'a> FromIterator<&'a ByteStr> for ByteString

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

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

impl<'a> FromIterator<&'a [u8]> for ByteString

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

Available on non-no_global_oom_handling only.

impl<'a> FromIterator<Cow<'a, str>> for datex_core::stdlib::boxed::Box<str>

Available on non-no_global_oom_handling only.

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

Available on non-no_global_oom_handling only.

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

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

Available on non-no_global_oom_handling only.

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

Available on non-no_global_oom_handling only.

impl<'a> FromIterator<AttributeTypeAndValue<'a>> for RelativeDistinguishedName<'a>

impl<'a> FromIterator<RelativeDistinguishedName<'a>> for X509Name<'a>

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

Available on non-no_global_oom_handling only.

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

where T: Clone,

impl<A> FromIterator<<A as Array>::Item> for 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.

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

where A: Array,

impl<A> FromIterator<Box<str, A>> for datex_core::stdlib::boxed::Box<str>

where A: Allocator,

Available on non-no_global_oom_handling only.

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

where A: Allocator,

Available on non-no_global_oom_handling only.

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

where V: FromIterator<A>,

impl<A, V> FromIterator<Option<A>> for Option<V>

where V: FromIterator<A>,

impl<B> FromIterator<bool> for BitVec<B>

where B: BitBlock,

impl<B> FromIterator<usize> for BitSet<B>

where B: BitBlock,

impl<F> FromIterator<F> for JoinAll<F>

where F: Future,

impl<F> FromIterator<F> for TryJoinAll<F>

where F: TryFuture,

impl<Fut> FromIterator<Fut> for futures_util::future::select_all::SelectAll<Fut>

where Fut: Future + Unpin,

impl<Fut> FromIterator<Fut> for SelectOk<Fut>

where Fut: TryFuture + Unpin,

impl<Fut> FromIterator<Fut> for FuturesOrdered<Fut>

where Fut: Future,

impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>

impl<I> FromIterator<I> for datex_core::stdlib::boxed::Box<[I]>

Available on non-no_global_oom_handling only.

impl<I> FromIterator<I> for allocator_api2::stable::boxed::Box<[I]>

Available on non-no_global_oom_handling only.

impl<K, S> FromIterator<K> for DashSet<K, S>

where K: Eq + Hash, S: BuildHasher + Clone + Default,

impl<K, V> FromIterator<(K, V)> for datex_core::values::core_values::map::Map

where K: Into<ValueContainer>, V: Into<ValueContainer>,

impl<K, V> FromIterator<(K, V)> for Value

where K: Into<String>, V: Into<Value>,

impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>

where K: Ord,

impl<K, V> FromIterator<(K, V)> for Dictionary

where K: Into<String>, V: Into<Value>,

impl<K, V> FromIterator<(K, V)> for StreamMap<K, V>

where K: Hash + Eq,

impl<K, V, S> FromIterator<(K, V)> for datex_core::collections::HashMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Default,

impl<K, V, S> FromIterator<(K, V)> for DashMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Clone + Default,

impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S>

where K: Hash + Eq, S: BuildHasher + Default,

impl<K, V, S> FromIterator<(K, V)> for LinkedHashMap<K, V, S>

where K: Hash + Eq, S: BuildHasher + Default,

impl<K, V, S> FromIterator<(K, V)> for LiteMap<K, V, S>

where K: Ord, S: StoreFromIterable<K, V>,

impl<K, V, S> FromIterator<(K, V)> for RingMap<K, V, S>

where K: Hash + Eq, S: BuildHasher + Default,

impl<K, V, S, A> FromIterator<(K, V)> for hashbrown::map::HashMap<K, V, S, A>

where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<K, V, S, A> FromIterator<(K, V)> for hashbrown::map::HashMap<K, V, S, A>

where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<K, V, S, A> FromIterator<(K, V)> for hashbrown::map::HashMap<K, V, S, A>

where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<P> FromIterator<P> for PathBuf

where P: AsRef<Path>,

impl<St> FromIterator<St> for futures_util::stream::select_all::SelectAll<St>

where St: Stream + Unpin,

impl<T> FromIterator<(usize, T)> for Slab<T>

Create a slab from an iterator of key-value pairs.

If the iterator produces duplicate keys, the previous value is replaced with the later one. The keys does not need to be sorted beforehand, and this function always takes O(n) time. Note that the returned slab will use space proportional to the largest key, so don’t use Slab with untrusted keys.

Examples

let vec = vec![(2,'a'), (6,'b'), (7,'c')];
let slab = vec.into_iter().collect::<Slab<char>>();
assert_eq!(slab.len(), 3);
assert!(slab.capacity() >= 8);
assert_eq!(slab[2], 'a');

With duplicate and unsorted keys:

let vec = vec![(20,'a'), (10,'b'), (11,'c'), (10,'d')];
let slab = vec.into_iter().collect::<Slab<char>>();
assert_eq!(slab.len(), 3);
assert_eq!(slab[10], 'd');

impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>

impl<T> FromIterator<T> for CoreValue

where T: Into<ValueContainer>,

impl<T> FromIterator<T> for Value

where T: Into<Value>,

impl<T> FromIterator<T> for BTreeSet<T>

where T: Ord,

impl<T> FromIterator<T> for BinaryHeap<T>

where T: Ord,

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

impl<T> FromIterator<T> for VecDeque<T>

impl<T> FromIterator<T> for List

where T: Into<ValueContainer>,

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

Available on non-no_global_oom_handling only.

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

Available on non-no_global_oom_handling only.

impl<T> FromIterator<T> for datex_core::stdlib::vec::Vec<T>

Available on non-no_global_oom_handling only.

Collects an iterator into a Vec, commonly called via Iterator::collect()

Allocation behavior

In general Vec does not guarantee any particular growth or allocation strategy. That also applies to this trait impl.

Note: This section covers implementation details and is therefore exempt from stability guarantees.

Vec may use any or none of the following strategies, depending on the supplied iterator:

• preallocate based on Iterator::size_hint()
  • and panic if the number of items is outside the provided lower/upper bounds
• use an amortized growth strategy similar to pushing one item at a time
• perform the iteration in-place on the original allocation backing the iterator

The last case warrants some attention. It is an optimization that in many cases reduces peak memory consumption and improves cache locality. But when big, short-lived allocations are created, only a small fraction of their items get collected, no further use is made of the spare capacity and the resulting Vec is moved into a longer-lived structure, then this can lead to the large allocations having their lifetimes unnecessarily extended which can result in increased memory footprint.

In cases where this is an issue, the excess capacity can be discarded with Vec::shrink_to(), Vec::shrink_to_fit() or by collecting into Box<[T]> instead, which additionally reduces the size of the long-lived struct.

static LONG_LIVED: Mutex<Vec<Vec<u16>>> = Mutex::new(Vec::new());

for i in 0..10 {
    let big_temporary: Vec<u16> = (0..1024).collect();
    // discard most items
    let mut result: Vec<_> = big_temporary.into_iter().filter(|i| i % 100 == 0).collect();
    // without this a lot of unused capacity might be moved into the global
    result.shrink_to_fit();
    LONG_LIVED.lock().unwrap().push(result);
}

impl<T> FromIterator<T> for allocator_api2::stable::vec::Vec<T>

Available on non-no_global_oom_handling only.

impl<T> FromIterator<T> for SequenceOf<T>

impl<T> FromIterator<T> for SetOf<T>

impl<T, ExtendT> FromIterator<(T₁, T₂, …, Tₙ)> for (ExtendT₁, ExtendT₂, …, ExtendTₙ)

where ExtendT: Default + Extend<T>,

This implementation turns an iterator of tuples into a tuple of types which implement Default and Extend.

This is similar to Iterator::unzip, but is also composable with other FromIterator implementations:

let string = "1,2,123,4";

// Example given for a 2-tuple, but 1- through 12-tuples are supported
let (numbers, lengths): (Vec<_>, Vec<_>) = string
    .split(',')
    .map(|s| s.parse().map(|n: u32| (n, s.len())))
    .collect::<Result<_, _>>()?;

assert_eq!(numbers, [1, 2, 123, 4]);
assert_eq!(lengths, [1, 1, 3, 1]);

impl<T, F> FromIterator<F> for JoinSet<T>

where F: Future<Output = T> + Send + 'static, T: Send + 'static,

Collect an iterator of futures into a JoinSet.

This is equivalent to calling JoinSet::spawn on each element of the iterator.

Examples

The main example from JoinSet’s documentation can also be written using collect:

use tokio::task::JoinSet;

let mut set: JoinSet<_> = (0..10).map(|i| async move { i }).collect();

let mut seen = [false; 10];
while let Some(res) = set.join_next().await {
    let idx = res.unwrap();
    seen[idx] = true;
}

for i in 0..10 {
     assert!(seen[i]);
}

impl<T, N> FromIterator<T> for GenericArray<T, N>

where N: ArrayLength<T>,

impl<T, S> FromIterator<T> for datex_core::collections::HashSet<T, S>

where T: Eq + Hash, S: BuildHasher + Default,

impl<T, S> FromIterator<T> for IndexSet<T, S>

where T: Hash + Eq, S: BuildHasher + Default,

impl<T, S> FromIterator<T> for RingSet<T, S>

where T: Hash + Eq, S: BuildHasher + Default,

impl<T, S, A> FromIterator<T> for hashbrown::set::HashSet<T, S, A>

where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<T, S, A> FromIterator<T> for hashbrown::set::HashSet<T, S, A>

where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<T, S, A> FromIterator<T> for hashbrown::set::HashSet<T, S, A>

where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,