Creates a pointer with the given address and noprovenance.

For more details, see the equivalent method on a raw pointer,ptr::without_provenance_mut.

This is aStrict Provenance API.

Creates a newNonNull that is dangling, but well-aligned.

This is useful for initializing types which lazily allocate, likeVec::new does.

Note that the address of the returned pointer may potentiallybe that of a valid pointer, which means this must not be usedas a “not yet initialized” sentinel value.Types that lazily allocate must track initialization by some other means.

§Examples

usestd::ptr::NonNull;letptr = NonNull::<u32>::dangling();// Important: don't try to access the value of `ptr` without// initializing it first! The pointer is not null but isn't valid either!

Converts an address back to a mutable pointer, picking up some previously ‘exposed’provenance.

For more details, see the equivalent method on a raw pointer,ptr::with_exposed_provenance_mut.

This is anExposed Provenance API.

Returns a shared references to the value. In contrast toas_ref, this does not requirethat the value has to be initialized.

For the mutable counterpart seeas_uninit_mut.

§Safety

When calling this method, you have to ensure thatthe pointer isconvertible to a reference.Note that because the created reference is toMaybeUninit<T>, thesource pointer can point to uninitialized memory.

Returns a unique references to the value. In contrast toas_mut, this does not requirethat the value has to be initialized.

For the shared counterpart seeas_uninit_ref.

§Safety

When calling this method, you have to ensure thatthe pointer isconvertible to a reference.Note that because the created reference is toMaybeUninit<T>, thesource pointer can point to uninitialized memory.

Casts from a pointer-to-T to a pointer-to-[T; N].

Creates a newNonNull.

§Safety

ptr must be non-null.

§Examples

usestd::ptr::NonNull;letmutx =0u32;letptr =unsafe{ NonNull::new_unchecked(&mutxas*mut_) };

Incorrect usage of this function:

usestd::ptr::NonNull;// NEVER DO THAT!!! This is undefined behavior. ⚠️letptr =unsafe{ NonNull::<u32>::new_unchecked(std::ptr::null_mut()) };

Creates a newNonNull ifptr is non-null.

§Panics during const evaluation

This method will panic during const evaluation if the pointer cannot bedetermined to be null or not. Seeis_null for more information.

§Examples

usestd::ptr::NonNull;letmutx =0u32;letptr = NonNull::<u32>::new(&mutxas*mut_).expect("ptr is null!");if letSome(ptr) = NonNull::<u32>::new(std::ptr::null_mut()) {unreachable!();}

Converts a reference to aNonNull pointer.

Converts a mutable reference to aNonNull pointer.

Performs the same functionality asstd::ptr::from_raw_parts, except that aNonNull pointer is returned, as opposed to a raw*const pointer.

See the documentation ofstd::ptr::from_raw_parts for more details.

Decompose a (possibly wide) pointer into its data pointer and metadata components.

The pointer can be later reconstructed withNonNull::from_raw_parts.

Gets the “address” portion of the pointer.

For more details, see the equivalent method on a raw pointer,pointer::addr.

This is aStrict Provenance API.

Exposes the“provenance” part of the pointer for future use inwith_exposed_provenance and returns the “address” portion.

For more details, see the equivalent method on a raw pointer,pointer::expose_provenance.

This is anExposed Provenance API.

Creates a new pointer with the given address and theprovenance ofself.

For more details, see the equivalent method on a raw pointer,pointer::with_addr.

This is aStrict Provenance API.

Creates a new pointer by mappingself’s address to a new one, preserving theprovenance ofself.

For more details, see the equivalent method on a raw pointer,pointer::map_addr.

This is aStrict Provenance API.

Acquires the underlying*mut pointer.

§Examples

usestd::ptr::NonNull;letmutx =0u32;letptr = NonNull::new(&mutx).expect("ptr is null!");letx_value =unsafe{*ptr.as_ptr() };assert_eq!(x_value,0);unsafe{*ptr.as_ptr() +=2; }letx_value =unsafe{*ptr.as_ptr() };assert_eq!(x_value,2);

Returns a shared reference to the value. If the value may be uninitialized,as_uninit_refmust be used instead.

For the mutable counterpart seeas_mut.

§Safety

When calling this method, you have to ensure thatthe pointer isconvertible to a reference.

§Examples

usestd::ptr::NonNull;letmutx =0u32;letptr = NonNull::new(&mutxas*mut_).expect("ptr is null!");letref_x =unsafe{ ptr.as_ref() };println!("{ref_x}");

Returns a unique reference to the value. If the value may be uninitialized,as_uninit_mutmust be used instead.

For the shared counterpart seeas_ref.

§Safety

When calling this method, you have to ensure thatthe pointer isconvertible to a reference.

§Examples

usestd::ptr::NonNull;letmutx =0u32;letmutptr = NonNull::new(&mutx).expect("null pointer");letx_ref =unsafe{ ptr.as_mut() };assert_eq!(*x_ref,0);*x_ref +=2;assert_eq!(*x_ref,2);

Casts to a pointer of another type.

§Examples

usestd::ptr::NonNull;letmutx =0u32;letptr = NonNull::new(&mutxas*mut_).expect("null pointer");letcasted_ptr = ptr.cast::<i8>();letraw_ptr:*muti8 = casted_ptr.as_ptr();

Try to cast to a pointer of another type by checking alignment.

If the pointer is properly aligned to the target type, it will becast to the target type. Otherwise,None is returned.

§Examples

#![feature(pointer_try_cast_aligned)]usestd::ptr::NonNull;letmutx =0u64;letaligned = NonNull::from_mut(&mutx);letunaligned =unsafe{ aligned.byte_add(1) };assert!(aligned.try_cast_aligned::<u32>().is_some());assert!(unaligned.try_cast_aligned::<u32>().is_none());

Adds an offset to a pointer.

count is in units of T; e.g., acount of 3 represents a pointeroffset of3 * size_of::<T>() bytes.

§Safety

If any of the following conditions are violated, the result is Undefined Behavior:

• The computed offset,count * size_of::<T>() bytes, must not overflowisize.

• If the computed offset is non-zero, thenself must be derived from a pointer to someallocation, and the entire memory range betweenself and the result must be inbounds of that allocation. In particular, this range must not “wrap around” the edgeof the address space.

Allocations can never be larger thanisize::MAX bytes, so if the computed offsetstays in bounds of the allocation, it is guaranteed to satisfy the first requirement.This implies, for instance, thatvec.as_ptr().add(vec.len()) (forvec: Vec<T>) is alwayssafe.

§Examples

usestd::ptr::NonNull;letmuts = [1,2,3];letptr: NonNull<u32> = NonNull::new(s.as_mut_ptr()).unwrap();unsafe{println!("{}", ptr.offset(1).read());println!("{}", ptr.offset(2).read());}

Calculates the offset from a pointer in bytes.

count is in units ofbytes.

This is purely a convenience for casting to au8 pointer andusingoffset on it. See that method for documentationand safety requirements.

For non-Sized pointees this operation changes only the data pointer,leaving the metadata untouched.

Adds an offset to a pointer (convenience for.offset(count as isize)).

count is in units of T; e.g., acount of 3 represents a pointeroffset of3 * size_of::<T>() bytes.

§Safety

If any of the following conditions are violated, the result is Undefined Behavior:

• The computed offset,count * size_of::<T>() bytes, must not overflowisize.

• If the computed offset is non-zero, thenself must be derived from a pointer to someallocation, and the entire memory range betweenself and the result must be inbounds of that allocation. In particular, this range must not “wrap around” the edgeof the address space.

Allocations can never be larger thanisize::MAX bytes, so if the computed offsetstays in bounds of the allocation, it is guaranteed to satisfy the first requirement.This implies, for instance, thatvec.as_ptr().add(vec.len()) (forvec: Vec<T>) is alwayssafe.

§Examples

usestd::ptr::NonNull;lets:&str ="123";letptr: NonNull<u8> = NonNull::new(s.as_ptr().cast_mut()).unwrap();unsafe{println!("{}", ptr.add(1).read()aschar);println!("{}", ptr.add(2).read()aschar);}

Calculates the offset from a pointer in bytes (convenience for.byte_offset(count as isize)).

count is in units of bytes.

This is purely a convenience for casting to au8 pointer andusingadd on it. See that method for documentationand safety requirements.

For non-Sized pointees this operation changes only the data pointer,leaving the metadata untouched.

Subtracts an offset from a pointer (convenience for.offset((count as isize).wrapping_neg())).

count is in units of T; e.g., acount of 3 represents a pointeroffset of3 * size_of::<T>() bytes.

§Safety

If any of the following conditions are violated, the result is Undefined Behavior:

• The computed offset,count * size_of::<T>() bytes, must not overflowisize.

• If the computed offset is non-zero, thenself must be derived from a pointer to someallocation, and the entire memory range betweenself and the result must be inbounds of that allocation. In particular, this range must not “wrap around” the edgeof the address space.

Allocations can never be larger thanisize::MAX bytes, so if the computed offsetstays in bounds of the allocation, it is guaranteed to satisfy the first requirement.This implies, for instance, thatvec.as_ptr().add(vec.len()) (forvec: Vec<T>) is alwayssafe.

§Examples

usestd::ptr::NonNull;lets:&str ="123";unsafe{letend: NonNull<u8> = NonNull::new(s.as_ptr().cast_mut()).unwrap().add(3);println!("{}", end.sub(1).read()aschar);println!("{}", end.sub(2).read()aschar);}

Calculates the offset from a pointer in bytes (convenience for.byte_offset((count as isize).wrapping_neg())).

count is in units of bytes.

This is purely a convenience for casting to au8 pointer andusingsub on it. See that method for documentationand safety requirements.

For non-Sized pointees this operation changes only the data pointer,leaving the metadata untouched.

Calculates the distance between two pointers within the same allocation. The returned value is inunits of T: the distance in bytes divided bysize_of::<T>().

This is equivalent to(self as isize - origin as isize) / (size_of::<T>() as isize),except that it has a lot more opportunities for UB, in exchange for the compilerbetter understanding what you are doing.

The primary motivation of this method is for computing thelen of an array/sliceofT that you are currently representing as a “start” and “end” pointer(and “end” is “one past the end” of the array).In that case,end.offset_from(start) gets you the length of the array.

All of the following safety requirements are trivially satisfied for this usecase.

§Safety

If any of the following conditions are violated, the result is Undefined Behavior:

• self andorigin must either

  • point to the same address, or
  • both bederived from a pointer to the sameallocation, and the memory range betweenthe two pointers must be in bounds of that object. (See below for an example.)

• The distance between the pointers, in bytes, must be an exact multipleof the size ofT.

As a consequence, the absolute distance between the pointers, in bytes, computed onmathematical integers (without “wrapping around”), cannot overflow anisize. This isimplied by the in-bounds requirement, and the fact that no allocation can be largerthanisize::MAX bytes.

The requirement for pointers to be derived from the same allocation is primarilyneeded forconst-compatibility: the distance between pointers intodifferent allocatedobjects is not known at compile-time. However, the requirement also exists atruntime and may be exploited by optimizations. If you wish to compute the difference betweenpointers that are not guaranteed to be from the same allocation, use(self as isize - origin as isize) / size_of::<T>().

§Panics

This function panics ifT is a Zero-Sized Type (“ZST”).

§Examples

Basic usage:

usestd::ptr::NonNull;leta = [0;5];letptr1: NonNull<u32> = NonNull::from(&a[1]);letptr2: NonNull<u32> = NonNull::from(&a[3]);unsafe{assert_eq!(ptr2.offset_from(ptr1),2);assert_eq!(ptr1.offset_from(ptr2), -2);assert_eq!(ptr1.offset(2), ptr2);assert_eq!(ptr2.offset(-2), ptr1);}

Incorrect usage:

usestd::ptr::NonNull;letptr1 = NonNull::new(Box::into_raw(Box::new(0u8))).unwrap();letptr2 = NonNull::new(Box::into_raw(Box::new(1u8))).unwrap();letdiff = (ptr2.addr().get()asisize).wrapping_sub(ptr1.addr().get()asisize);// Make ptr2_other an "alias" of ptr2.add(1), but derived from ptr1.letdiff_plus_1 = diff.wrapping_add(1);letptr2_other = NonNull::new(ptr1.as_ptr().wrapping_byte_offset(diff_plus_1)).unwrap();assert_eq!(ptr2.addr(), ptr2_other.addr());// Since ptr2_other and ptr2 are derived from pointers to different objects,// computing their offset is undefined behavior, even though// they point to addresses that are in-bounds of the same object!letone =unsafe{ ptr2_other.offset_from(ptr2) };// Undefined Behavior! ⚠️

Calculates the distance between two pointers within the same allocation. The returned value is inunits ofbytes.

This is purely a convenience for casting to au8 pointer andusingoffset_from on it. See that method fordocumentation and safety requirements.

For non-Sized pointees this operation considers only the data pointers,ignoring the metadata.

Calculates the distance between two pointers within the same allocation,where it’s known thatself is equal to or greater thanorigin. The returned value is inunits of T: the distance in bytes is divided bysize_of::<T>().

This computes the same value thatoffset_fromwould compute, but with the added precondition that the offset isguaranteed to be non-negative. This method is equivalent tousize::try_from(self.offset_from(origin)).unwrap_unchecked(),but it provides slightly more information to the optimizer, which cansometimes allow it to optimize slightly better with some backends.

This method can be though of as recovering thecount that was passedtoadd (or, with the parameters in the other order,tosub). The following are all equivalent, assumingthat their safety preconditions are met:

ptr.offset_from_unsigned(origin) == countorigin.add(count) == ptrptr.sub(count) == origin

§Safety

• The distance between the pointers must be non-negative (self >= origin)

• All the safety conditions ofoffset_fromapply to this method as well; see it for the full details.

Importantly, despite the return type of this method being able to representa larger offset, it’s stillnot permitted to pass pointers which differby more thanisize::MAXbytes. As such, the result of this method willalways be less than or equal toisize::MAX as usize.

§Panics

This function panics ifT is a Zero-Sized Type (“ZST”).

§Examples

usestd::ptr::NonNull;leta = [0;5];letptr1: NonNull<u32> = NonNull::from(&a[1]);letptr2: NonNull<u32> = NonNull::from(&a[3]);unsafe{assert_eq!(ptr2.offset_from_unsigned(ptr1),2);assert_eq!(ptr1.add(2), ptr2);assert_eq!(ptr2.sub(2), ptr1);assert_eq!(ptr2.offset_from_unsigned(ptr2),0);}// This would be incorrect, as the pointers are not correctly ordered:// ptr1.offset_from_unsigned(ptr2)

Calculates the distance between two pointers within the same allocation,where it’s known thatself is equal to or greater thanorigin. The returned value is inunits ofbytes.

This is purely a convenience for casting to au8 pointer andusingoffset_from_unsigned on it.See that method for documentation and safety requirements.

For non-Sized pointees this operation considers only the data pointers,ignoring the metadata.

Reads the value fromself without moving it. This leaves thememory inself unchanged.

Seeptr::read for safety concerns and examples.

Performs a volatile read of the value fromself without moving it. Thisleaves the memory inself unchanged.

Volatile operations are intended to act on I/O memory, and are guaranteedto not be elided or reordered by the compiler across other volatileoperations.

Seeptr::read_volatile for safety concerns and examples.

Reads the value fromself without moving it. This leaves thememory inself unchanged.

Unlikeread, the pointer may be unaligned.

Seeptr::read_unaligned for safety concerns and examples.

Copiescount * size_of::<T>() bytes fromself todest. The sourceand destination may overlap.

NOTE: this has thesame argument order asptr::copy.

Seeptr::copy for safety concerns and examples.

Copiescount * size_of::<T>() bytes fromself todest. The sourceand destination maynot overlap.

NOTE: this has thesame argument order asptr::copy_nonoverlapping.

Seeptr::copy_nonoverlapping for safety concerns and examples.

Copiescount * size_of::<T>() bytes fromsrc toself. The sourceand destination may overlap.

NOTE: this has theopposite argument order ofptr::copy.

Seeptr::copy for safety concerns and examples.

Copiescount * size_of::<T>() bytes fromsrc toself. The sourceand destination maynot overlap.

NOTE: this has theopposite argument order ofptr::copy_nonoverlapping.

Seeptr::copy_nonoverlapping for safety concerns and examples.

Executes the destructor (if any) of the pointed-to value.

Seeptr::drop_in_place for safety concerns and examples.

Overwrites a memory location with the given value without reading ordropping the old value.

Seeptr::write for safety concerns and examples.

Invokes memset on the specified pointer, settingcount * size_of::<T>()bytes of memory starting atself toval.

Seeptr::write_bytes for safety concerns and examples.

Performs a volatile write of a memory location with the given value withoutreading or dropping the old value.

Volatile operations are intended to act on I/O memory, and are guaranteedto not be elided or reordered by the compiler across other volatileoperations.

Seeptr::write_volatile for safety concerns and examples.

Overwrites a memory location with the given value without reading ordropping the old value.

Unlikewrite, the pointer may be unaligned.

Seeptr::write_unaligned for safety concerns and examples.

Replaces the value atself withsrc, returning the oldvalue, without dropping either.

Seeptr::replace for safety concerns and examples.

Swaps the values at two mutable locations of the same type, withoutdeinitializing either. They may overlap, unlikemem::swap which isotherwise equivalent.

Seeptr::swap for safety concerns and examples.

Computes the offset that needs to be applied to the pointer in order to make it aligned toalign.

If it is not possible to align the pointer, the implementation returnsusize::MAX.

The offset is expressed in number ofT elements, and not bytes.

There are no guarantees whatsoever that offsetting the pointer will not overflow or gobeyond the allocation that the pointer points into. It is up to the caller to ensure thatthe returned offset is correct in all terms other than alignment.

When this is called during compile-time evaluation (which is unstable), the implementationmay returnusize::MAX in cases where that can never happen at runtime. This is because theactual alignment of pointers is not known yet during compile-time, so an offset withguaranteed alignment can sometimes not be computed. For example, a buffer declared as[u8; N] might be allocated at an odd or an even address, but at compile-time this is not yetknown, so the execution has to be correct for either choice. It is therefore impossible tofind an offset that is guaranteed to be 2-aligned. (This behavior is subject to change, as usualfor unstable APIs.)

§Panics

The function panics ifalign is not a power-of-two.

§Examples

Accessing adjacentu8 asu16

usestd::ptr::NonNull;letx = [5_u8,6,7,8,9];letptr = NonNull::new(x.as_ptr()as*mutu8).unwrap();letoffset = ptr.align_offset(align_of::<u16>());ifoffset < x.len() -1{letu16_ptr = ptr.add(offset).cast::<u16>();assert!(u16_ptr.read() == u16::from_ne_bytes([5,6]) || u16_ptr.read() == u16::from_ne_bytes([6,7]));}else{// while the pointer can be aligned via `offset`, it would point    // outside the allocation}

Returns whether the pointer is properly aligned forT.

§Examples

usestd::ptr::NonNull;// On some platforms, the alignment of i32 is less than 4.#[repr(align(4))]structAlignedI32(i32);letdata = AlignedI32(42);letptr = NonNull::<AlignedI32>::from(&data);assert!(ptr.is_aligned());assert!(!NonNull::new(ptr.as_ptr().wrapping_byte_add(1)).unwrap().is_aligned());

Returns whether the pointer is aligned toalign.

For non-Sized pointees this operation considers only the data pointer,ignoring the metadata.

§Panics

The function panics ifalign is not a power-of-two (this includes 0).

§Examples

#![feature(pointer_is_aligned_to)]// On some platforms, the alignment of i32 is less than 4.#[repr(align(4))]structAlignedI32(i32);letdata = AlignedI32(42);letptr =&dataas*constAlignedI32;assert!(ptr.is_aligned_to(1));assert!(ptr.is_aligned_to(2));assert!(ptr.is_aligned_to(4));assert!(ptr.wrapping_byte_add(2).is_aligned_to(2));assert!(!ptr.wrapping_byte_add(2).is_aligned_to(4));assert_ne!(ptr.is_aligned_to(8), ptr.wrapping_add(1).is_aligned_to(8));

Casts from a type to its maybe-uninitialized version.

Casts from a maybe-uninitialized type to its initialized version.

This is always safe, since UB can only occur if the pointer is readbefore being initialized.

Creates a non-null raw slice from a thin pointer and a length.

Thelen argument is the number ofelements, not the number of bytes.

This function is safe, but dereferencing the return value is unsafe.See the documentation ofslice::from_raw_parts for slice safety requirements.

§Examples

usestd::ptr::NonNull;// create a slice pointer when starting out with a pointer to the first elementletmutx = [5,6,7];letnonnull_pointer = NonNull::new(x.as_mut_ptr()).unwrap();letslice = NonNull::slice_from_raw_parts(nonnull_pointer,3);assert_eq!(unsafe{ slice.as_ref()[2] },7);

(Note that this example artificially demonstrates a use of this method,butlet slice = NonNull::from(&x[..]); would be a better way to write code like this.)

Returns the length of a non-null raw slice.

The returned value is the number ofelements, not the number of bytes.

This function is safe, even when the non-null raw slice cannot be dereferenced to a slicebecause the pointer does not have a valid address.

§Examples

usestd::ptr::NonNull;letslice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(),3);assert_eq!(slice.len(),3);

Returnstrue if the non-null raw slice has a length of 0.

§Examples

usestd::ptr::NonNull;letslice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(),3);assert!(!slice.is_empty());

Returns a non-null pointer to the slice’s buffer.

§Examples

#![feature(slice_ptr_get)]usestd::ptr::NonNull;letslice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(),3);assert_eq!(slice.as_non_null_ptr(), NonNull::<i8>::dangling());

Returns a raw pointer to the slice’s buffer.

§Examples

#![feature(slice_ptr_get)]usestd::ptr::NonNull;letslice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(),3);assert_eq!(slice.as_mut_ptr(), NonNull::<i8>::dangling().as_ptr());

Returns a shared reference to a slice of possibly uninitialized values. In contrast toas_ref, this does not require that the value has to be initialized.

For the mutable counterpart seeas_uninit_slice_mut.

§Safety

When calling this method, you have to ensure that all of the following is true:

• The pointer must bevalid for reads forptr.len() * size_of::<T>() many bytes,and it must be properly aligned. This means in particular:

  • The entire memory range of this slice must be contained within a single allocation!Slices can never span across multiple allocations.

  • The pointer must be aligned even for zero-length slices. Onereason for this is that enum layout optimizations may rely on references(including slices of any length) being aligned and non-null to distinguishthem from other data. You can obtain a pointer that is usable asdatafor zero-length slices usingNonNull::dangling().

• The total sizeptr.len() * size_of::<T>() of the slice must be no larger thanisize::MAX.See the safety documentation ofpointer::offset.

• You must enforce Rust’s aliasing rules, since the returned lifetime'a isarbitrarily chosen and does not necessarily reflect the actual lifetime of the data.In particular, while this reference exists, the memory the pointer points to mustnot get mutated (except insideUnsafeCell).

This applies even if the result of this method is unused!

See alsoslice::from_raw_parts.

Returns a unique reference to a slice of possibly uninitialized values. In contrast toas_mut, this does not require that the value has to be initialized.

For the shared counterpart seeas_uninit_slice.

§Safety

When calling this method, you have to ensure that all of the following is true:

• The pointer must bevalid for reads and writes forptr.len() * size_of::<T>()many bytes, and it must be properly aligned. This means in particular:

  • The entire memory range of this slice must be contained within a single allocation!Slices can never span across multiple allocations.

  • The pointer must be aligned even for zero-length slices. Onereason for this is that enum layout optimizations may rely on references(including slices of any length) being aligned and non-null to distinguishthem from other data. You can obtain a pointer that is usable asdatafor zero-length slices usingNonNull::dangling().

• The total sizeptr.len() * size_of::<T>() of the slice must be no larger thanisize::MAX.See the safety documentation ofpointer::offset.

• You must enforce Rust’s aliasing rules, since the returned lifetime'a isarbitrarily chosen and does not necessarily reflect the actual lifetime of the data.In particular, while this reference exists, the memory the pointer points to mustnot get accessed (read or written) through any other pointer.

This applies even if the result of this method is unused!

See alsoslice::from_raw_parts_mut.

§Examples

#![feature(allocator_api, ptr_as_uninit)]usestd::alloc::{Allocator, Layout, Global};usestd::mem::MaybeUninit;usestd::ptr::NonNull;letmemory: NonNull<[u8]> = Global.allocate(Layout::new::<[u8;32]>())?;// This is safe as `memory` is valid for reads and writes for `memory.len()` many bytes.// Note that calling `memory.as_mut()` is not allowed here as the content may be uninitialized.letslice:&mut[MaybeUninit<u8>] =unsafe{ memory.as_uninit_slice_mut() };

Returns a raw pointer to an element or subslice, without doing boundschecking.

Calling this method with an out-of-bounds index or whenself is not dereferenceableisundefined behavior even if the resulting pointer is not used.

§Examples

#![feature(slice_ptr_get)]usestd::ptr::NonNull;letx =&mut[1,2,4];letx = NonNull::slice_from_raw_parts(NonNull::new(x.as_mut_ptr()).unwrap(), x.len());unsafe{assert_eq!(x.get_unchecked_mut(1).as_ptr(), x.as_non_null_ptr().as_ptr().add(1));}

Converts a&T to aNonNull<T>.

This conversion is safe and infallible since references cannot be null.

Converts a&mut T to aNonNull<T>.

This conversion is safe and infallible since references cannot be null.

Returns the argument unchanged.

CallsU::from(self).

That is, this conversion is whatever the implementation ofFrom<T> for U chooses to do.