pub trait FromIterator<A>: Sized {
    // Required method
    fn from_iter<T>(iter: T) -> Self
       where T: IntoIterator<Item = A>;
}
Available on non-crate feature miri-test-libstd only.
Expand description

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§

source

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = A>,

Creates a value from an iterator.

See the module-level documentation for more.

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

Implementors§

§

impl FromIterator<char> for CompactString

source§

impl FromIterator<char> for String

Available on non-no_global_oom_handling only.
§

impl FromIterator<u8> for Bytes

§

impl FromIterator<u8> for BytesMut

1.23.0 · source§

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

impl FromIterator<usize> for FixedBitSet

Return a FixedBitSet containing bits set to true for every bit index in the iterator, other bits are set to false.

§

impl FromIterator<CompactString> for Cow<'_, str>

§

impl FromIterator<CompactString> for CompactString

§

impl FromIterator<CompactString> for String

§

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

1.45.0 · source§

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

Available on non-no_global_oom_handling only.
§

impl FromIterator<String> for CompactString

1.4.0 · source§

impl FromIterator<String> for String

Available on non-no_global_oom_handling only.
1.52.0 · source§

impl FromIterator<OsString> for OsString

§

impl FromIterator<EventMask> for EventMask

§

impl FromIterator<Flags> for Flags

§

impl FromIterator<FsyncFlags> for FsyncFlags

§

impl FromIterator<TimeoutFlags> for TimeoutFlags

§

impl FromIterator<WatchMask> for WatchMask

§

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

1.17.0 · source§

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

Available on non-no_global_oom_handling only.
§

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

source§

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

Available on non-no_global_oom_handling only.
§

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

1.52.0 · source§

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

§

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

1.19.0 · source§

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

Available on non-no_global_oom_handling only.
1.52.0 · source§

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

1.12.0 · source§

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

Available on non-no_global_oom_handling only.
1.12.0 · source§

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>

1.12.0 · source§

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

Available on non-no_global_oom_handling only.
source§

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,

§

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

§

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

§

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

§

impl<A> FromIterator<A> for UniqueArc<[A]>

source§

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

source§

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

§

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 FuturesOrdered<Fut>where Fut: Future,

§

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

§

impl<Fut> FromIterator<Fut> for SelectAll<Fut>where Fut: Future + Unpin,

§

impl<Fut> FromIterator<Fut> for SelectOk<Fut>where Fut: TryFuture + Unpin,

1.32.0 · source§

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

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,

source§

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

source§

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

source§

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 DashMap<K, V, S>where K: Eq + Hash, S: BuildHasher + Clone + Default,

§

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

§

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

source§

impl<N, E, Ty, Item> FromIterator<Item> for GraphMap<N, E, Ty>where Item: IntoWeightedEdge<E, NodeId = N>, N: NodeTrait, Ty: EdgeType,

Create a new GraphMap from an iterable of edges.

source§

impl<P> FromIterator<P> for PathBufwhere P: AsRef<Path>,

§

impl<St> FromIterator<St> for 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');
source§

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

1.37.0 · source§

impl<T> FromIterator<T> for kvarn::prelude::Arc<[T]>

Available on non-no_global_oom_handling only.
source§

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

source§

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

source§

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

source§

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

1.37.0 · source§

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

Available on non-no_global_oom_handling only.
source§

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

Available on non-no_global_oom_handling only.
§

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

§

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

§

impl<T, N> FromIterator<T> for GenericArray<T, N>where N: ArrayLength<T>,

source§

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

source§

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

§

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

§

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