Trait otter_api_tests::iter::FromIterator
1.0.0 · source · [−]pub trait FromIterator<A> {
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
fn from_iter<T>(iter: T) -> Self where
T: IntoIterator<Item = A>,
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
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]);
Implementations on Foreign Types
1.52.0 · sourceimpl FromIterator<OsString> for OsString
impl FromIterator<OsString> for OsString
fn from_iter<I>(iter: I) -> OsString where
I: IntoIterator<Item = OsString>,
1.52.0 · sourceimpl<'a> FromIterator<&'a OsStr> for OsString
impl<'a> FromIterator<&'a OsStr> for OsString
fn from_iter<I>(iter: I) -> OsString where
I: IntoIterator<Item = &'a OsStr>,
1.52.0 · sourceimpl<'a> FromIterator<Cow<'a, OsStr>> for OsString
impl<'a> FromIterator<Cow<'a, OsStr>> for OsString
1.23.0 · sourceimpl FromIterator<()> for ()
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());
fn from_iter<I>(iter: I) where
I: IntoIterator<Item = ()>,
sourceimpl FromIterator<char> for String
impl FromIterator<char> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = char>,
sourceimpl<T> FromIterator<T> for BinaryHeap<T> where
T: Ord,
impl<T> FromIterator<T> for BinaryHeap<T> where
T: Ord,
fn from_iter<I>(iter: I) -> BinaryHeap<T> where
I: IntoIterator<Item = T>,
sourceimpl<T> FromIterator<T> for Vec<T, Global>
impl<T> FromIterator<T> for Vec<T, Global>
sourceimpl<'a> FromIterator<&'a str> for String
impl<'a> FromIterator<&'a str> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = &'a str>,
1.19.0 · sourceimpl<'a> FromIterator<Cow<'a, str>> for String
impl<'a> FromIterator<Cow<'a, str>> for String
1.4.0 · sourceimpl FromIterator<String> for String
impl FromIterator<String> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = String>,
1.37.0 · sourceimpl<T> FromIterator<T> for Rc<[T]>
impl<T> FromIterator<T> for Rc<[T]>
sourcefn from_iter<I>(iter: I) -> Rc<[T]> where
I: IntoIterator<Item = T>,
fn from_iter<I>(iter: I) -> Rc<[T]> where
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.
1.17.0 · sourceimpl<'a> FromIterator<&'a char> for String
impl<'a> FromIterator<&'a char> for String
fn from_iter<I>(iter: I) -> String where
I: IntoIterator<Item = &'a char>,
1.32.0 · sourceimpl<I> FromIterator<I> for Box<[I], Global>
impl<I> FromIterator<I> for Box<[I], Global>
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
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = I>,
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
sourceimpl<T> FromIterator<T> for LinkedList<T>
impl<T> FromIterator<T> for LinkedList<T>
fn from_iter<I>(iter: I) -> LinkedList<T> where
I: IntoIterator<Item = T>,
impl<A> FromIterator<<A as Array>::Item> for SmallVec<A> where
A: Array,
impl<A> FromIterator<<A as Array>::Item> for SmallVec<A> where
A: Array,
fn from_iter<I>(iterable: I) -> SmallVec<A> where
I: IntoIterator<Item = <A as Array>::Item>,
impl<EntryData> FromIterator<EntryData> for VecList<EntryData>
impl<EntryData> FromIterator<EntryData> for VecList<EntryData>
fn from_iter<Iter>(iter: Iter) -> VecList<EntryData> where
Iter: IntoIterator<Item = EntryData>,
impl FromIterator<Op> for Op
impl FromIterator<Op> for Op
fn from_iter<T>(iterator: T) -> Op where
T: IntoIterator<Item = Op>,
impl<T> FromIterator<(usize, T)> for Slab<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');
fn from_iter<I>(iterable: I) -> Slab<T> where
I: IntoIterator<Item = (usize, T)>,
impl FromIterator<WatchMask> for WatchMask
impl FromIterator<WatchMask> for WatchMask
fn from_iter<T>(iterator: T) -> WatchMask where
T: IntoIterator<Item = WatchMask>,
impl FromIterator<EventMask> for EventMask
impl FromIterator<EventMask> for EventMask
fn from_iter<T>(iterator: T) -> EventMask where
T: IntoIterator<Item = EventMask>,
impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>, 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
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = A>,
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
impl FromIterator<FileType> for FileType
impl FromIterator<FileType> for FileType
fn from_iter<T>(iterator: T) -> FileType where
T: IntoIterator<Item = FileType>,
impl FromIterator<u8> for BString
impl FromIterator<u8> for BString
fn from_iter<T>(iter: T) -> BString where
T: IntoIterator<Item = u8>,
impl<'a> FromIterator<&'a BStr> for BString
impl<'a> FromIterator<&'a BStr> for BString
fn from_iter<T>(iter: T) -> BString where
T: IntoIterator<Item = &'a BStr>,
impl<'a> FromIterator<&'a [u8]> for BString
impl<'a> FromIterator<&'a [u8]> for BString
fn from_iter<T>(iter: T) -> BString where
T: IntoIterator<Item = &'a [u8]>,
impl FromIterator<char> for BString
impl FromIterator<char> for BString
fn from_iter<T>(iter: T) -> BString where
T: IntoIterator<Item = char>,
impl FromIterator<BString> for BString
impl FromIterator<BString> for BString
fn from_iter<T>(iter: T) -> BString where
T: IntoIterator<Item = BString>,
impl<'a> FromIterator<&'a str> for BString
impl<'a> FromIterator<&'a str> for BString
fn from_iter<T>(iter: T) -> BString where
T: IntoIterator<Item = &'a str>,
sourceimpl<'a> FromIterator<(Ident<'a>, Value<'a>)> for ParamsString
impl<'a> FromIterator<(Ident<'a>, Value<'a>)> for ParamsString
fn from_iter<I>(iter: I) -> ParamsString where
I: IntoIterator<Item = (Ident<'a>, Value<'a>)>,
impl<A> FromIterator<<A as Array>::Item> for ArrayVec<A> where
A: Array,
impl<A> FromIterator<<A as Array>::Item> for ArrayVec<A> where
A: Array,
fn from_iter<T>(iter: T) -> ArrayVec<A> where
T: IntoIterator<Item = <A as Array>::Item>,
impl<A> FromIterator<<A as Array>::Item> for TinyVec<A> where
A: Array,
impl<A> FromIterator<<A as Array>::Item> for TinyVec<A> where
A: Array,
fn from_iter<T>(iter: T) -> TinyVec<A> where
T: IntoIterator<Item = <A as Array>::Item>,
impl FromIterator<Transformations> for Transformations
impl FromIterator<Transformations> for Transformations
fn from_iter<T>(iterator: T) -> Transformations where
T: IntoIterator<Item = Transformations>,
impl<V> FromIterator<(usize, V)> for VecMap<V>
impl<V> FromIterator<(usize, V)> for VecMap<V>
fn from_iter<I>(iter: I) -> VecMap<V> where
I: IntoIterator<Item = (usize, V)>,
sourceimpl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>
impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T>
fn from_iter<I>(iter: I) -> HeaderMap<T> where
I: IntoIterator<Item = (HeaderName, T)>,
impl FromIterator<u8> for BytesMut
impl FromIterator<u8> for BytesMut
fn from_iter<T>(into_iter: T) -> BytesMut where
T: IntoIterator<Item = u8>,
impl FromIterator<u8> for Bytes
impl FromIterator<u8> for Bytes
fn from_iter<T>(into_iter: T) -> Bytes where
T: IntoIterator<Item = u8>,
impl<'a> FromIterator<&'a u8> for BytesMut
impl<'a> FromIterator<&'a u8> for BytesMut
fn from_iter<T>(into_iter: T) -> BytesMut where
T: IntoIterator<Item = &'a u8>,
impl<Fut> FromIterator<Fut> for FuturesOrdered<Fut> where
Fut: Future,
impl<Fut> FromIterator<Fut> for FuturesOrdered<Fut> where
Fut: Future,
fn from_iter<T>(iter: T) -> FuturesOrdered<Fut> where
T: IntoIterator<Item = Fut>,
impl<Fut> FromIterator<Fut> for SelectOk<Fut> where
Fut: TryFuture + Unpin,
impl<Fut> FromIterator<Fut> for SelectOk<Fut> where
Fut: TryFuture + Unpin,
impl<Fut> FromIterator<Fut> for SelectAll<Fut> where
Fut: Future + Unpin,
impl<Fut> FromIterator<Fut> for SelectAll<Fut> where
Fut: Future + Unpin,
impl<St> FromIterator<St> for SelectAll<St> where
St: Stream + Unpin,
impl<St> FromIterator<St> for SelectAll<St> where
St: Stream + Unpin,
fn from_iter<T>(iter: T) -> SelectAll<St> where
T: IntoIterator<Item = St>,
impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>
impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>
fn from_iter<I>(iter: I) -> FuturesUnordered<Fut> where
I: IntoIterator<Item = Fut>,
impl<F> FromIterator<F> for TryJoinAll<F> where
F: TryFuture,
impl<F> FromIterator<F> for TryJoinAll<F> where
F: TryFuture,
impl<F> FromIterator<F> for JoinAll<F> where
F: Future,
impl<F> FromIterator<F> for JoinAll<F> where
F: Future,
sourceimpl<K, V, S> FromIterator<(K, V)> for 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,
sourceimpl<T, S> FromIterator<T> for 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,
fn from_iter<I>(iterable: I) -> IndexSet<T, S> where
I: IntoIterator<Item = T>,
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,
fn from_iter<I>(iter: I) -> HashSet<T, S, A> where
I: IntoIterator<Item = T>,
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,
fn from_iter<T>(iter: T) -> HashMap<K, V, S, A> where
T: IntoIterator<Item = (K, V)>,
sourceimpl FromIterator<SslOptions> for SslOptions
impl FromIterator<SslOptions> for SslOptions
fn from_iter<T>(iterator: T) -> SslOptions where
T: IntoIterator<Item = SslOptions>,
sourceimpl FromIterator<ExtensionContext> for ExtensionContext
impl FromIterator<ExtensionContext> for ExtensionContext
fn from_iter<T>(iterator: T) -> ExtensionContext where
T: IntoIterator<Item = ExtensionContext>,
sourceimpl FromIterator<X509VerifyFlags> for X509VerifyFlags
impl FromIterator<X509VerifyFlags> for X509VerifyFlags
fn from_iter<T>(iterator: T) -> X509VerifyFlags where
T: IntoIterator<Item = X509VerifyFlags>,
sourceimpl FromIterator<OcspFlag> for OcspFlag
impl FromIterator<OcspFlag> for OcspFlag
fn from_iter<T>(iterator: T) -> OcspFlag where
T: IntoIterator<Item = OcspFlag>,
sourceimpl FromIterator<SslSessionCacheMode> for SslSessionCacheMode
impl FromIterator<SslSessionCacheMode> for SslSessionCacheMode
fn from_iter<T>(iterator: T) -> SslSessionCacheMode where
T: IntoIterator<Item = SslSessionCacheMode>,
sourceimpl FromIterator<CMSOptions> for CMSOptions
impl FromIterator<CMSOptions> for CMSOptions
fn from_iter<T>(iterator: T) -> CMSOptions where
T: IntoIterator<Item = CMSOptions>,
sourceimpl FromIterator<SslMode> for SslMode
impl FromIterator<SslMode> for SslMode
fn from_iter<T>(iterator: T) -> SslMode where
T: IntoIterator<Item = SslMode>,
sourceimpl FromIterator<SslVerifyMode> for SslVerifyMode
impl FromIterator<SslVerifyMode> for SslVerifyMode
fn from_iter<T>(iterator: T) -> SslVerifyMode where
T: IntoIterator<Item = SslVerifyMode>,
sourceimpl FromIterator<Pkcs7Flags> for Pkcs7Flags
impl FromIterator<Pkcs7Flags> for Pkcs7Flags
fn from_iter<T>(iterator: T) -> Pkcs7Flags where
T: IntoIterator<Item = Pkcs7Flags>,
sourceimpl FromIterator<ShutdownState> for ShutdownState
impl FromIterator<ShutdownState> for ShutdownState
fn from_iter<T>(iterator: T) -> ShutdownState where
T: IntoIterator<Item = ShutdownState>,
sourceimpl FromIterator<X509CheckFlags> for X509CheckFlags
impl FromIterator<X509CheckFlags> for X509CheckFlags
fn from_iter<T>(iterator: T) -> X509CheckFlags where
T: IntoIterator<Item = X509CheckFlags>,
Implementors
impl FromIterator<(String, Value)> for otter_api_tests::imports::toml::value::Map<String, Value>
impl FromIterator<(String, Value)> for otter_api_tests::serde_json::Map<String, Value>
impl FromIterator<AtFlags> for AtFlags
impl FromIterator<FallocateFlags> for FallocateFlags
impl FromIterator<FdFlag> for otter_api_tests::imports::nix::fcntl::FdFlag
impl FromIterator<OFlag> for OFlag
impl FromIterator<RenameFlags> for RenameFlags
impl FromIterator<SealFlag> for SealFlag
impl FromIterator<SpliceFFlags> for SpliceFFlags
impl FromIterator<DeleteModuleFlags> for DeleteModuleFlags
impl FromIterator<ModuleInitFlags> for ModuleInitFlags
impl FromIterator<MntFlags> for MntFlags
impl FromIterator<MsFlags> for otter_api_tests::imports::nix::mount::MsFlags
impl FromIterator<FdFlag> for otter_api_tests::imports::nix::mqueue::FdFlag
impl FromIterator<MQ_OFlag> for MQ_OFlag
impl FromIterator<InterfaceFlags> for InterfaceFlags
impl FromIterator<PollFlags> for PollFlags
impl FromIterator<CloneFlags> for CloneFlags
impl FromIterator<EpollCreateFlags> for EpollCreateFlags
impl FromIterator<EpollFlags> for EpollFlags
impl FromIterator<EfdFlags> for EfdFlags
impl FromIterator<AddWatchFlags> for AddWatchFlags
impl FromIterator<InitFlags> for InitFlags
impl FromIterator<MemFdCreateFlag> for MemFdCreateFlag
impl FromIterator<MRemapFlags> for MRemapFlags
impl FromIterator<MapFlags> for MapFlags
impl FromIterator<MlockAllFlags> for MlockAllFlags
impl FromIterator<MsFlags> for otter_api_tests::imports::nix::sys::mman::MsFlags
impl FromIterator<ProtFlags> for ProtFlags
impl FromIterator<Persona> for Persona
impl FromIterator<Options> for Options
impl FromIterator<QuotaValidFlags> for QuotaValidFlags
impl FromIterator<SaFlags> for SaFlags
impl FromIterator<SfdFlags> for SfdFlags
impl FromIterator<MsgFlags> for MsgFlags
impl FromIterator<SockFlag> for SockFlag
impl FromIterator<Mode> for Mode
impl FromIterator<SFlag> for SFlag
impl FromIterator<FsFlags> for FsFlags
impl FromIterator<ControlFlags> for ControlFlags
impl FromIterator<InputFlags> for InputFlags
impl FromIterator<LocalFlags> for LocalFlags
impl FromIterator<OutputFlags> for OutputFlags
impl FromIterator<TimerFlags> for TimerFlags
impl FromIterator<TimerSetTimeFlags> for TimerSetTimeFlags
impl FromIterator<WaitPidFlag> for WaitPidFlag
impl FromIterator<AccessFlags> for AccessFlags
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, 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, T> FromIterator<T> for IndexVec<I, T> where
I: Idx,
impl<K, V> FromIterator<(K, V)> for Value where
K: Into<String>,
V: Into<Value>,
impl<K, V> FromIterator<(K, V)> for SecondaryMap<K, V> where
K: Key,
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V> where
K: Ord,
impl<K, V> FromIterator<(K, V)> for EnumMap<K, V> where
K: EnumArray<V>,
EnumMap<K, V>: Default,
impl<K, V, S> FromIterator<(K, V)> for otter_api_tests::shapelib::HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher + Default,
impl<K, V, S> FromIterator<(K, V)> for SparseSecondaryMap<K, V, S> where
K: Key,
S: BuildHasher + Default,
impl<P> FromIterator<P> for PathBuf where
P: AsRef<Path>,
impl<T> FromIterator<T> for Value where
T: Into<Value>,
impl<T> FromIterator<T> for Arc<[T]>
impl<T> FromIterator<T> for BTreeSet<T> where
T: Ord,
impl<T> FromIterator<T> for VecDeque<T, Global>
impl<T, N> FromIterator<T> for GenericArray<T, N> where
N: ArrayLength<T>,
impl<T, S> FromIterator<T> for otter_api_tests::shapelib::HashSet<T, S> where
T: Eq + Hash,
S: BuildHasher + Default,
impl<T, const CAP: usize> FromIterator<T> for otter_api_tests::shapelib::ArrayVec<T, CAP>
Create an ArrayVec
from an iterator.
Panics if the number of elements in the iterator exceeds the arrayvec’s capacity.