Trait tor_hsservice::internal_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§
1.0.0 · 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<(String, Value)> for serde_json::map::Map<String, Value>
impl FromIterator<(String, String)> for OptionsMap
impl FromIterator<(String, Value)> for Map<String, Value>
impl FromIterator<Error> for Option<Error>
impl FromIterator<char> for alloc::boxed::Box<str>
no_global_oom_handling
only.impl FromIterator<char> for String
no_global_oom_handling
only.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<String> for alloc::boxed::Box<str>
no_global_oom_handling
only.impl FromIterator<String> for String
no_global_oom_handling
only.impl FromIterator<OsString> for OsString
impl FromIterator<CipherCtxFlags> for CipherCtxFlags
impl FromIterator<CMSOptions> for CMSOptions
impl FromIterator<OcspFlag> for OcspFlag
impl FromIterator<Pkcs7Flags> for Pkcs7Flags
impl FromIterator<ExtensionContext> for ExtensionContext
impl FromIterator<ShutdownState> for ShutdownState
impl FromIterator<SslMode> for SslMode
impl FromIterator<SslOptions> for SslOptions
impl FromIterator<SslSessionCacheMode> for SslSessionCacheMode
impl FromIterator<SslVerifyMode> for SslVerifyMode
impl FromIterator<X509CheckFlags> for X509CheckFlags
impl FromIterator<X509VerifyFlags> for X509VerifyFlags
impl FromIterator<Access> for Access
impl FromIterator<Access> for Access
impl FromIterator<AtFlags> for AtFlags
impl FromIterator<AtFlags> for AtFlags
impl FromIterator<AuthCertKeyIds> for AuthCertRequest
impl FromIterator<BeginFlags> for BeginFlags
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<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<FloatingPointEmulationControl> for FloatingPointEmulationControl
impl FromIterator<FloatingPointExceptionMode> for FloatingPointExceptionMode
impl FromIterator<IFlags> for IFlags
impl FromIterator<InputModes> for InputModes
impl FromIterator<Literal> for Seq
impl FromIterator<LocalModes> for LocalModes
impl FromIterator<MembarrierQuery> for MembarrierQuery
impl FromIterator<MemfdFlags> for MemfdFlags
impl FromIterator<MemfdFlags> for MemfdFlags
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<OFlags> for OFlags
impl FromIterator<OFlags> for OFlags
impl FromIterator<OutputModes> for OutputModes
impl FromIterator<PidfdFlags> for PidfdFlags
impl FromIterator<PidfdGetfdFlags> for PidfdGetfdFlags
impl FromIterator<PipeFlags> for PipeFlags
impl FromIterator<PipeFlags> for PipeFlags
impl FromIterator<PollFlags> for PollFlags
impl FromIterator<PollFlags> for PollFlags
impl FromIterator<ReadWriteFlags> for ReadWriteFlags
impl FromIterator<ReadWriteFlags> for ReadWriteFlags
impl FromIterator<RecvFlags> for RecvFlags
impl FromIterator<RelayFlags> for RelayFlags
impl FromIterator<RelayId> for RelayIdSet
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<SendFlags> for SendFlags
impl FromIterator<SockaddrXdpFlags> for SockaddrXdpFlags
impl FromIterator<SocketFlags> for SocketFlags
impl FromIterator<SpeculationFeatureControl> for SpeculationFeatureControl
impl FromIterator<SpeculationFeatureState> for SpeculationFeatureState
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
impl FromIterator<StatxFlags> for StatxFlags
impl FromIterator<Table> for ArrayOfTables
impl FromIterator<TimerfdFlags> for TimerfdFlags
impl FromIterator<TimerfdTimerFlags> for TimerfdTimerFlags
impl FromIterator<TrustAnchor<'static>> for RootCertStore
impl FromIterator<UnalignedAccessControl> for UnalignedAccessControl
impl FromIterator<UnmountFlags> for UnmountFlags
impl FromIterator<UnmountFlags> for UnmountFlags
impl FromIterator<WaitOptions> for WaitOptions
impl FromIterator<WaitidOptions> for WaitidOptions
impl FromIterator<WatchFlags> for WatchFlags
impl FromIterator<WatchFlags> for WatchFlags
impl FromIterator<XattrFlags> for XattrFlags
impl FromIterator<XattrFlags> for XattrFlags
impl FromIterator<XdpDescOptions> for XdpDescOptions
impl FromIterator<XdpOptionsFlags> for XdpOptionsFlags
impl FromIterator<XdpRingFlags> for XdpRingFlags
impl FromIterator<XdpUmemRegFlags> for XdpUmemRegFlags
impl FromIterator<[u8; 20]> for RouterDescRequest
routerdesc
only.impl FromIterator<[u8; 32]> for MicrodescRequest
impl<'a> FromIterator<&'a char> for alloc::boxed::Box<str>
no_global_oom_handling
only.impl<'a> FromIterator<&'a char> for String
no_global_oom_handling
only.impl<'a> FromIterator<&'a str> for alloc::boxed::Box<str>
no_global_oom_handling
only.impl<'a> FromIterator<&'a str> for String
no_global_oom_handling
only.impl<'a> FromIterator<&'a u8> for BytesMut
impl<'a> FromIterator<&'a OsStr> for OsString
impl<'a> FromIterator<Cow<'a, str>> for alloc::boxed::Box<str>
no_global_oom_handling
only.impl<'a> FromIterator<Cow<'a, str>> for String
no_global_oom_handling
only.impl<'a> FromIterator<Cow<'a, OsStr>> for OsString
impl<'a> FromIterator<char> for Cow<'a, str>
no_global_oom_handling
only.impl<'a> FromIterator<String> for Cow<'a, str>
no_global_oom_handling
only.impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>
no_global_oom_handling
only.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,
tarpaulin_include
only.§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,
tarpaulin_include
only.impl<'a, T, O> FromIterator<&'a T> for BitVec<T, O>where
T: BitStore,
O: BitOrder,
tarpaulin_include
only.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 alloc::boxed::Box<str>where
A: Allocator,
no_global_oom_handling
only.impl<A> FromIterator<Box<str, A>> for Stringwhere
A: Allocator,
no_global_oom_handling
only.impl<A> FromIterator<A> for AsciiStringwhere
A: AsRef<AsciiStr>,
impl<A, B, AE, BE> FromIterator<(AE, BE)> for (A, B)
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]);
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 tor_hsservice::internal_prelude::future::SelectAll<Fut>
impl<Fut> FromIterator<Fut> for SelectOk<Fut>
impl<Fut> FromIterator<Fut> for FuturesOrdered<Fut>where
Fut: Future,
impl<Fut> FromIterator<Fut> for FuturesUnordered<Fut>
impl<H> FromIterator<H> for ByRelayIds<H>
impl<I> FromIterator<I> for alloc::boxed::Box<[I]>
no_global_oom_handling
only.impl<I> FromIterator<I> for Box<[I]>
no_global_oom_handling
only.impl<K, T> FromIterator<(K, T)> for NetParams<T>
impl<K, V> FromIterator<(Range<K>, V)> for RangeMap<K, V>
impl<K, V> FromIterator<(RangeInclusive<K>, V)> for RangeInclusiveMap<K, V>
impl<K, V> FromIterator<(K, V)> for serde_json::value::Value
impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>where
K: Ord,
impl<K, V> FromIterator<(K, V)> for InlineTable
impl<K, V> FromIterator<(K, V)> for Table
impl<K, V> FromIterator<(K, V)> for Value
impl<K, V> FromIterator<V> for alloc::boxed::Box<TiSlice<K, V>>
impl<K, V> FromIterator<V> for TiVec<K, V>
impl<K, V, S> FromIterator<(<K as WeakElement>::Strong, <V as WeakElement>::Strong)> for PtrWeakWeakHashMap<K, V, S>
impl<K, V, S> FromIterator<(<K as WeakElement>::Strong, <V as WeakElement>::Strong)> for WeakWeakHashMap<K, V, S>
impl<K, V, S> FromIterator<(<K as WeakElement>::Strong, V)> for PtrWeakKeyHashMap<K, V, S>
impl<K, V, S> FromIterator<(<K as WeakElement>::Strong, V)> for WeakKeyHashMap<K, V, S>
impl<K, V, S> FromIterator<(K, <V as WeakElement>::Strong)> for WeakValueHashMap<K, V, S>
impl<K, V, S> FromIterator<(K, V)> for tor_hsservice::internal_prelude::HashMap<K, V, S>
impl<K, V, S> FromIterator<(K, V)> for IndexMap<K, V, S>
impl<K, V, S, A> FromIterator<(K, V)> for HashMap<K, V, S, A>
impl<P> FromIterator<P> for tor_hsservice::internal_prelude::PathBuf
impl<P> FromIterator<P> for PathBufwhere
P: AsRef<Path>,
impl<St> FromIterator<St> for SelectAll<St>
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<(HeaderName, T)> for HeaderMap<T>
impl<T> FromIterator<Range<T>> for RangeSet<T>
impl<T> FromIterator<RangeInclusive<T>> for RangeInclusiveSet<T>
impl<T> FromIterator<T> for serde_json::value::Value
impl<T> FromIterator<T> for Arc<[T]>
no_global_oom_handling
only.impl<T> FromIterator<T> for BinaryHeap<T>where
T: Ord,
impl<T> FromIterator<T> for VecDeque<T>
impl<T> FromIterator<T> for BTreeSet<T>where
T: Ord,
impl<T> FromIterator<T> for LinkedList<T>
impl<T> FromIterator<T> for Rc<[T]>
no_global_oom_handling
only.impl<T> FromIterator<T> for alloc::vec::Vec<T>
no_global_oom_handling
only.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);
}
impl<T> FromIterator<T> for Vec<T>
no_global_oom_handling
only.impl<T, F> FromIterator<F> for JoinSet<T>
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, 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,
tarpaulin_include
only.§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,
tarpaulin_include
only.impl<T, O, I> FromIterator<I> for BitBox<T, O>where
T: BitStore,
O: BitOrder,
BitVec<T, O>: FromIterator<I>,
tarpaulin_include
only.impl<T, S> FromIterator<<T as WeakElement>::Strong> for PtrWeakHashSet<T, S>
impl<T, S> FromIterator<<T as WeakElement>::Strong> for WeakHashSet<T, S>
impl<T, S> FromIterator<T> for tor_hsservice::internal_prelude::HashSet<T, S>
impl<T, S> FromIterator<T> for IndexSet<T, S>
impl<T, S, A> FromIterator<T> for HashSet<T, S, A>
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.