Trait scale_info::prelude::marker::Sync

1.0.0 · source · []
pub unsafe auto trait Sync { }
Expand description

Types for which it is safe to share references between threads.

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

The precise definition is: a type T is Sync if and only if &T is Send. In other words, if there is no possibility of undefined behavior (including data races) when passing &T references between threads.

As one would expect, primitive types like u8 and f64 are all Sync, and so are simple aggregate types containing them, like tuples, structs and enums. More examples of basic Sync types include “immutable” types like &T, and those with simple inherited mutability, such as Box<T>, Vec<T> and most other collection types. (Generic parameters need to be Sync for their container to be Sync.)

A somewhat surprising consequence of the definition is that &mut T is Sync (if T is Sync) even though it seems like that might provide unsynchronized mutation. The trick is that a mutable reference behind a shared reference (that is, & &mut T) becomes read-only, as if it were a & &T. Hence there is no risk of a data race.

Types that are not Sync are those that have “interior mutability” in a non-thread-safe form, such as Cell and RefCell. These types allow for mutation of their contents even through an immutable, shared reference. For example the set method on Cell<T> takes &self, so it requires only a shared reference &Cell<T>. The method performs no synchronization, thus Cell cannot be Sync.

Another example of a non-Sync type is the reference-counting pointer Rc. Given any reference &Rc<T>, you can clone a new Rc<T>, modifying the reference counts in a non-atomic way.

For cases when one does need thread-safe interior mutability, Rust provides atomic data types, as well as explicit locking via sync::Mutex and sync::RwLock. These types ensure that any mutation cannot cause data races, hence the types are Sync. Likewise, sync::Arc provides a thread-safe analogue of Rc.

Any types with interior mutability must also use the cell::UnsafeCell wrapper around the value(s) which can be mutated through a shared reference. Failing to doing this is undefined behavior. For example, transmute-ing from &T to &mut T is invalid.

See the Nomicon for more details about Sync.

Implementations on Foreign Types

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

Conditionally mark BitSlice as Sync based on its T type argument.

In order for BitSlice to be Sync (that is, &BitSlice can be copied across thread boundaries), it must be capable of reading from memory without being invalidated by any other &mut BitSlice handles that alias the same memory address.

This is true when T is one of the fundamental integers, because no other &mut BitSlice handle can exist to effect mutations, or when T is a BitSafe type that implements atomic read-modify-write instructions, because it will guard against other &mut BitSlice modifications in hardware.

When T is a non-atomic BitSafe type, BitSlice cannot be Sync, because one &BitSlice moved across a thread boundary may read from memory that is modified by the originally-owning thread, but the instructions used to access memory do not guard against such data races.

A &BitSlice over aliased memory addresses is equivalent to either a &Cell or &AtomicT, depending on what the radium crate makes available for the register width.

Implementors

impl<'a, T: Sync, const CAP: usize> Sync for Drain<'a, T, CAP>

impl<T> Sync for BitPtrError<T> where
    T: BitStore

impl<T> Sync for BitSpanError<T> where
    T: BitStore

impl<O, T> Sync for Iter<'_, O, T> where
    O: BitOrder,
    T: BitStore

impl<O, T> Sync for IterMut<'_, O, T> where
    O: BitOrder,
    T: BitStore

impl<O, T> Sync for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore + Sync

impl<O, T> Sync for BitBox<O, T> where
    O: BitOrder,
    T: BitStore

impl<O, T> Sync for Drain<'_, O, T> where
    O: BitOrder,
    T: BitStore

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

impl<Fut: Sync> Sync for IterPinRef<'_, Fut>

impl<Fut: Sync> Sync for IterPinMut<'_, Fut>

impl<Fut: Sync + Unpin> Sync for IntoIter<Fut>

impl<Fut: Sync> Sync for FuturesUnordered<Fut>

impl<T: ?Sized + Send> Sync for Mutex<T>

impl<T: ?Sized> Sync for MutexLockFuture<'_, T>

impl<T: ?Sized + Sync> Sync for MutexGuard<'_, T>

impl<T: ?Sized + Sync, U: ?Sized + Sync> Sync for MappedMutexGuard<'_, T, U>

impl<T: Sync, N: ArrayLength<T>> Sync for GenericArray<T, N>

impl<K, V, S, A> Sync for RawOccupiedEntryMut<'_, K, V, S, A> where
    K: Sync,
    V: Sync,
    A: Send + Allocator + Clone

impl<K, V, S, A> Sync for OccupiedEntry<'_, K, V, S, A> where
    K: Sync,
    V: Sync,
    S: Sync,
    A: Sync + Allocator + Clone

impl Sync for GuardNoSend

impl<R: RawMutex + Sync, T: ?Sized + Send> Sync for Mutex<R, T>

impl<'a, R: RawMutex + Sync + 'a, T: ?Sized + Sync + 'a> Sync for MutexGuard<'a, R, T>

impl<'a, R: RawMutex + Sync + 'a, T: ?Sized + Sync + 'a> Sync for MappedMutexGuard<'a, R, T>

impl<R: RawMutex + Sync, G: GetThreadId + Sync> Sync for RawReentrantMutex<R, G>

impl<R: RawMutex + Sync, G: GetThreadId + Sync, T: ?Sized + Send> Sync for ReentrantMutex<R, G, T>

impl<'a, R: RawMutex + Sync + 'a, G: GetThreadId + Sync + 'a, T: ?Sized + Sync + 'a> Sync for ReentrantMutexGuard<'a, R, G, T>

impl<'a, R: RawMutex + Sync + 'a, G: GetThreadId + Sync + 'a, T: ?Sized + Sync + 'a> Sync for MappedReentrantMutexGuard<'a, R, G, T>

impl<R: RawRwLock + Sync, T: ?Sized + Send + Sync> Sync for RwLock<R, T>

impl<'a, R: RawRwLockUpgrade + 'a, T: ?Sized + Sync + 'a> Sync for RwLockUpgradableReadGuard<'a, R, T>

impl<'a, R: RawRwLock + 'a, T: ?Sized + Sync + 'a> Sync for MappedRwLockReadGuard<'a, R, T>

impl<'a, R: RawRwLock + 'a, T: ?Sized + Sync + 'a> Sync for MappedRwLockWriteGuard<'a, R, T>

impl<'a, T: Scalar + Sync, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Sync for SliceStorage<'a, T, R, C, RStride, CStride>

impl<'a, T: Scalar + Sync, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Sync for SliceStorageMut<'a, T, R, C, RStride, CStride>

impl<T, F: Send> Sync for Lazy<T, F> where
    OnceCell<T>: Sync

impl<T: Sync + Send> Sync for OnceBox<T>

impl<T, F, S> Sync for ScopeGuard<T, F, S> where
    T: Sync,
    F: FnOnce(T),
    S: Strategy

impl<T, C> Sync for Pool<T, C> where
    T: Sync + Clear + Default,
    C: Config

impl<T, C> Sync for OwnedRef<T, C> where
    T: Sync + Clear + Default,
    C: Config

impl<T, C> Sync for OwnedRefMut<T, C> where
    T: Sync + Clear + Default,
    C: Config

impl<T: Sync, C: Config> Sync for Slab<T, C>

impl<T, C> Sync for OwnedEntry<T, C> where
    T: Sync,
    C: Config

impl<'a, T: Sync + Array> Sync for Drain<'a, T>

impl<T> Sync for ExchangeableFunction<T>

impl<T: Send> Sync for ThreadLocal<T>

Auto implementors

impl<R> !Sync for Context<R>

impl<'ctx, R> !Sync for LocationRangeIter<'ctx, R>

impl<'ctx, R> !Sync for FrameIter<'ctx, R>

impl<'ctx, R> Sync for Frame<'ctx, R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for FunctionName<R> where
    R: Sync

impl<'a> Sync for Location<'a>

impl Sync for Adler32

impl Sync for AHasher

impl Sync for RandomState

impl<S> Sync for AhoCorasick<S> where
    S: Sync

impl<'a, 'b, S> Sync for FindIter<'a, 'b, S> where
    S: Sync

impl<'a, 'b, S> Sync for FindOverlappingIter<'a, 'b, S> where
    S: Sync

impl<'a, R, S> Sync for StreamFindIter<'a, R, S> where
    R: Sync,
    S: Sync

impl Sync for MatchKind

impl Sync for Error

impl Sync for ErrorKind

impl Sync for MatchKind

impl Sync for Config

impl Sync for Builder

impl Sync for Searcher

impl<'s, 'h> Sync for FindIter<'s, 'h>

impl Sync for Match

impl Sync for Prefix

impl Sync for Infix

impl Sync for Suffix

impl Sync for Style

impl Sync for Colour

impl<'a, S: ?Sized> Sync for ANSIGenericString<'a, S> where
    S: Sync,
    <S as ToOwned>::Owned: Sync

impl<'a, S: ?Sized> Sync for ANSIGenericStrings<'a, S> where
    S: Sync,
    <S as ToOwned>::Owned: Sync

impl Sync for Error

impl<'a> !Sync for Chain<'a>

impl<A: ?Sized, B: ?Sized> Sync for AbsDiff<A, B> where
    <A as AbsDiffEq<B>>::Epsilon: Sync

impl<A: ?Sized, B: ?Sized> Sync for Relative<A, B> where
    <A as AbsDiffEq<B>>::Epsilon: Sync

impl<A: ?Sized, B: ?Sized> Sync for Ulps<A, B> where
    <A as AbsDiffEq<B>>::Epsilon: Sync

impl<T, const CAP: usize> Sync for ArrayVec<T, CAP> where
    T: Sync

impl<T, const CAP: usize> Sync for IntoIter<T, CAP> where
    T: Sync

impl<const CAP: usize> Sync for ArrayString<CAP>

impl<T> Sync for CapacityError<T> where
    T: Sync

impl Sync for Frame

impl !Sync for Symbol

impl<'a> Sync for SymbolName<'a>

impl<'a> Sync for BytesOrWideString<'a>

impl<'a, 'b> !Sync for BacktraceFmt<'a, 'b>

impl Sync for PrintFmt

impl<'fmt, 'a, 'b> !Sync for BacktraceFrameFmt<'fmt, 'a, 'b>

impl Sync for Backtrace

impl<'a> Sync for Base64Display<'a>

impl<'a, R> Sync for DecoderReader<'a, R> where
    R: Sync

impl<W> Sync for EncoderWriter<W> where
    W: Sync

impl<S> Sync for EncoderStringWriter<S> where
    S: Sync

impl Sync for DecodeError

impl Sync for Config

impl Sync for ErrorKind

impl Sync for Language

impl Sync for Mnemonic

impl Sync for Seed

impl !Sync for BitSafeU8

impl !Sync for BitSafeU16

impl !Sync for BitSafeU32

impl !Sync for BitSafeU64

impl !Sync for BitSafeUsize

impl<O, V> Sync for IntoIter<O, V> where
    O: Sync,
    V: Sync

impl<O, V> Sync for BitArray<O, V> where
    O: Sync,
    V: Sync

impl<'a, O, T> Sync for BitDomain<'a, O, T> where
    T: Sync,
    <T as BitStore>::Unalias: Sync

impl<'a, O, T> Sync for BitDomainMut<'a, O, T> where
    T: Sync,
    <T as BitStore>::Unalias: Sync

impl<'a, T> Sync for Domain<'a, T> where
    T: Sync,
    <T as BitStore>::Unalias: Sync

impl<'a, T> Sync for DomainMut<'a, T> where
    <T as BitStore>::Access: Sync,
    <T as BitStore>::Unalias: Sync

impl<R> Sync for BitIdx<R>

impl<R> Sync for BitIdxError<R>

impl<R> Sync for BitTail<R>

impl<R> Sync for BitPos<R>

impl<R> Sync for BitSel<R>

impl<R> Sync for BitMask<R>

impl Sync for Const

impl Sync for Mut

impl Sync for Lsb0

impl Sync for Msb0

impl<M, O = Lsb0, T = usize> !Sync for BitPtr<M, O, T>

impl<M, O = Lsb0, T = usize> !Sync for BitPtrRange<M, O, T>

impl<'a, M, O = Lsb0, T = usize> !Sync for BitRef<'a, M, O, T>

impl<M, T = usize> !Sync for Address<M, T>

impl<T> !Sync for AddressError<T>

impl<'a, O, T> Sync for Windows<'a, O, T> where
    T: Sync

impl<'a, O, T> Sync for Chunks<'a, O, T> where
    T: Sync

impl<'a, O, T> Sync for ChunksMut<'a, O, T> where
    <T as BitStore>::Alias: Sync

impl<'a, O, T> Sync for ChunksExact<'a, O, T> where
    T: Sync

impl<'a, O, T> Sync for ChunksExactMut<'a, O, T> where
    <T as BitStore>::Alias: Sync

impl<'a, O, T> Sync for RChunks<'a, O, T> where
    T: Sync

impl<'a, O, T> Sync for RChunksMut<'a, O, T> where
    <T as BitStore>::Alias: Sync

impl<'a, O, T> Sync for RChunksExact<'a, O, T> where
    T: Sync

impl<'a, O, T> Sync for RChunksExactMut<'a, O, T> where
    <T as BitStore>::Alias: Sync

impl<'a, O, T, P> Sync for Split<'a, O, T, P> where
    P: Sync,
    T: Sync

impl<'a, O, T, P> Sync for SplitMut<'a, O, T, P> where
    P: Sync,
    <T as BitStore>::Alias: Sync

impl<'a, O, T, P> Sync for RSplit<'a, O, T, P> where
    P: Sync,
    T: Sync

impl<'a, O, T, P> Sync for RSplitMut<'a, O, T, P> where
    P: Sync,
    <T as BitStore>::Alias: Sync

impl<'a, O, T, P> Sync for SplitN<'a, O, T, P> where
    P: Sync,
    T: Sync

impl<'a, O, T, P> Sync for SplitNMut<'a, O, T, P> where
    P: Sync,
    <T as BitStore>::Alias: Sync

impl<'a, O, T, P> Sync for RSplitN<'a, O, T, P> where
    P: Sync,
    T: Sync

impl<'a, O, T, P> Sync for RSplitNMut<'a, O, T, P> where
    P: Sync,
    <T as BitStore>::Alias: Sync

impl<'a, O, T> Sync for IterOnes<'a, O, T> where
    T: Sync

impl<'a, O, T> Sync for IterZeros<'a, O, T> where
    T: Sync

impl<O, T> !Sync for IntoIter<O, T>

impl<'a, O, T, I> Sync for Splice<'a, O, T, I> where
    I: Sync

impl Sync for Blake2b

impl Sync for Blake2s

impl<BlockSize> Sync for BlockBuffer<BlockSize>

impl Sync for Error

impl Sync for BigEndian

impl Sync for Duration

impl Sync for FixedOffset

impl Sync for Local

impl Sync for Utc

impl<T> Sync for LocalResult<T> where
    T: Sync

impl Sync for NaiveDate

impl Sync for IsoWeek

impl Sync for NaiveTime

impl<Tz> Sync for Date<Tz> where
    <Tz as TimeZone>::Offset: Sync

impl<Tz> Sync for DateTime<Tz> where
    <Tz as TimeZone>::Offset: Sync

impl Sync for Parsed

impl<'a> Sync for StrftimeItems<'a>

impl Sync for Pad

impl Sync for Numeric

impl Sync for Fixed

impl<'a> Sync for Item<'a>

impl Sync for ParseError

impl<I> Sync for DelayedFormat<I> where
    I: Sync

impl Sync for Weekday

impl Sync for Month

impl Sync for Case

impl Sync for FromCasing

impl Sync for MacError

impl<M> Sync for Output<M>

impl Sync for Scalar

impl Sync for Signature

impl Sync for Keypair

impl Sync for PublicKey

impl Sync for SecretKey

impl<L, R> Sync for Either<L, R> where
    L: Sync,
    R: Sync

impl Sync for Analysis

impl<T> Sync for ExtrinsicMetadata<T> where
    <T as Form>::String: Sync,
    <T as Form>::Type: Sync

impl<T> Sync for SignedExtensionMetadata<T> where
    <T as Form>::String: Sync,
    <T as Form>::Type: Sync

impl<T> Sync for PalletMetadata<T> where
    <T as Form>::String: Sync,
    <T as Form>::Type: Sync

impl<T> Sync for PalletStorageMetadata<T> where
    <T as Form>::String: Sync,
    <T as Form>::Type: Sync

impl<T> Sync for StorageEntryMetadata<T> where
    <T as Form>::String: Sync,
    <T as Form>::Type: Sync

impl<T> Sync for StorageEntryType<T> where
    <T as Form>::Type: Sync

impl<T> Sync for PalletCallMetadata<T> where
    <T as Form>::Type: Sync

impl<T> Sync for PalletEventMetadata<T> where
    <T as Form>::Type: Sync

impl<T> Sync for PalletConstantMetadata<T> where
    <T as Form>::String: Sync,
    <T as Form>::Type: Sync

impl<T> Sync for PalletErrorMetadata<T> where
    <T as Form>::Type: Sync

impl !Sync for StopParse

impl<P> !Sync for Braces<P>

impl<P> !Sync for Brackets<P>

impl<P> !Sync for Parens<P>

impl<P, T, V> Sync for PunctuatedInner<P, T, V> where
    P: Sync,
    T: Sync,
    V: Sync

impl Sync for NoTrailing

impl Sync for Trailing

impl !Sync for Meta

impl Sync for BlockLength

impl Sync for ForAll

impl Sync for ForAny

impl<T, OverarchingCall> Sync for SubmitTransaction<T, OverarchingCall> where
    OverarchingCall: Sync,
    T: Sync

impl<T, C, X> Sync for Signer<T, C, X> where
    C: Sync,
    X: Sync,
    <T as SigningTypes>::Public: Sync

impl<T> Sync for Account<T> where
    <T as SigningTypes>::Public: Sync

impl<T> Sync for CheckGenesis<T>

impl<T> Sync for CheckMortality<T>

impl<T> Sync for CheckNonce<T>

impl<T> Sync for CheckSpecVersion<T>

impl<T> Sync for CheckTxVersion<T>

impl<T> Sync for CheckWeight<T>

impl<T> Sync for SubstrateWeight<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageAccount<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageBlockHash<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageLastRuntimeUpgrade<T> where
    T: Sync

impl Sync for Phase

impl<E, T> Sync for EventRecord<E, T> where
    T: Sync

impl<AccountId> Sync for RawOrigin<AccountId> where
    AccountId: Sync

impl<Index, AccountData> Sync for AccountInfo<Index, AccountData> where
    AccountData: Sync,
    Index: Sync

impl<AccountId> Sync for EnsureRoot<AccountId> where
    AccountId: Sync

impl<AccountId> Sync for EnsureSigned<AccountId> where
    AccountId: Sync

impl<Who, AccountId> Sync for EnsureSignedBy<Who, AccountId> where
    AccountId: Sync,
    Who: Sync

impl<AccountId> Sync for EnsureNone<AccountId> where
    AccountId: Sync

impl<T> Sync for EnsureNever<T> where
    T: Sync

impl<AccountId, L, R> Sync for EnsureOneOf<AccountId, L, R> where
    AccountId: Sync,
    L: Sync,
    R: Sync

impl Sync for InitKind

impl Sync for RefStatus

impl<T> Sync for Provider<T> where
    T: Sync

impl<T> Sync for SelfSufficient<T> where
    T: Sync

impl<T> Sync for Consumer<T> where
    T: Sync

impl<T> Sync for ChainContext<T> where
    T: Sync

impl<T> Sync for Sender<T> where
    T: Send

impl<T> Sync for UnboundedSender<T> where
    T: Send

impl<T> Sync for Receiver<T> where
    T: Send

impl<T> Sync for UnboundedReceiver<T> where
    T: Send

impl Sync for SendError

impl<T> Sync for TrySendError<T> where
    T: Sync

impl<T> Sync for Receiver<T> where
    T: Send

impl<T> Sync for Sender<T> where
    T: Send

impl<'a, T> Sync for Cancellation<'a, T> where
    T: Send

impl Sync for Canceled

impl !Sync for LocalPool

impl !Sync for LocalSpawner

impl<S> Sync for BlockingStream<S> where
    S: Sync

impl Sync for ThreadPool

impl Sync for Enter

impl Sync for EnterError

impl Sync for SpawnError

impl<'a> Sync for WakerRef<'a>

impl<'a, T> !Sync for LocalFutureObj<'a, T>

impl<'a, T> !Sync for FutureObj<'a, T>

impl Sync for Delay

impl<Fut> Sync for Fuse<Fut> where
    Fut: Sync

impl<Fut> Sync for CatchUnwind<Fut> where
    Fut: Sync

impl<T> Sync for RemoteHandle<T> where
    T: Send

impl<Fut> Sync for Remote<Fut> where
    Fut: Sync,
    <Fut as Future>::Output: Send

impl<Fut> Sync for Shared<Fut> where
    Fut: Send,
    <Fut as Future>::Output: Send + Sync

impl<Fut> Sync for WeakShared<Fut> where
    Fut: Send,
    <Fut as Future>::Output: Send + Sync

impl<F> Sync for Flatten<F> where
    F: Sync,
    <F as Future>::Output: Sync

impl<F> Sync for FlattenStream<F> where
    F: Sync,
    <F as Future>::Output: Sync

impl<Fut, F> Sync for Map<Fut, F> where
    F: Sync,
    Fut: Sync

impl<F> Sync for IntoStream<F> where
    F: Sync

impl<Fut, T> Sync for MapInto<Fut, T> where
    Fut: Sync

impl<Fut1, Fut2, F> Sync for Then<Fut1, Fut2, F> where
    F: Sync,
    Fut1: Sync,
    Fut2: Sync

impl<Fut, F> Sync for Inspect<Fut, F> where
    F: Sync,
    Fut: Sync

impl<Fut> Sync for NeverError<Fut> where
    Fut: Sync

impl<Fut> Sync for UnitError<Fut> where
    Fut: Sync

impl<Fut> Sync for IntoFuture<Fut> where
    Fut: Sync

impl<Fut1, Fut2> Sync for TryFlatten<Fut1, Fut2> where
    Fut1: Sync,
    Fut2: Sync

impl<Fut> Sync for TryFlattenStream<Fut> where
    Fut: Sync,
    <Fut as TryFuture>::Ok: Sync

impl<Fut, Si> Sync for FlattenSink<Fut, Si> where
    Fut: Sync,
    Si: Sync

impl<Fut1, Fut2, F> Sync for AndThen<Fut1, Fut2, F> where
    F: Sync,
    Fut1: Sync,
    Fut2: Sync

impl<Fut1, Fut2, F> Sync for OrElse<Fut1, Fut2, F> where
    F: Sync,
    Fut1: Sync,
    Fut2: Sync

impl<Fut, E> Sync for ErrInto<Fut, E> where
    Fut: Sync

impl<Fut, E> Sync for OkInto<Fut, E> where
    Fut: Sync

impl<Fut, F> Sync for InspectOk<Fut, F> where
    F: Sync,
    Fut: Sync

impl<Fut, F> Sync for InspectErr<Fut, F> where
    F: Sync,
    Fut: Sync

impl<Fut, F> Sync for MapOk<Fut, F> where
    F: Sync,
    Fut: Sync

impl<Fut, F> Sync for MapErr<Fut, F> where
    F: Sync,
    Fut: Sync

impl<Fut, F, G> Sync for MapOkOrElse<Fut, F, G> where
    F: Sync,
    Fut: Sync,
    G: Sync

impl<Fut, F> Sync for UnwrapOrElse<Fut, F> where
    F: Sync,
    Fut: Sync

impl<F> Sync for Lazy<F> where
    F: Sync

impl<T> Sync for Pending<T> where
    T: Sync

impl<Fut> Sync for MaybeDone<Fut> where
    Fut: Sync,
    <Fut as Future>::Output: Sync

impl<Fut> Sync for TryMaybeDone<Fut> where
    Fut: Sync,
    <Fut as TryFuture>::Ok: Sync

impl<F> Sync for OptionFuture<F> where
    F: Sync

impl<F> Sync for PollFn<F> where
    F: Sync

impl<T> Sync for PollImmediate<T> where
    T: Sync

impl<T> Sync for Ready<T> where
    T: Sync

impl<Fut1, Fut2> Sync for Join<Fut1, Fut2> where
    Fut1: Sync,
    Fut2: Sync,
    <Fut1 as Future>::Output: Sync,
    <Fut2 as Future>::Output: Sync

impl<Fut1, Fut2, Fut3> Sync for Join3<Fut1, Fut2, Fut3> where
    Fut1: Sync,
    Fut2: Sync,
    Fut3: Sync,
    <Fut1 as Future>::Output: Sync,
    <Fut2 as Future>::Output: Sync,
    <Fut3 as Future>::Output: Sync

impl<Fut1, Fut2, Fut3, Fut4> Sync for Join4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Sync,
    Fut2: Sync,
    Fut3: Sync,
    Fut4: Sync,
    <Fut1 as Future>::Output: Sync,
    <Fut2 as Future>::Output: Sync,
    <Fut3 as Future>::Output: Sync,
    <Fut4 as Future>::Output: Sync

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Sync for Join5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Sync,
    Fut2: Sync,
    Fut3: Sync,
    Fut4: Sync,
    Fut5: Sync,
    <Fut1 as Future>::Output: Sync,
    <Fut2 as Future>::Output: Sync,
    <Fut3 as Future>::Output: Sync,
    <Fut4 as Future>::Output: Sync,
    <Fut5 as Future>::Output: Sync

impl<F> Sync for JoinAll<F> where
    F: Sync,
    <F as Future>::Output: Sync

impl<A, B> Sync for Select<A, B> where
    A: Sync,
    B: Sync

impl<Fut> Sync for SelectAll<Fut> where
    Fut: Sync

impl<Fut1, Fut2> Sync for TryJoin<Fut1, Fut2> where
    Fut1: Sync,
    Fut2: Sync,
    <Fut1 as TryFuture>::Ok: Sync,
    <Fut2 as TryFuture>::Ok: Sync

impl<Fut1, Fut2, Fut3> Sync for TryJoin3<Fut1, Fut2, Fut3> where
    Fut1: Sync,
    Fut2: Sync,
    Fut3: Sync,
    <Fut1 as TryFuture>::Ok: Sync,
    <Fut2 as TryFuture>::Ok: Sync,
    <Fut3 as TryFuture>::Ok: Sync

impl<Fut1, Fut2, Fut3, Fut4> Sync for TryJoin4<Fut1, Fut2, Fut3, Fut4> where
    Fut1: Sync,
    Fut2: Sync,
    Fut3: Sync,
    Fut4: Sync,
    <Fut1 as TryFuture>::Ok: Sync,
    <Fut2 as TryFuture>::Ok: Sync,
    <Fut3 as TryFuture>::Ok: Sync,
    <Fut4 as TryFuture>::Ok: Sync

impl<Fut1, Fut2, Fut3, Fut4, Fut5> Sync for TryJoin5<Fut1, Fut2, Fut3, Fut4, Fut5> where
    Fut1: Sync,
    Fut2: Sync,
    Fut3: Sync,
    Fut4: Sync,
    Fut5: Sync,
    <Fut1 as TryFuture>::Ok: Sync,
    <Fut2 as TryFuture>::Ok: Sync,
    <Fut3 as TryFuture>::Ok: Sync,
    <Fut4 as TryFuture>::Ok: Sync,
    <Fut5 as TryFuture>::Ok: Sync

impl<F> Sync for TryJoinAll<F> where
    F: Sync,
    <F as TryFuture>::Ok: Sync

impl<A, B> Sync for TrySelect<A, B> where
    A: Sync,
    B: Sync

impl<Fut> Sync for SelectOk<Fut> where
    Fut: Sync

impl<A, B> Sync for Either<A, B> where
    A: Sync,
    B: Sync

impl Sync for AbortHandle

impl<T> Sync for Abortable<T> where
    T: Sync

impl Sync for Aborted

impl<St1, St2> Sync for Chain<St1, St2> where
    St1: Sync,
    St2: Sync

impl<St, C> Sync for Collect<St, C> where
    C: Sync,
    St: Sync

impl<St, FromA, FromB> Sync for Unzip<St, FromA, FromB> where
    FromA: Sync,
    FromB: Sync,
    St: Sync

impl<St> Sync for Concat<St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<St> Sync for Cycle<St> where
    St: Sync

impl<St> Sync for Enumerate<St> where
    St: Sync

impl<St, Fut, F> Sync for Filter<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    <St as Stream>::Item: Sync

impl<St, Fut, F> Sync for FilterMap<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St, Fut, T, F> Sync for Fold<St, Fut, T, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    T: Sync

impl<St, Fut, F> Sync for ForEach<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St> Sync for Fuse<St> where
    St: Sync

impl<St> Sync for StreamFuture<St> where
    St: Sync

impl<St, F> Sync for Map<St, F> where
    F: Sync,
    St: Sync

impl<'a, St: ?Sized> Sync for Next<'a, St> where
    St: Sync

impl<'a, St: ?Sized> Sync for SelectNextSome<'a, St> where
    St: Sync

impl<St> Sync for Peekable<St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<'a, St> Sync for Peek<'a, St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<'a, St> Sync for PeekMut<'a, St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<'a, St, F> Sync for NextIf<'a, St, F> where
    F: Sync,
    St: Sync,
    <St as Stream>::Item: Sync

impl<'a, St, T: ?Sized> Sync for NextIfEq<'a, St, T> where
    St: Sync,
    T: Sync,
    <St as Stream>::Item: Sync

impl<St> Sync for Skip<St> where
    St: Sync

impl<St, Fut, F> Sync for SkipWhile<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    <St as Stream>::Item: Sync

impl<St> Sync for Take<St> where
    St: Sync

impl<St, Fut, F> Sync for TakeWhile<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    <St as Stream>::Item: Sync

impl<St, Fut> Sync for TakeUntil<St, Fut> where
    Fut: Sync,
    St: Sync,
    <Fut as Future>::Output: Sync

impl<St, Fut, F> Sync for Then<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St1, St2> Sync for Zip<St1, St2> where
    St1: Sync,
    St2: Sync,
    <St1 as Stream>::Item: Sync,
    <St2 as Stream>::Item: Sync

impl<St> Sync for Chunks<St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<St> Sync for ReadyChunks<St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<St, S, Fut, F> Sync for Scan<St, S, Fut, F> where
    F: Sync,
    Fut: Sync,
    S: Sync,
    St: Sync

impl<St> Sync for BufferUnordered<St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<St> Sync for Buffered<St> where
    St: Sync,
    <St as Stream>::Item: Sync,
    <<St as Stream>::Item as Future>::Output: Sync

impl<St, Fut, F> Sync for ForEachConcurrent<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<S> Sync for SplitStream<S> where
    S: Send

impl<S, Item> Sync for SplitSink<S, Item> where
    Item: Sync,
    S: Send

impl<T, Item> Sync for ReuniteError<T, Item> where
    Item: Sync,
    T: Send

impl<St> Sync for CatchUnwind<St> where
    St: Sync

impl<St> Sync for Flatten<St> where
    St: Sync,
    <St as Stream>::Item: Sync

impl<St, Si> Sync for Forward<St, Si> where
    Si: Sync,
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St, F> Sync for Inspect<St, F> where
    F: Sync,
    St: Sync

impl<St, U, F> Sync for FlatMap<St, U, F> where
    F: Sync,
    St: Sync,
    U: Sync

impl<St, Fut, F> Sync for AndThen<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St> Sync for IntoStream<St> where
    St: Sync

impl<St, Fut, F> Sync for OrElse<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<'a, St: ?Sized> Sync for TryNext<'a, St> where
    St: Sync

impl<St, Fut, F> Sync for TryForEach<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St, Fut, F> Sync for TryFilter<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St, Fut, F> Sync for TryFilterMap<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St> Sync for TryFlatten<St> where
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St, C> Sync for TryCollect<St, C> where
    C: Sync,
    St: Sync

impl<St> Sync for TryConcat<St> where
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St> Sync for TryChunks<St> where
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<T, E> Sync for TryChunksError<T, E> where
    E: Sync,
    T: Sync

impl<St, Fut, T, F> Sync for TryFold<St, Fut, T, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    T: Sync

impl<T, F, Fut> Sync for TryUnfold<T, F, Fut> where
    F: Sync,
    Fut: Sync,
    T: Sync

impl<St, Fut, F> Sync for TrySkipWhile<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St, Fut, F> Sync for TryTakeWhile<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St> Sync for TryBufferUnordered<St> where
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St> Sync for TryBuffered<St> where
    St: Sync,
    <<St as TryStream>::Ok as TryFuture>::Error: Sync,
    <St as TryStream>::Ok: Sync,
    <<St as TryStream>::Ok as TryFuture>::Ok: Sync

impl<St, Fut, F> Sync for TryForEachConcurrent<St, Fut, F> where
    F: Sync,
    Fut: Sync,
    St: Sync

impl<St> Sync for IntoAsyncRead<St> where
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<St, E> Sync for ErrInto<St, E> where
    St: Sync

impl<St, F> Sync for InspectOk<St, F> where
    F: Sync,
    St: Sync

impl<St, F> Sync for InspectErr<St, F> where
    F: Sync,
    St: Sync

impl<St, F> Sync for MapOk<St, F> where
    F: Sync,
    St: Sync

impl<St, F> Sync for MapErr<St, F> where
    F: Sync,
    St: Sync

impl<I> Sync for Iter<I> where
    I: Sync

impl<T> Sync for Repeat<T> where
    T: Sync

impl<F> Sync for RepeatWith<F> where
    F: Sync

impl<T> Sync for Empty<T> where
    T: Sync

impl<Fut> Sync for Once<Fut> where
    Fut: Sync

impl<T> Sync for Pending<T> where
    T: Sync

impl<F> Sync for PollFn<F> where
    F: Sync

impl<S> Sync for PollImmediate<S> where
    S: Sync

impl<St1, St2> Sync for Select<St1, St2> where
    St1: Sync,
    St2: Sync

impl Sync for PollNext

impl<St1, St2, Clos, State> Sync for SelectWithStrategy<St1, St2, Clos, State> where
    Clos: Sync,
    St1: Sync,
    St2: Sync,
    State: Sync

impl<T, F, Fut> Sync for Unfold<T, F, Fut> where
    F: Sync,
    Fut: Sync,
    T: Sync

impl<T> Sync for FuturesOrdered<T> where
    T: Sync,
    <T as Future>::Output: Sync

impl<'a, Fut> Sync for IterMut<'a, Fut> where
    Fut: Sync

impl<'a, Fut> Sync for Iter<'a, Fut> where
    Fut: Sync

impl<St> Sync for SelectAll<St> where
    St: Sync

impl<'a, St> Sync for Iter<'a, St> where
    St: Sync

impl<'a, St> Sync for IterMut<'a, St> where
    St: Sync

impl<St> Sync for IntoIter<St> where
    St: Sync

impl<'a, Si: ?Sized, Item> Sync for Close<'a, Si, Item> where
    Si: Sync

impl<T> Sync for Drain<T> where
    T: Sync

impl<Si1, Si2> Sync for Fanout<Si1, Si2> where
    Si1: Sync,
    Si2: Sync

impl<'a, Si: ?Sized, Item> Sync for Feed<'a, Si, Item> where
    Item: Sync,
    Si: Sync

impl<'a, Si: ?Sized, Item> Sync for Flush<'a, Si, Item> where
    Si: Sync

impl<Si, Item, E> Sync for SinkErrInto<Si, Item, E> where
    Si: Sync

impl<Si, F> Sync for SinkMapErr<Si, F> where
    F: Sync,
    Si: Sync

impl<'a, Si: ?Sized, Item> Sync for Send<'a, Si, Item> where
    Item: Sync,
    Si: Sync

impl<'a, Si: ?Sized, St: ?Sized> Sync for SendAll<'a, Si, St> where
    Si: Sync,
    St: Sync,
    <St as TryStream>::Ok: Sync

impl<T, F, R> Sync for Unfold<T, F, R> where
    F: Sync,
    R: Sync,
    T: Sync

impl<Si, Item, U, Fut, F> Sync for With<Si, Item, U, Fut, F> where
    F: Sync,
    Fut: Sync,
    Si: Sync

impl<Si, Item, U, St, F> Sync for WithFlatMap<Si, Item, U, St, F> where
    F: Sync,
    Item: Sync,
    Si: Sync,
    St: Sync

impl<Si, Item> Sync for Buffer<Si, Item> where
    Item: Sync,
    Si: Sync

impl<T> Sync for AllowStdIo<T> where
    T: Sync

impl<R> Sync for BufReader<R> where
    R: Sync

impl<'a, R> Sync for SeeKRelative<'a, R> where
    R: Sync

impl<W> Sync for BufWriter<W> where
    W: Sync

impl<W> Sync for LineWriter<W> where
    W: Sync

impl<T, U> Sync for Chain<T, U> where
    T: Sync,
    U: Sync

impl<'a, W: ?Sized> Sync for Close<'a, W> where
    W: Sync

impl<'a, R, W: ?Sized> Sync for Copy<'a, R, W> where
    R: Sync,
    W: Sync

impl<'a, R, W: ?Sized> Sync for CopyBuf<'a, R, W> where
    R: Sync,
    W: Sync

impl<T> Sync for Cursor<T> where
    T: Sync

impl Sync for Empty

impl<'a, R: ?Sized> Sync for FillBuf<'a, R> where
    R: Sync

impl<'a, W: ?Sized> Sync for Flush<'a, W> where
    W: Sync

impl<W, Item> Sync for IntoSink<W, Item> where
    Item: Sync,
    W: Sync

impl<R> Sync for Lines<R> where
    R: Sync

impl<'a, R: ?Sized> Sync for Read<'a, R> where
    R: Sync

impl<'a, R: ?Sized> Sync for ReadVectored<'a, R> where
    R: Sync

impl<'a, R: ?Sized> Sync for ReadExact<'a, R> where
    R: Sync

impl<'a, R: ?Sized> Sync for ReadLine<'a, R> where
    R: Sync

impl<'a, R: ?Sized> Sync for ReadToEnd<'a, R> where
    R: Sync

impl<'a, R: ?Sized> Sync for ReadToString<'a, R> where
    R: Sync

impl<'a, R: ?Sized> Sync for ReadUntil<'a, R> where
    R: Sync

impl Sync for Repeat

impl<'a, S: ?Sized> Sync for Seek<'a, S> where
    S: Sync

impl Sync for Sink

impl<T> Sync for ReadHalf<T> where
    T: Send

impl<T> Sync for WriteHalf<T> where
    T: Send

impl<T> Sync for ReuniteError<T> where
    T: Send

impl<R> Sync for Take<R> where
    R: Sync

impl<T> Sync for Window<T> where
    T: Sync

impl<'a, W: ?Sized> Sync for Write<'a, W> where
    W: Sync

impl<'a, W: ?Sized> Sync for WriteVectored<'a, W> where
    W: Sync

impl<'a, W: ?Sized> Sync for WriteAll<'a, W> where
    W: Sync

impl<T, N> Sync for GenericArrayIter<T, N> where
    T: Sync

impl Sync for Error

impl Sync for Format

impl Sync for Encoding

impl Sync for Register

impl<T> Sync for DebugAbbrevOffset<T> where
    T: Sync

impl<T> Sync for DebugAddrBase<T> where
    T: Sync

impl<T> Sync for DebugAddrIndex<T> where
    T: Sync

impl<T> Sync for DebugArangesOffset<T> where
    T: Sync

impl<T> Sync for DebugInfoOffset<T> where
    T: Sync

impl<T> Sync for DebugLineOffset<T> where
    T: Sync

impl<T> Sync for DebugLineStrOffset<T> where
    T: Sync

impl<T> Sync for LocationListsOffset<T> where
    T: Sync

impl<T> Sync for DebugLocListsBase<T> where
    T: Sync

impl<T> Sync for DebugLocListsIndex<T> where
    T: Sync

impl<T> Sync for DebugMacinfoOffset<T> where
    T: Sync

impl<T> Sync for DebugMacroOffset<T> where
    T: Sync

impl<T> Sync for RawRangeListsOffset<T> where
    T: Sync

impl<T> Sync for RangeListsOffset<T> where
    T: Sync

impl<T> Sync for DebugRngListsBase<T> where
    T: Sync

impl<T> Sync for DebugRngListsIndex<T> where
    T: Sync

impl<T> Sync for DebugStrOffset<T> where
    T: Sync

impl<T> Sync for DebugStrOffsetsBase<T> where
    T: Sync

impl<T> Sync for DebugStrOffsetsIndex<T> where
    T: Sync

impl<T> Sync for DebugTypesOffset<T> where
    T: Sync

impl<T> Sync for DebugFrameOffset<T> where
    T: Sync

impl<T> Sync for EhFrameOffset<T> where
    T: Sync

impl<T> Sync for UnitSectionOffset<T> where
    T: Sync

impl Sync for SectionId

impl Sync for DwoId

impl Sync for Arm

impl Sync for AArch64

impl Sync for RiscV

impl Sync for X86

impl Sync for X86_64

impl Sync for DwSect

impl Sync for DwSectV2

impl Sync for DwUt

impl Sync for DwCfa

impl Sync for DwChildren

impl Sync for DwTag

impl Sync for DwAt

impl Sync for DwForm

impl Sync for DwAte

impl Sync for DwLle

impl Sync for DwDs

impl Sync for DwEnd

impl Sync for DwAccess

impl Sync for DwVis

impl Sync for DwLang

impl Sync for DwAddr

impl Sync for DwId

impl Sync for DwCc

impl Sync for DwInl

impl Sync for DwOrd

impl Sync for DwDsc

impl Sync for DwIdx

impl Sync for DwDefaulted

impl Sync for DwLns

impl Sync for DwLne

impl Sync for DwLnct

impl Sync for DwMacro

impl Sync for DwRle

impl Sync for DwOp

impl Sync for DwEhPe

impl Sync for BigEndian

impl<R> Sync for DebugAddr<R> where
    R: Sync

impl<R> Sync for DebugFrame<R> where
    R: Sync

impl<R> Sync for EhFrameHdr<R> where
    R: Sync

impl<R> Sync for ParsedEhFrameHdr<R> where
    R: Sync

impl<'a, R> Sync for EhHdrTable<'a, R> where
    R: Sync

impl<R> Sync for EhFrame<R> where
    R: Sync

impl<'bases, Section, R> Sync for CfiEntriesIter<'bases, Section, R> where
    R: Sync,
    Section: Sync

impl<'bases, Section, R> Sync for CieOrFde<'bases, Section, R> where
    R: Sync,
    Section: Sync,
    <R as Reader>::Offset: Sync,
    <Section as UnwindSection<R>>::Offset: Sync

impl<R, Offset> Sync for CommonInformationEntry<R, Offset> where
    Offset: Sync,
    R: Sync

impl<'bases, Section, R> Sync for PartialFrameDescriptionEntry<'bases, Section, R> where
    R: Sync,
    Section: Sync,
    <R as Reader>::Offset: Sync,
    <Section as UnwindSection<R>>::Offset: Sync

impl<R, Offset> Sync for FrameDescriptionEntry<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R, A> Sync for UnwindContext<R, A> where
    R: Sync,
    <<A as UnwindContextStorage<R>>::Stack as Sealed>::Storage: Sync

impl<'a, 'ctx, R, A> Sync for UnwindTable<'a, 'ctx, R, A> where
    R: Sync,
    <<A as UnwindContextStorage<R>>::Stack as Sealed>::Storage: Sync

impl<'iter, R> Sync for RegisterRuleIter<'iter, R> where
    R: Sync

impl<R, S> Sync for UnwindTableRow<R, S> where
    R: Sync,
    <<S as UnwindContextStorage<R>>::Rules as Sealed>::Storage: Sync

impl<R> Sync for CfaRule<R> where
    R: Sync

impl<R> Sync for RegisterRule<R> where
    R: Sync

impl<R> Sync for CallFrameInstruction<R> where
    R: Sync

impl<'a, R> Sync for CallFrameInstructionIter<'a, R> where
    R: Sync

impl Sync for Pointer

impl<R> Sync for Dwarf<R> where
    R: Send + Sync

impl<R> Sync for DwarfPackage<R> where
    R: Sync

impl<R, Offset> Sync for Unit<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R> Sync for RangeIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<'input, Endian> Sync for EndianSlice<'input, Endian> where
    Endian: Sync

impl<R> Sync for DebugAbbrev<R> where
    R: Sync

impl<R> Sync for DebugAranges<R> where
    R: Sync

impl<R> Sync for ArangeHeaderIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R, Offset> Sync for ArangeHeader<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R> Sync for ArangeEntryIter<R> where
    R: Sync

impl Sync for ArangeEntry

impl<R> Sync for DebugCuIndex<R> where
    R: Sync

impl<R> Sync for DebugTuIndex<R> where
    R: Sync

impl<R> Sync for UnitIndex<R> where
    R: Sync

impl<'index, R> Sync for UnitIndexSectionIterator<'index, R> where
    R: Sync

impl<R> Sync for DebugLine<R> where
    R: Sync

impl<R, Program, Offset> Sync for LineRows<R, Program, Offset> where
    Program: Sync,
    R: Sync

impl<R, Offset> Sync for LineInstruction<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R> Sync for LineInstructions<R> where
    R: Sync

impl Sync for LineRow

impl Sync for ColumnType

impl<R> Sync for LineSequence<R> where
    R: Sync

impl<R, Offset> Sync for LineProgramHeader<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R, Offset> Sync for IncompleteLineProgram<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R, Offset> Sync for CompleteLineProgram<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R, Offset> Sync for FileEntry<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R> Sync for DebugLoc<R> where
    R: Sync

impl<R> Sync for DebugLocLists<R> where
    R: Sync

impl<R> Sync for LocationLists<R> where
    R: Sync

impl<R> Sync for RawLocListIter<R> where
    R: Sync

impl<R> Sync for RawLocListEntry<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for LocListIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for LocationListEntry<R> where
    R: Sync

impl<T> Sync for DieReference<T> where
    T: Sync

impl<R, Offset> Sync for Operation<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R, Offset> Sync for Location<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R, Offset> Sync for Piece<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R> Sync for EvaluationResult<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for Expression<R> where
    R: Sync

impl<R> Sync for OperationIter<R> where
    R: Sync

impl<R, S> Sync for Evaluation<R, S> where
    R: Sync,
    <<S as EvaluationStorage<R>>::ExpressionStack as Sealed>::Storage: Sync,
    <<S as EvaluationStorage<R>>::Result as Sealed>::Storage: Sync,
    <<S as EvaluationStorage<R>>::Stack as Sealed>::Storage: Sync

impl<R> Sync for PubNamesEntry<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for DebugPubNames<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for PubNamesEntryIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for PubTypesEntry<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for DebugPubTypes<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for PubTypesEntryIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<R> Sync for DebugRanges<R> where
    R: Sync

impl<R> Sync for DebugRngLists<R> where
    R: Sync

impl<R> Sync for RangeLists<R> where
    R: Sync

impl<R> Sync for RawRngListIter<R> where
    R: Sync

impl<T> Sync for RawRngListEntry<T> where
    T: Sync

impl<R> Sync for RngListIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl Sync for Range

impl<R> Sync for DebugStr<R> where
    R: Sync

impl<R> Sync for DebugStrOffsets<R> where
    R: Sync

impl<R> Sync for DebugLineStr<R> where
    R: Sync

impl<R> Sync for DebugInfo<R> where
    R: Sync

impl<R> Sync for DebugInfoUnitHeadersIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<Offset> Sync for UnitType<Offset> where
    Offset: Sync

impl<R, Offset> Sync for UnitHeader<R, Offset> where
    Offset: Sync,
    R: Sync

impl<'abbrev, 'unit, R, Offset = <R as Reader>::Offset> !Sync for DebuggingInformationEntry<'abbrev, 'unit, R, Offset>

impl<R, Offset> Sync for AttributeValue<R, Offset> where
    Offset: Sync,
    R: Sync

impl<R> Sync for Attribute<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<'abbrev, 'entry, 'unit, R> !Sync for AttrsIter<'abbrev, 'entry, 'unit, R>

impl<'abbrev, 'unit, R> Sync for EntriesRaw<'abbrev, 'unit, R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl<'abbrev, 'unit, R> !Sync for EntriesCursor<'abbrev, 'unit, R>

impl<'abbrev, 'unit, R> !Sync for EntriesTree<'abbrev, 'unit, R>

impl<'abbrev, 'unit, 'tree, R> !Sync for EntriesTreeNode<'abbrev, 'unit, 'tree, R>

impl<'abbrev, 'unit, 'tree, R> !Sync for EntriesTreeIter<'abbrev, 'unit, 'tree, R>

impl<R> Sync for DebugTypes<R> where
    R: Sync

impl<R> Sync for DebugTypesUnitHeadersIter<R> where
    R: Sync,
    <R as Reader>::Offset: Sync

impl Sync for ValueType

impl Sync for Value

impl<T> Sync for UnitOffset<T> where
    T: Sync

impl Sync for StoreOnHeap

impl Sync for Error

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

impl<'a, K, V> Sync for Iter<'a, K, V> where
    K: Sync,
    V: Sync

impl<'a, K, V> Sync for IterMut<'a, K, V> where
    K: Sync,
    V: Sync

impl<K, V, A> Sync for IntoIter<K, V, A> where
    K: Sync,
    V: Sync

impl<'a, K, V> Sync for Keys<'a, K, V> where
    K: Sync,
    V: Sync

impl<'a, K, V> Sync for Values<'a, K, V> where
    K: Sync,
    V: Sync

impl<'a, K, V, A> Sync for Drain<'a, K, V, A> where
    A: Copy,
    K: Sync,
    V: Sync

impl<'a, K, V, F, A> Sync for DrainFilter<'a, K, V, F, A> where
    F: Sync,
    K: Sync,
    V: Sync

impl<'a, K, V> Sync for ValuesMut<'a, K, V> where
    K: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for RawEntryBuilderMut<'a, K, V, S, A> where
    K: Sync,
    S: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for RawEntryMut<'a, K, V, S, A> where
    A: Send,
    K: Sync,
    S: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for RawVacantEntryMut<'a, K, V, S, A> where
    K: Sync,
    S: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for RawEntryBuilder<'a, K, V, S, A> where
    K: Sync,
    S: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for Entry<'a, K, V, S, A> where
    A: Sync,
    K: Sync,
    S: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for VacantEntry<'a, K, V, S, A> where
    K: Sync,
    S: Sync,
    V: Sync

impl<'a, K, V, S, A> Sync for OccupiedError<'a, K, V, S, A> where
    A: Sync,
    K: Sync,
    S: Sync,
    V: Sync

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

impl<'a, K> Sync for Iter<'a, K> where
    K: Sync

impl<K, A> Sync for IntoIter<K, A> where
    K: Sync

impl<'a, K, A> Sync for Drain<'a, K, A> where
    A: Copy,
    K: Sync

impl<'a, K, F, A> Sync for DrainFilter<'a, K, F, A> where
    F: Sync,
    K: Sync

impl<'a, T, S, A> Sync for Intersection<'a, T, S, A> where
    S: Sync,
    T: Sync

impl<'a, T, S, A> Sync for Difference<'a, T, S, A> where
    S: Sync,
    T: Sync

impl<'a, T, S, A> Sync for SymmetricDifference<'a, T, S, A> where
    S: Sync,
    T: Sync

impl<'a, T, S, A> Sync for Union<'a, T, S, A> where
    S: Sync,
    T: Sync

impl<D> Sync for Hmac<D> where
    D: Sync

impl<D> Sync for HmacDRBG<D>

impl Sync for Buffer

impl Sync for statvfs

impl Sync for max_align_t

impl Sync for sigaction

impl Sync for statfs

impl Sync for flock

impl Sync for flock64

impl Sync for siginfo_t

impl !Sync for stack_t

impl Sync for stat

impl Sync for stat64

impl Sync for statfs64

impl Sync for statvfs64

impl !Sync for user

impl !Sync for mcontext_t

impl Sync for ipc_perm

impl Sync for shmid_ds

impl Sync for ip_mreqn

impl !Sync for ucontext_t

impl Sync for sigset_t

impl Sync for sysinfo

impl Sync for msqid_ds

impl Sync for semid_ds

impl Sync for sem_t

impl Sync for statx

impl !Sync for aiocb

impl Sync for __timeval

impl !Sync for glob64_t

impl !Sync for msghdr

impl Sync for cmsghdr

impl Sync for termios

impl Sync for mallinfo

impl Sync for mallinfo2

impl Sync for nl_pktinfo

impl Sync for nl_mmap_req

impl Sync for nl_mmap_hdr

impl !Sync for rtentry

impl Sync for timex

impl Sync for ntptimeval

impl !Sync for regex_t

impl Sync for Elf64_Chdr

impl Sync for Elf32_Chdr

impl Sync for seminfo

impl Sync for utmpx

impl Sync for termios2

impl Sync for open_how

impl Sync for fpos64_t

impl Sync for rlimit64

impl !Sync for glob_t

impl !Sync for passwd

impl !Sync for spwd

impl Sync for dqblk

impl Sync for itimerspec

impl Sync for fsid_t

impl Sync for packet_mreq

impl Sync for cpu_set_t

impl !Sync for if_nameindex

impl Sync for msginfo

impl Sync for sembuf

impl Sync for input_event

impl Sync for input_id

impl Sync for input_mask

impl Sync for ff_replay

impl Sync for ff_trigger

impl Sync for ff_envelope

impl Sync for ff_effect

impl !Sync for dl_phdr_info

impl Sync for Elf32_Ehdr

impl Sync for Elf64_Ehdr

impl Sync for Elf32_Sym

impl Sync for Elf64_Sym

impl Sync for Elf32_Phdr

impl Sync for Elf64_Phdr

impl Sync for Elf32_Shdr

impl Sync for Elf64_Shdr

impl Sync for ucred

impl !Sync for mntent

impl Sync for genlmsghdr

impl Sync for in6_pktinfo

impl Sync for sockaddr_vm

impl Sync for regmatch_t

impl Sync for can_filter

impl Sync for sock_filter

impl !Sync for sock_fprog

impl Sync for nlmsghdr

impl Sync for nlmsgerr

impl Sync for nlattr

impl Sync for sockaddr_nl

impl Sync for dirent

impl Sync for dirent64

impl Sync for af_alg_iv

impl Sync for mq_attr

impl Sync for sock_txtime

impl Sync for can_frame

impl Sync for canfd_frame

impl Sync for timezone

impl Sync for in_addr

impl Sync for ip_mreq

impl Sync for sockaddr

impl Sync for sockaddr_in

impl !Sync for addrinfo

impl Sync for sockaddr_ll

impl Sync for fd_set

impl !Sync for tm

impl Sync for sched_param

impl !Sync for Dl_info

impl !Sync for lconv

impl Sync for in_pktinfo

impl !Sync for ifaddrs

impl Sync for in6_rtmsg

impl Sync for arpreq

impl Sync for arpreq_old

impl Sync for arphdr

impl !Sync for mmsghdr

impl Sync for epoll_event

impl Sync for sockaddr_un

impl Sync for utsname

impl !Sync for sigevent

impl Sync for in6_addr

impl Sync for DIR

impl !Sync for group

impl Sync for utimbuf

impl Sync for timeval

impl Sync for timespec

impl Sync for rlimit

impl Sync for rusage

impl Sync for ipv6_mreq

impl !Sync for hostent

impl !Sync for iovec

impl Sync for pollfd

impl Sync for winsize

impl Sync for linger

impl !Sync for sigval

impl Sync for itimerval

impl Sync for tms

impl !Sync for servent

impl !Sync for protoent

impl Sync for FILE

impl Sync for fpos_t

impl Sync for PublicKey

impl Sync for SecretKey

impl Sync for Signature

impl Sync for RecoveryId

impl Sync for Message

impl<D> Sync for SharedSecret<D>

impl Sync for Field

impl Sync for Affine

impl Sync for Jacobian

impl<'a> Sync for Decoder<'a>

impl Sync for Error

impl Sync for Scalar

impl Sync for Error

impl<'a> Sync for RegressionData<'a>

impl<'a, R, T: ?Sized> Sync for RwLockReadGuard<'a, R, T> where
    R: Sync,
    T: Send + Sync,
    <R as RawRwLock>::GuardMarker: Sync

impl<'a, R, T: ?Sized> Sync for RwLockWriteGuard<'a, R, T> where
    R: Sync,
    T: Send + Sync,
    <R as RawRwLock>::GuardMarker: Sync

impl Sync for GuardSend

impl Sync for Level

impl Sync for LevelFilter

impl<'a> !Sync for Record<'a>

impl<'a> !Sync for RecordBuilder<'a>

impl<'a> Sync for Metadata<'a>

impl<'a> Sync for MetadataBuilder<'a>

impl<S, A> Sync for Pattern<S, A> where
    A: Sync

impl<'a, S, A> Sync for Matcher<'a, S, A> where
    A: Sync,
    S: Sync

impl<'a> Sync for Memchr<'a>

impl<'a> Sync for Memchr2<'a>

impl<'a> Sync for Memchr3<'a>

impl Sync for Prefilter

impl<'h, 'n> Sync for FindIter<'h, 'n>

impl<'h, 'n> Sync for FindRevIter<'h, 'n>

impl<'n> Sync for Finder<'n>

impl<'n> Sync for FinderRev<'n>

impl<T> Sync for MemCounter<T> where
    T: Sync

impl<T> Sync for NoopTracker<T> where
    T: Sync

impl<H, KF, T, M> Sync for MemoryDB<H, KF, T, M> where
    KF: Sync,
    M: Sync,
    T: Sync

impl<H> Sync for HashKey<H> where
    H: Sync

impl<H> Sync for PrefixedKey<H> where
    H: Sync

impl<H> Sync for LegacyPrefixedKey<H>

impl Sync for Words

impl Sync for Pages

impl Sync for Words

impl Sync for Pages

impl Sync for Bytes

impl Sync for Transcript

impl Sync for TDEFLFlush

impl Sync for TDEFLStatus

impl<'a> !Sync for CallbackFunc<'a>

impl Sync for MinReset

impl Sync for ZeroReset

impl Sync for FullReset

impl Sync for TINFLStatus

impl Sync for MZFlush

impl Sync for MZStatus

impl Sync for MZError

impl Sync for DataFormat

impl<T> Sync for X<T> where
    T: Sync

impl<T> Sync for XY<T> where
    T: Sync

impl<T> Sync for XYZ<T> where
    T: Sync

impl<T> Sync for XYZW<T> where
    T: Sync

impl<T> Sync for XYZWA<T> where
    T: Sync

impl<T> Sync for XYZWAB<T> where
    T: Sync

impl<T> Sync for IJKW<T> where
    T: Sync

impl<T> Sync for M2x2<T> where
    T: Sync

impl<T> Sync for M2x3<T> where
    T: Sync

impl<T> Sync for M2x4<T> where
    T: Sync

impl<T> Sync for M2x5<T> where
    T: Sync

impl<T> Sync for M2x6<T> where
    T: Sync

impl<T> Sync for M3x2<T> where
    T: Sync

impl<T> Sync for M3x3<T> where
    T: Sync

impl<T> Sync for M3x4<T> where
    T: Sync

impl<T> Sync for M3x5<T> where
    T: Sync

impl<T> Sync for M3x6<T> where
    T: Sync

impl<T> Sync for M4x2<T> where
    T: Sync

impl<T> Sync for M4x3<T> where
    T: Sync

impl<T> Sync for M4x4<T> where
    T: Sync

impl<T> Sync for M4x5<T> where
    T: Sync

impl<T> Sync for M4x6<T> where
    T: Sync

impl<T> Sync for M5x2<T> where
    T: Sync

impl<T> Sync for M5x3<T> where
    T: Sync

impl<T> Sync for M5x4<T> where
    T: Sync

impl<T> Sync for M5x5<T> where
    T: Sync

impl<T> Sync for M5x6<T> where
    T: Sync

impl<T> Sync for M6x2<T> where
    T: Sync

impl<T> Sync for M6x3<T> where
    T: Sync

impl<T> Sync for M6x4<T> where
    T: Sync

impl<T> Sync for M6x5<T> where
    T: Sync

impl<T> Sync for M6x6<T> where
    T: Sync

impl Sync for Dynamic

impl<const R: usize> Sync for Const<R>

impl<'a, T, R, C, S> !Sync for MatrixIter<'a, T, R, C, S>

impl<'a, T, R, C, S> !Sync for MatrixIterMut<'a, T, R, C, S>

impl<'a, T, R, C, S> Sync for RowIter<'a, T, R, C, S> where
    S: Sync,
    T: Sync

impl<'a, T, R, C, S> !Sync for RowIterMut<'a, T, R, C, S>

impl<'a, T, R, C, S> Sync for ColumnIter<'a, T, R, C, S> where
    S: Sync,
    T: Sync

impl<'a, T, R, C, S> !Sync for ColumnIterMut<'a, T, R, C, S>

impl<T, const R: usize, const C: usize> Sync for ArrayStorage<T, R, C> where
    T: Sync

impl<T, R, C, S> Sync for Matrix<T, R, C, S> where
    C: Sync,
    R: Sync,
    S: Sync,
    T: Sync

impl Sync for LpNorm

impl Sync for UniformNorm

impl<T> Sync for Unit<T> where
    T: Sync

impl<T, R, C> Sync for VecStorage<T, R, C> where
    T: Sync

impl<T, const D: usize> Sync for Point<T, D> where
    T: Sync

impl<T, const D: usize> Sync for Rotation<T, D> where
    T: Sync

impl<T> Sync for Quaternion<T> where
    T: Sync

impl<T> Sync for DualQuaternion<T> where
    T: Sync

impl<T, const D: usize> Sync for Translation<T, D> where
    T: Sync

impl<T, R, const D: usize> Sync for Isometry<T, R, D> where
    R: Sync,
    T: Sync

impl<T, R, const D: usize> Sync for Similarity<T, R, D> where
    R: Sync,
    T: Sync

impl Sync for TGeneral

impl Sync for TProjective

impl Sync for TAffine

impl<T, C, const D: usize> !Sync for Transform<T, C, D>

impl<T, D, S> Sync for Reflection<T, D, S> where
    S: Sync,
    T: Sync

impl<T> Sync for Orthographic3<T>

impl<T> Sync for Perspective3<T> where
    T: Sync

impl<T, R, C> !Sync for Bidiagonal<T, R, C>

impl<T, D> !Sync for Cholesky<T, D>

impl<T, R, C> !Sync for ColPivQR<T, R, C>

impl<T, R, C> !Sync for FullPivLU<T, R, C>

impl<T> Sync for GivensRotation<T>

impl<T, D> !Sync for Hessenberg<T, D>

impl<T, R, C> !Sync for LU<T, R, C>

impl<D> !Sync for PermutationSequence<D>

impl<T, R, C> !Sync for QR<T, R, C>

impl<T, D> !Sync for Schur<T, D>

impl<T, R, C> !Sync for SVD<T, R, C>

impl<T, D> !Sync for SymmetricEigen<T, D>

impl<T, D> !Sync for SymmetricTridiagonal<T, D>

impl<T, D> !Sync for UDU<T, D>

impl<T> Sync for Complex<T> where
    T: Sync

impl<E> Sync for ParseComplexError<E> where
    E: Sync

impl<A> Sync for ExtendedGcd<A> where
    A: Sync

impl<T> Sync for IterBinomial<T> where
    T: Sync

impl<T> Sync for Ratio<T> where
    T: Sync

impl Sync for AddressSize

impl Sync for SectionKind

impl Sync for ComdatKind

impl Sync for SymbolKind

impl Sync for SymbolScope

impl Sync for FileFlags

impl<Section> Sync for SymbolFlags<Section> where
    Section: Sync

impl Sync for Endianness

impl Sync for BigEndian

impl<E> Sync for U16Bytes<E> where
    E: Sync

impl<E> Sync for U32Bytes<E> where
    E: Sync

impl<E> Sync for U64Bytes<E> where
    E: Sync

impl<E> Sync for I16Bytes<E> where
    E: Sync

impl<E> Sync for I32Bytes<E> where
    E: Sync

impl<E> Sync for I64Bytes<E> where
    E: Sync

impl<'data> Sync for Bytes<'data>

impl<'data, R> Sync for StringTable<'data, R> where
    R: Sync

impl<'data, R> Sync for File<'data, R> where
    R: Sync

impl<'data, 'file, R> Sync for SegmentIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for Segment<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for SectionIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for Section<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for ComdatIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for Comdat<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for ComdatSectionIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for SymbolTable<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for SymbolIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for Symbol<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for DynamicRelocationIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for SectionRelocationIterator<'data, 'file, R> where
    R: Sync

impl Sync for ArchiveKind

impl<'data, R> Sync for ArchiveFile<'data, R> where
    R: Sync

impl<'data, R> Sync for ArchiveMemberIterator<'data, R> where
    R: Sync

impl<'data> Sync for ArchiveMember<'data>

impl<'data, R> Sync for CoffFile<'data, R> where
    R: Sync

impl<'data> Sync for SectionTable<'data>

impl<'data, 'file, R> Sync for CoffSegmentIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffSegment<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffSectionIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffSection<'data, 'file, R> where
    R: Sync

impl<'data, R> Sync for SymbolTable<'data, R> where
    R: Sync

impl<'data, 'table, R> Sync for SymbolIterator<'data, 'table, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffSymbolTable<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffSymbolIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffSymbol<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffRelocationIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffComdatIterator<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffComdat<'data, 'file, R> where
    R: Sync

impl<'data, 'file, R> Sync for CoffComdatSectionIterator<'data, 'file, R> where
    R: Sync

impl<'data, Elf, R> Sync for ElfFile<'data, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSegmentIterator<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSegment<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, Elf, R> Sync for SectionTable<'data, Elf, R> where
    R: Sync,
    <Elf as FileHeader>::SectionHeader: Sync

impl<'data, 'file, Elf, R> Sync for ElfSectionIterator<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSection<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, Elf, R> Sync for SymbolTable<'data, Elf, R> where
    R: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSymbolTable<'data, 'file, Elf, R> where
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSymbolIterator<'data, 'file, Elf, R> where
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSymbol<'data, 'file, Elf, R> where
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfDynamicRelocationIterator<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::Rel: Sync,
    <Elf as FileHeader>::Rela: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfSectionRelocationIterator<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::Rel: Sync,
    <Elf as FileHeader>::Rela: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfComdatIterator<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfComdat<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, 'file, Elf, R> Sync for ElfComdatSectionIterator<'data, 'file, Elf, R> where
    Elf: Sync,
    R: Sync,
    <Elf as FileHeader>::Endian: Sync,
    <Elf as FileHeader>::ProgramHeader: Sync,
    <Elf as FileHeader>::SectionHeader: Sync,
    <Elf as FileHeader>::Sym: Sync

impl<'data, Elf> Sync for NoteIterator<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, Elf> Sync for Note<'data, Elf> where
    <Elf as FileHeader>::NoteHeader: Sync

impl<'data, Elf> Sync for HashTable<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, Elf> Sync for GnuHashTable<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data> Sync for Version<'data>

impl<'data, Elf> Sync for VersionTable<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, Elf> Sync for VerdefIterator<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, Elf> Sync for VerdauxIterator<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, Elf> Sync for VerneedIterator<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, Elf> Sync for VernauxIterator<'data, Elf> where
    <Elf as FileHeader>::Endian: Sync

impl<'data, E, R> Sync for DyldCache<'data, E, R> where
    E: Sync,
    R: Sync

impl<'data, 'cache, E, R> Sync for DyldCacheImageIterator<'data, 'cache, E, R> where
    E: Sync,
    R: Sync

impl<'data, E, R> Sync for DyldCacheImage<'data, E, R> where
    E: Sync,
    R: Sync

impl<'data, Mach, R> Sync for MachOFile<'data, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOComdatIterator<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOComdat<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOComdatSectionIterator<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, E> Sync for LoadCommandIterator<'data, E> where
    E: Sync

impl<'data, E> Sync for LoadCommandData<'data, E> where
    E: Sync

impl<'data, E> Sync for LoadCommandVariant<'data, E> where
    E: Sync

impl<'data, 'file, Mach, R> Sync for MachOSegmentIterator<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOSegment<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync,
    <Mach as MachHeader>::Segment: Sync

impl<'data, 'file, Mach, R> Sync for MachOSectionIterator<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOSection<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, Mach, R> Sync for SymbolTable<'data, Mach, R> where
    R: Sync,
    <Mach as MachHeader>::Nlist: Sync

impl<'data, 'file, Mach, R> Sync for MachOSymbolTable<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOSymbolIterator<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachOSymbol<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, 'file, Mach, R> Sync for MachORelocationIterator<'data, 'file, Mach, R> where
    Mach: Sync,
    R: Sync,
    <Mach as MachHeader>::Endian: Sync,
    <Mach as MachHeader>::Nlist: Sync,
    <Mach as MachHeader>::Section: Sync

impl<'data, Pe, R> Sync for PeFile<'data, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeComdatIterator<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeComdat<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeComdatSectionIterator<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeSegmentIterator<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeSegment<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeSectionIterator<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, Pe, R> Sync for PeSection<'data, 'file, Pe, R> where
    Pe: Sync,
    R: Sync

impl<'data, 'file, R> Sync for PeRelocationIterator<'data, 'file, R> where
    R: Sync

impl<'data> Sync for DataDirectories<'data>

impl<'data> Sync for ExportTarget<'data>

impl<'data> Sync for Export<'data>

impl<'data> Sync for ExportTable<'data>

impl<'data> Sync for ImportTable<'data>

impl<'data> Sync for ImportDescriptorIterator<'data>

impl<'data> Sync for ImportThunkList<'data>

impl<'data> Sync for Import<'data>

impl<'data> Sync for RelocationBlockIterator<'data>

impl<'data> Sync for RelocationIterator<'data>

impl Sync for Relocation

impl<'data> Sync for RichHeaderInfo<'data>

impl Sync for Error

impl Sync for FileKind

impl Sync for ObjectKind

impl Sync for SymbolIndex

impl<T> Sync for SymbolMap<T> where
    T: Sync

impl<'data> Sync for SymbolMapName<'data>

impl<'data> Sync for ObjectMap<'data>

impl<'data> Sync for ObjectMapEntry<'data>

impl<'data> Sync for Import<'data>

impl<'data> Sync for Export<'data>

impl<'data> Sync for CodeView<'data>

impl Sync for Relocation

impl<'data> Sync for CompressedData<'data>

impl Sync for Header

impl<E> Sync for FileHeader32<E> where
    E: Sync

impl<E> Sync for FileHeader64<E> where
    E: Sync

impl Sync for Ident

impl<E> Sync for SectionHeader32<E> where
    E: Sync

impl<E> Sync for SectionHeader64<E> where
    E: Sync

impl<E> Sync for CompressionHeader32<E> where
    E: Sync

impl<E> Sync for CompressionHeader64<E> where
    E: Sync

impl<E> Sync for Sym32<E> where
    E: Sync

impl<E> Sync for Sym64<E> where
    E: Sync

impl<E> Sync for Syminfo32<E> where
    E: Sync

impl<E> Sync for Syminfo64<E> where
    E: Sync

impl<E> Sync for Rel32<E> where
    E: Sync

impl<E> Sync for Rela32<E> where
    E: Sync

impl<E> Sync for Rel64<E> where
    E: Sync

impl<E> Sync for Rela64<E> where
    E: Sync

impl<E> Sync for ProgramHeader32<E> where
    E: Sync

impl<E> Sync for ProgramHeader64<E> where
    E: Sync

impl<E> Sync for Dyn32<E> where
    E: Sync

impl<E> Sync for Dyn64<E> where
    E: Sync

impl<E> Sync for Versym<E> where
    E: Sync

impl<E> Sync for Verdef<E> where
    E: Sync

impl<E> Sync for Verdaux<E> where
    E: Sync

impl<E> Sync for Verneed<E> where
    E: Sync

impl<E> Sync for Vernaux<E> where
    E: Sync

impl<E> Sync for NoteHeader32<E> where
    E: Sync

impl<E> Sync for NoteHeader64<E> where
    E: Sync

impl<E> Sync for HashHeader<E> where
    E: Sync

impl<E> Sync for GnuHashHeader<E> where
    E: Sync

impl<E> Sync for DyldCacheHeader<E> where
    E: Sync

impl<E> Sync for DyldCacheMappingInfo<E> where
    E: Sync

impl<E> Sync for DyldCacheImageInfo<E> where
    E: Sync

impl Sync for FatHeader

impl Sync for FatArch32

impl Sync for FatArch64

impl<E> Sync for MachHeader32<E> where
    E: Sync

impl<E> Sync for MachHeader64<E> where
    E: Sync

impl<E> Sync for LoadCommand<E> where
    E: Sync

impl<E> Sync for LcStr<E> where
    E: Sync

impl<E> Sync for SegmentCommand32<E> where
    E: Sync

impl<E> Sync for SegmentCommand64<E> where
    E: Sync

impl<E> Sync for Section32<E> where
    E: Sync

impl<E> Sync for Section64<E> where
    E: Sync

impl<E> Sync for Fvmlib<E> where
    E: Sync

impl<E> Sync for FvmlibCommand<E> where
    E: Sync

impl<E> Sync for Dylib<E> where
    E: Sync

impl<E> Sync for DylibCommand<E> where
    E: Sync

impl<E> Sync for SubFrameworkCommand<E> where
    E: Sync

impl<E> Sync for SubClientCommand<E> where
    E: Sync

impl<E> Sync for SubUmbrellaCommand<E> where
    E: Sync

impl<E> Sync for SubLibraryCommand<E> where
    E: Sync

impl<E> Sync for PreboundDylibCommand<E> where
    E: Sync

impl<E> Sync for DylinkerCommand<E> where
    E: Sync

impl<E> Sync for ThreadCommand<E> where
    E: Sync

impl<E> Sync for RoutinesCommand32<E> where
    E: Sync

impl<E> Sync for RoutinesCommand64<E> where
    E: Sync

impl<E> Sync for SymtabCommand<E> where
    E: Sync

impl<E> Sync for DysymtabCommand<E> where
    E: Sync

impl<E> Sync for DylibTableOfContents<E> where
    E: Sync

impl<E> Sync for DylibModule32<E> where
    E: Sync

impl<E> Sync for DylibModule64<E> where
    E: Sync

impl<E> Sync for DylibReference<E> where
    E: Sync

impl<E> Sync for TwolevelHintsCommand<E> where
    E: Sync

impl<E> Sync for TwolevelHint<E> where
    E: Sync

impl<E> Sync for PrebindCksumCommand<E> where
    E: Sync

impl<E> Sync for UuidCommand<E> where
    E: Sync

impl<E> Sync for RpathCommand<E> where
    E: Sync

impl<E> Sync for LinkeditDataCommand<E> where
    E: Sync

impl<E> Sync for FilesetEntryCommand<E> where
    E: Sync

impl<E> Sync for EncryptionInfoCommand32<E> where
    E: Sync

impl<E> Sync for EncryptionInfoCommand64<E> where
    E: Sync

impl<E> Sync for VersionMinCommand<E> where
    E: Sync

impl<E> Sync for BuildVersionCommand<E> where
    E: Sync

impl<E> Sync for BuildToolVersion<E> where
    E: Sync

impl<E> Sync for DyldInfoCommand<E> where
    E: Sync

impl<E> Sync for LinkerOptionCommand<E> where
    E: Sync

impl<E> Sync for SymsegCommand<E> where
    E: Sync

impl<E> Sync for IdentCommand<E> where
    E: Sync

impl<E> Sync for FvmfileCommand<E> where
    E: Sync

impl<E> Sync for EntryPointCommand<E> where
    E: Sync

impl<E> Sync for SourceVersionCommand<E> where
    E: Sync

impl<E> Sync for DataInCodeEntry<E> where
    E: Sync

impl<E> Sync for NoteCommand<E> where
    E: Sync

impl<E> Sync for Nlist32<E> where
    E: Sync

impl<E> Sync for Nlist64<E> where
    E: Sync

impl<E> Sync for Relocation<E> where
    E: Sync

impl Sync for Guid

impl Sync for ImageSymbol

impl<T> !Sync for OnceCell<T>

impl<T, F = fn() -> T> !Sync for Lazy<T, F>

impl<T> Sync for OnceCell<T> where
    T: Send + Sync

impl Sync for OnceBool

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStoragePostingNumber<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageBalanceByLedger<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStoragePostingDetail<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageGlobalLedger<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageTaxesByJurisdiction<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for SubstrateWeight<T> where
    T: Sync

impl<T, I> Sync for Pallet<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for Event<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for Error<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for GenesisConfig<T, I>

impl<T, I> Sync for Call<T, I> where
    I: Sync,
    T: Sync,
    <<T as Config>::Lookup as StaticLookup>::Source: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageTotalIssuance<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageAccount<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageLocks<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageReserves<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for PositiveImbalance<T, I>

impl<T, I> Sync for NegativeImbalance<T, I>

impl Sync for Reasons

impl<Balance> Sync for BalanceLock<Balance> where
    Balance: Sync

impl<ReserveIdentifier, Balance> Sync for ReserveData<ReserveIdentifier, Balance> where
    Balance: Sync,
    ReserveIdentifier: Sync

impl<Balance> Sync for AccountData<Balance> where
    Balance: Sync

impl<T, I> Sync for DustCleaner<T, I>

impl<T, I> Sync for Pallet<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for Event<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for Error<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for GenesisConfig<T, I>

impl<T, I> Sync for Call<T, I> where
    I: Sync,
    T: Sync,
    <<T as Config>::Lookup as StaticLookup>::Source: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageTotalIssuance<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageAccount<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageLocks<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for _GeneratedPrefixForStorageReserves<T, I> where
    I: Sync,
    T: Sync

impl<T, I> Sync for PositiveImbalance<T, I>

impl<T, I> Sync for NegativeImbalance<T, I>

impl Sync for Reasons

impl<Balance> Sync for BalanceLock<Balance> where
    Balance: Sync

impl<ReserveIdentifier, Balance> Sync for ReserveData<ReserveIdentifier, Balance> where
    Balance: Sync,
    ReserveIdentifier: Sync

impl<Balance> Sync for AccountData<Balance> where
    Balance: Sync

impl<T, I> Sync for DustCleaner<T, I>

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageIsValidRecord<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageIsStarted<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageIsSuccessful<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageTxList<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<Balance, BlockNumber> Sync for EscrowedAmount<Balance, BlockNumber> where
    Balance: Sync,
    BlockNumber: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageEscrowed<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for GenesisConfig<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageTransferStatus<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageMaxlIssuance<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageUnIssued<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageIssued<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageController<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageTotalDistributed<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageAccountIdBalances<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageHoldersAccountIds<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageOwner<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageBeneficiary<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageApprover<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStoragePostulate<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageOrders<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageOrderItems<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync,
    <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Sync

impl<T> Sync for _GeneratedPrefixForStoragePrefunding<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStoragePrefundingHashOwner<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageReferenceStatus<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageProjectHashStatus<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageDeletedProjects<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageProjectHashOwner<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageOwnerProjectsList<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageProjectInvitesList<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageProjectWorkersList<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageProjectFirstSeen<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageTimeHashOwner<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageTimeRecord<T> where
    T: Sync

impl<T> Sync for SubstrateWeight<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync,
    <T as Config>::Moment: Sync

impl<T> Sync for _GeneratedPrefixForStorageNow<T> where
    T: Sync

impl<C, OU> Sync for CurrencyAdapter<C, OU> where
    C: Sync,
    OU: Sync

impl<Balance> Sync for InclusionFee<Balance> where
    Balance: Sync

impl<Balance> Sync for FeeDetails<Balance> where
    Balance: Sync

impl<Balance> Sync for RuntimeDispatchInfo<Balance> where
    Balance: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageNextFeeMultiplier<T> where
    T: Sync

impl<T, S, V, M> Sync for TargetedFeeAdjustment<T, S, V, M> where
    M: Sync,
    S: Sync,
    T: Sync,
    V: Sync

impl<C, OU> Sync for CurrencyAdapter<C, OU> where
    C: Sync,
    OU: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync

impl<T> Sync for _GeneratedPrefixForStorageNextFeeMultiplier<T> where
    T: Sync

impl<T> Sync for Pallet<T> where
    T: Sync

impl<T> Sync for Error<T> where
    T: Sync

impl<T> Sync for Event<T> where
    T: Sync

impl<T> Sync for Call<T> where
    T: Sync,
    <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: Sync

impl<R> Sync for IoReader<R> where
    R: Sync

impl Sync for OptionBool

impl<T> Sync for Compact<T> where
    T: Sync

impl<'a, T, U> Sync for Ref<'a, T, U> where
    T: Sync,
    U: Sync

impl Sync for Error

impl Sync for VarUint32

impl Sync for VarUint64

impl Sync for VarUint7

impl Sync for VarInt7

impl Sync for Uint8

impl Sync for VarInt32

impl Sync for VarInt64

impl Sync for Uint32

impl Sync for Uint64

impl Sync for VarUint1

impl<T> Sync for CountedList<T> where
    T: Sync

impl<'a, W> Sync for CountedWriter<'a, W> where
    W: Sync

impl<I, T> Sync for CountedListWriter<I, T> where
    T: Sync

impl Sync for Module

impl Sync for Section

impl Sync for TypeSection

impl Sync for CodeSection

impl Sync for DataSection

impl Sync for Type

impl Sync for ValueType

impl Sync for BlockType

impl Sync for GlobalType

impl Sync for TableType

impl Sync for MemoryType

impl Sync for External

impl Sync for ImportEntry

impl Sync for Internal

impl Sync for ExportEntry

impl Sync for GlobalEntry

impl Sync for InitExpr

impl Sync for Instruction

impl Sync for BrTableData

impl Sync for Func

impl Sync for Local

impl Sync for FuncBody

impl Sync for DataSegment

impl<T> Sync for IndexMap<T> where
    T: Sync

impl Sync for NameSection

impl Sync for Error

impl Sync for Unparsed

impl Sync for Identity

impl<F> Sync for ModuleBuilder<F> where
    F: Sync

impl<F> Sync for SignatureBuilder<F> where
    F: Sync

impl<F> Sync for TypeRefBuilder<F> where
    F: Sync

impl<F> Sync for SignaturesBuilder<F> where
    F: Sync

impl<F> Sync for FuncBodyBuilder<F> where
    F: Sync

impl<F> Sync for FunctionBuilder<F> where
    F: Sync

impl<F> Sync for ImportBuilder<F> where
    F: Sync

impl<F> Sync for MemoryBuilder<F> where
    F: Sync

impl<F> Sync for TableBuilder<F> where
    F: Sync

impl<F> Sync for ExportBuilder<F> where
    F: Sync

impl<F> Sync for ExportInternalBuilder<F> where
    F: Sync

impl<F> Sync for GlobalBuilder<F> where
    F: Sync

impl<F> Sync for DataSegmentBuilder<F> where
    F: Sync

impl Sync for Condvar

impl Sync for OnceState

impl Sync for Once

impl Sync for RawMutex

impl Sync for RawRwLock

impl Sync for RawThreadId

impl Sync for ParkResult

impl Sync for RequeueOp

impl Sync for FilterOp

impl Sync for UnparkToken

impl Sync for ParkToken

impl Sync for SpinWait

impl Sync for YesS3

impl Sync for NoS3

impl Sync for YesS4

impl Sync for NoS4

impl Sync for YesA1

impl Sync for NoA1

impl Sync for YesA2

impl Sync for NoA2

impl Sync for YesNI

impl Sync for NoNI

impl<S3, S4, NI> Sync for SseMachine<S3, S4, NI> where
    NI: Sync,
    S3: Sync,
    S4: Sync

impl<NI> Sync for Avx2Machine<NI> where
    NI: Sync

impl Sync for Error

impl Sync for U128

impl Sync for U256

impl Sync for U512

impl Sync for H128

impl Sync for H160

impl Sync for H256

impl Sync for H512

impl !Sync for IntoIter

impl !Sync for TokenStream

impl !Sync for LexError

impl !Sync for Span

impl !Sync for TokenTree

impl !Sync for Group

impl Sync for Delimiter

impl !Sync for Punct

impl Sync for Spacing

impl !Sync for Ident

impl !Sync for Literal

impl Sync for Error

impl Sync for FoundCrate

impl Sync for Bernoulli

impl<D, R, T> Sync for DistIter<D, R, T> where
    D: Sync,
    R: Sync,
    T: Sync

impl<D, F, T, S> Sync for DistMap<D, F, T, S> where
    D: Sync,
    F: Sync

impl Sync for Open01

impl<'a, T> Sync for Slice<'a, T> where
    T: Sync

impl<X> Sync for WeightedIndex<X> where
    X: Sync,
    <X as SampleUniform>::Sampler: Sync

impl<X> Sync for Uniform<X> where
    <X as SampleUniform>::Sampler: Sync

impl<X> Sync for UniformInt<X> where
    X: Sync

impl Sync for UniformChar

impl<X> Sync for UniformFloat<X> where
    X: Sync

impl<W> Sync for WeightedIndex<W> where
    W: Sync

impl Sync for Standard

impl<R> Sync for ReadRng<R> where
    R: Sync

impl Sync for ReadError

impl<R, Rsdr> Sync for ReseedingRng<R, Rsdr> where
    R: Sync,
    Rsdr: Sync,
    <R as BlockRngCore>::Results: Sync

impl Sync for StepRng

impl Sync for StdRng

impl !Sync for ThreadRng

impl Sync for IndexVec

impl<'a> Sync for IndexVecIter<'a>

impl<'a, S: ?Sized, T> Sync for SliceChooseIter<'a, S, T> where
    S: Sync,
    T: Sync

impl Sync for ChaCha20Rng

impl Sync for ChaCha12Rng

impl Sync for ChaCha8Core

impl Sync for ChaCha8Rng

impl<R: ?Sized> Sync for BlockRng<R> where
    R: Sync,
    <R as BlockRngCore>::Results: Sync

impl<R: ?Sized> Sync for BlockRng64<R> where
    R: Sync,
    <R as BlockRngCore>::Results: Sync

impl Sync for Error

impl Sync for OsRng

impl Sync for Binomial

impl Sync for Error

impl<F> Sync for Cauchy<F> where
    F: Sync

impl Sync for Error

impl Sync for Exp1

impl<F> Sync for Exp<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for Frechet<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for Gamma<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for ChiSquared<F> where
    F: Sync

impl<F> Sync for FisherF<F> where
    F: Sync

impl<F> Sync for StudentT<F> where
    F: Sync

impl<F> Sync for Beta<F> where
    F: Sync

impl Sync for BetaError

impl Sync for Geometric

impl Sync for Error

impl<F> Sync for Gumbel<F> where
    F: Sync

impl Sync for Error

impl Sync for Error

impl Sync for Error

impl<F> Sync for InverseGaussian<F> where
    F: Sync

impl<F> Sync for Normal<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for LogNormal<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for NormalInverseGaussian<F> where
    F: Sync

impl<F> Sync for Pareto<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for Pert<F> where
    F: Sync

impl Sync for PertError

impl<F> Sync for Poisson<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for SkewNormal<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for Triangular<F> where
    F: Sync

impl Sync for UnitBall

impl Sync for UnitCircle

impl Sync for UnitDisc

impl Sync for UnitSphere

impl<F> Sync for Weibull<F> where
    F: Sync

impl Sync for Error

impl<F> Sync for Zeta<F> where
    F: Sync

impl Sync for ZetaError

impl<F> Sync for Zipf<F> where
    F: Sync

impl Sync for ZipfError

impl<'t> Sync for Match<'t>

impl Sync for Regex

impl<'r, 't> !Sync for Matches<'r, 't>

impl<'r, 't> !Sync for CaptureMatches<'r, 't>

impl<'r, 't> !Sync for Split<'r, 't>

impl<'r, 't> !Sync for SplitN<'r, 't>

impl<'r> Sync for CaptureNames<'r>

impl<'t> Sync for Captures<'t>

impl<'c, 't> Sync for SubCaptureMatches<'c, 't>

impl<'a, R: ?Sized> Sync for ReplacerRef<'a, R> where
    R: Sync

impl<'t> Sync for NoExpand<'t>

impl Sync for RegexSet

impl Sync for SetMatches

impl<'a> Sync for SetMatchesIter<'a>

impl Sync for Error

impl Sync for RegexSet

impl Sync for SetMatches

impl<'a> Sync for SetMatchesIter<'a>

impl<'t> Sync for Match<'t>

impl Sync for Regex

impl<'r> Sync for CaptureNames<'r>

impl<'r, 't> !Sync for Split<'r, 't>

impl<'r, 't> !Sync for SplitN<'r, 't>

impl<'t> Sync for Captures<'t>

impl<'c, 't> Sync for SubCaptureMatches<'c, 't>

impl<'r, 't> !Sync for CaptureMatches<'r, 't>

impl<'r, 't> !Sync for Matches<'r, 't>

impl<'a, R: ?Sized> Sync for ReplacerRef<'a, R> where
    R: Sync

impl<'t> Sync for NoExpand<'t>

impl<T, S> Sync for DenseDFA<T, S> where
    S: Sync,
    T: Sync

impl<T, S> Sync for Standard<T, S> where
    S: Sync,
    T: Sync

impl<T, S> Sync for ByteClass<T, S> where
    S: Sync,
    T: Sync

impl<T, S> Sync for Premultiplied<T, S> where
    S: Sync,
    T: Sync

impl<T, S> Sync for PremultipliedByteClass<T, S> where
    S: Sync,
    T: Sync

impl Sync for Builder

impl Sync for Error

impl Sync for ErrorKind

impl<D> Sync for Regex<D> where
    D: Sync

impl<T, S> Sync for SparseDFA<T, S> where
    S: Sync,
    T: Sync

impl<T, S> Sync for Standard<T, S> where
    S: Sync,
    T: Sync

impl<T, S> Sync for ByteClass<T, S> where
    S: Sync,
    T: Sync

impl !Sync for Parser

impl Sync for Printer

impl Sync for Error

impl Sync for ErrorKind

impl Sync for Span

impl Sync for Position

impl Sync for Comment

impl Sync for Ast

impl Sync for Alternation

impl Sync for Concat

impl Sync for Literal

impl Sync for LiteralKind

impl Sync for Class

impl Sync for ClassPerl

impl Sync for ClassAscii

impl Sync for ClassSet

impl Sync for Assertion

impl Sync for Repetition

impl Sync for Group

impl Sync for GroupKind

impl Sync for CaptureName

impl Sync for SetFlags

impl Sync for Flags

impl Sync for FlagsItem

impl Sync for Flag

impl Sync for Error

impl Sync for Literals

impl Sync for Literal

impl Sync for Printer

impl !Sync for Translator

impl Sync for Error

impl Sync for ErrorKind

impl Sync for Hir

impl Sync for HirKind

impl Sync for Literal

impl Sync for Class

impl<'a> Sync for ClassUnicodeIter<'a>

impl Sync for ClassBytes

impl<'a> Sync for ClassBytesIter<'a>

impl Sync for Anchor

impl Sync for Group

impl Sync for GroupKind

impl Sync for Repetition

impl !Sync for Parser

impl Sync for Utf8Range

impl<'a> Sync for Demangle<'a>

impl Sync for FxHasher

impl<T> Sync for ToHexIter<T> where
    T: Sync

impl<'a> Sync for FromHexIter<'a>

impl Sync for Buffer

impl Sync for SecretKey

impl Sync for PublicKey

impl Sync for Keypair

impl<H> Sync for XoFTranscript<H> where
    H: Sync

impl<T, R> !Sync for SigningTranscriptWithRng<T, R>

impl Sync for Signature

impl<T> Sync for Malleable<T> where
    T: Sync

impl Sync for VRFOutput

impl Sync for VRFInOut

impl Sync for VRFProof

impl Sync for ChainCode

impl<K> Sync for ExtendedKey<K> where
    K: Sync

impl<'a, K> Sync for AggregatePublicKeySlice<'a, K> where
    K: Sync

impl Sync for Commitment

impl Sync for Reveal

impl<T, S> Sync for MuSig<T, S> where
    S: Sync,
    T: Sync

impl<K> Sync for CommitStage<K> where
    K: Sync

impl<K> Sync for RevealStage<K> where
    K: Sync

impl Sync for CosignStage

impl Sync for Cosignature

impl Sync for Always

impl<S> Sync for Secret<S> where
    S: Sync

impl Sync for Error

impl<E> Sync for UnitDeserializer<E> where
    E: Sync

impl<E> Sync for BoolDeserializer<E> where
    E: Sync

impl<E> Sync for I8Deserializer<E> where
    E: Sync

impl<E> Sync for I16Deserializer<E> where
    E: Sync

impl<E> Sync for I32Deserializer<E> where
    E: Sync

impl<E> Sync for I64Deserializer<E> where
    E: Sync

impl<E> Sync for IsizeDeserializer<E> where
    E: Sync

impl<E> Sync for U8Deserializer<E> where
    E: Sync

impl<E> Sync for U16Deserializer<E> where
    E: Sync

impl<E> Sync for U64Deserializer<E> where
    E: Sync

impl<E> Sync for UsizeDeserializer<E> where
    E: Sync

impl<E> Sync for F32Deserializer<E> where
    E: Sync

impl<E> Sync for F64Deserializer<E> where
    E: Sync

impl<E> Sync for CharDeserializer<E> where
    E: Sync

impl<E> Sync for I128Deserializer<E> where
    E: Sync

impl<E> Sync for U128Deserializer<E> where
    E: Sync

impl<E> Sync for U32Deserializer<E> where
    E: Sync

impl<'a, E> Sync for StrDeserializer<'a, E> where
    E: Sync

impl<'de, E> Sync for BorrowedStrDeserializer<'de, E> where
    E: Sync

impl<E> Sync for StringDeserializer<E> where
    E: Sync

impl<'a, E> Sync for CowStrDeserializer<'a, E> where
    E: Sync

impl<'a, E> Sync for BytesDeserializer<'a, E> where
    E: Sync

impl<'de, E> Sync for BorrowedBytesDeserializer<'de, E> where
    E: Sync

impl<I, E> Sync for SeqDeserializer<I, E> where
    E: Sync,
    I: Sync

impl<A> Sync for SeqAccessDeserializer<A> where
    A: Sync

impl<'de, I, E> Sync for MapDeserializer<'de, I, E> where
    E: Sync,
    I: Sync,
    <<I as Iterator>::Item as Pair>::Second: Sync

impl<A> Sync for MapAccessDeserializer<A> where
    A: Sync

impl Sync for IgnoredAny

impl<'a> Sync for Unexpected<'a>

impl<Ok, Error> Sync for Impossible<Ok, Error> where
    Error: Sync,
    Ok: Sync

impl<'a> Sync for SliceRead<'a>

impl<'a> Sync for StrRead<'a>

impl<R> Sync for IoRead<R> where
    R: Sync

impl<R> Sync for Deserializer<R> where
    R: Sync

impl<'de, R, T> Sync for StreamDeserializer<'de, R, T> where
    R: Sync,
    T: Sync

impl Sync for Error

impl Sync for Category

impl<K, V> Sync for Map<K, V> where
    K: Sync,
    V: Sync

impl<'a> Sync for Entry<'a>

impl<'a> Sync for VacantEntry<'a>

impl<'a> Sync for OccupiedEntry<'a>

impl<'a> Sync for Iter<'a>

impl<'a> Sync for IterMut<'a>

impl Sync for IntoIter

impl<'a> Sync for Keys<'a>

impl<'a> Sync for Values<'a>

impl<'a> Sync for ValuesMut<'a>

impl<W, F> Sync for Serializer<W, F> where
    F: Sync,
    W: Sync

impl Sync for CharEscape

impl<'a> Sync for PrettyFormatter<'a>

impl Sync for Serializer

impl Sync for Number

impl Sync for Value

impl Sync for Sha256

impl Sync for Sha224

impl Sync for Sha512

impl Sync for Sha384

impl<'a, T, C = DefaultConfig> !Sync for Ref<'a, T, C>

impl<'a, T, C = DefaultConfig> !Sync for RefMut<'a, T, C>

impl<'a, T, C = DefaultConfig> !Sync for Entry<'a, T, C>

impl<'a, T, C = DefaultConfig> !Sync for VacantEntry<'a, T, C>

impl Sync for Error

impl<N> Sync for AutoSimd<N> where
    N: Sync

impl<N> Sync for AutoBoolSimd<N> where
    N: Sync

impl<V> Sync for SimdOption<V> where
    V: Sync,
    <V as SimdValue>::SimdBool: Sync

impl<T> Sync for Slab<T> where
    T: Sync

impl<'a, T> Sync for VacantEntry<'a, T> where
    T: Sync

impl<T> Sync for IntoIter<T> where
    T: Sync

impl<'a, T> Sync for Iter<'a, T> where
    T: Sync

impl<'a, T> Sync for IterMut<'a, T> where
    T: Sync

impl<'a, T> Sync for Drain<'a, T> where
    T: Sync

impl<A> Sync for SmallVec<A> where
    A: Sync

impl<A> Sync for IntoIter<A> where
    A: Sync

impl Sync for ApiError

impl<'a, Block, NC, Backend> !Sync for CallApiAtParams<'a, Block, NC, Backend>

impl<'a, T> Sync for ApiRef<'a, T> where
    T: Sync

impl Sync for Public

impl Sync for Signature

impl Sync for Pair

impl Sync for Public

impl Sync for Signature

impl Sync for Pair

impl Sync for Public

impl Sync for Signature

impl Sync for Pair

impl Sync for BigUint

impl Sync for FixedI64

impl Sync for FixedI128

impl Sync for FixedU128

impl Sync for Percent

impl Sync for PerU16

impl Sync for Permill

impl Sync for Perbill

impl Sync for Perquintill

impl Sync for Rational128

impl Sync for Dummy

impl Sync for Infallible

impl Sync for PublicError

impl Sync for AccountId32

impl Sync for KeyTypeId

impl<'a> Sync for HexDisplay<'a>

impl Sync for _0

impl Sync for _1

impl Sync for _2

impl Sync for _3

impl Sync for _4

impl Sync for _5

impl Sync for _6

impl Sync for _7

impl Sync for _8

impl Sync for _9

impl Sync for _10

impl Sync for _11

impl Sync for _12

impl Sync for _13

impl Sync for _14

impl Sync for _15

impl Sync for _16

impl Sync for _17

impl Sync for _18

impl Sync for _19

impl Sync for _20

impl Sync for _21

impl Sync for _22

impl Sync for _23

impl Sync for _24

impl Sync for _25

impl Sync for _26

impl Sync for _27

impl Sync for _28

impl Sync for _29

impl Sync for _30

impl Sync for _31

impl Sync for _32

impl Sync for _33

impl Sync for _34

impl Sync for _35

impl Sync for _36

impl Sync for _37

impl Sync for _38

impl Sync for _39

impl Sync for _40

impl Sync for _41

impl Sync for _42

impl Sync for _43

impl Sync for _44

impl Sync for _45

impl Sync for _46

impl Sync for _47

impl Sync for _48

impl Sync for _49

impl Sync for _50

impl Sync for _51

impl Sync for _52

impl Sync for _53

impl Sync for _54

impl Sync for _55

impl Sync for _56

impl Sync for _57

impl Sync for _58

impl Sync for _59

impl Sync for _60

impl Sync for _61

impl Sync for _62

impl Sync for _63

impl Sync for _64

impl Sync for _65

impl Sync for _66

impl Sync for _67

impl Sync for _68

impl Sync for _69

impl Sync for _70

impl Sync for _71

impl Sync for _72

impl Sync for _73

impl Sync for _74

impl Sync for _75

impl Sync for _76

impl Sync for _77

impl Sync for _78

impl Sync for _79

impl Sync for _80

impl Sync for _81

impl Sync for _82

impl Sync for _83

impl Sync for _84

impl Sync for _85

impl Sync for _86

impl Sync for _87

impl Sync for _88

impl Sync for _89

impl Sync for _90

impl Sync for _91

impl Sync for _92

impl Sync for _93

impl Sync for _94

impl Sync for _95

impl Sync for _96

impl Sync for _97

impl Sync for _98

impl Sync for _99

impl Sync for _100

impl Sync for _112

impl Sync for _128

impl Sync for _160

impl Sync for _192

impl Sync for _224

impl Sync for _256

impl Sync for _384

impl Sync for _512

impl Sync for Public

impl Sync for PublicError

impl Sync for Signature

impl Sync for DeriveError

impl Sync for Pair

impl Sync for Public

impl Sync for Pair

impl Sync for Signature

impl Sync for PublicError

impl Sync for DeriveError

impl Sync for PoolState

impl Sync for StorageKind

impl Sync for HttpError

impl Sync for Timestamp

impl Sync for Duration

impl<T> Sync for LimitedExternalities<T> where
    T: Sync

impl Sync for HostError

impl Sync for Entry

impl Sync for Public

impl Sync for Pair

impl Sync for Signature

impl<'a> Sync for WrappedRuntimeCode<'a>

impl<'a> !Sync for RuntimeCode<'a>

impl Sync for Bytes

impl<R> Sync for NativeOrEncoded<R> where
    R: Sync

impl Sync for LogLevel

impl Sync for Void

impl !Sync for Extensions

impl Sync for Error

impl Sync for Error

impl<E> Sync for MakeFatalError<E> where
    E: Sync

impl<T> Sync for Crossing<T> where
    T: Sync

impl Sync for KeyStore

impl Sync for Error

impl Sync for KeystoreExt

impl !Sync for AbortGuard

impl<'a> Sync for PiecewiseLinear<'a>

impl<Block> Sync for BlockId<Block>

impl<Header, Extrinsic> Sync for Block<Header, Extrinsic> where
    Extrinsic: Sync,
    Header: Sync

impl<Block> Sync for SignedBlock<Block> where
    Block: Sync

impl<AccountId, Call, Extra> Sync for CheckedExtrinsic<AccountId, Call, Extra> where
    AccountId: Sync,
    Call: Sync,
    Extra: Sync

impl Sync for Digest

impl Sync for DigestItem

impl<'a> Sync for DigestItemRef<'a>

impl<'a> Sync for OpaqueDigestItemId<'a>

impl Sync for Era

impl<Number, Hash> Sync for Header<Number, Hash> where
    Number: Sync

impl<Address, Call, Signature, Extra> Sync for UncheckedExtrinsic<Address, Call, Signature, Extra> where
    Address: Sync,
    Call: Sync,
    Signature: Sync

impl<Call, Extra> Sync for SignedPayload<Call, Extra> where
    Call: Sync,
    <Extra as SignedExtension>::AdditionalSigned: Sync

impl<AccountId, AccountIndex> Sync for MultiAddress<AccountId, AccountIndex> where
    AccountId: Sync,
    AccountIndex: Sync

impl Sync for Method

impl<'a, T> Sync for Request<'a, T> where
    T: Sync

impl Sync for Error

impl Sync for Response

impl Sync for Headers

impl<'a> Sync for HeadersIterator<'a>

impl<'a> Sync for StorageValueRef<'a>

impl<T, E> Sync for MutateStorageError<T, E> where
    E: Sync,
    T: Sync

impl Sync for Time

impl<B> Sync for BlockAndTimeDeadline<B> where
    <B as BlockNumberProvider>::BlockNumber: Sync

impl<B> Sync for BlockAndTime<B> where
    B: Sync

impl<'a, L> Sync for StorageLock<'a, L> where
    L: Sync

impl<'a, 'b, L> Sync for StorageLockGuard<'a, 'b, L> where
    L: Sync

impl<Xt> Sync for ExtrinsicWrapper<Xt> where
    Xt: Sync

impl<Xt> Sync for Block<Xt> where
    Xt: Sync

impl<Call, Extra> Sync for TestXt<Call, Extra> where
    Call: Sync,
    Extra: Sync

impl Sync for BadOrigin

impl Sync for LookupError

impl<T> Sync for IdentityLookup<T> where
    T: Sync

impl<AccountId, AccountIndex> Sync for AccountIdLookup<AccountId, AccountIndex> where
    AccountId: Sync,
    AccountIndex: Sync

impl Sync for Identity

impl Sync for ConvertInto

impl Sync for BlakeTwo256

impl Sync for Keccak256

impl<'a, T> Sync for AppendZerosInput<'a, T> where
    T: Sync

impl<'a> Sync for TrailingZeroInput<'a>

impl Sync for MultiSigner

impl<Info> Sync for DispatchErrorWithPostInfo<Info> where
    Info: Sync

impl Sync for TokenError

impl<R> Sync for TransactionOutcome<R> where
    R: Sync

impl<T> Sync for Codec<T> where
    T: Sync

impl<T, I> Sync for Inner<T, I> where
    I: Sync,
    T: Sync

impl<T> Sync for Enum<T> where
    T: Sync

impl<T, O> Sync for WrappedFFIValue<T, O> where
    O: Sync,
    T: Sync

impl<T> Sync for RestoreImplementation<T> where
    T: Sync

impl<Reporter, Offender> Sync for OffenceDetails<Reporter, Offender> where
    Offender: Sync,
    Reporter: Sync

impl<'a, B, H> Sync for BackendRuntimeCode<'a, B, H> where
    B: Sync,
    H: Sync

impl<'a, H, B> !Sync for Ext<'a, H, B>

impl<Transaction, H> Sync for StorageChanges<Transaction, H> where
    Transaction: Sync

impl<Transaction, H> Sync for StorageTransactionCache<Transaction, H> where
    Transaction: Sync

impl<'a, S, H> Sync for ProvingBackendRecorder<'a, S, H>

impl<Hash> Sync for ProofRecorder<Hash> where
    Hash: Send + Sync

impl<'a, S, H> Sync for ProvingBackend<'a, S, H>

impl<'a, H, B> Sync for ReadOnlyExternalities<'a, H, B> where
    B: Sync

impl Sync for UsageUnit

impl Sync for UsageInfo

impl<H> !Sync for TestExternalities<H>

impl<S, H> Sync for TrieBackend<S, H>

impl<F> Sync for ExecutionManager<F> where
    F: Sync

impl<'a, B, H, Exec> !Sync for StateMachine<'a, B, H, Exec>

impl Sync for StorageKey

impl Sync for StorageData

impl Sync for Storage

impl<Hash> Sync for StorageChangeSet<Hash> where
    Hash: Sync

impl Sync for ChildInfo

impl Sync for ChildType

impl Sync for Timestamp

impl Sync for WasmLevel

impl Sync for WasmValue

impl Sync for WasmFields

impl Sync for Error

impl<H> Sync for NodeCodec<H> where
    H: Sync

impl<L> Sync for Error<L> where
    <<L as TrieLayout>::Codec as NodeCodec>::Error: Sync

impl Sync for TrieStream

impl<H> Sync for Layout<H> where
    H: Sync

impl<'a, DB, H> Sync for KeySpacedDB<'a, DB, H> where
    DB: Sync,
    H: Sync

impl<'a, DB, H> Sync for KeySpacedDBMut<'a, DB, H> where
    DB: Sync,
    H: Sync

impl Sync for Error

impl Sync for ValueType

impl Sync for Value

impl<T> Sync for Pointer<T> where
    T: Sync

impl Sync for Signature

impl Sync for ReturnValue

impl Sync for ParseError

impl Sync for Bernoulli

impl Sync for Beta

impl Sync for Binomial

impl Sync for Categorical

impl Sync for Cauchy

impl Sync for Chi

impl Sync for ChiSquared

impl Sync for Dirac

impl Sync for Dirichlet

impl Sync for Empirical

impl Sync for Erlang

impl Sync for Exp

impl Sync for Gamma

impl Sync for Geometric

impl Sync for Laplace

impl Sync for LogNormal

impl Sync for Multinomial

impl Sync for Normal

impl Sync for Pareto

impl Sync for Poisson

impl Sync for StudentsT

impl Sync for Triangular

impl Sync for Uniform

impl Sync for Weibull

impl<D> Sync for Data<D> where
    D: Sync

impl Sync for StatsError

impl Sync for ParseError

impl Sync for Error

impl Sync for Choice

impl<T> Sync for CtOption<T> where
    T: Sync

impl !Sync for Underscore

impl !Sync for Abstract

impl !Sync for As

impl !Sync for Async

impl !Sync for Auto

impl !Sync for Await

impl !Sync for Become

impl !Sync for Box

impl !Sync for Break

impl !Sync for Const

impl !Sync for Continue

impl !Sync for Crate

impl !Sync for Default

impl !Sync for Do

impl !Sync for Dyn

impl !Sync for Else

impl !Sync for Enum

impl !Sync for Extern

impl !Sync for Final

impl !Sync for Fn

impl !Sync for For

impl !Sync for If

impl !Sync for Impl

impl !Sync for In

impl !Sync for Let

impl !Sync for Loop

impl !Sync for Macro

impl !Sync for Match

impl !Sync for Mod

impl !Sync for Move

impl !Sync for Mut

impl !Sync for Override

impl !Sync for Priv

impl !Sync for Pub

impl !Sync for Ref

impl !Sync for Return

impl !Sync for SelfType

impl !Sync for SelfValue

impl !Sync for Static

impl !Sync for Struct

impl !Sync for Super

impl !Sync for Trait

impl !Sync for Try

impl !Sync for Type

impl !Sync for Typeof

impl !Sync for Union

impl !Sync for Unsafe

impl !Sync for Unsized

impl !Sync for Use

impl !Sync for Virtual

impl !Sync for Where

impl !Sync for While

impl !Sync for Yield

impl !Sync for Add

impl !Sync for AddEq

impl !Sync for And

impl !Sync for AndAnd

impl !Sync for AndEq

impl !Sync for At

impl !Sync for Bang

impl !Sync for Caret

impl !Sync for CaretEq

impl !Sync for Colon

impl !Sync for Colon2

impl !Sync for Comma

impl !Sync for Div

impl !Sync for DivEq

impl !Sync for Dollar

impl !Sync for Dot

impl !Sync for Dot2

impl !Sync for Dot3

impl !Sync for DotDotEq

impl !Sync for Eq

impl !Sync for EqEq

impl !Sync for Ge

impl !Sync for Gt

impl !Sync for Le

impl !Sync for Lt

impl !Sync for MulEq

impl !Sync for Ne

impl !Sync for Or

impl !Sync for OrEq

impl !Sync for OrOr

impl !Sync for Pound

impl !Sync for Question

impl !Sync for RArrow

impl !Sync for LArrow

impl !Sync for Rem

impl !Sync for RemEq

impl !Sync for FatArrow

impl !Sync for Semi

impl !Sync for Shl

impl !Sync for ShlEq

impl !Sync for Shr

impl !Sync for ShrEq

impl !Sync for Star

impl !Sync for Sub

impl !Sync for SubEq

impl !Sync for Tilde

impl !Sync for Brace

impl !Sync for Bracket

impl !Sync for Paren

impl !Sync for Group

impl !Sync for Attribute

impl !Sync for AttrStyle

impl !Sync for Meta

impl !Sync for MetaList

impl !Sync for NestedMeta

impl !Sync for Variant

impl !Sync for Fields

impl !Sync for FieldsNamed

impl !Sync for Field

impl !Sync for Visibility

impl !Sync for VisPublic

impl !Sync for VisCrate

impl !Sync for Expr

impl !Sync for ExprArray

impl !Sync for ExprAssign

impl !Sync for ExprAssignOp

impl !Sync for ExprAsync

impl !Sync for ExprAwait

impl !Sync for ExprBinary

impl !Sync for ExprBlock

impl !Sync for ExprBox

impl !Sync for ExprBreak

impl !Sync for ExprCall

impl !Sync for ExprCast

impl !Sync for ExprClosure

impl !Sync for ExprContinue

impl !Sync for ExprField

impl !Sync for ExprForLoop

impl !Sync for ExprGroup

impl !Sync for ExprIf

impl !Sync for ExprIndex

impl !Sync for ExprLet

impl !Sync for ExprLit

impl !Sync for ExprLoop

impl !Sync for ExprMacro

impl !Sync for ExprMatch

impl !Sync for ExprParen

impl !Sync for ExprPath

impl !Sync for ExprRange

impl !Sync for ExprRepeat

impl !Sync for ExprReturn

impl !Sync for ExprStruct

impl !Sync for ExprTry

impl !Sync for ExprTryBlock

impl !Sync for ExprTuple

impl !Sync for ExprType

impl !Sync for ExprUnary

impl !Sync for ExprUnsafe

impl !Sync for ExprWhile

impl !Sync for ExprYield

impl !Sync for Member

impl !Sync for Index

impl !Sync for FieldValue

impl !Sync for Label

impl !Sync for Arm

impl !Sync for RangeLimits

impl !Sync for Generics

impl !Sync for GenericParam

impl !Sync for TypeParam

impl !Sync for LifetimeDef

impl !Sync for ConstParam

impl<'a> !Sync for ImplGenerics<'a>

impl<'a> !Sync for TypeGenerics<'a>

impl<'a> !Sync for Turbofish<'a>

impl !Sync for TraitBound

impl !Sync for WhereClause

impl !Sync for PredicateEq

impl !Sync for Item

impl !Sync for ItemConst

impl !Sync for ItemEnum

impl !Sync for ItemFn

impl !Sync for ItemImpl

impl !Sync for ItemMacro

impl !Sync for ItemMacro2

impl !Sync for ItemMod

impl !Sync for ItemStatic

impl !Sync for ItemStruct

impl !Sync for ItemTrait

impl !Sync for ItemType

impl !Sync for ItemUnion

impl !Sync for ItemUse

impl !Sync for UseTree

impl !Sync for UsePath

impl !Sync for UseName

impl !Sync for UseRename

impl !Sync for UseGlob

impl !Sync for UseGroup

impl !Sync for ForeignItem

impl !Sync for TraitItem

impl !Sync for ImplItem

impl !Sync for ImplItemType

impl !Sync for Signature

impl !Sync for FnArg

impl !Sync for Receiver

impl !Sync for File

impl !Sync for Lifetime

impl !Sync for Lit

impl !Sync for LitStr

impl !Sync for LitByteStr

impl !Sync for LitByte

impl !Sync for LitChar

impl !Sync for LitInt

impl !Sync for LitFloat

impl !Sync for LitBool

impl Sync for StrStyle

impl !Sync for Macro

impl !Sync for DeriveInput

impl !Sync for Data

impl !Sync for DataStruct

impl !Sync for DataEnum

impl !Sync for DataUnion

impl !Sync for BinOp

impl !Sync for UnOp

impl !Sync for Block

impl !Sync for Stmt

impl !Sync for Local

impl !Sync for Type

impl !Sync for TypeArray

impl !Sync for TypeBareFn

impl !Sync for TypeGroup

impl !Sync for TypeInfer

impl !Sync for TypeMacro

impl !Sync for TypeNever

impl !Sync for TypeParen

impl !Sync for TypePath

impl !Sync for TypePtr

impl !Sync for TypeSlice

impl !Sync for TypeTuple

impl !Sync for Abi

impl !Sync for BareFnArg

impl !Sync for Variadic

impl !Sync for ReturnType

impl !Sync for Pat

impl !Sync for PatBox

impl !Sync for PatIdent

impl !Sync for PatLit

impl !Sync for PatMacro

impl !Sync for PatOr

impl !Sync for PatPath

impl !Sync for PatRange

impl !Sync for PatReference

impl !Sync for PatRest

impl !Sync for PatSlice

impl !Sync for PatStruct

impl !Sync for PatTuple

impl !Sync for PatType

impl !Sync for PatWild

impl !Sync for FieldPat

impl !Sync for Path

impl !Sync for PathSegment

impl !Sync for Binding

impl !Sync for Constraint

impl !Sync for QSelf

impl !Sync for TokenBuffer

impl<'a> !Sync for Cursor<'a>

impl<T, P> Sync for Punctuated<T, P> where
    P: Sync,
    T: Sync

impl<'a, T, P> Sync for Pairs<'a, T, P> where
    P: Sync,
    T: Sync

impl<'a, T, P> Sync for PairsMut<'a, T, P> where
    P: Sync,
    T: Sync

impl<T, P> Sync for IntoPairs<T, P> where
    P: Sync,
    T: Sync

impl<T> Sync for IntoIter<T> where
    T: Sync

impl<'a, T> !Sync for Iter<'a, T>

impl<'a, T> !Sync for IterMut<'a, T>

impl<T, P> Sync for Pair<T, P> where
    P: Sync,
    T: Sync

impl<'a> !Sync for Lookahead1<'a>

impl Sync for Error

impl<'a> !Sync for ParseBuffer<'a>

impl<'c, 'a> !Sync for StepCursor<'c, 'a>

impl Sync for Nothing

impl Sync for AddBounds

impl Sync for BindStyle

impl<'a> !Sync for BindingInfo<'a>

impl<'a> !Sync for VariantAst<'a>

impl<'a> !Sync for VariantInfo<'a>

impl<'a> !Sync for Structure<'a>

impl<T> Sync for CachedThreadLocal<T>

impl<'a, T> Sync for CachedIterMut<'a, T>

impl<T> Sync for CachedIntoIter<T>

impl<'a, T> Sync for Iter<'a, T>

impl<'a, T> Sync for IterMut<'a, T>

impl<T> Sync for IntoIter<T>

impl Sync for Keccak

impl<A> Sync for ArrayVec<A> where
    A: Sync

impl<'p, A, I> Sync for ArrayVecSplice<'p, A, I> where
    A: Sync,
    I: Sync

impl<A> Sync for ArrayVecIterator<A> where
    A: Sync

impl<'a, T> Sync for ArrayVecDrain<'a, T> where
    T: Sync

impl<'s, T> Sync for SliceVec<'s, T> where
    T: Sync

impl<'p, 's, T> Sync for SliceVecDrain<'p, 's, T> where
    T: Sync

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

impl<'p, A> Sync for TinyVecDrain<'p, A> where
    <A as Array>::Item: Sync

impl<'p, A, I> Sync for TinyVecSplice<'p, A, I> where
    A: Sync,
    I: Sync,
    <A as Array>::Item: Sync

impl<A> Sync for TinyVecIterator<A> where
    A: Sync,
    <A as Array>::Item: Sync

impl<K, V> Sync for Map<K, V> where
    K: Sync,
    V: Sync

impl<'a> Sync for Entry<'a>

impl<'a> Sync for VacantEntry<'a>

impl<'a> Sync for OccupiedEntry<'a>

impl<'a> Sync for Iter<'a>

impl<'a> Sync for IterMut<'a>

impl Sync for IntoIter

impl<'a> Sync for Keys<'a>

impl<'a> Sync for Values<'a>

impl Sync for Datetime

impl Sync for Value

impl Sync for Error

impl<'a> !Sync for Serializer<'a>

impl Sync for Error

impl<'a> Sync for Deserializer<'a>

impl<T> Sync for Spanned<T> where
    T: Sync

impl Sync for Converter

impl Sync for Cogs

impl Sync for _0002_

impl Sync for _0003_

impl Sync for _0004_

impl Sync for _0005_

impl Sync for _0006_

impl Sync for _0007_

impl Sync for _0008_

impl Sync for _0009_

impl Sync for _0010_

impl Sync for _0011_

impl Sync for _0012_

impl Sync for _0013_

impl Sync for _0014_

impl Sync for _0015_

impl Sync for _0016_

impl Sync for _0017_

impl Sync for _0018_

impl Sync for _0019_

impl Sync for _0020_

impl Sync for _0021_

impl Sync for _0022_

impl Sync for _0023_

impl Sync for _0024_

impl Sync for _0025_

impl Sync for _0026_

impl Sync for _0027_

impl Sync for _0028_

impl Sync for _0029_

impl Sync for _0030_

impl Sync for _0031_

impl Sync for _0032_

impl Sync for _0033_

impl Sync for _0034_

impl Sync for _0035_

impl Sync for _0036_

impl Sync for _0038_

impl Sync for _1001_

impl Sync for _2001_

impl Sync for _2002_

impl Sync for _2003_

impl Sync for _2004_

impl Sync for _2005_

impl Sync for _3001_

impl Sync for Inventory

impl Sync for Coins

impl Sync for Fungibility

impl Sync for Tokens

impl Sync for FixedAssets

impl Sync for Provisions

impl Sync for Parties

impl Sync for Derivatives

impl Sync for OtherEquity

impl Sync for _3003_

impl Sync for Sales

impl Sync for _1002_

impl Sync for OtherIncome

impl Sync for A

impl Sync for L

impl Sync for E

impl Sync for I

impl Sync for X

impl Sync for P

impl Sync for B

impl Sync for Ledger

impl Sync for Indicator

impl<AccountId, Hash, BlockNumber> Sync for Record<AccountId, Hash, BlockNumber> where
    AccountId: Sync,
    BlockNumber: Sync,
    Hash: Sync

impl Sync for Reason

impl<Hash> Sync for TxKeysT<Hash> where
    Hash: Sync

impl<AccountId> Sync for OrderHeader<AccountId> where
    AccountId: Sync

impl<Hash> Sync for OrderItem<Hash> where
    Hash: Sync

impl<Hash> Sync for TxKeysL<Hash> where
    Hash: Sync

impl<Hash> Sync for TxKeysM<Hash> where
    Hash: Sync

impl<Hash> Sync for TxKeysS<Hash> where
    Hash: Sync

impl Sync for LockStatus

impl<AccountId, ProjectStatus> Sync for DeletedProject<AccountId, ProjectStatus> where
    AccountId: Sync,
    ProjectStatus: Sync

impl<AccountId, ReferenceHash, NumberOfBlocks, LockStatus, StatusOfTimeRecord, ReasonCodeStruct, PostingPeriod, StartOrEndBlockNumber, NumberOfBreaks> Sync for Timekeeper<AccountId, ReferenceHash, NumberOfBlocks, LockStatus, StatusOfTimeRecord, ReasonCodeStruct, PostingPeriod, StartOrEndBlockNumber, NumberOfBreaks> where
    AccountId: Sync,
    LockStatus: Sync,
    NumberOfBlocks: Sync,
    NumberOfBreaks: Sync,
    PostingPeriod: Sync,
    ReasonCodeStruct: Sync,
    ReferenceHash: Sync,
    StartOrEndBlockNumber: Sync,
    StatusOfTimeRecord: Sync

impl Sync for RecordType

impl<T> Sync for Set<T> where
    T: Sync

impl<T> Sync for WithDispatch<T> where
    T: Sync

impl<T> Sync for Instrumented<T> where
    T: Sync

impl Sync for Span

impl<'a> Sync for Entered<'a>

impl Sync for EnteredSpan

impl Sync for Identifier

impl Sync for Dispatch

impl<'a> !Sync for Event<'a>

impl Sync for Field

impl Sync for Empty

impl Sync for FieldSet

impl<'a> !Sync for ValueSet<'a>

impl Sync for Iter

impl<T> Sync for DisplayValue<T> where
    T: Sync

impl<T> Sync for DebugValue<T> where
    T: Sync

impl<'a> Sync for Metadata<'a>

impl Sync for Kind

impl Sync for Level

impl Sync for LevelFilter

impl Sync for Id

impl<'a> !Sync for Attributes<'a>

impl<'a> !Sync for Record<'a>

impl Sync for Current

impl Sync for Interest

impl Sync for LogTracer

impl Sync for Builder

impl<'a, T> Sync for SerializeFieldMap<'a, T> where
    T: Sync

impl<'a> Sync for SerializeFieldSet<'a>

impl<'a> Sync for SerializeLevel<'a>

impl<'a> Sync for SerializeId<'a>

impl<'a> Sync for SerializeMetadata<'a>

impl<'a> !Sync for SerializeEvent<'a>

impl<'a> !Sync for SerializeAttributes<'a>

impl<'a> !Sync for SerializeRecord<'a>

impl<S> Sync for SerdeMapVisitor<S> where
    S: Sync,
    <S as SerializeMap>::Error: Sync

impl<S> Sync for SerdeStructVisitor<S> where
    S: Sync,
    <S as SerializeStruct>::Error: Sync

impl<V> Sync for Alt<V> where
    V: Sync

impl<D, V> Sync for Delimited<D, V> where
    D: Sync,
    V: Sync

impl<D, V> Sync for VisitDelimited<D, V> where
    D: Sync,
    V: Sync

impl<V> Sync for Messages<V> where
    V: Sync

impl Sync for ParseError

impl Sync for Directive

impl Sync for BadName

impl Sync for EnvFilter

impl<F> Sync for FilterFn<F> where
    F: Sync

impl<S, F, R> Sync for DynFilterFn<S, F, R> where
    F: Sync,
    R: Sync

impl<L, F, S> Sync for Filtered<L, F, S> where
    F: Sync,
    L: Sync

impl Sync for FilterId

impl Sync for Targets

impl Sync for IntoIter

impl<'a> Sync for Iter<'a>

impl<S, N, E, W> Sync for Layer<S, N, E, W> where
    E: Sync,
    N: Sync,
    S: Sync,
    W: Sync

impl<E> Sync for FormattedFields<E>

impl<'a, S, N> Sync for FmtContext<'a, S, N> where
    N: Sync,
    S: Sync

impl Sync for Json

impl Sync for JsonFields

impl<'a> !Sync for JsonVisitor<'a>

impl Sync for Pretty

impl<'a> !Sync for PrettyVisitor<'a>

impl<F> Sync for FieldFn<F> where
    F: Sync

impl<'a, F> !Sync for FieldFnVisitor<'a, F>

impl Sync for Compact

impl Sync for Full

impl<F, T> Sync for Format<F, T> where
    F: Sync,
    T: Sync

impl<'a> !Sync for DefaultVisitor<'a>

impl Sync for FmtSpan

impl Sync for SystemTime

impl Sync for Uptime

impl Sync for ChronoUtc

impl Sync for ChronoLocal

impl Sync for TestWriter

impl<A, B> Sync for EitherWriter<A, B> where
    A: Sync,
    B: Sync

impl<M> Sync for WithMaxLevel<M> where
    M: Sync

impl<M> Sync for WithMinLevel<M> where
    M: Sync

impl<M, F> Sync for WithFilter<M, F> where
    F: Sync,
    M: Sync

impl<A, B> Sync for OrElse<A, B> where
    A: Sync,
    B: Sync

impl<A, B> Sync for Tee<A, B> where
    A: Sync,
    B: Sync

impl<W> Sync for ArcWriter<W> where
    W: Send + Sync

impl<N, E, F, W> Sync for Subscriber<N, E, F, W> where
    E: Sync,
    F: Sync,
    N: Sync,
    W: Sync

impl<N, E, F, W> Sync for SubscriberBuilder<N, E, F, W> where
    E: Sync,
    F: Sync,
    N: Sync,
    W: Sync

impl<'a, S> Sync for Context<'a, S> where
    S: Sync

impl<'a, L> Sync for Scope<'a, L> where
    L: Sync,
    <L as LookupSpan<'a>>::Data: Sync

impl<L, I, S> Sync for Layered<L, I, S> where
    I: Sync,
    L: Sync

impl Sync for Identity

impl<'a> Sync for Extensions<'a>

impl<'a> Sync for ExtensionsMut<'a>

impl Sync for Registry

impl<'a> !Sync for Data<'a>

impl<'a, R> Sync for SpanRef<'a, R> where
    R: Sync,
    <R as LookupSpan<'a>>::Data: Sync

impl<'a, R> Sync for Scope<'a, R> where
    R: Sync

impl<'a, R> Sync for ScopeFromRoot<'a, R> where
    R: Sync,
    <R as LookupSpan<'a>>::Data: Sync

impl<'a, R> Sync for Parents<'a, R> where
    R: Sync

impl<'a, R> Sync for FromRoot<'a, R> where
    R: Sync,
    <R as LookupSpan<'a>>::Data: Sync

impl<L, S> Sync for Layer<L, S> where
    L: Send + Sync

impl<L, S> Sync for Handle<L, S> where
    L: Send + Sync

impl Sync for Error

impl Sync for CurrentSpan

impl<'a> Sync for NodeHandle<'a>

impl<'a> Sync for Node<'a>

impl Sync for NodePlan

impl<D> Sync for OwnedNode<D> where
    D: Sync

impl<HO, CE> Sync for Error<HO, CE> where
    CE: Sync,
    HO: Sync

impl<'db, L> !Sync for TrieDB<'db, L>

impl<'a, L> !Sync for TrieDBIterator<'a, L>

impl<HO> Sync for ChildReference<HO> where
    HO: Sync

impl<'a, L> Sync for TrieDBMut<'a, L>

impl<'db, L> !Sync for SecTrieDB<'db, L>

impl<'db, L> Sync for SecTrieDBMut<'db, L>

impl<HO> Sync for Record<HO> where
    HO: Sync

impl<HO> Sync for Recorder<HO> where
    HO: Sync

impl<'db, L> !Sync for FatDB<'db, L>

impl<'db, L> !Sync for FatDBIterator<'db, L>

impl<'db, L> Sync for FatDBMut<'db, L>

impl<'a, H, HO, V, DB> Sync for TrieBuilder<'a, H, HO, V, DB> where
    DB: Sync,
    H: Sync,
    HO: Sync,
    V: Sync

impl<H, HO> Sync for TrieRoot<H, HO> where
    H: Sync,
    HO: Sync

impl<H> Sync for TrieRootUnhashed<H> where
    H: Sync

impl<H, HO> Sync for TrieRootPrint<H, HO> where
    H: Sync,
    HO: Sync

impl<'a, L> !Sync for TrieDBNodeIterator<'a, L>

impl<'a, L, Q> !Sync for Lookup<'a, L, Q>

impl Sync for NibbleVec

impl<'a> Sync for NibbleSlice<'a>

impl<T, E> Sync for TrieError<T, E> where
    E: Sync,
    T: Sync

impl Sync for TrieSpec

impl<L> Sync for TrieFactory<L> where
    L: Sync

impl<'db, L> !Sync for TrieKinds<'db, L>

impl Sync for XxHash64

impl Sync for XxHash32

impl Sync for Hash64

impl Sync for Hash128

impl Sync for B0

impl Sync for B1

impl<U> Sync for PInt<U> where
    U: Sync

impl<U> Sync for NInt<U> where
    U: Sync

impl Sync for Z0

impl Sync for UTerm

impl<U, B> Sync for UInt<U, B> where
    B: Sync,
    U: Sync

impl Sync for ATerm

impl<V, A> Sync for TArr<V, A> where
    A: Sync,
    V: Sync

impl Sync for Greater

impl Sync for Less

impl Sync for Equal

impl<I> Sync for Decompositions<I> where
    I: Sync

impl<I> Sync for Recompositions<I> where
    I: Sync

impl<I> Sync for Replacements<I> where
    I: Sync

impl<I> Sync for StreamSafe<I> where
    I: Sync

impl<'a> Sync for GraphemeIndices<'a>

impl<'a> Sync for Graphemes<'a>

impl<'a> Sync for UnicodeWords<'a>

impl<'a> Sync for UnicodeWordIndices<'a>

impl<'a> Sync for UWordBounds<'a>

impl<'a> Sync for UWordBoundIndices<'a>

impl<'a> Sync for UnicodeSentences<'a>

impl<'a> Sync for USentenceBounds<'a>

impl<'a> Sync for USentenceBoundIndices<'a>

impl !Sync for FuncRef

impl !Sync for FuncInstance

impl<'args> !Sync for FuncInvocation<'args>

impl !Sync for GlobalRef

impl<'a> Sync for RuntimeArgs<'a>

impl<'a> !Sync for ImportsBuilder<'a>

impl !Sync for MemoryRef

impl !Sync for ModuleRef

impl !Sync for ExternVal

impl<'a> !Sync for NotStartedModuleRef<'a>

impl Sync for F32

impl Sync for F64

impl !Sync for TableRef

impl Sync for Signature

impl Sync for ValueType

impl Sync for Error

impl Sync for Trap

impl Sync for TrapKind

impl Sync for Error

impl Sync for Module

impl Sync for Error

impl<T> Sync for StackWithLimit<T> where
    T: Sync

impl Sync for BlockFrame

impl Sync for StartedWith

impl<'a> Sync for Locals<'a>

impl Sync for Error

impl<T> Sync for FmtBinary<T> where
    T: Sync

impl<T> Sync for FmtDisplay<T> where
    T: Sync

impl<T> Sync for FmtLowerExp<T> where
    T: Sync

impl<T> Sync for FmtLowerHex<T> where
    T: Sync

impl<T> Sync for FmtOctal<T> where
    T: Sync

impl<T> Sync for FmtPointer<T> where
    T: Sync

impl<T> Sync for FmtUpperExp<T> where
    T: Sync

impl<T> Sync for FmtUpperHex<T> where
    T: Sync

impl<Z> Sync for Zeroizing<Z> where
    Z: Sync