pub trait IteratorFrom<A>: Sized {
// Required method
fn from_iter<T>(iter: T) -> Self
where T: IntoIterator<Item = A>;
}
Expand description
๐
core
Conversion from an Iterator
.
Re-exported from core
::iter::
FromIterator
โIteratorFrom
.
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ยง
1.0.0 ยท Sourcefn from_iter<T>(iter: T) -> Selfwhere
T: IntoIterator<Item = A>,
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
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<char> for ByteString
impl FromIterator<char> for devela::all::Box<str>
impl FromIterator<char> for String
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<KeyEventState> for KeyEventState
impl FromIterator<KeyModifiers> for KeyModifiers
impl FromIterator<KeyboardEnhancementFlags> for KeyboardEnhancementFlags
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::codec::decoder::slice::Flags
impl FromIterator<Check> for Check
impl FromIterator<Conceal> for Conceal
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::codec::packet::Flags
impl FromIterator<Capabilities> for Capabilities
impl FromIterator<CodecProperties> for CodecProperties
impl FromIterator<Debug> for Debug
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::codec::Flags
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::codec::subtitle::Flags
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::filter::Flags
impl FromIterator<Disposition> for Disposition
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::format::Flags
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::software::resampling::Flags
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::software::scaling::Flags
impl FromIterator<ChannelLayoutMask> for ChannelLayoutMask
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::util::frame::Flags
impl FromIterator<Flags> for devela::_dep::ffmpeg_the_third::util::log::Flags
impl FromIterator<Type> for Type
impl FromIterator<InitFlag> for devela::_dep::sdl2::image::InitFlag
impl FromIterator<Mod> for Mod
impl FromIterator<MessageBoxButtonFlag> for MessageBoxButtonFlag
impl FromIterator<MessageBoxFlag> for MessageBoxFlag
impl FromIterator<AllowChangeFlag> for AllowChangeFlag
impl FromIterator<InitFlag> for devela::_dep::sdl2::mixer::InitFlag
impl FromIterator<FontStyle> for FontStyle
impl FromIterator<Channels> for Channels
impl FromIterator<Table> for ArrayOfTables
impl FromIterator<OsString> for OsString
impl FromIterator<String> for devela::all::Box<str>
impl FromIterator<String> for String
impl FromIterator<ControlModes> for ControlModes
impl FromIterator<DupFlags> for DupFlags
impl FromIterator<EfdFlags> for EfdFlags
impl FromIterator<EpollCreateFlags> for EpollCreateFlags
impl FromIterator<EpollFlags> for EpollFlags
impl FromIterator<EventMask> for EventMask
impl FromIterator<FdFlags> for FdFlags
impl FromIterator<Flags> for Flags
impl FromIterator<InputModes> for InputModes
impl FromIterator<LocalModes> for LocalModes
impl FromIterator<OutputModes> for OutputModes
impl FromIterator<PortCap> for PortCap
impl FromIterator<PortType> for PortType
impl FromIterator<ReadWriteFlags> for ReadWriteFlags
impl FromIterator<Remove> for Remove
impl FromIterator<Transformations> for Transformations
impl FromIterator<WatchMask> for WatchMask
impl<'a> FromIterator<&'a char> for devela::all::Box<str>
impl<'a> FromIterator<&'a char> for String
impl<'a> FromIterator<&'a str> for ByteString
impl<'a> FromIterator<&'a str> for devela::all::Box<str>
impl<'a> FromIterator<&'a str> for String
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 [u8]> for ByteString
impl<'a> FromIterator<(String, String)> for Owned<'a>
impl<'a> FromIterator<Cow<'a, str>> for devela::all::Box<str>
impl<'a> FromIterator<Cow<'a, str>> for String
impl<'a> FromIterator<Cow<'a, OsStr>> for OsString
impl<'a> FromIterator<char> for Cow<'a, str>
impl<'a> FromIterator<String> for Cow<'a, str>
impl<'a, 'b> FromIterator<&'b (&'b str, &'b str)> for Owned<'a>
impl<'a, 'b> FromIterator<&'b (String, String)> for Owned<'a>
impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>
impl<'a, 'b> FromIterator<(&'b str, &'b str)> for Owned<'a>
impl<'a, T> FromIterator<T> for Cow<'a, [T]>where
T: Clone,
impl<A> FromIterator<<A as Array>::Item> for SmallVec<A>where
A: Array,
impl<A> FromIterator<Box<str, A>> for devela::all::Box<str>where
A: Allocator,
impl<A> FromIterator<Box<str, A>> for Stringwhere
A: Allocator,
impl<A> FromIterator<A> for VecChunk<A>
alloc
only.impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>where
V: FromIterator<A>,
impl<A, EA> FromIterator<(EAโ, EAโ, โฆ, EAโ)> for (Aโ, Aโ, โฆ, Aโ)
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]);
This trait is implemented for tuples up to twelve items long. The impl
s for 1- and 3- through 12-ary tuples were stabilized after 2-tuples, in 1.85.0.
impl<A, V> FromIterator<Option<A>> for Option<V>where
V: FromIterator<A>,
impl<I> FromIterator<I> for devela::_dep::allocator_api2::boxed::Box<[I]>
impl<I> FromIterator<I> for devela::all::Box<[I]>
impl<I> FromIterator<I> for Box<[I]>
impl<K, V> FromIterator<(K, V)> for Value
impl<K, V> FromIterator<(K, V)> for InlineTable
impl<K, V> FromIterator<(K, V)> for Table
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>where
K: Ord,
impl<K, V, S> FromIterator<(K, V)> for devela::_dep::_std::collections::HashMap<K, V, S>
impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S>
impl<K, V, S, A> FromIterator<(K, V)> for devela::all::HashMap<K, V, S, A>
impl<P> FromIterator<P> for PathBuf
impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>
impl<T> FromIterator<Steal<T>> for Steal<T>
impl<T> FromIterator<T> for devela::_dep::_alloc::sync::Arc<[T]>
impl<T> FromIterator<T> for devela::_dep::allocator_api2::vec::Vec<T>
impl<T> FromIterator<T> for devela::all::Arc<[T]>
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 Rc<[T]>
impl<T> FromIterator<T> for devela::all::Vec<T>
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 VecDeque<T>
impl<T> FromIterator<T> for Vec<T>
impl<T, F> FromIterator<F> for JoinSet<T>
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;
#[tokio::main]
async fn main() {
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, S> FromIterator<T> for devela::_dep::_std::collections::HashSet<T, S>
impl<T, S> FromIterator<T> for IndexSet<T, S>
impl<T, S, A> FromIterator<T> for devela::all::HashSet<T, S, A>
impl<T, const CAP: usize> FromIterator<T> for ArrayVec<T, CAP>
Create an ArrayVec
from an iterator.
Panics if the number of elements in the iterator exceeds the arrayvecโs capacity.