Trait Send 

pub unsafe auto trait Send { }

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.

Implementors

impl !Send for Args

impl !Send for ArgsOs

impl !Send for Arguments<'_>

impl !Send for LocalWaker

impl Send for alloc::string::Drain<'_>

impl Send for TypeId

impl Send for Bytes<'_>

impl Send for Location<'_>

impl Send for Waker

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

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

impl<'a, 'b, K, Q, V, S, A> Send for OccupiedEntryRef<'a, 'b, K, Q, V, S, A>

where K: Send, Q: Sync + ?Sized, V: Send, S: Send, A: Send + Allocator + Clone,

impl<'a, A, D> Send for AxisChunksIter<'a, A, D>

where A: Sync, D: Send,

impl<'a, A, D> Send for AxisChunksIterMut<'a, A, D>

where A: Send, D: Send,

impl<'a, A, D> Send for AxisIter<'a, A, D>

where A: Sync, D: Send,

impl<'a, A, D> Send for AxisIterMut<'a, A, D>

where A: Send, D: Send,

impl<'a, A, D> Send for IndexedIter<'a, A, D>

where A: Sync, D: Send,

impl<'a, A, D> Send for IndexedIterMut<'a, A, D>

where A: Send, D: Send,

impl<'a, A, D> Send for ndarray::iterators::Iter<'a, A, D>

where A: Sync, D: Send,

impl<'a, A, D> Send for ndarray::iterators::IterMut<'a, A, D>

where A: Send, D: Send,

impl<'a, A, D> Send for LanesIter<'a, A, D>

where A: Sync, D: Send,

impl<'a, A, D> Send for LanesIterMut<'a, A, D>

where A: Send, D: Send,

impl<'a, T, R, C, RStride, CStride> Send for SliceStorage<'a, T, R, C, RStride, CStride>

where T: Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim,

impl<'a, T, R, C, RStride, CStride> Send for SliceStorageMut<'a, T, R, C, RStride, CStride>

where T: Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim,

impl<A> Send for OwnedRepr<A>

where A: Send,

impl<Dyn> Send for DynMetadata<Dyn>

where Dyn: ?Sized,

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

where K: Send, V: Send,

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

where K: Send, V: Send,

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

where K: Send, V: Send, S: Send, A: Send + Allocator + Clone,

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

where K: Send, V: Send, S: Send, A: Send + Allocator,

impl<K, V, S, A> Send for RawOccupiedEntryMut<'_, K, V, S, A>

where K: Send, V: Send, S: Send, A: Send + Allocator + Clone,

impl<S, D> Send for ArrayBase<S, D>

where S: Send + Data, D: Send,

ArrayBase is Send when the storage type is.

impl<T> !Send for *const T

where T: ?Sized,

impl<T> !Send for *mut T

where T: ?Sized,

impl<T> !Send for NonNull<T>

where T: ?Sized,

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

impl<T> !Send for std::sync::nonpoison::mutex::MappedMutexGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::nonpoison::mutex::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.

impl<T> !Send for std::sync::nonpoison::rwlock::MappedRwLockReadGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::nonpoison::rwlock::MappedRwLockWriteGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::nonpoison::rwlock::RwLockReadGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::nonpoison::rwlock::RwLockWriteGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::poison::mutex::MappedMutexGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::poison::mutex::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.

impl<T> !Send for std::sync::poison::rwlock::MappedRwLockReadGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::poison::rwlock::MappedRwLockWriteGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::poison::rwlock::RwLockReadGuard<'_, T>

where T: ?Sized,

impl<T> !Send for std::sync::poison::rwlock::RwLockWriteGuard<'_, T>

where T: ?Sized,

impl<T> !Send for ReentrantLockGuard<'_, T>

where T: ?Sized,

impl<T> Send for &T

where T: Sync + ?Sized,

impl<T> Send for ThinBox<T>

where T: Send + ?Sized,

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

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

where T: Sync,

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

where T: Send,

impl<T> Send for Cell<T>

where T: Send + ?Sized,

impl<T> Send for RefCell<T>

where T: Send + ?Sized,

impl<T> Send for NonZero<T>

where T: ZeroablePrimitive + Send,

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

where T: Send,

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

where T: Send,

impl<T> Send for core::slice::iter::Iter<'_, T>

where T: Sync,

impl<T> Send for core::slice::iter::IterMut<'_, T>

where T: Send,

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

where T: Send,

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

where T: Send,

impl<T> Send for AtomicPtr<T>

impl<T> Send for std::sync::mpmc::Receiver<T>

where T: Send,

impl<T> Send for std::sync::mpmc::Sender<T>

where T: Send,

impl<T> Send for std::sync::mpsc::Receiver<T>

where T: Send,

impl<T> Send for std::sync::mpsc::Sender<T>

where T: Send,

impl<T> Send for SyncSender<T>

where T: Send,

impl<T> Send for std::sync::nonpoison::mutex::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.

impl<T> Send for std::sync::nonpoison::rwlock::RwLock<T>

where T: Send + ?Sized,

impl<T> Send for OnceLock<T>

where T: Send,

impl<T> Send for std::sync::poison::mutex::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.

impl<T> Send for std::sync::poison::rwlock::RwLock<T>

where T: Send + ?Sized,

impl<T> Send for ReentrantLock<T>

where T: Send + ?Sized,

impl<T> Send for JoinHandle<T>

impl<T, A> !Send for Rc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> !Send for UniqueRc<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> !Send for alloc::rc::Weak<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> Send for Cursor<'_, T, A>

where T: Sync, A: Allocator + Sync,

impl<T, A> Send for CursorMut<'_, T, A>

where T: Send, A: Allocator + Send,

impl<T, A> Send for LinkedList<T, A>

where T: Send, A: Allocator + Send,

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

where T: Send, A: Allocator + Send,

impl<T, A> Send for Arc<T, A>

where T: Sync + Send + ?Sized, A: Allocator + Send,

impl<T, A> Send for UniqueArc<T, A>

where T: Sync + Send + ?Sized, A: Allocator + Send,

impl<T, A> Send for alloc::sync::Weak<T, A>

where T: Sync + Send + ?Sized, A: Allocator + Send,

impl<T, A> Send for alloc::vec::drain::Drain<'_, T, A>

where T: Send, A: Send + Allocator,

impl<T, A> Send for IntoIter<T, A>

where T: Send, A: Allocator + Send,

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

where T: Send, A: Send + Allocator,

Auto implementors

impl !Send for Vars

impl !Send for VarsOs

impl Send for TrainType

impl Send for VarError

impl Send for JoinPathsError

impl Send for AlignScores

impl Send for AlignSums

impl Send for AlignfoldScores

impl Send for Axis

impl Send for DirEntry

impl Send for FastaRecord

impl Send for File

impl Send for FoldScoreSets

impl Send for HAIRPIN_SCORES_SPECIAL

impl Send for Index

impl Send for LoopSums

impl Send for NewAxis

impl Send for Options

impl Send for Path

impl Send for Pool

impl Send for RangeInsertScores

impl Send for Record

impl Send for Sequence

impl<'a> Send for SplitPaths<'a>

impl<'a, R> Send for IndexedReaderIterator<'a, R>

where R: Send,

impl<B> Send for Reader<B>

where B: Send,

impl<B> Send for Records<B>

where B: Send,

impl<F> Send for Normal<F>

where F: Send,

impl<I> Send for Dim<I>

where I: Send + ?Sized,

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

where S: Send, A: Send, K: Send, V: Send,

impl<N> Send for Interval<N>

where N: Send,

impl<R> Send for BufReader<R>

where R: Send + ?Sized,

impl<R> Send for IndexedReader<R>

where R: Send,

impl<T> Send for Align<T>

where T: Send,

impl<T> Send for AlignfoldProbMats<T>

where T: Send,

impl<T> Send for AlignfoldProbMatsAvg<T>

where T: Send,

impl<T> Send for AlignfoldSums<T>

where T: Send,

impl<T> Send for FoldScores<T>

where T: Send,

impl<T> Send for FoldScoresTrained<T>

where T: Send,

impl<T> Send for FoldSums<T>

where T: Send,

impl<T> Send for MatchProbMats<T>

where T: Send,

impl<T> Send for PairAlignfold<T>

where T: Send,

impl<T> Send for TrainDatum<T>

where T: Send,

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

where S: Send, A: Send, T: Send,

impl<W> Send for BufWriter<W>

where W: Send + ?Sized,

impl<W> Send for Writer<W>

where W: Send,