[−][src]Trait coercion::Coerce

pub unsafe trait Coerce<T: ?Sized> {
    unsafe fn coerce(self) -> T
    where
        Self: Sized,
        T: Sized,
    { ... }
    fn coerce_ptr(this: *const Self) -> *const T { ... }
    fn coerce_mut_ptr(this: *mut Self) -> *mut T { ... }
}

Unsafe, unchecked, coercion between types of the same size and alignment.

Provided methods

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,`

Performs the coercion on an owned value.

Examples

use coercion::Coerce;

// Safe because 1 is non-zero.
let nonzero: NonZeroU64 = unsafe { 1u64.coerce() };
assert_eq!(nonzero.get(), 1);

`fn coerce_ptr(this: const Self) -> const T`

Perform the conversion on a const pointer.

`fn coerce_mut_ptr(this: mut Self) -> mut T`

Perform the conversion on a mut pointer.

Loading content...

Implementations on Foreign Types

`impl<T, U> Coerce<[U]> for [T] where T: Coerce,` [src]

`fn coerce_ptr(this: const Self) -> const [U]`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<T: ?Sized, U: ?Sized> Coerce<Box> for Box<T> where T: Coerce,` [src]

`unsafe fn coerce(self) -> Box`[src]

`fn coerce_ptr(this: const Self) -> const Box`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<str> for [u8]`[src]

`fn coerce_ptr(this: const Self) -> const str`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<[u8]> for str`[src]

`fn coerce_ptr(this: const Self) -> const [u8]`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<&'a T> for &'a U where T: Coerce,` [src]

`fn coerce_ptr(this: const Self) -> const &'a T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<&'a mut T> for &'a mut U where T: Coerce,` [src]

`fn coerce_ptr(this: const Self) -> const &'a mut T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<const T> for const U where T: Coerce,` [src]

`fn coerce_ptr(this: const Self) -> const *const T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<mut T> for mut U where T: Coerce,` [src]

`fn coerce_ptr(this: const Self) -> const *mut T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<T: ?Sized, U: ?Sized> Coerce<ManuallyDrop> for ManuallyDrop<T> where T: Coerce,` [src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_ptr(this: const Self) -> const T`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for u8`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for i8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for u8`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for NonZeroU8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for u8`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for NonZeroI8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for u8`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for AtomicU8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for u8`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for AtomicI8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for u8`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for bool`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for u8`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for AtomicBool`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for i8`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for NonZeroU8`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for i8`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for NonZeroI8`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for i8`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for AtomicU8`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for i8`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for AtomicI8`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for i8`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for bool`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for i8`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for AtomicBool`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for NonZeroU8`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for NonZeroI8`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for NonZeroU8`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for AtomicU8`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for NonZeroU8`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for AtomicI8`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for NonZeroU8`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for bool`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for NonZeroU8`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for AtomicBool`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for NonZeroI8`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for AtomicU8`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for NonZeroI8`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for AtomicI8`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for NonZeroI8`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for bool`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for NonZeroI8`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for AtomicBool`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for AtomicU8`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for AtomicI8`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for AtomicU8`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for bool`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for AtomicU8`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for AtomicBool`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for AtomicI8`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for bool`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for AtomicI8`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for AtomicBool`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicBool> for bool`[src]

`unsafe fn coerce(self) -> AtomicBool`[src]

`fn coerce_ptr(this: const Self) -> const AtomicBool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for AtomicBool`[src]

`unsafe fn coerce(self) -> bool`[src]

`fn coerce_ptr(this: const Self) -> const bool`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i16> for u16`[src]

`unsafe fn coerce(self) -> i16`[src]

`fn coerce_ptr(this: const Self) -> const i16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u16> for i16`[src]

`unsafe fn coerce(self) -> u16`[src]

`fn coerce_ptr(this: const Self) -> const u16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU16> for u16`[src]

`unsafe fn coerce(self) -> NonZeroU16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u16> for NonZeroU16`[src]

`unsafe fn coerce(self) -> u16`[src]

`fn coerce_ptr(this: const Self) -> const u16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI16> for u16`[src]

`unsafe fn coerce(self) -> NonZeroI16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u16> for NonZeroI16`[src]

`unsafe fn coerce(self) -> u16`[src]

`fn coerce_ptr(this: const Self) -> const u16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU16> for u16`[src]

`unsafe fn coerce(self) -> AtomicU16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u16> for AtomicU16`[src]

`unsafe fn coerce(self) -> u16`[src]

`fn coerce_ptr(this: const Self) -> const u16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI16> for u16`[src]

`unsafe fn coerce(self) -> AtomicI16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u16> for AtomicI16`[src]

`unsafe fn coerce(self) -> u16`[src]

`fn coerce_ptr(this: const Self) -> const u16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU16> for i16`[src]

`unsafe fn coerce(self) -> NonZeroU16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i16> for NonZeroU16`[src]

`unsafe fn coerce(self) -> i16`[src]

`fn coerce_ptr(this: const Self) -> const i16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI16> for i16`[src]

`unsafe fn coerce(self) -> NonZeroI16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i16> for NonZeroI16`[src]

`unsafe fn coerce(self) -> i16`[src]

`fn coerce_ptr(this: const Self) -> const i16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU16> for i16`[src]

`unsafe fn coerce(self) -> AtomicU16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i16> for AtomicU16`[src]

`unsafe fn coerce(self) -> i16`[src]

`fn coerce_ptr(this: const Self) -> const i16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI16> for i16`[src]

`unsafe fn coerce(self) -> AtomicI16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i16> for AtomicI16`[src]

`unsafe fn coerce(self) -> i16`[src]

`fn coerce_ptr(this: const Self) -> const i16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI16> for NonZeroU16`[src]

`unsafe fn coerce(self) -> NonZeroI16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU16> for NonZeroI16`[src]

`unsafe fn coerce(self) -> NonZeroU16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU16> for NonZeroU16`[src]

`unsafe fn coerce(self) -> AtomicU16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU16> for AtomicU16`[src]

`unsafe fn coerce(self) -> NonZeroU16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI16> for NonZeroU16`[src]

`unsafe fn coerce(self) -> AtomicI16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU16> for AtomicI16`[src]

`unsafe fn coerce(self) -> NonZeroU16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU16> for NonZeroI16`[src]

`unsafe fn coerce(self) -> AtomicU16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI16> for AtomicU16`[src]

`unsafe fn coerce(self) -> NonZeroI16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI16> for NonZeroI16`[src]

`unsafe fn coerce(self) -> AtomicI16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI16> for AtomicI16`[src]

`unsafe fn coerce(self) -> NonZeroI16`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI16> for AtomicU16`[src]

`unsafe fn coerce(self) -> AtomicI16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU16> for AtomicI16`[src]

`unsafe fn coerce(self) -> AtomicU16`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU16`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i32> for u32`[src]

`unsafe fn coerce(self) -> i32`[src]

`fn coerce_ptr(this: const Self) -> const i32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u32> for i32`[src]

`unsafe fn coerce(self) -> u32`[src]

`fn coerce_ptr(this: const Self) -> const u32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU32> for u32`[src]

`unsafe fn coerce(self) -> NonZeroU32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u32> for NonZeroU32`[src]

`unsafe fn coerce(self) -> u32`[src]

`fn coerce_ptr(this: const Self) -> const u32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI32> for u32`[src]

`unsafe fn coerce(self) -> NonZeroI32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u32> for NonZeroI32`[src]

`unsafe fn coerce(self) -> u32`[src]

`fn coerce_ptr(this: const Self) -> const u32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU32> for u32`[src]

`unsafe fn coerce(self) -> AtomicU32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u32> for AtomicU32`[src]

`unsafe fn coerce(self) -> u32`[src]

`fn coerce_ptr(this: const Self) -> const u32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI32> for u32`[src]

`unsafe fn coerce(self) -> AtomicI32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u32> for AtomicI32`[src]

`unsafe fn coerce(self) -> u32`[src]

`fn coerce_ptr(this: const Self) -> const u32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU32> for i32`[src]

`unsafe fn coerce(self) -> NonZeroU32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i32> for NonZeroU32`[src]

`unsafe fn coerce(self) -> i32`[src]

`fn coerce_ptr(this: const Self) -> const i32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI32> for i32`[src]

`unsafe fn coerce(self) -> NonZeroI32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i32> for NonZeroI32`[src]

`unsafe fn coerce(self) -> i32`[src]

`fn coerce_ptr(this: const Self) -> const i32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU32> for i32`[src]

`unsafe fn coerce(self) -> AtomicU32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i32> for AtomicU32`[src]

`unsafe fn coerce(self) -> i32`[src]

`fn coerce_ptr(this: const Self) -> const i32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI32> for i32`[src]

`unsafe fn coerce(self) -> AtomicI32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i32> for AtomicI32`[src]

`unsafe fn coerce(self) -> i32`[src]

`fn coerce_ptr(this: const Self) -> const i32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI32> for NonZeroU32`[src]

`unsafe fn coerce(self) -> NonZeroI32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU32> for NonZeroI32`[src]

`unsafe fn coerce(self) -> NonZeroU32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU32> for NonZeroU32`[src]

`unsafe fn coerce(self) -> AtomicU32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU32> for AtomicU32`[src]

`unsafe fn coerce(self) -> NonZeroU32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI32> for NonZeroU32`[src]

`unsafe fn coerce(self) -> AtomicI32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU32> for AtomicI32`[src]

`unsafe fn coerce(self) -> NonZeroU32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU32> for NonZeroI32`[src]

`unsafe fn coerce(self) -> AtomicU32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI32> for AtomicU32`[src]

`unsafe fn coerce(self) -> NonZeroI32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI32> for NonZeroI32`[src]

`unsafe fn coerce(self) -> AtomicI32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI32> for AtomicI32`[src]

`unsafe fn coerce(self) -> NonZeroI32`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI32> for AtomicU32`[src]

`unsafe fn coerce(self) -> AtomicI32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU32> for AtomicI32`[src]

`unsafe fn coerce(self) -> AtomicU32`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU32`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i64> for u64`[src]

`unsafe fn coerce(self) -> i64`[src]

`fn coerce_ptr(this: const Self) -> const i64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u64> for i64`[src]

`unsafe fn coerce(self) -> u64`[src]

`fn coerce_ptr(this: const Self) -> const u64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU64> for u64`[src]

`unsafe fn coerce(self) -> NonZeroU64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u64> for NonZeroU64`[src]

`unsafe fn coerce(self) -> u64`[src]

`fn coerce_ptr(this: const Self) -> const u64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI64> for u64`[src]

`unsafe fn coerce(self) -> NonZeroI64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u64> for NonZeroI64`[src]

`unsafe fn coerce(self) -> u64`[src]

`fn coerce_ptr(this: const Self) -> const u64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU64> for u64`[src]

`unsafe fn coerce(self) -> AtomicU64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u64> for AtomicU64`[src]

`unsafe fn coerce(self) -> u64`[src]

`fn coerce_ptr(this: const Self) -> const u64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI64> for u64`[src]

`unsafe fn coerce(self) -> AtomicI64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u64> for AtomicI64`[src]

`unsafe fn coerce(self) -> u64`[src]

`fn coerce_ptr(this: const Self) -> const u64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU64> for i64`[src]

`unsafe fn coerce(self) -> NonZeroU64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i64> for NonZeroU64`[src]

`unsafe fn coerce(self) -> i64`[src]

`fn coerce_ptr(this: const Self) -> const i64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI64> for i64`[src]

`unsafe fn coerce(self) -> NonZeroI64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i64> for NonZeroI64`[src]

`unsafe fn coerce(self) -> i64`[src]

`fn coerce_ptr(this: const Self) -> const i64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU64> for i64`[src]

`unsafe fn coerce(self) -> AtomicU64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i64> for AtomicU64`[src]

`unsafe fn coerce(self) -> i64`[src]

`fn coerce_ptr(this: const Self) -> const i64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI64> for i64`[src]

`unsafe fn coerce(self) -> AtomicI64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i64> for AtomicI64`[src]

`unsafe fn coerce(self) -> i64`[src]

`fn coerce_ptr(this: const Self) -> const i64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI64> for NonZeroU64`[src]

`unsafe fn coerce(self) -> NonZeroI64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU64> for NonZeroI64`[src]

`unsafe fn coerce(self) -> NonZeroU64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU64> for NonZeroU64`[src]

`unsafe fn coerce(self) -> AtomicU64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU64> for AtomicU64`[src]

`unsafe fn coerce(self) -> NonZeroU64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI64> for NonZeroU64`[src]

`unsafe fn coerce(self) -> AtomicI64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU64> for AtomicI64`[src]

`unsafe fn coerce(self) -> NonZeroU64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU64> for NonZeroI64`[src]

`unsafe fn coerce(self) -> AtomicU64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI64> for AtomicU64`[src]

`unsafe fn coerce(self) -> NonZeroI64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI64> for NonZeroI64`[src]

`unsafe fn coerce(self) -> AtomicI64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI64> for AtomicI64`[src]

`unsafe fn coerce(self) -> NonZeroI64`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI64> for AtomicU64`[src]

`unsafe fn coerce(self) -> AtomicI64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU64> for AtomicI64`[src]

`unsafe fn coerce(self) -> AtomicU64`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU64`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i128> for u128`[src]

`unsafe fn coerce(self) -> i128`[src]

`fn coerce_ptr(this: const Self) -> const i128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u128> for i128`[src]

`unsafe fn coerce(self) -> u128`[src]

`fn coerce_ptr(this: const Self) -> const u128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU128> for u128`[src]

`unsafe fn coerce(self) -> NonZeroU128`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u128> for NonZeroU128`[src]

`unsafe fn coerce(self) -> u128`[src]

`fn coerce_ptr(this: const Self) -> const u128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI128> for u128`[src]

`unsafe fn coerce(self) -> NonZeroI128`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u128> for NonZeroI128`[src]

`unsafe fn coerce(self) -> u128`[src]

`fn coerce_ptr(this: const Self) -> const u128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU128> for i128`[src]

`unsafe fn coerce(self) -> NonZeroU128`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i128> for NonZeroU128`[src]

`unsafe fn coerce(self) -> i128`[src]

`fn coerce_ptr(this: const Self) -> const i128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI128> for i128`[src]

`unsafe fn coerce(self) -> NonZeroI128`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i128> for NonZeroI128`[src]

`unsafe fn coerce(self) -> i128`[src]

`fn coerce_ptr(this: const Self) -> const i128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI128> for NonZeroU128`[src]

`unsafe fn coerce(self) -> NonZeroI128`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU128> for NonZeroI128`[src]

`unsafe fn coerce(self) -> NonZeroU128`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU128`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<isize> for usize`[src]

`unsafe fn coerce(self) -> isize`[src]

`fn coerce_ptr(this: const Self) -> const isize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<usize> for isize`[src]

`unsafe fn coerce(self) -> usize`[src]

`fn coerce_ptr(this: const Self) -> const usize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroUsize> for usize`[src]

`unsafe fn coerce(self) -> NonZeroUsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<usize> for NonZeroUsize`[src]

`unsafe fn coerce(self) -> usize`[src]

`fn coerce_ptr(this: const Self) -> const usize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroIsize> for usize`[src]

`unsafe fn coerce(self) -> NonZeroIsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<usize> for NonZeroIsize`[src]

`unsafe fn coerce(self) -> usize`[src]

`fn coerce_ptr(this: const Self) -> const usize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicUsize> for usize`[src]

`unsafe fn coerce(self) -> AtomicUsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<usize> for AtomicUsize`[src]

`unsafe fn coerce(self) -> usize`[src]

`fn coerce_ptr(this: const Self) -> const usize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicIsize> for usize`[src]

`unsafe fn coerce(self) -> AtomicIsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<usize> for AtomicIsize`[src]

`unsafe fn coerce(self) -> usize`[src]

`fn coerce_ptr(this: const Self) -> const usize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroUsize> for isize`[src]

`unsafe fn coerce(self) -> NonZeroUsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<isize> for NonZeroUsize`[src]

`unsafe fn coerce(self) -> isize`[src]

`fn coerce_ptr(this: const Self) -> const isize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroIsize> for isize`[src]

`unsafe fn coerce(self) -> NonZeroIsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<isize> for NonZeroIsize`[src]

`unsafe fn coerce(self) -> isize`[src]

`fn coerce_ptr(this: const Self) -> const isize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicUsize> for isize`[src]

`unsafe fn coerce(self) -> AtomicUsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<isize> for AtomicUsize`[src]

`unsafe fn coerce(self) -> isize`[src]

`fn coerce_ptr(this: const Self) -> const isize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicIsize> for isize`[src]

`unsafe fn coerce(self) -> AtomicIsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<isize> for AtomicIsize`[src]

`unsafe fn coerce(self) -> isize`[src]

`fn coerce_ptr(this: const Self) -> const isize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroIsize> for NonZeroUsize`[src]

`unsafe fn coerce(self) -> NonZeroIsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroUsize> for NonZeroIsize`[src]

`unsafe fn coerce(self) -> NonZeroUsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicUsize> for NonZeroUsize`[src]

`unsafe fn coerce(self) -> AtomicUsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroUsize> for AtomicUsize`[src]

`unsafe fn coerce(self) -> NonZeroUsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicIsize> for NonZeroUsize`[src]

`unsafe fn coerce(self) -> AtomicIsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroUsize> for AtomicIsize`[src]

`unsafe fn coerce(self) -> NonZeroUsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicUsize> for NonZeroIsize`[src]

`unsafe fn coerce(self) -> AtomicUsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroIsize> for AtomicUsize`[src]

`unsafe fn coerce(self) -> NonZeroIsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicIsize> for NonZeroIsize`[src]

`unsafe fn coerce(self) -> AtomicIsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroIsize> for AtomicIsize`[src]

`unsafe fn coerce(self) -> NonZeroIsize`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicIsize> for AtomicUsize`[src]

`unsafe fn coerce(self) -> AtomicIsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicIsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicUsize> for AtomicIsize`[src]

`unsafe fn coerce(self) -> AtomicUsize`[src]

`fn coerce_ptr(this: const Self) -> const AtomicUsize`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

Loading content...

Implementors

Loading content...

[−][src]Trait coercion::Coerce

Provided methods

unsafe fn coerce(self) -> T where Self: Sized, T: Sized,

Examples

fn coerce_ptr(this: *const Self) -> *const T

fn coerce_mut_ptr(this: *mut Self) -> *mut T

Implementations on Foreign Types

impl<T, U> Coerce<[U]> for [T] where T: Coerce<U>, [src]

fn coerce_ptr(this: *const Self) -> *const [U][src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl<T: ?Sized, U: ?Sized> Coerce<Box<U>> for Box<T> where T: Coerce<U>, [src]

unsafe fn coerce(self) -> Box<U>[src]

fn coerce_ptr(this: *const Self) -> *const Box<U>[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<str> for [u8][src]

fn coerce_ptr(this: *const Self) -> *const str[src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<[u8]> for str[src]

fn coerce_ptr(this: *const Self) -> *const [u8][src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl<'a, T: ?Sized, U: ?Sized> Coerce<&'a T> for &'a U where T: Coerce<U>, [src]

fn coerce_ptr(this: *const Self) -> *const &'a T[src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl<'a, T: ?Sized, U: ?Sized> Coerce<&'a mut T> for &'a mut U where T: Coerce<U>, [src]

fn coerce_ptr(this: *const Self) -> *const &'a mut T[src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl<'a, T: ?Sized, U: ?Sized> Coerce<*const T> for *const U where T: Coerce<U>, [src]

fn coerce_ptr(this: *const Self) -> *const *const T[src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl<'a, T: ?Sized, U: ?Sized> Coerce<*mut T> for *mut U where T: Coerce<U>, [src]

fn coerce_ptr(this: *const Self) -> *const *mut T[src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl<T: ?Sized, U: ?Sized> Coerce<ManuallyDrop<U>> for ManuallyDrop<T> where T: Coerce<U>, [src]

unsafe fn coerce(self) -> T where Self: Sized, T: Sized, [src]

fn coerce_ptr(this: *const Self) -> *const T[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<i8> for u8[src]

unsafe fn coerce(self) -> i8[src]

fn coerce_ptr(this: *const Self) -> *const i8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<u8> for i8[src]

unsafe fn coerce(self) -> u8[src]

fn coerce_ptr(this: *const Self) -> *const u8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<NonZeroU8> for u8[src]

unsafe fn coerce(self) -> NonZeroU8[src]

fn coerce_ptr(this: *const Self) -> *const NonZeroU8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<u8> for NonZeroU8[src]

unsafe fn coerce(self) -> u8[src]

fn coerce_ptr(this: *const Self) -> *const u8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<NonZeroI8> for u8[src]

unsafe fn coerce(self) -> NonZeroI8[src]

fn coerce_ptr(this: *const Self) -> *const NonZeroI8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<u8> for NonZeroI8[src]

unsafe fn coerce(self) -> u8[src]

fn coerce_ptr(this: *const Self) -> *const u8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<AtomicU8> for u8[src]

unsafe fn coerce(self) -> AtomicU8[src]

fn coerce_ptr(this: *const Self) -> *const AtomicU8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<u8> for AtomicU8[src]

unsafe fn coerce(self) -> u8[src]

fn coerce_ptr(this: *const Self) -> *const u8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<AtomicI8> for u8[src]

unsafe fn coerce(self) -> AtomicI8[src]

fn coerce_ptr(this: *const Self) -> *const AtomicI8[src]

fn coerce_mut_ptr(this: *mut Self) -> *mut T[src]

impl Coerce<u8> for AtomicI8[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,`

`fn coerce_ptr(this: const Self) -> const T`

`fn coerce_mut_ptr(this: mut Self) -> mut T`

`impl<T, U> Coerce<[U]> for [T] where T: Coerce<U>,` [src]

`fn coerce_ptr(this: const Self) -> const [U]`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<T: ?Sized, U: ?Sized> Coerce<Box<U>> for Box<T> where T: Coerce<U>,` [src]

`unsafe fn coerce(self) -> Box<U>`[src]

`fn coerce_ptr(this: const Self) -> const Box<U>`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<str> for [u8]`[src]

`fn coerce_ptr(this: const Self) -> const str`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<[u8]> for str`[src]

`fn coerce_ptr(this: const Self) -> const [u8]`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<&'a T> for &'a U where T: Coerce<U>,` [src]

`fn coerce_ptr(this: const Self) -> const &'a T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<&'a mut T> for &'a mut U where T: Coerce<U>,` [src]

`fn coerce_ptr(this: const Self) -> const &'a mut T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<const T> for const U where T: Coerce<U>,` [src]

`fn coerce_ptr(this: const Self) -> const *const T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<'a, T: ?Sized, U: ?Sized> Coerce<mut T> for mut U where T: Coerce<U>,` [src]

`fn coerce_ptr(this: const Self) -> const *mut T`[src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl<T: ?Sized, U: ?Sized> Coerce<ManuallyDrop<U>> for ManuallyDrop<T> where T: Coerce<U>,` [src]

`unsafe fn coerce(self) -> T where Self: Sized, T: Sized,` [src]

`fn coerce_ptr(this: const Self) -> const T`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<i8> for u8`[src]

`unsafe fn coerce(self) -> i8`[src]

`fn coerce_ptr(this: const Self) -> const i8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for i8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroU8> for u8`[src]

`unsafe fn coerce(self) -> NonZeroU8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for NonZeroU8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<NonZeroI8> for u8`[src]

`unsafe fn coerce(self) -> NonZeroI8`[src]

`fn coerce_ptr(this: const Self) -> const NonZeroI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for NonZeroI8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicU8> for u8`[src]

`unsafe fn coerce(self) -> AtomicU8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicU8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for AtomicU8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<AtomicI8> for u8`[src]

`unsafe fn coerce(self) -> AtomicI8`[src]

`fn coerce_ptr(this: const Self) -> const AtomicI8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<u8> for AtomicI8`[src]

`unsafe fn coerce(self) -> u8`[src]

`fn coerce_ptr(this: const Self) -> const u8`[src]

`fn coerce_mut_ptr(this: mut Self) -> mut T`[src]

`impl Coerce<bool> for u8`[src]