Skip to main content

Send

Trait Send 

1.0.0 · Source
pub unsafe auto trait Send { }
Expand description

Types that can be transferred across thread boundaries.

This trait is automatically implemented when the compiler determines it’s appropriate.

An example of a non-Send type is the reference-counting pointer rc::Rc. If two threads attempt to clone Rcs that point to the same reference-counted value, they might try to update the reference count at the same time, which is undefined behavior because Rc doesn’t use atomic operations. Its cousin sync::Arc does use atomic operations (incurring some overhead) and thus is Send.

See the Nomicon and the Sync trait for more details.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§

1.26.0 · Source§

impl !Send for Args

1.26.0 · Source§

impl !Send for ArgsOs

1.0.0 · Source§

impl !Send for Arguments<'_>

Source§

impl !Send for LocalWaker

1.98.0 · Source§

impl !Send for VarsOs

Source§

impl Send for core::ffi::c_str::Bytes<'_>

1.6.0 · Source§

impl Send for radix_rust::rust::string::Drain<'_>

1.10.0 · Source§

impl Send for Location<'_>

1.0.0 · Source§

impl Send for TypeId

1.36.0 · Source§

impl Send for Waker

1.44.0 · Source§

impl<'a> Send for IoSlice<'a>

1.44.0 · Source§

impl<'a> Send for IoSliceMut<'a>

Source§

impl<Dyn> Send for DynMetadata<Dyn>
where Dyn: ?Sized,

Source§

impl<K, V, S, A> Send for hashbrown::map::OccupiedEntry<'_, K, V, S, A>
where K: Send, V: Send, S: Send, A: Send + Allocator,

Source§

impl<K, V> Send for hashbrown::map::IterMut<'_, K, V>
where K: Send, V: Send,

1.0.0 · Source§

impl<T, A> !Send for Rc<T, A>
where A: Allocator, T: ?Sized,

Source§

impl<T, A> !Send for UniqueRc<T, A>
where A: Allocator, T: ?Sized,

1.4.0 · Source§

impl<T, A> !Send for radix_rust::rust::rc::Weak<T, A>
where A: Allocator, T: ?Sized,

1.0.0 · Source§

impl<T, A> Send for Arc<T, A>
where T: Sync + Send + ?Sized, A: Allocator + Send + Sync,

Source§

impl<T, A> Send for alloc::collections::linked_list::Cursor<'_, T, A>
where T: Sync, A: Allocator + Sync,

Source§

impl<T, A> Send for alloc::collections::linked_list::CursorMut<'_, T, A>
where T: Send, A: Allocator + Send,

1.6.0 · Source§

impl<T, A> Send for alloc::collections::vec_deque::drain::Drain<'_, T, A>
where T: Send, A: Allocator + Send,

1.6.0 · Source§

impl<T, A> Send for radix_rust::rust::vec::Drain<'_, T, A>
where T: Send, A: Send + Allocator,

1.0.0 · Source§

impl<T, A> Send for radix_rust::rust::vec::IntoIter<T, A>
where T: Send, A: Allocator + Send,

1.0.0 · Source§

impl<T, A> Send for LinkedList<T, A>
where T: Send, A: Allocator + Send,

Source§

impl<T, A> Send for hashbrown::table::OccupiedEntry<'_, T, A>
where T: Send, A: Send + Allocator,

Source§

impl<T, A> Send for UniqueArc<T, A>
where T: Sync + Send + ?Sized, A: Allocator + Send + Sync,

1.4.0 · Source§

impl<T, A> Send for radix_rust::rust::sync::Weak<T, A>
where T: Sync + Send + ?Sized, A: Allocator + Send + Sync,

1.0.0 · Source§

impl<T> !Send for *const T
where T: ?Sized,

1.0.0 · Source§

impl<T> !Send for *mut T
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::nonpoison::MappedMutexGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::MappedMutexGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::nonpoison::MappedRwLockReadGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::MappedRwLockReadGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::nonpoison::MappedRwLockWriteGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::MappedRwLockWriteGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::nonpoison::MutexGuard<'_, T>
where T: ?Sized,

A MutexGuard is not Send to maximize platform portability.

On platforms that use POSIX threads (commonly referred to as pthreads) there is a requirement to release mutex locks on the same thread they were acquired. For this reason, MutexGuard must not implement Send to prevent it being dropped from another thread.

1.0.0 · Source§

impl<T> !Send for radix_rust::rust::sync::MutexGuard<'_, T>
where T: ?Sized,

A MutexGuard is not Send to maximize platform portability.

On platforms that use POSIX threads (commonly referred to as pthreads) there is a requirement to release mutex locks on the same thread they were acquired. For this reason, MutexGuard must not implement Send to prevent it being dropped from another thread.

1.25.0 · Source§

impl<T> !Send for NonNull<T>
where T: ?Sized,

NonNull pointers are not Send because the data they reference may be aliased.

Source§

impl<T> !Send for ReentrantLockGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::nonpoison::RwLockReadGuard<'_, T>
where T: ?Sized,

1.0.0 · Source§

impl<T> !Send for radix_rust::rust::sync::RwLockReadGuard<'_, T>
where T: ?Sized,

Source§

impl<T> !Send for radix_rust::rust::sync::nonpoison::RwLockWriteGuard<'_, T>
where T: ?Sized,

1.0.0 · Source§

impl<T> !Send for radix_rust::rust::sync::RwLockWriteGuard<'_, T>
where T: ?Sized,

1.0.0 · Source§

impl<T> Send for &T
where T: Sync + ?Sized,

1.0.0 · Source§

impl<T> Send for Atomic<T>
where T: AtomicPrimitive,

1.0.0 · Source§

impl<T> Send for Cell<T>
where T: Send + ?Sized,

1.31.0 · Source§

impl<T> Send for ChunksExactMut<'_, T>
where T: Send,

1.0.0 · Source§

impl<T> Send for ChunksMut<'_, T>
where T: Send,

1.0.0 · Source§

impl<T> Send for radix_rust::rust::slice::Iter<'_, T>
where T: Sync,

1.0.0 · Source§

impl<T> Send for alloc::collections::linked_list::Iter<'_, T>
where T: Sync,

1.0.0 · Source§

impl<T> Send for radix_rust::rust::slice::IterMut<'_, T>
where T: Send,

1.0.0 · Source§

impl<T> Send for alloc::collections::linked_list::IterMut<'_, T>
where T: Send,

1.29.0 · Source§

impl<T> Send for JoinHandle<T>

Source§

impl<T> Send for radix_rust::rust::sync::nonpoison::Mutex<T>
where T: Send + ?Sized,

T must be Send for a Mutex to be Send because it is possible to acquire the owned T from the Mutex via into_inner.

1.0.0 · Source§

impl<T> Send for radix_rust::rust::sync::Mutex<T>
where T: Send + ?Sized,

T must be Send for a Mutex to be Send because it is possible to acquire the owned T from the Mutex via into_inner.

1.28.0 · Source§

impl<T> Send for NonZero<T>

1.70.0 · Source§

impl<T> Send for OnceLock<T>
where T: Send,

1.31.0 · Source§

impl<T> Send for RChunksExactMut<'_, T>
where T: Send,

1.31.0 · Source§

impl<T> Send for RChunksMut<'_, T>
where T: Send,

Source§

impl<T> Send for radix_rust::rust::sync::mpmc::Receiver<T>
where T: Send,

1.0.0 · Source§

impl<T> Send for radix_rust::rust::sync::mpsc::Receiver<T>
where T: Send,

Source§

impl<T> Send for ReentrantLock<T>
where T: Send + ?Sized,

1.0.0 · Source§

impl<T> Send for RefCell<T>
where T: Send + ?Sized,

Source§

impl<T> Send for radix_rust::rust::sync::nonpoison::RwLock<T>
where T: Send + ?Sized,

1.0.0 · Source§

impl<T> Send for radix_rust::rust::sync::RwLock<T>
where T: Send + ?Sized,

Source§

impl<T> Send for radix_rust::rust::sync::mpmc::Sender<T>
where T: Send,

1.0.0 · Source§

impl<T> Send for radix_rust::rust::sync::mpsc::Sender<T>
where T: Send,

1.0.0 · Source§

impl<T> Send for SyncSender<T>
where T: Send,

Source§

impl<T> Send for ThinBox<T>
where T: Send + ?Sized,

ThinBox<T> is Send if T is Send because the data is owned.

Auto implementors§

§

impl Send for Abi

§

impl Send for radix_rust::rust::fmt::Alignment

§

impl Send for radix_rust::rust::mem::Alignment

§

impl Send for AllocError

§

impl Send for Assume

§

impl Send for Barrier

§

impl Send for BarrierWaitResult

§

impl Send for BorrowError

§

impl Send for BorrowMutError

§

impl Send for radix_rust::rust::sync::nonpoison::Condvar

§

impl Send for radix_rust::rust::sync::Condvar

§

impl Send for Const

§

impl Send for DebugAsHex

§

impl Send for DefaultHasher

§

impl Send for DynTrait

§

impl Send for DynTraitPredicate

§

impl Send for Error

§

impl Send for FieldId

§

impl Send for FnPtr

§

impl Send for FormattingOptions

§

impl Send for FpCategory

§

impl Send for FromUtf8Error

§

impl Send for FromUtf16Error

§

impl Send for Generic

§

impl Send for GenericType

§

impl Send for GetDisjointMutError

§

impl Send for Global

§

impl Send for IntErrorKind

§

impl Send for IntoChars

§

impl Send for Layout

§

impl Send for LayoutError

§

impl Send for Lifetime

§

impl Send for radix_rust::rust::sync::Once

§

impl Send for OnceState

§

impl Send for OneSidedRangeBound

§

impl Send for radix_rust::rust::cmp::Ordering

§

impl Send for radix_rust::rust::sync::atomic::Ordering

§

impl Send for ParseBoolError

§

impl Send for ParseFloatError

§

impl Send for ParseIntError

§

impl Send for PhantomPinned

§

impl Send for RandomState

§

impl Send for RangeFull

§

impl Send for RecvError

§

impl Send for radix_rust::rust::sync::mpmc::RecvTimeoutError

§

impl Send for SearchStep

§

impl Send for Sign

§

impl Send for SipHasher

§

impl Send for Str

§

impl Send for String

§

impl Send for System

§

impl Send for Trait

§

impl Send for TryFromIntError

§

impl Send for radix_rust::rust::sync::mpmc::TryRecvError

§

impl Send for Type

§

impl Send for TypeKind

§

impl Send for UnorderedKeyError

§

impl Send for Utf8Error

§

impl Send for VariantId

§

impl Send for WaitTimeoutResult

§

impl Send for WouldBlock

§

impl<'a, 'b, const N: usize> Send for CharArrayRefSearcher<'a, 'b, N>
where <MultiCharEqPattern<&'b [char; N]> as Pattern>::Searcher<'a>: Send,

§

impl<'a, 'b> !Send for DebugList<'a, 'b>

§

impl<'a, 'b> !Send for DebugMap<'a, 'b>

§

impl<'a, 'b> !Send for DebugSet<'a, 'b>

§

impl<'a, 'b> !Send for DebugStruct<'a, 'b>

§

impl<'a, 'b> !Send for DebugTuple<'a, 'b>

§

impl<'a, 'b> Send for CharSliceSearcher<'a, 'b>

§

impl<'a, 'b> Send for StrSearcher<'a, 'b>

§

impl<'a, A> Send for radix_rust::rust::option::Iter<'a, A>
where Item<&'a A>: Send,

§

impl<'a, A> Send for radix_rust::rust::option::IterMut<'a, A>
where Item<&'a mut A>: Send,

§

impl<'a, B> Send for Cow<'a, B>
where &'a B: Send, <B as ToOwned>::Owned: Send, B: ?Sized,

§

impl<'a, F> Send for CharPredicateSearcher<'a, F>
where <MultiCharEqPattern<F> as Pattern>::Searcher<'a>: Send,

§

impl<'a, I, A> Send for Splice<'a, I, A>
where Drain<'a, <I as Iterator>::Item, A>: Send, I: Send,

§

impl<'a, I> Send for ByRefSized<'a, I>
where &'a mut I: Send,

§

impl<'a, K, A> Send for radix_rust::rust::collections::btree_set::CursorMut<'a, K, A>
where CursorMut<'a, K, SetValZST, A>: Send,

§

impl<'a, K, A> Send for radix_rust::rust::collections::btree_set::CursorMutKey<'a, K, A>
where CursorMutKey<'a, K, SetValZST, A>: Send,

§

impl<'a, K, A> Send for radix_rust::rust::collections::hash_set::Drain<'a, K, A>
where Drain<'a, K, A>: Send,

§

impl<'a, K, F, A> Send for radix_rust::rust::collections::hash_set::ExtractIf<'a, K, F, A>
where ExtractIf<'a, K, F, A>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::btree_map::CursorMut<'a, K, V, A>
where CursorMutKey<'a, K, V, A>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::btree_map::CursorMutKey<'a, K, V, A>
where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: Send, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: Send, &'a mut A: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::hash_map::Drain<'a, K, V, A>
where Drain<'a, K, V, A>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::hash_map::Entry<'a, K, V, A>
where OccupiedEntry<'a, K, V, A>: Send, VacantEntry<'a, K, V, A>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::btree_map::Entry<'a, K, V, A>
where VacantEntry<'a, K, V, A>: Send, OccupiedEntry<'a, K, V, A>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::btree_map::OccupiedEntry<'a, K, V, A>
where Handle<NodeRef<Mut<'a>, K, V, LeafOrInternal>, KV>: Send, DormantMutRef<'a, BTreeMap<K, V, A>>: Send, A: Send, PhantomData<&'a mut (K, V)>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::hash_map::OccupiedEntry<'a, K, V, A>
where RustcOccupiedEntry<'a, K, V, A>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::btree_map::OccupiedError<'a, K, V, A>
where OccupiedEntry<'a, K, V, A>: Send, K: Send, V: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::hash_map::OccupiedError<'a, K, V, A>
where OccupiedEntry<'a, K, V, A>: Send, K: Send, V: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::btree_map::VacantEntry<'a, K, V, A>
where K: Send, Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: Send, DormantMutRef<'a, BTreeMap<K, V, A>>: Send, A: Send, PhantomData<&'a mut (K, V)>: Send,

§

impl<'a, K, V, A> Send for radix_rust::rust::collections::hash_map::VacantEntry<'a, K, V, A>
where RustcVacantEntry<'a, K, V, A>: Send,

§

impl<'a, K, V, F, A> Send for radix_rust::rust::collections::hash_map::ExtractIf<'a, K, V, F, A>
where ExtractIf<'a, K, V, F, A>: Send,

§

impl<'a, K, V, R, F, A> Send for radix_rust::rust::collections::btree_map::ExtractIf<'a, K, V, R, F, A>
where F: Send, ExtractIfInner<'a, K, V, R>: Send, A: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::Cursor<'a, K, V>
where Option<Handle<NodeRef<Immut<'a>, K, V, Leaf>, Edge>>: Send, Option<&'a NodeRef<Owned, K, V, LeafOrInternal>>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::hash_map::Iter<'a, K, V>
where Iter<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::Iter<'a, K, V>
where LazyLeafRange<Immut<'a>, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::hash_map::IterMut<'a, K, V>
where IterMut<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::IterMut<'a, K, V>
where LazyLeafRange<ValMut<'a>, K, V>: Send, PhantomData<&'a mut (K, V)>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::Keys<'a, K, V>
where Iter<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::hash_map::Keys<'a, K, V>
where Iter<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::Range<'a, K, V>
where LeafRange<Immut<'a>, K, V>: Send,

§

impl<'a, K, V> Send for RangeMut<'a, K, V>
where LeafRange<ValMut<'a>, K, V>: Send, PhantomData<&'a mut (K, V)>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::Values<'a, K, V>
where Iter<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::hash_map::Values<'a, K, V>
where Iter<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::btree_map::ValuesMut<'a, K, V>
where IterMut<'a, K, V>: Send,

§

impl<'a, K, V> Send for radix_rust::rust::collections::hash_map::ValuesMut<'a, K, V>
where IterMut<'a, K, V>: Send,

§

impl<'a, K> Send for radix_rust::rust::collections::btree_set::Cursor<'a, K>
where Cursor<'a, K, SetValZST>: Send,

§

impl<'a, K> Send for radix_rust::rust::collections::hash_set::Iter<'a, K>
where Iter<'a, K>: Send,

§

impl<'a, P> Send for MatchIndices<'a, P>
where MatchIndicesInternal<'a, P>: Send,

§

impl<'a, P> Send for Matches<'a, P>
where MatchesInternal<'a, P>: Send,

§

impl<'a, P> Send for RMatchIndices<'a, P>
where MatchIndicesInternal<'a, P>: Send,

§

impl<'a, P> Send for RMatches<'a, P>
where MatchesInternal<'a, P>: Send,

§

impl<'a, P> Send for radix_rust::rust::str::RSplit<'a, P>
where SplitInternal<'a, P>: Send,

§

impl<'a, P> Send for radix_rust::rust::str::RSplitN<'a, P>
where SplitNInternal<'a, P>: Send,

§

impl<'a, P> Send for RSplitTerminator<'a, P>
where SplitInternal<'a, P>: Send,

§

impl<'a, P> Send for radix_rust::rust::str::Split<'a, P>
where SplitInternal<'a, P>: Send,

§

impl<'a, P> Send for radix_rust::rust::str::SplitInclusive<'a, P>
where SplitInternal<'a, P>: Send,

§

impl<'a, P> Send for radix_rust::rust::str::SplitN<'a, P>
where SplitNInternal<'a, P>: Send,

§

impl<'a, P> Send for SplitTerminator<'a, P>
where SplitInternal<'a, P>: Send,

§

impl<'a, T, A> Send for radix_rust::rust::collections::btree_set::Difference<'a, T, A>
where DifferenceInner<'a, T, A>: Send,

§

impl<'a, T, A> Send for radix_rust::rust::collections::btree_set::Entry<'a, T, A>
where OccupiedEntry<'a, T, A>: Send, VacantEntry<'a, T, A>: Send,

§

impl<'a, T, A> Send for radix_rust::rust::collections::btree_set::Intersection<'a, T, A>
where IntersectionInner<'a, T, A>: Send,

§

impl<'a, T, A> Send for radix_rust::rust::collections::btree_set::OccupiedEntry<'a, T, A>
where OccupiedEntry<'a, T, SetValZST, A>: Send,

§

impl<'a, T, A> Send for PeekMut<'a, T, A>
where &'a mut Vec<T, A>: Send,

§

impl<'a, T, A> Send for radix_rust::rust::collections::btree_set::VacantEntry<'a, T, A>
where VacantEntry<'a, T, SetValZST, A>: Send,

§

impl<'a, T, F, A> Send for radix_rust::rust::vec::ExtractIf<'a, T, F, A>
where &'a mut Vec<T, A>: Send, F: Send,

§

impl<'a, T, P> Send for ChunkBy<'a, T, P>
where &'a [T]: Send, P: Send,

§

impl<'a, T, P> Send for ChunkByMut<'a, T, P>
where &'a mut [T]: Send, P: Send,

§

impl<'a, T, P> Send for radix_rust::rust::slice::RSplit<'a, T, P>
where Split<'a, T, P>: Send,

§

impl<'a, T, P> Send for RSplitMut<'a, T, P>
where SplitMut<'a, T, P>: Send,

§

impl<'a, T, P> Send for radix_rust::rust::slice::RSplitN<'a, T, P>
where GenericSplitN<RSplit<'a, T, P>>: Send,

§

impl<'a, T, P> Send for RSplitNMut<'a, T, P>
where GenericSplitN<RSplitMut<'a, T, P>>: Send,

§

impl<'a, T, P> Send for radix_rust::rust::slice::Split<'a, T, P>
where &'a [T]: Send, P: Send,

§

impl<'a, T, P> Send for radix_rust::rust::slice::SplitInclusive<'a, T, P>
where &'a [T]: Send, P: Send,

§

impl<'a, T, P> Send for SplitInclusiveMut<'a, T, P>
where &'a mut [T]: Send, P: Send,

§

impl<'a, T, P> Send for SplitMut<'a, T, P>
where &'a mut [T]: Send, P: Send,

§

impl<'a, T, P> Send for radix_rust::rust::slice::SplitN<'a, T, P>
where GenericSplitN<Split<'a, T, P>>: Send,

§

impl<'a, T, P> Send for SplitNMut<'a, T, P>
where GenericSplitN<SplitMut<'a, T, P>>: Send,

§

impl<'a, T, R, F, A> Send for radix_rust::rust::collections::btree_set::ExtractIf<'a, T, R, F, A>
where F: Send, ExtractIfInner<'a, T, SetValZST, R>: Send, A: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::Difference<'a, T, S, A>
where Iter<'a, T>: Send, &'a HashSet<T, S, A>: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::Entry<'a, T, S, A>
where OccupiedEntry<'a, T, S, A>: Send, VacantEntry<'a, T, S, A>: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::Intersection<'a, T, S, A>
where Iter<'a, T>: Send, &'a HashSet<T, S, A>: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::OccupiedEntry<'a, T, S, A>
where OccupiedEntry<'a, T, S, A>: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::SymmetricDifference<'a, T, S, A>
where Chain<Difference<'a, T, S, A>, Difference<'a, T, S, A>>: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::Union<'a, T, S, A>
where Chain<Iter<'a, T>, Difference<'a, T, S, A>>: Send,

§

impl<'a, T, S, A> Send for radix_rust::rust::collections::hash_set::VacantEntry<'a, T, S, A>
where VacantEntry<'a, T, S, A>: Send,

§

impl<'a, T, const N: usize> Send for ArrayWindows<'a, T, N>
where &'a [T]: Send,

§

impl<'a, T> !Send for radix_rust::rust::sync::mpsc::Iter<'a, T>

§

impl<'a, T> !Send for radix_rust::rust::sync::mpsc::TryIter<'a, T>

§

impl<'a, T> Send for Chunks<'a, T>
where &'a [T]: Send,

§

impl<'a, T> Send for ChunksExact<'a, T>
where &'a [T]: Send,

§

impl<'a, T> Send for radix_rust::rust::sync::mpmc::Iter<'a, T>
where &'a Receiver<T>: Send,

§

impl<'a, T> Send for radix_rust::rust::collections::btree_set::Iter<'a, T>
where Keys<'a, T, SetValZST>: Send,

§

impl<'a, T> Send for radix_rust::rust::result::Iter<'a, T>
where Option<&'a T>: Send,

§

impl<'a, T> Send for radix_rust::rust::result::IterMut<'a, T>

§

impl<'a, T> Send for RChunks<'a, T>
where &'a [T]: Send,

§

impl<'a, T> Send for RChunksExact<'a, T>
where &'a [T]: Send,

§

impl<'a, T> Send for radix_rust::rust::collections::btree_set::Range<'a, T>
where Range<'a, T, SetValZST>: Send,

§

impl<'a, T> Send for radix_rust::rust::collections::btree_set::SymmetricDifference<'a, T>
where MergeIterInner<Iter<'a, T>>: Send,

§

impl<'a, T> Send for radix_rust::rust::sync::mpmc::TryIter<'a, T>
where &'a Receiver<T>: Send,

§

impl<'a, T> Send for radix_rust::rust::collections::btree_set::Union<'a, T>
where MergeIterInner<Iter<'a, T>>: Send,

§

impl<'a, T> Send for Windows<'a, T>
where &'a [T]: Send,

§

impl<'a, TValue, TContext> Send for ContextDebuggableAsDisplay<'a, TValue, TContext>
where &'a TValue: Send, TContext: Send, TValue: ?Sized,

§

impl<'a, TValue, TContext> Send for ContextDisplayable<'a, TValue, TContext>
where &'a TValue: Send, TContext: Send, TValue: ?Sized,

§

impl<'a, const N: usize> Send for CharArraySearcher<'a, N>
where <MultiCharEqPattern<[char; N]> as Pattern>::Searcher<'a>: Send,

§

impl<'a> !Send for Formatter<'a>

§

impl<'a> Send for radix_rust::rust::str::Bytes<'a>

§

impl<'a> Send for CharIndices<'a>

§

impl<'a> Send for CharSearcher<'a>

§

impl<'a> Send for Chars<'a>

§

impl<'a> Send for EncodeUtf16<'a>

§

impl<'a> Send for EscapeAscii<'a>

§

impl<'a> Send for EscapeDebug<'a>

§

impl<'a> Send for EscapeDefault<'a>

§

impl<'a> Send for EscapeUnicode<'a>

§

impl<'a> Send for Lines<'a>

§

impl<'a> Send for LinesAny<'a>

§

impl<'a> Send for PhantomContravariantLifetime<'a>

§

impl<'a> Send for PhantomCovariantLifetime<'a>

§

impl<'a> Send for PhantomInvariantLifetime<'a>

§

impl<'a> Send for SplitAsciiWhitespace<'a>

§

impl<'a> Send for SplitWhitespace<'a>

§

impl<'a> Send for Utf8Chunk<'a>

§

impl<'a> Send for Utf8Chunks<'a>

§

impl<'a> Send for Utf8Pattern<'a>

§

impl<'b, T> !Send for Ref<'b, T>

§

impl<'b, T> !Send for RefMut<'b, T>

§

impl<A, B> Send for Chain<A, B>
where Option<A>: Send, Option<B>: Send,

§

impl<A, B> Send for Zip<A, B>
where A: Send, B: Send,

§

impl<A> Send for radix_rust::rust::option::IntoIter<A>
where Item<A>: Send,

§

impl<A> Send for OptionFlatten<A>
where Option<A>: Send,

§

impl<A> Send for Repeat<A>
where A: Send,

§

impl<A> Send for RepeatN<A>
where Option<RepeatNInner<A>>: Send,

§

impl<B, C> Send for ControlFlow<B, C>
where C: Send, B: Send,

§

impl<F> Send for radix_rust::rust::fmt::FromFn<F>
where F: Send,

§

impl<F> Send for radix_rust::rust::iter::FromFn<F>
where F: Send,

§

impl<F> Send for OnceWith<F>
where Option<F>: Send,

§

impl<F> Send for RepeatWith<F>
where F: Send,

§

impl<G> Send for FromCoroutine<G>
where G: Send,

§

impl<H> Send for BuildHasherDefault<H>
where PhantomData<fn() -> H>: Send,

§

impl<I, F, const N: usize> Send for MapWindows<I, F, N>
where F: Send, MapWindowsInner<I, N>: Send,

§

impl<I, F> Send for FilterMap<I, F>
where I: Send, F: Send,

§

impl<I, F> Send for Inspect<I, F>
where I: Send, F: Send,

§

impl<I, F> Send for Map<I, F>
where I: Send, F: Send,

§

impl<I, G> Send for IntersperseWith<I, G>
where G: Send, Option<<I as Iterator>::Item>: Send, I: Send,

§

impl<I, P> Send for Filter<I, P>
where I: Send, P: Send,

§

impl<I, P> Send for MapWhile<I, P>
where I: Send, P: Send,

§

impl<I, P> Send for SkipWhile<I, P>
where I: Send, P: Send,

§

impl<I, P> Send for TakeWhile<I, P>
where I: Send, P: Send,

§

impl<I, St, F> Send for Scan<I, St, F>
where I: Send, F: Send, St: Send,

§

impl<I, U, F> Send for FlatMap<I, U, F>
where FlattenCompat<Map<I, F>, <U as IntoIterator>::IntoIter>: Send,

§

impl<I, const N: usize> Send for ArrayChunks<I, N>
where I: Send, Option<IntoIter<<I as Iterator>::Item, N>>: Send,

§

impl<I> Send for Cloned<I>
where I: Send,

§

impl<I> Send for Copied<I>
where I: Send,

§

impl<I> Send for Cycle<I>
where I: Send,

§

impl<I> Send for Enumerate<I>
where I: Send,

§

impl<I> Send for Flatten<I>
where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: Send,

§

impl<I> Send for Fuse<I>
where Option<I>: Send,

§

impl<I> Send for Intersperse<I>
where <I as Iterator>::Item: Sized + Send, Option<<I as Iterator>::Item>: Send, I: Send,

§

impl<I> Send for Peekable<I>
where I: Send, Option<Option<<I as Iterator>::Item>>: Send,

§

impl<I> Send for Skip<I>
where I: Send,

§

impl<I> Send for StepBy<I>
where I: Send,

§

impl<I> Send for Take<I>
where I: Send,

§

impl<Idx> Send for radix_rust::rust::ops::Range<Idx>
where Idx: Send,

§

impl<Idx> Send for RangeFrom<Idx>
where Idx: Send,

§

impl<Idx> Send for RangeInclusive<Idx>
where Idx: Send,

§

impl<Idx> Send for RangeTo<Idx>
where Idx: Send,

§

impl<Idx> Send for RangeToInclusive<Idx>
where Idx: Send,

§

impl<K, A> Send for radix_rust::rust::collections::hash_set::IntoIter<K, A>
where IntoIter<K, A>: Send,

§

impl<K, V, A> Send for BTreeMap<K, V, A>
where Option<NodeRef<Owned, K, V, LeafOrInternal>>: Send, ManuallyDrop<A>: Send, PhantomData<Box<(K, V), A>>: Send,

§

impl<K, V, A> Send for radix_rust::rust::collections::hash_map::IntoIter<K, V, A>
where IntoIter<K, V, A>: Send,

§

impl<K, V, A> Send for radix_rust::rust::collections::btree_map::IntoIter<K, V, A>
where LazyLeafRange<Dying, K, V>: Send, A: Send,

§

impl<K, V, A> Send for radix_rust::rust::collections::btree_map::IntoKeys<K, V, A>
where IntoIter<K, V, A>: Send,

§

impl<K, V, A> Send for radix_rust::rust::collections::hash_map::IntoKeys<K, V, A>
where IntoIter<K, V, A>: Send,

§

impl<K, V, A> Send for radix_rust::rust::collections::btree_map::IntoValues<K, V, A>
where IntoIter<K, V, A>: Send,

§

impl<K, V, A> Send for radix_rust::rust::collections::hash_map::IntoValues<K, V, A>
where IntoIter<K, V, A>: Send,

§

impl<K, V, S, A> Send for HashMap<K, V, S, A>
where HashMap<K, V, S, A>: Send,

§

impl<K, V, S> Send for NonIterMap<K, V, S>
where HashMap<K, V, S>: Send,

§

impl<P> Send for MaybeDangling<P>
where P: Send + ?Sized,

§

impl<T, A> Send for BTreeSet<T, A>
where BTreeMap<T, SetValZST, A>: Send,

§

impl<T, A> Send for Box<T, A>
where Unique<T>: Send, A: Send, T: ?Sized,

§

impl<T, A> Send for radix_rust::rust::collections::btree_set::IntoIter<T, A>
where IntoIter<T, SetValZST, A>: Send,

§

impl<T, A> Send for Vec<T, A>
where RawVec<T, A>: Send,

§

impl<T, A> Send for VecDeque<T, A>
where RawVec<T, A>: Send,

§

impl<T, E> Send for Result<T, E>
where T: Send, E: Send,

§

impl<T, F> Send for DropGuard<T, F>

§

impl<T, F> Send for LazyCell<T, F>
where UnsafeCell<State<T, F>>: Send,

§

impl<T, F> Send for LazyLock<T, F>
where UnsafeCell<Data<T, F>>: Send,

§

impl<T, F> Send for Successors<T, F>
where Option<T>: Send, F: Send,

§

impl<T, S, A> Send for HashSet<T, S, A>
where HashSet<T, S, A>: Send,

§

impl<T, const N: usize, A> Send for BoxedArrayIntoIter<T, N, A>
where IntoIter<T, A>: Send,

§

impl<T> Send for Bound<T>
where T: Send,

§

impl<T> Send for Complex<T>
where T: Send,

§

impl<T> Send for CovariantUnsafeCell<T>
where UnsafeCell<T>: Send, T: ?Sized,

§

impl<T> Send for Discriminant<T>

§

impl<T> Send for Empty<T>
where PhantomData<fn() -> T>: Send,

§

impl<T> Send for radix_rust::rust::result::IntoIter<T>
where Option<T>: Send,

§

impl<T> Send for radix_rust::rust::sync::mpmc::IntoIter<T>
where Receiver<T>: Send,

§

impl<T> Send for radix_rust::rust::sync::mpsc::IntoIter<T>
where Receiver<T>: Send,

§

impl<T> Send for ManuallyDrop<T>
where T: Send + ?Sized,

§

impl<T> Send for MaybeUninit<T>
where ManuallyDrop<T>: Send,

§

impl<T> Send for radix_rust::rust::iter::Once<T>
where IntoIter<T>: Send,

§

impl<T> Send for OnceCell<T>
where UnsafeCell<Option<T>>: Send,

§

impl<T> Send for Option<T>
where T: Send,

§

impl<T> Send for PhantomContravariant<T>
where PhantomData<fn(T)>: Send, T: ?Sized,

§

impl<T> Send for PhantomCovariant<T>
where PhantomData<fn() -> T>: Send, T: ?Sized,

§

impl<T> Send for PhantomData<T>
where T: ?Sized,

§

impl<T> Send for PhantomInvariant<T>
where PhantomData<fn(T) -> T>: Send, T: ?Sized,

§

impl<T> Send for PoisonError<T>
where T: Send,

§

impl<T> Send for radix_rust::rust::sync::oneshot::Receiver<T>
where Receiver<T>: Send,

§

impl<T> Send for radix_rust::rust::sync::oneshot::RecvTimeoutError<T>
where Receiver<T>: Send,

§

impl<T> Send for Rev<T>
where T: Send,

§

impl<T> Send for Reverse<T>
where T: Send,

§

impl<T> Send for Saturating<T>
where T: Send,

§

impl<T> Send for SendError<T>
where T: Send,

§

impl<T> Send for SendTimeoutError<T>
where T: Send,

§

impl<T> Send for radix_rust::rust::sync::oneshot::Sender<T>
where Sender<T>: Send,

§

impl<T> Send for SyncUnsafeCell<T>
where UnsafeCell<T>: Send, T: ?Sized,

§

impl<T> Send for SyncView<T>
where T: Send + ?Sized,

§

impl<T> Send for TraitImpl<T>
where DynMetadata<T>: Send, T: ?Sized,

§

impl<T> Send for TryLockError<T>
where PoisonError<T>: Send,

§

impl<T> Send for radix_rust::rust::sync::oneshot::TryRecvError<T>
where Receiver<T>: Send,

§

impl<T> Send for TrySendError<T>
where T: Send,

§

impl<T> Send for UnsafeCell<T>
where T: Send + ?Sized,

§

impl<T> Send for Wrapping<T>
where T: Send,

§

impl<T> Send for Yeet<T>
where T: Send,

§

impl<U, O> Send for OverlayingIterator<U, O>
where Peekable<U>: Send, Peekable<O>: Send,

§

impl<U, O> Send for OverlayingResultIterator<U, O>
where Peekable<U>: Send, Peekable<O>: Send,

§

impl<Y, R> Send for CoroutineState<Y, R>
where Y: Send, R: Send,