Trait gstd::prelude::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§
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<char> for String
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<Box<str>> for String
impl FromIterator<String> for String
impl FromIterator<OsString> for OsString
impl<'a> FromIterator<&'a char> for String
impl<'a> FromIterator<&'a str> for String
impl<'a> FromIterator<&'a u8> for BytesMut
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, M, T1, T2, O1, O2> FromIterator<BitRef<'a, M, T2, O2>> for BitVec<T1, O1>where
M: Mutability,
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
§Bit-Vector Collection from Proxy References
DO NOT use this. You clearly have a bit-slice. Use
::from_bitslice()
instead!
Iterating over a bit-slice requires loading from memory and constructing a proxy reference for each bit. This is needlessly slow; the specialized method is able to avoid this per-bit cost and possibly even use batched operations.
impl<'a, T> FromIterator<T> for Cow<'a, [T]>where
T: Clone,
impl<'a, T, O> FromIterator<&'a bool> for BitVec<T, O>where
T: BitStore,
O: BitOrder,
impl<'a, T, O> FromIterator<&'a T> for BitVec<T, O>where
T: BitStore,
O: BitOrder,
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<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>
impl<Fut> FromIterator<Fut> for SelectOk<Fut>where
Fut: TryFuture + Unpin,
impl<I> FromIterator<I> for gstd::prelude::Box<[I]>
impl<I> FromIterator<I> for Box<[I]>
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>where
K: Ord,
impl<K, V> FromIterator<(K, V)> for AHashMap<K, V>
impl<K, V, S> FromIterator<(K, V)> for std::collections::hash::map::HashMap<K, V, S>
impl<K, V, S, A> FromIterator<(K, V)> for gstd::prelude::collections::HashMap<K, V, S, A>
impl<P> FromIterator<P> for PathBuf
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');
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 Rc<[T]>
impl<T> FromIterator<T> for gstd::prelude::Vec<T>
impl<T> FromIterator<T> for Arc<[T]>
impl<T> FromIterator<T> for AHashSet<T>
impl<T> FromIterator<T> for Vec<T>
impl<T, O> FromIterator<bool> for BitVec<T, O>where
T: BitStore,
O: BitOrder,
§Bit-Vector Collection
This collects a bit-vector from anything that produces individual bits.
§Original
impl<T> FromIterator<T> for Vec<T>
§Notes
This .collect()
call is the second-slowest possible way to collect bits into a
bit-vector, faster only than calling iter.for_each(|bit| bv.push(bit))
.
DO NOT use this if you have any other choice.
If you are collecting a bit-vector from the contents of a bit-slice, then you
should use ::from_bitslice()
instead. That method is specialized to
perform upfront allocation and, where possible, use a batch copy rather than
copying each bit individually from the source into the bit-vector.
impl<T, O> FromIterator<T> for BitVec<T, O>where
T: BitStore,
O: BitOrder,
impl<T, O, I> FromIterator<I> for BitBox<T, O>where
T: BitStore,
O: BitOrder,
BitVec<T, O>: FromIterator<I>,
impl<T, S> FromIterator<T> for std::collections::hash::set::HashSet<T, S>
impl<T, S, A> FromIterator<T> for gstd::prelude::collections::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.