/// Deallocates a block suitable for holding an instance of `T`.
///
/// The given block must have been produced by this allocator,
/// and must be suitable for storing a `T` (in terms of alignment
/// as well as minimum and maximum size); otherwise yields
/// undefined behavior.
///
/// Captures a common usage pattern for allocators.
///
/// # Safety
///
/// This function is unsafe because undefined behavior can result
/// if the caller does not ensure both:
///
/// * `ptr` must denote a block of memory currently allocated via this allocator
///
/// * the layout of `T` must *fit* that block of memory.
Deallocates a block suitable for holding an instance of `T`.
The given block must have been produced by this allocator,
and must be suitable for storing a `T` (in terms of alignment
as well as minimum and maximum size); otherwise yields
undefined behavior.

Captures a common usage pattern for allocators.
Deallocates a block suitable for holding an instance of ` T ` . The given block must have been produced by this allocator and must be suitable for storing a ` T ` ( in terms of alignment as well as minimum and maximum size ) ; otherwise yields undefined behavior . Captures a common usage pattern for allocators .
unsafe fn dealloc_one<T>(&mut self, ptr: NonNull<T>)
        where Self: Sized
    {
        let k = Layout::new::<T>();
        if k.size() > 0 {
            self.dealloc(ptr.cast(), k);
        }
    }
unsafe fn dealloc_one < T > ( & mut self , ptr : NonNull < T > ) where Self : Sized { let k = Layout :: new :: < T > ( ) ; if k . size ( ) > 0 { self . dealloc ( ptr . cast ( ) , k ) ; } }
Deallocates a block suitable for holding an instance of `T`.
Deallocates a block suitable for holding an instance of ` T ` .
&mut self
ptr
NonNull<T>
safety
This function is unsafe because undefined behavior can result
if the caller does not ensure both.

`ptr` must denote a block of memory currently allocated via this allocator

the layout of `T` must *fit* that block of memory.
This function is unsafe because undefined behavior can result if the caller does not ensure both . ` ptr ` must denote a block of memory currently allocated via this allocator the layout of ` T ` must * fit * that block of memory .