Trait cairo_vm::with_std::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
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<(String, Value)> for Map<String, Value>
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<Box<str, Global>> 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 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<I> FromIterator<I> for Box<[I], Global>
impl<K, V> FromIterator<(K, V)> for Valuewhere K: Into<String>, V: Into<Value>,
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V, Global>where K: Ord,
impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S>where K: Eq + Hash, S: BuildHasher + Default,
impl<P> FromIterator<P> for PathBufwhere P: AsRef<Path>,
impl<T> FromIterator<T> for Valuewhere T: Into<Value>,
impl<T> FromIterator<T> for Rc<[T]>
impl<T> FromIterator<T> for Arc<[T]>
impl<T> FromIterator<T> for Vec<T, Global>
impl<T> FromIterator<T> for BinaryHeap<T>where T: Ord,
impl<T> FromIterator<T> for BTreeSet<T, Global>where T: Ord,
impl<T> FromIterator<T> for LinkedList<T>
impl<T> FromIterator<T> for VecDeque<T, Global>
impl<T, N> FromIterator<T> for GenericArray<T, N>where N: ArrayLength<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.