Trait wasmtime_environ::__core::prelude::rust_2021::FromIterator
1.0.0 · source · [−]pub trait FromIterator<A> {
fn from_iter<T>(iter: T) -> Self
where
T: IntoIterator<Item = A>;
}
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
fn from_iter<T>(iter: T) -> Self where
T: IntoIterator<Item = A>,
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:
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]);
Implementations on Foreign Types
1.52.0 · sourceimpl FromIterator<OsString> for OsString
impl FromIterator<OsString> for OsString
fn from_iter<I>(iter: I) -> OsString where
I: IntoIterator<Item = OsString>,
sourceimpl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher + Default,
impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher + Default,
1.52.0 · sourceimpl<'a> FromIterator<&'a OsStr> for OsString
impl<'a> FromIterator<&'a OsStr> for OsString
fn from_iter<I>(iter: I) -> OsString where
I: IntoIterator<Item = &'a OsStr>,
sourceimpl<P> FromIterator<P> for PathBuf where
P: AsRef<Path>,
impl<P> FromIterator<P> for PathBuf where
P: AsRef<Path>,
fn from_iter<I>(iter: I) -> PathBuf where
I: IntoIterator<Item = P>,
1.52.0 · sourceimpl<'a> FromIterator<Cow<'a, OsStr>> for OsString
impl<'a> FromIterator<Cow<'a, OsStr>> for OsString
sourceimpl<T, S> FromIterator<T> for HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher + Default,
impl<T, S> FromIterator<T> for HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher + Default,
fn from_iter<I>(iter: I) -> HashSet<T, S> where
I: IntoIterator<Item = T>,
1.23.0 · sourceimpl FromIterator<()> for ()
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());
fn from_iter<I>(iter: I) where
I: IntoIterator<Item = ()>,
sourceimpl<T> FromIterator<T> for BTreeSet<T> where
T: Ord,
impl<T> FromIterator<T> for BTreeSet<T> where
T: Ord,
fn from_iter<I>(iter: I) -> BTreeSet<T> where
I: IntoIterator<Item = T>,
sourceimpl<'a> FromIterator<&'a str> for String
impl<'a> FromIterator<&'a str> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = &'a str>,
sourceimpl FromIterator<char> for String
impl FromIterator<char> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = char>,
1.12.0 · sourceimpl<'a> FromIterator<char> for Cow<'a, str>
impl<'a> FromIterator<char> for Cow<'a, str>
sourceimpl<T> FromIterator<T> for VecDeque<T, Global>
impl<T> FromIterator<T> for VecDeque<T, Global>
fn from_iter<I>(iter: I) -> VecDeque<T, Global> where
I: IntoIterator<Item = T>,
sourceimpl<T> FromIterator<T> for LinkedList<T>
impl<T> FromIterator<T> for LinkedList<T>
fn from_iter<I>(iter: I) -> LinkedList<T> where
I: IntoIterator<Item = T>,
1.12.0 · sourceimpl<'a> FromIterator<String> for Cow<'a, str>
impl<'a> FromIterator<String> for Cow<'a, str>
1.37.0 · sourceimpl<T> FromIterator<T> for Rc<[T]>
impl<T> FromIterator<T> for Rc<[T]>
sourcefn from_iter<I>(iter: I) -> Rc<[T]> where
I: IntoIterator<Item = T>,
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.
sourceimpl<T> FromIterator<T> for BinaryHeap<T> where
T: Ord,
impl<T> FromIterator<T> for BinaryHeap<T> where
T: Ord,
fn from_iter<I>(iter: I) -> BinaryHeap<T> where
I: IntoIterator<Item = T>,
1.37.0 · sourceimpl<T> FromIterator<T> for Arc<[T]>
impl<T> FromIterator<T> for Arc<[T]>
sourcefn from_iter<I>(iter: I) -> Arc<[T]> where
I: IntoIterator<Item = T>,
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.
1.19.0 · sourceimpl<'a> FromIterator<Cow<'a, str>> for String
impl<'a> FromIterator<Cow<'a, str>> for String
sourceimpl<T> FromIterator<T> for Vec<T, Global>
impl<T> FromIterator<T> for Vec<T, Global>
fn from_iter<I>(iter: I) -> Vec<T, Global> where
I: IntoIterator<Item = T>,
1.4.0 · sourceimpl FromIterator<String> for String
impl FromIterator<String> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = String>,
1.12.0 · sourceimpl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>
impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>
1.32.0 · sourceimpl<I> FromIterator<I> for Box<[I], Global>
impl<I> FromIterator<I> for Box<[I], Global>
fn from_iter<T>(iter: T) -> Box<[I], Global>ⓘNotable traits for Box<I, A>impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;
where
T: IntoIterator<Item = I>,
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;