Trait scrypto_test::prelude::rust::iter::FromIterator
1.0.0 · source · pub trait FromIterator<A>: Sized {
// Required method
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§
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]);Object Safety§
Implementors§
impl FromIterator<(String, Value)> for serde_json::map::Map<String, Value>
impl FromIterator<(String, Value)> for toml::map::Map<String, Value>
impl FromIterator<TokenTree> for proc_macro::TokenStream
Collects a number of token trees into a single stream.
impl FromIterator<TokenTree> for proc_macro2::TokenStream
Collects a number of token trees into a single stream.
impl FromIterator<char> for String
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<EventFlags> for EventFlags
impl FromIterator<LockFlags> for LockFlags
impl FromIterator<Box<str>> for String
impl FromIterator<String> for String
impl FromIterator<EnabledModules> for EnabledModules
impl FromIterator<VaultFreezeFlags> for VaultFreezeFlags
impl FromIterator<TokenStream> for proc_macro::TokenStream
A “flattening” operation on token streams, collects token trees from multiple token streams into a single stream.
impl FromIterator<OsString> for OsString
impl FromIterator<TokenStream> for proc_macro2::TokenStream
impl FromIterator<RefTypes> for RefTypes
impl FromIterator<Nibble> for NibblePath
Convert a vector of bytes into NibblePath using the lower 4 bits of each byte as nibble.
impl FromIterator<Literal> for Seq
impl FromIterator<CreateFlags> for CreateFlags
impl FromIterator<WatchFlags> for WatchFlags
impl FromIterator<Access> for Access
impl FromIterator<AtFlags> for AtFlags
impl FromIterator<FallocateFlags> for FallocateFlags
impl FromIterator<MemfdFlags> for MemfdFlags
impl FromIterator<Mode> for Mode
impl FromIterator<OFlags> for OFlags
impl FromIterator<RenameFlags> for RenameFlags
impl FromIterator<ResolveFlags> for ResolveFlags
impl FromIterator<SealFlags> for SealFlags
impl FromIterator<StatVfsMountFlags> for StatVfsMountFlags
impl FromIterator<StatxFlags> for StatxFlags
impl FromIterator<DupFlags> for DupFlags
impl FromIterator<FdFlags> for FdFlags
impl FromIterator<ReadWriteFlags> for ReadWriteFlags
impl FromIterator<MountFlags> for MountFlags
impl FromIterator<MountPropagationFlags> for MountPropagationFlags
impl FromIterator<UnmountFlags> for UnmountFlags
impl FromIterator<IFlags> for IFlags
impl FromIterator<XattrFlags> for XattrFlags
impl FromIterator<Comparator> for VersionReq
impl FromIterator<Table> for ArrayOfTables
impl<'a> FromIterator<&'a char> for String
impl<'a> FromIterator<&'a str> for String
impl<'a> FromIterator<&'a OsStr> for OsString
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 str> for Cow<'a, str>
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<A> for triomphe::arc::Arc<[A]>
impl<A> FromIterator<A> for UniqueArc<[A]>
impl<A, B, AE, BE> FromIterator<(AE, BE)> for (A, B)
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";
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<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<I> FromIterator<I> for Box<[I]>
impl<Idx, T> FromIterator<T> for DedupArena<Idx, T>
impl<Idx, T> FromIterator<T> for Arena<Idx, T>
impl<K, V> FromIterator<(K, V)> for serde_json::value::Value
impl<K, V> FromIterator<(K, V)> for toml_edit::value::Value
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>where
K: Ord,
impl<K, V> FromIterator<(K, V)> for NonIterMap<K, V>
impl<K, V> FromIterator<(K, V)> for indexmap_nostd::map::IndexMap<K, V>
impl<K, V> FromIterator<(K, V)> for InlineTable
impl<K, V> FromIterator<(K, V)> for Table
impl<K, V, S> FromIterator<(K, V)> for scrypto_test::prelude::rust::prelude::hash_map::ext_HashMap<K, V, S>
impl<K, V, S> FromIterator<(K, V)> for scrypto_test::prelude::rust::prelude::index_map::indexmap::IndexMap<K, V, S>
impl<K, V, S> FromIterator<(K, V)> for indexmap::map::IndexMap<K, V, S>
impl<K, V, S, A> FromIterator<(K, V)> for hashbrown::map::HashMap<K, V, S, A>
impl<K, V, S, A> FromIterator<(K, V)> for hashbrown::map::HashMap<K, V, S, A>
impl<P> FromIterator<P> for PathBuf
impl<T> FromIterator<T> for serde_json::value::Value
impl<T> FromIterator<T> for BTreeSet<T>where
T: Ord,
impl<T> FromIterator<T> for LinkedList<T>
impl<T> FromIterator<T> for Rc<[T]>
impl<T> FromIterator<T> for 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
pushingone 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);
}