Trait gclient::ext::sp_core::sp_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.

§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 · source

fn from_iter<T>(iter: T) -> Self
where 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§

This trait is not object safe.

Implementors§

§

impl FromIterator<(Vec<u8>, Vec<u8>)> for BasicExternalities

source §

impl FromIterator<(String, Value)> for Map<String, Value>

§

impl FromIterator<bool> for Bits

1.0.0 · source§

impl FromIterator<char> for String

1.80.0 · source§

impl FromIterator<char> for gclient::ext::sp_core::sp_std::prelude::Box<str>

§

impl FromIterator<u8> for Bytes

§

impl FromIterator<u8> for BytesMut

1.23.0 · source§

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<Capabilities> for Capabilities

1.4.0 · source§

impl FromIterator<String> for String

1.80.0 · source§

impl FromIterator<String> for gclient::ext::sp_core::sp_std::prelude::Box<str>

1.52.0 · source§

impl FromIterator<XattrFlags> for XattrFlags

1.17.0 · source§

impl<'a> FromIterator<&'a char> for String

1.80.0 · source§

impl<'a> FromIterator<&'a char> for gclient::ext::sp_core::sp_std::prelude::Box<str>

1.0.0 · source§

impl<'a> FromIterator<&'a str> for String

1.80.0 · source§

impl<'a> FromIterator<&'a str> for gclient::ext::sp_core::sp_std::prelude::Box<str>

§

impl<'a> FromIterator<&'a u8> for BytesMut

1.52.0 · source§

impl<'a> FromIterator<&'a OsStr> for OsString

§

impl<'a> FromIterator<(Ident<'a>, Value<'a>)> for ParamsString

1.19.0 · source§

impl<'a> FromIterator<Cow<'a, str>> for String

1.80.0 · source§

impl<'a> FromIterator<Cow<'a, str>> for gclient::ext::sp_core::sp_std::prelude::Box<str>

1.52.0 · source§

impl<'a> FromIterator<Cow<'a, OsStr>> for OsString

1.12.0 · source§

impl<'a> FromIterator<char> for Cow<'a, str>

1.12.0 · source§

impl<'a> FromIterator<String> for Cow<'a, str>

1.12.0 · source§

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.

1.0.0 · source§

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> FromIterator<<A as Array>::Item> for ArrayVec<A>
where A: Array,

§

impl<A> FromIterator<<A as Array>::Item> for SmallVec<A>
where A: Array,

§

impl<A> FromIterator<<A as Array>::Item> for TinyVec<A>
where A: Array,

1.45.0 · source§

impl<A> FromIterator<Box<str, A>> for String
where A: Allocator,

1.80.0 · source§

impl<A> FromIterator<Box<str, A>> for gclient::ext::sp_core::sp_std::prelude::Box<str>
where A: Allocator,

1.79.0 · source§

impl<A, B, AE, BE> FromIterator<(AE, BE)> for (A, B)
where A: Default + Extend<AE>, B: Default + Extend<BE>,

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]);

1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where V: FromIterator<A>,

1.0.0 · source§

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>
where Fut: Future + Unpin,

§

impl<Fut> FromIterator<Fut> for SelectOk<Fut>
where Fut: TryFuture + Unpin,

1.32.0 · source§

impl FromIterator for gclient::ext::sp_core::sp_std::prelude::Box<[I]>

§

impl FromIterator for Box<[I]>

source §

impl<K, V> FromIterator<(K, V)> for Value
where K: Into<String>, V: Into<Value>,

1.0.0 · source§

impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>
where K: Ord,

§

impl<K, V> FromIterator<(K, V)> for AHashMap<K, V>
where K: Eq + Hash,

§

impl<K, V> FromIterator<(K, V)> for IndexMap<K, V>
where K: Ord + Clone,

§

impl<K, V> FromIterator<(K, V)> for StreamMap<K, V>
where K: Hash + Eq,

§

impl<K, V> FromIterator<V> for PrimaryMap<K, V>
where K: EntityRef,

1.0.0 · source§

impl<K, V, S> FromIterator<(K, V)> for std::collections::hash::map::HashMap<K, V, S>
where K: Eq + Hash, S: BuildHasher + Default,

source §

impl<K, V, S> FromIterator<(K, V)> for indexmap::map::IndexMap<K, V, S>
where K: Hash + Eq, S: BuildHasher + Default,

§

impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S>
where K: Hash + Eq, S: BuildHasher + Default,

§

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator + Clone,

§

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator + Clone,

§

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

§

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

1.0.0 · source§

impl FromIterator for PathBuf
where P: AsRef<Path>,

§

impl<St> FromIterator<St> for SelectAll<St>
where St: Stream + Unpin,

§

impl<Store, Order> FromIterator<bool> for DecodedBits<Store, Order>

§

impl<T> FromIterator<(u32, T)> for IndexMap<T>

§

impl<T> FromIterator<(u32, T)> for IndexMap<T>

§

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');

source §

impl<T> FromIterator<(HeaderName, T)> for http::header::map::HeaderMap<T>

§

impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>

source §

impl<T> FromIterator<T> for Value
where T: Into<Value>,

1.0.0 · source§

impl<T> FromIterator<T> for gclient::ext::sp_runtime::app_crypto::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);
}

1.0.0 · source§

impl<T> FromIterator<T> for BTreeSet<T>
where T: Ord,

1.0.0 · source§

impl<T> FromIterator<T> for BinaryHeap<T>
where T: Ord,

1.0.0 · source§

impl<T> FromIterator<T> for LinkedList<T>

1.0.0 · source§

impl<T> FromIterator<T> for VecDeque<T>

1.37.0 · source§

impl<T> FromIterator<T> for Rc<[T]>

1.37.0 · source§

impl<T> FromIterator<T> for Arc<[T]>

§

impl<T> FromIterator<T> for AHashSet<T>
where T: Eq + Hash,

§

impl<T> FromIterator<T> for IndexSet<T>
where T: Ord + Clone,

§

impl<T> FromIterator<T> for Vec<T>

§

impl<T, D> FromIterator<D> for IntervalsTree<T>
where T: Numerated, D: Into<IntervalIterator<T>>,

§

impl<T, F> FromIterator<F> for JoinSet<T>
where F: Future<Output = T> + Send + 'static, T: Send + 'static,

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, L> FromIterator<(T, L)> for Targets
where T: Into<String>, L: Into<LevelFilter>,

§

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.

§

impl<T, O> FromIterator<T> for BitVec<T, O>
where T: BitStore, O: BitOrder,

§

impl<T, O, I> FromIterator for BitBox<T, O>
where T: BitStore, O: BitOrder, BitVec<T, O>: FromIterator,

1.0.0 · source§

impl<T, S> FromIterator<T> for std::collections::hash::set::HashSet<T, S>
where T: Eq + Hash, S: BuildHasher + Default,

source §

impl<T, S> FromIterator<T> for indexmap::set::IndexSet<T, S>
where T: Hash + Eq, S: BuildHasher + Default,

§

impl<T, S> FromIterator<T> for IndexSet<T, S>
where T: Hash + Eq, S: BuildHasher + Default,

§

impl<T, S, A> FromIterator<T> for HashSet<T, S, A>
where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator + Clone,

§

impl<T, S, A> FromIterator<T> for HashSet<T, S, A>
where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator + Clone,

§

impl<T, S, A> FromIterator<T> for HashSet<T, S, A>
where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

§

impl<T, S, A> FromIterator<T> for HashSet<T, S, A>
where T: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

source §

impl<T, const CAP: usize> FromIterator<T> for arrayvec::arrayvec::ArrayVec<T, CAP>

Create an ArrayVec from an iterator.

Panics if the number of elements in the iterator exceeds the arrayvec’s capacity.

Trait gclient::ext::sp_core::sp_std::iter::FromIteratorCopy item path

§Examples

Required Methods§

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = A>,

§Examples

Object Safety§

Implementors§

impl FromIterator<(Vec<u8>, Vec<u8>)> for BasicExternalities

impl FromIterator<(String, Value)> for Map<String, Value>

impl FromIterator<bool> for Bits

impl FromIterator<char> for String

impl FromIterator<char> for gclient::ext::sp_core::sp_std::prelude::Box<str>

impl FromIterator<u8> for Bytes

impl FromIterator<u8> for BytesMut

impl FromIterator<()> for ()

impl FromIterator<Capabilities> for Capabilities

impl FromIterator<String> for String

impl FromIterator<String> for gclient::ext::sp_core::sp_std::prelude::Box<str>

impl FromIterator<OsString> for OsString

impl FromIterator<Access> for Access

impl FromIterator<Access> for Access

impl FromIterator<AtFlags> for AtFlags

impl FromIterator<AtFlags> for AtFlags

impl FromIterator<ControlModes> for ControlModes

impl FromIterator<CreateFlags> for CreateFlags

impl FromIterator<CreateFlags> for CreateFlags

impl FromIterator<CreateFlags> for CreateFlags

impl FromIterator<CreateFlags> for CreateFlags

impl FromIterator<DupFlags> for DupFlags

impl FromIterator<DupFlags> for DupFlags

impl FromIterator<DupFlags> for DupFlags

impl FromIterator<EventFlags> for EventFlags

impl FromIterator<EventFlags> for EventFlags

impl FromIterator<EventfdFlags> for EventfdFlags

impl FromIterator<EventfdFlags> for EventfdFlags

impl FromIterator<FallocateFlags> for FallocateFlags

impl FromIterator<FallocateFlags> for FallocateFlags

impl FromIterator<FdFlags> for FdFlags

impl FromIterator<FdFlags> for FdFlags

impl FromIterator<FdFlags> for FdFlags

impl FromIterator<IFlags> for IFlags

impl FromIterator<InputModes> for InputModes

impl FromIterator<Literal> for Seq

impl FromIterator<LocalModes> for LocalModes

impl FromIterator<MapFlags> for MapFlags

impl FromIterator<MemfdFlags> for MemfdFlags

impl FromIterator<MemfdFlags> for MemfdFlags

impl FromIterator<MlockFlags> for MlockFlags

impl FromIterator<Mode> for Mode

impl FromIterator<Mode> for Mode

impl FromIterator<MountFlags> for MountFlags

impl FromIterator<MountFlags> for MountFlags

impl FromIterator<MountPropagationFlags> for MountPropagationFlags

impl FromIterator<MountPropagationFlags> for MountPropagationFlags

impl FromIterator<MprotectFlags> for MprotectFlags

impl FromIterator<MremapFlags> for MremapFlags

impl FromIterator<MsyncFlags> for MsyncFlags

impl FromIterator<OFlags> for OFlags

impl FromIterator<OFlags> for OFlags

impl FromIterator<OutputModes> for OutputModes

impl FromIterator<PipeFlags> for PipeFlags

impl FromIterator<PipeFlags> for PipeFlags

impl FromIterator<PollFlags> for PollFlags

impl FromIterator<PollFlags> for PollFlags

impl FromIterator<ProtFlags> for ProtFlags

impl FromIterator<ReadFlags> for ReadFlags

impl FromIterator<ReadWriteFlags> for ReadWriteFlags

impl FromIterator<ReadWriteFlags> for ReadWriteFlags

impl FromIterator<ReadWriteFlags> for ReadWriteFlags

impl FromIterator<RenameFlags> for RenameFlags

impl FromIterator<RenameFlags> for RenameFlags

impl FromIterator<ResolveFlags> for ResolveFlags

impl FromIterator<ResolveFlags> for ResolveFlags

impl FromIterator<SealFlags> for SealFlags

impl FromIterator<SealFlags> for SealFlags

impl FromIterator<SpliceFlags> for SpliceFlags

impl FromIterator<SpliceFlags> for SpliceFlags

impl FromIterator<StatVfsMountFlags> for StatVfsMountFlags

impl FromIterator<StatVfsMountFlags> for StatVfsMountFlags

impl FromIterator<StatxFlags> for StatxFlags

Trait gclient::ext::sp_core::sp_std::iter::FromIterator

fn from_iter<T>(iter: T) -> Self
where T: IntoIterator<Item = A>,

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,

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> FromIterator<<A as Array>::Item> for ArrayVec<A>
where A: Array,

impl<A> FromIterator<<A as Array>::Item> for SmallVec<A>
where A: Array,

impl<A> FromIterator<<A as Array>::Item> for TinyVec<A>
where A: Array,

impl<A> FromIterator<Box<str, A>> for String
where A: Allocator,

impl<A> FromIterator<Box<str, A>> for gclient::ext::sp_core::sp_std::prelude::Box<str>
where A: Allocator,

impl<A, B, AE, BE> FromIterator<(AE, BE)> for (A, B)
where A: Default + Extend<AE>, B: Default + Extend<BE>,

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 SelectAll<Fut>
where Fut: Future + Unpin,

impl<Fut> FromIterator<Fut> for SelectOk<Fut>
where Fut: TryFuture + Unpin,

impl<K, V> FromIterator<(K, V)> for Value
where K: Into<String>, V: Into<Value>,

impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>
where K: Ord,

impl<K, V> FromIterator<(K, V)> for AHashMap<K, V>
where K: Eq + Hash,

impl<K, V> FromIterator<(K, V)> for IndexMap<K, V>
where K: Ord + Clone,

impl<K, V> FromIterator<(K, V)> for StreamMap<K, V>
where K: Hash + Eq,

impl<K, V> FromIterator<V> for PrimaryMap<K, V>
where K: EntityRef,

impl<K, V, S> FromIterator<(K, V)> for std::collections::hash::map::HashMap<K, V, S>
where K: Eq + Hash, S: BuildHasher + Default,

impl<K, V, S> FromIterator<(K, V)> for indexmap::map::IndexMap<K, V, S>
where K: Hash + Eq, S: BuildHasher + Default,

impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S>
where K: Hash + Eq, S: BuildHasher + Default,

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator + Clone,

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator + Clone,

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
where K: Eq + Hash, S: BuildHasher + Default, A: Default + Allocator,

impl<P> FromIterator<P> for PathBuf
where P: AsRef<Path>,

impl<St> FromIterator<St> for SelectAll<St>
where St: Stream + Unpin,