Rust Slice

A slice in Rust is a dynamically-sized type (DST) representing a contiguous view into a block of memory. It allows safe, borrow-checked access to a portion of a collection—such as an array, Vec<T>, or String—without copying the underlying data. Because the slice itself ([T]) is dynamically sized, its size is not known at compile time. Consequently, slices are almost exclusively interacted with via references (&[T] for shared access or &mut [T] for mutable access). Under the hood, a slice reference is a “fat pointer” consisting of exactly two machine words:

A pointer to the memory address of the first element in the slice.
A usize representing the length of the slice (the number of elements it contains).

Syntax and Instantiation

Slices are constructed using the borrowing operator (& or &mut) combined with Rust’s range syntax (start..end), where start is inclusive and end is exclusive.

let array: [i32; 5] = [10, 20, 30, 40, 50];

// Shared slice reference (&[i32])
let slice: &[i32] = &array[1..4]; // Contains [20, 30, 40]

// Mutable slice reference (&mut [i32])
let mut mut_array: [i32; 5] = [10, 20, 30, 40, 50];
let mut_slice: &mut [i32] = &mut mut_array[1..4];

Rust provides syntactic sugar for omitting bounds when slicing from the beginning or to the end of a collection:

let collection = [0, 1, 2, 3, 4];

let a = &collection[..];    // Full range: index 0 to len
let b = &collection[2..];   // From index 2 to len
let c = &collection[..3];   // From index 0 to 3 (exclusive)
let d = &collection[1..=3]; // Inclusive range: index 1 to 3 (inclusive)

String Slices (`&str`)

A string slice (&str) is a specialized, primitive slice type. While &[T] is a slice of arbitrary elements, &str is fundamentally a slice of bytes (&[u8]) with a strict type system and standard library guarantee that the underlying byte sequence is valid UTF-8.

let heap_string: String = String::from("Compiler");
let str_slice: &str = &heap_string[0..4]; // "Comp"

// String literals are inherently string slices pointing to static memory
let literal: &'static str = "Static data"; 

Note: Slicing a string must occur at valid UTF-8 character boundaries. Slicing in the middle of a multi-byte character will cause a runtime panic.

Type System Mechanics

[T]: The slice type itself. It does not implement the Sized trait (making it an unsized type), meaning it cannot be stored directly on the stack or passed by value.
&[T]: The slice reference. It implements the Sized trait because the fat pointer has a fixed, known size at compile time (16 bytes on a 64-bit architecture).
Deref Coercion: Collections that manage contiguous memory implement the Deref trait targeting their respective slice types. Vec<T> implements Deref<Target = [T]>, and String implements Deref<Target = str>. This allows a &Vec<T> to implicitly coerce into a &[T] when passed to functions or methods.

Tired of Poor Rust Skills? Fix That With Deep Grasping!Learn More

Functions

Traits

Closures

Generics

Enums

Pattern Matching

Structs

Macros

Lifetimes

Error Handling

Variables

Control Flow

Loops

Modules

Compound Types

Collection Types

Numeric Types

Text & Boolean Types

Attributes

Comments

Assignment Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Unary Operators

Reference Operators

Access & Path Operators

Range Operators

Bitwise Operators

Type Cast Operators

Syntax and Instantiation

String Slices (`&str`)

Type System Mechanics

​Syntax and Instantiation

​String Slices (&str)

​Type System Mechanics

Syntax and Instantiation

String Slices (`&str`)

Type System Mechanics