1.0.0[−][src]Trait af_lib::iter::FromIterator
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.
FromIterator::from_iter()
is rarely called explicitly, and is instead
used through Iterator::collect()
method. See Iterator::collect()
's
documentation for more examples.
See also: IntoIterator
.
Examples
Basic usage:
use std::iter::FromIterator; 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]);
Implementing FromIterator
for your type:
use std::iter::FromIterator; // 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
pub fn from_iter<T>(iter: T) -> Self where
T: IntoIterator<Item = A>,
[src]
T: IntoIterator<Item = A>,
Creates a value from an iterator.
See the module-level documentation for more.
Examples
Basic usage:
use std::iter::FromIterator; 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
impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
S: BuildHasher + Default,
K: Eq + Hash,
[src]
S: BuildHasher + Default,
K: Eq + Hash,
impl<P> FromIterator<P> for PathBuf where
P: AsRef<Path>,
[src]
P: AsRef<Path>,
pub fn from_iter<I>(iter: I) -> PathBuf where
I: IntoIterator<Item = P>,
[src]
I: IntoIterator<Item = P>,
impl<T, S> FromIterator<T> for HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher + Default,
[src]
T: Eq + Hash,
S: BuildHasher + Default,
pub fn from_iter<I>(iter: I) -> HashSet<T, S> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E> where
V: FromIterator<A>,
[src]
V: FromIterator<A>,
pub fn from_iter<I>(iter: I) -> Result<V, E> where
I: IntoIterator<Item = Result<A, E>>,
[src]
I: IntoIterator<Item = Result<A, E>>,
Takes each element in the Iterator
: if it is an Err
, no further
elements are taken, and the Err
is returned. Should no Err
occur, a
container with the values of each Result
is returned.
Here is an example which increments every integer in a vector, checking for overflow:
let v = vec![1, 2]; let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| x.checked_add(1).ok_or("Overflow!") ).collect(); assert_eq!(res, Ok(vec![2, 3]));
Here is another example that tries to subtract one from another list of integers, this time checking for underflow:
let v = vec![1, 2, 0]; let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| x.checked_sub(1).ok_or("Underflow!") ).collect(); assert_eq!(res, Err("Underflow!"));
Here is a variation on the previous example, showing that no
further elements are taken from iter
after the first Err
.
let v = vec![3, 2, 1, 10]; let mut shared = 0; let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| { shared += x; x.checked_sub(2).ok_or("Underflow!") }).collect(); assert_eq!(res, Err("Underflow!")); assert_eq!(shared, 6);
Since the third element caused an underflow, no further elements were taken,
so the final value of shared
is 6 (= 3 + 2 + 1
), not 16.
impl<A, V> FromIterator<Option<A>> for Option<V> where
V: FromIterator<A>,
[src]
V: FromIterator<A>,
pub fn from_iter<I>(iter: I) -> Option<V> where
I: IntoIterator<Item = Option<A>>,
[src]
I: IntoIterator<Item = Option<A>>,
Takes each element in the Iterator
: if it is None
,
no further elements are taken, and the None
is
returned. Should no None
occur, a container with the
values of each Option
is returned.
Examples
Here is an example which increments every integer in a vector.
We use the checked variant of add
that returns None
when the
calculation would result in an overflow.
let items = vec![0_u16, 1, 2]; let res: Option<Vec<u16>> = items .iter() .map(|x| x.checked_add(1)) .collect(); assert_eq!(res, Some(vec![1, 2, 3]));
As you can see, this will return the expected, valid items.
Here is another example that tries to subtract one from another list of integers, this time checking for underflow:
let items = vec![2_u16, 1, 0]; let res: Option<Vec<u16>> = items .iter() .map(|x| x.checked_sub(1)) .collect(); assert_eq!(res, None);
Since the last element is zero, it would underflow. Thus, the resulting
value is None
.
Here is a variation on the previous example, showing that no
further elements are taken from iter
after the first None
.
let items = vec![3_u16, 2, 1, 10]; let mut shared = 0; let res: Option<Vec<u16>> = items .iter() .map(|x| { shared += x; x.checked_sub(2) }) .collect(); assert_eq!(res, None); assert_eq!(shared, 6);
Since the third element caused an underflow, no further elements were taken,
so the final value of shared
is 6 (= 3 + 2 + 1
), not 16.
impl FromIterator<()> for ()
[src]
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());
pub fn from_iter<I>(iter: I) where
I: IntoIterator<Item = ()>,
[src]
I: IntoIterator<Item = ()>,
impl<T> FromIterator<T> for Vec<T, Global>
[src]
pub fn from_iter<I>(iter: I) -> Vec<T, Global>ⓘ where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl FromIterator<Box<str, Global>> for String
[src]
impl FromIterator<char> for String
[src]
pub fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = char>,
[src]
I: IntoIterator<Item = char>,
impl<'a> FromIterator<&'a char> for String
[src]
pub fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = &'a char>,
[src]
I: IntoIterator<Item = &'a char>,
impl<A> FromIterator<A> for VecDeque<A>
[src]
pub fn from_iter<T>(iter: T) -> VecDeque<A> where
T: IntoIterator<Item = A>,
[src]
T: IntoIterator<Item = A>,
impl<'a> FromIterator<Cow<'a, str>> for String
[src]
impl<'a> FromIterator<&'a str> for String
[src]
pub fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = &'a str>,
[src]
I: IntoIterator<Item = &'a str>,
impl<T> FromIterator<T> for LinkedList<T>
[src]
pub fn from_iter<I>(iter: I) -> LinkedList<T> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V> where
K: Ord,
[src]
K: Ord,
impl FromIterator<String> for String
[src]
pub fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = String>,
[src]
I: IntoIterator<Item = String>,
impl<I> FromIterator<I> for Box<[I], Global>
[src]
pub fn from_iter<T>(iter: T) -> Box<[I], Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = I>,
[src]
Notable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
T: IntoIterator<Item = I>,
impl<T> FromIterator<T> for BinaryHeap<T> where
T: Ord,
[src]
T: Ord,
pub fn from_iter<I>(iter: I) -> BinaryHeap<T> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T> FromIterator<T> for BTreeSet<T> where
T: Ord,
[src]
T: Ord,
pub fn from_iter<I>(iter: I) -> BTreeSet<T> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<A> FromIterator<<A as Array>::Item> for SmallVec<A> where
A: Array,
A: Array,
pub fn from_iter<I>(iterable: I) -> SmallVec<A> where
I: IntoIterator<Item = <A as Array>::Item>,
I: IntoIterator<Item = <A as Array>::Item>,
impl<K, V> FromIterator<(K, V)> for DashMap<K, V, RandomState> where
K: Eq + Hash,
K: Eq + Hash,
pub fn from_iter<I>(intoiter: I) -> DashMap<K, V, RandomState> where
I: IntoIterator<Item = (K, V)>,
I: IntoIterator<Item = (K, V)>,
impl<K> FromIterator<K> for DashSet<K, RandomState> where
K: Eq + Hash,
K: Eq + Hash,
pub fn from_iter<I>(iter: I) -> DashSet<K, RandomState> where
I: IntoIterator<Item = K>,
I: IntoIterator<Item = K>,
impl FromIterator<u8> for BytesMut
[src]
pub fn from_iter<T>(into_iter: T) -> BytesMut where
T: IntoIterator<Item = u8>,
[src]
T: IntoIterator<Item = u8>,
impl<'a> FromIterator<&'a u8> for BytesMut
[src]
pub fn from_iter<T>(into_iter: T) -> BytesMut where
T: IntoIterator<Item = &'a u8>,
[src]
T: IntoIterator<Item = &'a u8>,
impl FromIterator<u8> for Bytes
[src]
pub fn from_iter<T>(into_iter: T) -> Bytes where
T: IntoIterator<Item = u8>,
[src]
T: IntoIterator<Item = u8>,
impl<T, N> FromIterator<T> for GenericArray<T, N> where
N: ArrayLength<T>,
N: ArrayLength<T>,
pub fn from_iter<I>(iter: I) -> GenericArray<T, N> where
I: IntoIterator<Item = T>,
I: IntoIterator<Item = T>,
impl<A> FromIterator<<A as Array>::Item> for ArrayVec<A> where
A: Array,
A: Array,
#[must_use]pub fn from_iter<T>(iter: T) -> ArrayVec<A> where
T: IntoIterator<Item = <A as Array>::Item>,
T: IntoIterator<Item = <A as Array>::Item>,
impl<A> FromIterator<<A as Array>::Item> for TinyVec<A> where
A: Array,
A: Array,
#[must_use]pub fn from_iter<T>(iter: T) -> TinyVec<A> where
T: IntoIterator<Item = <A as Array>::Item>,
T: IntoIterator<Item = <A as Array>::Item>,
impl<A, R> FromIterator<R> for OrdSet<A> where
A: Ord + Clone + From<R>,
A: Ord + Clone + From<R>,
pub fn from_iter<T>(i: T) -> OrdSet<A> where
T: IntoIterator<Item = R>,
T: IntoIterator<Item = R>,
impl<A, RA, S> FromIterator<RA> for HashSet<A, S> where
A: Hash + Eq + Clone + From<RA>,
S: BuildHasher + Default,
A: Hash + Eq + Clone + From<RA>,
S: BuildHasher + Default,
pub fn from_iter<T>(i: T) -> HashSet<A, S> where
T: IntoIterator<Item = RA>,
T: IntoIterator<Item = RA>,
impl<A> FromIterator<A> for Vector<A> where
A: Clone,
A: Clone,
pub fn from_iter<I>(iter: I) -> Vector<A> where
I: IntoIterator<Item = A>,
I: IntoIterator<Item = A>,
Create a vector from an iterator.
Time: O(n)
impl<K, V, RK, RV> FromIterator<(RK, RV)> for OrdMap<K, V> where
V: Clone + From<RV>,
K: Ord + Clone + From<RK>,
V: Clone + From<RV>,
K: Ord + Clone + From<RK>,
pub fn from_iter<T>(i: T) -> OrdMap<K, V> where
T: IntoIterator<Item = (RK, RV)>,
T: IntoIterator<Item = (RK, RV)>,
impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
V: Clone,
S: BuildHasher + Default,
K: Hash + Eq + Clone,
V: Clone,
S: BuildHasher + Default,
K: Hash + Eq + Clone,
pub fn from_iter<T>(i: T) -> HashMap<K, V, S> where
T: IntoIterator<Item = (K, V)>,
T: IntoIterator<Item = (K, V)>,
impl<A, T> FromIterator<A> for InlineArray<A, T>
pub fn from_iter<I>(it: I) -> InlineArray<A, T> where
I: IntoIterator<Item = A>,
I: IntoIterator<Item = A>,
impl<A, N> FromIterator<A> for Chunk<A, N> where
N: ChunkLength<A>,
N: ChunkLength<A>,
pub fn from_iter<I>(it: I) -> Chunk<A, N>ⓘ where
I: IntoIterator<Item = A>,
I: IntoIterator<Item = A>,
impl<A, N> FromIterator<Option<A>> for SparseChunk<A, N> where
N: ChunkLength<A> + Bits,
N: ChunkLength<A> + Bits,
pub fn from_iter<I>(iter: I) -> SparseChunk<A, N> where
I: IntoIterator<Item = Option<A>>,
I: IntoIterator<Item = Option<A>>,
impl<T> FromIterator<T> for Arena<T>
pub fn from_iter<U>(iter: U) -> Arena<T> where
U: IntoIterator<Item = T>,
U: IntoIterator<Item = T>,
impl FromIterator<ExtensionContext> for ExtensionContext
[src]
pub fn from_iter<T>(iterator: T) -> ExtensionContext where
T: IntoIterator<Item = ExtensionContext>,
[src]
T: IntoIterator<Item = ExtensionContext>,
impl FromIterator<X509CheckFlags> for X509CheckFlags
[src]
pub fn from_iter<T>(iterator: T) -> X509CheckFlags where
T: IntoIterator<Item = X509CheckFlags>,
[src]
T: IntoIterator<Item = X509CheckFlags>,
impl FromIterator<SslVerifyMode> for SslVerifyMode
[src]
pub fn from_iter<T>(iterator: T) -> SslVerifyMode where
T: IntoIterator<Item = SslVerifyMode>,
[src]
T: IntoIterator<Item = SslVerifyMode>,
impl FromIterator<CMSOptions> for CMSOptions
[src]
pub fn from_iter<T>(iterator: T) -> CMSOptions where
T: IntoIterator<Item = CMSOptions>,
[src]
T: IntoIterator<Item = CMSOptions>,
impl FromIterator<OcspFlag> for OcspFlag
[src]
pub fn from_iter<T>(iterator: T) -> OcspFlag where
T: IntoIterator<Item = OcspFlag>,
[src]
T: IntoIterator<Item = OcspFlag>,
impl FromIterator<ShutdownState> for ShutdownState
[src]
pub fn from_iter<T>(iterator: T) -> ShutdownState where
T: IntoIterator<Item = ShutdownState>,
[src]
T: IntoIterator<Item = ShutdownState>,
impl FromIterator<X509VerifyFlags> for X509VerifyFlags
[src]
pub fn from_iter<T>(iterator: T) -> X509VerifyFlags where
T: IntoIterator<Item = X509VerifyFlags>,
[src]
T: IntoIterator<Item = X509VerifyFlags>,
impl FromIterator<SslSessionCacheMode> for SslSessionCacheMode
[src]
pub fn from_iter<T>(iterator: T) -> SslSessionCacheMode where
T: IntoIterator<Item = SslSessionCacheMode>,
[src]
T: IntoIterator<Item = SslSessionCacheMode>,
impl FromIterator<Pkcs7Flags> for Pkcs7Flags
[src]
pub fn from_iter<T>(iterator: T) -> Pkcs7Flags where
T: IntoIterator<Item = Pkcs7Flags>,
[src]
T: IntoIterator<Item = Pkcs7Flags>,
impl FromIterator<SslMode> for SslMode
[src]
pub fn from_iter<T>(iterator: T) -> SslMode where
T: IntoIterator<Item = SslMode>,
[src]
T: IntoIterator<Item = SslMode>,
impl FromIterator<SslOptions> for SslOptions
[src]
pub fn from_iter<T>(iterator: T) -> SslOptions where
T: IntoIterator<Item = SslOptions>,
[src]
T: IntoIterator<Item = SslOptions>,
impl<Fut> FromIterator<Fut> for SelectOk<Fut> where
Fut: Unpin + TryFuture,
Fut: Unpin + TryFuture,
pub fn from_iter<T>(iter: T) -> SelectOk<Fut>ⓘ where
T: IntoIterator<Item = Fut>,
T: IntoIterator<Item = Fut>,
impl<F> FromIterator<F> for JoinAll<F> where
F: Future,
F: Future,
pub fn from_iter<T>(iter: T) -> JoinAll<F>ⓘ where
T: IntoIterator<Item = F>,
T: IntoIterator<Item = F>,
impl<Fut> FromIterator<Fut> for FuturesOrdered<Fut> where
Fut: Future,
Fut: Future,
pub fn from_iter<T>(iter: T) -> FuturesOrdered<Fut> where
T: IntoIterator<Item = Fut>,
T: IntoIterator<Item = Fut>,
impl<St> FromIterator<St> for SelectAll<St> where
St: Unpin + Stream,
St: Unpin + Stream,
pub fn from_iter<T>(iter: T) -> SelectAll<St> where
T: IntoIterator<Item = St>,
T: IntoIterator<Item = St>,
impl<F> FromIterator<F> for TryJoinAll<F> where
F: TryFuture,
F: TryFuture,
pub fn from_iter<T>(iter: T) -> TryJoinAll<F>ⓘ where
T: IntoIterator<Item = F>,
T: IntoIterator<Item = F>,
impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>
pub fn from_iter<I>(iter: I) -> FuturesUnordered<Fut> where
I: IntoIterator<Item = Fut>,
I: IntoIterator<Item = Fut>,
impl<Fut> FromIterator<Fut> for SelectAll<Fut> where
Fut: Unpin + Future,
Fut: Unpin + Future,
pub fn from_iter<T>(iter: T) -> SelectAll<Fut>ⓘ where
T: IntoIterator<Item = Fut>,
T: IntoIterator<Item = Fut>,
impl<'a, A> FromIterator<&'a char> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
pub fn from_iter<I>(iter: I) -> SmallString<A> where
I: IntoIterator<Item = &'a char>,
I: IntoIterator<Item = &'a char>,
impl<A> FromIterator<String> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
pub fn from_iter<I>(iter: I) -> SmallString<A> where
I: IntoIterator<Item = String>,
I: IntoIterator<Item = String>,
impl<'a, A> FromIterator<Cow<'a, str>> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
pub fn from_iter<I>(iter: I) -> SmallString<A> where
I: IntoIterator<Item = Cow<'a, str>>,
I: IntoIterator<Item = Cow<'a, str>>,
impl<A> FromIterator<char> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
pub fn from_iter<I>(iter: I) -> SmallString<A> where
I: IntoIterator<Item = char>,
I: IntoIterator<Item = char>,
impl<'a, A> FromIterator<&'a str> for SmallString<A> where
A: Array<Item = u8>,
A: Array<Item = u8>,
pub fn from_iter<I>(iter: I) -> SmallString<A> where
I: IntoIterator<Item = &'a str>,
I: IntoIterator<Item = &'a str>,
impl<T> FromIterator<T> for Values<T>
pub fn from_iter<I>(iter: I) -> Values<T> where
I: IntoIterator<Item = T>,
I: IntoIterator<Item = T>,
impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>
[src]
pub fn from_iter<I>(iter: I) -> HeaderMap<T> where
I: IntoIterator<Item = (HeaderName, T)>,
[src]
I: IntoIterator<Item = (HeaderName, T)>,
impl FromIterator<u8> for BytesMut
[src]
pub fn from_iter<T>(into_iter: T) -> BytesMut where
T: IntoIterator<Item = u8>,
[src]
T: IntoIterator<Item = u8>,
impl<'a> FromIterator<&'a u8> for BytesMut
[src]
pub fn from_iter<T>(into_iter: T) -> BytesMut where
T: IntoIterator<Item = &'a u8>,
[src]
T: IntoIterator<Item = &'a u8>,
impl FromIterator<u8> for Bytes
[src]
pub fn from_iter<T>(into_iter: T) -> Bytes where
T: IntoIterator<Item = u8>,
[src]
T: IntoIterator<Item = u8>,
impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S> where
S: BuildHasher + Default,
K: Hash + Eq,
[src]
S: BuildHasher + Default,
K: Hash + Eq,
pub fn from_iter<I>(iterable: I) -> IndexMap<K, V, S> where
I: IntoIterator<Item = (K, V)>,
[src]
I: IntoIterator<Item = (K, V)>,
Create an IndexMap
from the sequence of key-value pairs in the
iterable.
from_iter
uses the same logic as extend
. See
extend
for more details.
impl<T, S> FromIterator<T> for IndexSet<T, S> where
T: Hash + Eq,
S: BuildHasher + Default,
[src]
T: Hash + Eq,
S: BuildHasher + Default,
pub fn from_iter<I>(iterable: I) -> IndexSet<T, S> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T, S> FromIterator<T> for HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher + Default,
T: Eq + Hash,
S: BuildHasher + Default,
pub fn from_iter<I>(iter: I) -> HashSet<T, S> where
I: IntoIterator<Item = T>,
I: IntoIterator<Item = T>,
impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
S: BuildHasher + Default,
K: Eq + Hash,
S: BuildHasher + Default,
K: Eq + Hash,
pub fn from_iter<T>(iter: T) -> HashMap<K, V, S> where
T: IntoIterator<Item = (K, V)>,
T: IntoIterator<Item = (K, V)>,
Implementors
impl FromIterator<(String, Value)> for Map<String, Value>
[src]
pub fn from_iter<T>(iter: T) -> Map<String, Value> where
T: IntoIterator<Item = (String, Value)>,
[src]
T: IntoIterator<Item = (String, Value)>,
impl<'a> FromIterator<char> for Cow<'a, str>
[src]
impl<'a> FromIterator<String> for Cow<'a, str>
[src]
impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>
[src]
impl<'a, T> FromIterator<T> for Cow<'a, [T]> where
T: Clone,
[src]
T: Clone,
impl<K, V> FromIterator<(K, V)> for Value where
V: Into<Value>,
K: Into<String>,
[src]
V: Into<Value>,
K: Into<String>,
pub fn from_iter<I>(iter: I) -> Value where
I: IntoIterator<Item = (K, V)>,
[src]
I: IntoIterator<Item = (K, V)>,
Convert an iteratable type to a Value
Examples
use serde_json::Value; let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)]; let x: Value = v.into_iter().collect();
impl<T> FromIterator<T> for Value where
T: Into<Value>,
[src]
T: Into<Value>,
pub fn from_iter<I>(iter: I) -> Value where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
Convert an iteratable type to a Value
Examples
use serde_json::Value; let v = std::iter::repeat(42).take(5); let x: Value = v.collect();
use serde_json::Value; let v: Vec<_> = vec!["lorem", "ipsum", "dolor"]; let x: Value = v.into_iter().collect();
use std::iter::FromIterator; use serde_json::Value; let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
impl<T> FromIterator<T> for Arc<[T]>
[src]
pub fn from_iter<I>(iter: I) -> Arc<[T]> where
I: IntoIterator<Item = T>,
[src]
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.
impl<T> FromIterator<T> for Rc<[T]>
[src]
pub fn from_iter<I>(iter: I) -> Rc<[T]> where
I: IntoIterator<Item = T>,
[src]
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.