Struct std::mem::slice

Fat pointers to a contiguous region of memory.

type &[T] = slice<&T>;
type &mut [T] = slice<&mut T>;

Slice fat "pointers" are just regular structs that compiler handles in a special way with regards to syntax, implicit coercion and type inference. They are generic over the pointer-to-element type rather than the element type itself. This is an implementation detail to ensure that &mut [T] and &[T] are distinguished without having to have two distinct types for mutable and const slices.

Methods

• fn empty<Ptr>() -> slice<Ptr>

  Ptr: Pointer

  source

  Empty slice

• fn from_raw<Ptr>(ptr: Ptr, len: usize) -> slice<Ptr>

  Ptr: Pointer

  source

  Create a slice from a pointer and length

  Example

  use std::mem::slice;
  
  let arr = [1, 2, 3];
  let ptr: &i32 = &arr[0];
  
  let slice = slice::from_raw(ptr, 2);
  assert_eq!(slice, &[1, 2]);
  Run this example

• fn len<Ptr>(self: slice<Ptr>) -> usize

  Ptr: Pointer

  source

  Returns the length of the slice

• fn as_ptr<Ptr>(self: slice<Ptr>) -> Ptr

  Ptr: Pointer

  source

  Returns a pointer to the first element of the slice.

  Unlike &slice[0], this is not range-checked, so it will not panic if the slice is empty, but may return null, a dangling or an otherwise invalid pointer.

• fn is_empty<Ptr>(self: slice<Ptr>) -> bool

  Ptr: Pointer

  source

  Returns true if the slice has a length of 0, and false otherwise.

• fn alloc<T>(len: usize) -> &mut [T]

  source

  Allocates an array of specified size on the heap.

  The values are not initialized.

  Example

  use std::mem::slice;
  
  let hw = "Hello, World!";
  let s = slice::alloc::<u8>(hw.len());
  defer s.free();
  
  hw.copy_to(&s[0]);
  assert_eq!(hw, s);
  Run this example

• fn alloc_zeroed<T>(len: usize) -> &mut [T]

  source

  Allocates an array of specified size on the heap.

  The values are zero-initialized.

  Example

  use std::mem::slice;
  
  let s = slice::alloc_zeroed::<u8>(10);
  defer s.free();
  
  assert_eq!(s, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
  Run this example

• fn realloc<T>(slice: &mut [T], len: usize) -> &mut [T]

  source

  Resizes a heap-allocated array. The original array must have been allocated with alloc.

  If the new size is larger than the old size, the new elements are uninitialized.

  Example

  use std::mem::slice;
  
  let v = slice::alloc::<i32>(2);
  defer v.free();
  
  v[0] = 1;
  v[1] = 2;
  
  v = v.realloc(3);
  v[2] = 3;
  
  assert_eq!(v, &[1, 2, 3]);
  Run this example

• fn copy_to_nonoverlapping<T>(src: &[T], dst: &mut T)

  source

  Copies a region of memory from src to dst.

  The memory regions must not overlap, use copy_to if they may be overlapping.

  Example

  let src = [1, 2, 3];
  let dst: [i32; 3];
  
  src[..].copy_to_nonoverlapping(&dst[0]);
  assert_eq!(dst, [1, 2, 3]);
  Run this example

• fn copy_to<T>(src: &[T], dst: &mut T)

  source

  Copies a region of memory from src to dst.

  The regions may overlap. Using copy_to_nonoverlapping can be more efficient if the ranges do not in fact overlap.

  Example

  let src = [1, 2, 3, 4, 5, 6];
  
  src[..3].copy_to(&src[1]);
  src[4..].copy_to(&src[3]);
  assert_eq!(src, [1, 1, 2, 5, 6, 6]);
  Run this example

• fn get<T>(self: &[T], index: usize) -> Option<T>

  source

  Returns the element at the given index.

  If the index is out of bounds, the function will return Option::none().

  Example

  let hw = "Hello, world";
  assert_eq!(hw[..5].get(0), Option::some('H'));
  assert_eq!(hw[..5].get(5), Option::none());
  Run this example

• fn get_range<Ptr, T>(self: slice<Ptr>, range: T) -> Option<slice<Ptr>>

  Ptr: Pointer

  T: RangeOf<usize>

  source

  Returns a subslice of the given slice.

  This is a safe version of range indexing (slice[a..b], slice[a..], ...). Instead of panicking or causing UB when the range is out of bounds, this function returns Option::none().

  Example

  let hw = "Hello, world";
  assert_eq!(hw.get_range(..5usize), Option::some("Hello"));
  assert_eq!(hw.get_range(7usize..), Option::some("world"));
  assert_eq!(hw.get_range(7usize..12), Option::some("world"));
  assert_eq!(hw.get_range(7usize..13), Option::none());
  Run this example

• fn to_array<T, Arr>(self: &[T]) -> Arr

  Arr: ArrayOf<T>

  source

  Copy a slice into a fixed-size array.

  The length of the result array must exactly match the length of the slice.

  Example

  let hw = "Hello, world";
  let hw: [u8; 5] = hw[..5].to_array();
  
  assert_eq!(hw[..] as &[u8], "Hello");
  Run this example

• fn iter<Ptr>(self: slice<Ptr>) -> SliceIterator<Ptr>

  Ptr: Pointer

  source

  Returns an iterator over the elements of this iterable.

  See Iterable for details.

• fn iter_ref<Ptr>(self: slice<Ptr>) -> SliceRefIterator<&deref_of<Ptr>>

  Ptr: Pointer

  source

  Returns an iterator over the pointers of the items of this iterable.

  See IterableRef for details.

• fn iter_mut<T>(self: &mut [T]) -> SliceRefIterator<&mut T>

  source

  Returns an iterator over mutable pointers to the elements of the collection.

  See IterableMut for details.

• fn fill<T>(slice: &mut [T], value: T)

  source

  Fill slice with a value

  Example

  let v = [0, 0, 0];
  v[..].fill(1);
  assert_eq!(v, [1, 1, 1]);
  Run this example

• fn equals<T, Ptr>(lhs: &slice<Ptr>, rhs: &slice<Ptr>) -> bool

  T: Equatable<T>

  Ptr: PointerOf<T>

  source

  Returns true if arguments are equal, false otherwise

  See Equatable for details.

• fn compare<T, Ptr>(lhs: &slice<Ptr>, rhs: &slice<Ptr>) -> Ordering

  T: Comparable<T>

  Ptr: PointerOf<T>

  source

  Compare the value

  See Comparable for details.

• fn hash<T, Ptr, H>(self: &slice<Ptr>, hasher: &mut H)

  T: Hashable<T, H>

  Ptr: PointerOf<T>

  H: Hasher<H>

  source

  Update hasher state with the contents of this object.

  See Hashable for details.

• fn fmt<Ptr, F>(self: &slice<Ptr>, f: &mut F) -> Result<(), Error>

  Ptr: PointerOf<u8>

  F: Formatter<F>

  source

  Write the object into a given formatter.

  See Formattable for details.

• fn free<T>(a: &mut [T])

  source

  Frees the slice.

  This requires that the slice was allocated with alloc or alloc_zeroed.

Mixins

• mixin<T, Ptr> Equatable<slice<Ptr>>

  T: Equatable<T>

  Ptr: PointerOf<T>

• fn not_equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns false if arguments are equal, true otherwise

• mixin<T, Ptr> Comparable<slice<Ptr>>

  T: Comparable<T>

  Ptr: PointerOf<T>

• fn less_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is strictly less than rhs, false otherwise

• fn less_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is less or equal to rhs, false otherwise

• fn greater_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs strictly greater than rhs, false otherwise

• fn greater_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs greater than or equal rhs, false otherwise