array-expr.md

r[expr.array]

Array and array index expressions

Array expressions

r[expr.array.syntax]

^Syntax
ArrayExpression :
   [ ArrayElements^? ]

ArrayElements :
      Expression ( , Expression )^* ,^?
   | Expression ; Expression

r[expr.array.constructor] Array expressions construct arrays. Array expressions come in two forms.

r[expr.array.array] The first form lists out every value in the array.

r[expr.array.array-syntax] The syntax for this form is a comma-separated list of expressions of uniform type enclosed in square brackets.

r[expr.array.array-behavior] This produces an array containing each of these values in the order they are written.

r[expr.array.repeat] The syntax for the second form is two expressions separated by a semicolon (;) enclosed in square brackets.

r[expr.array.repeat-operand] The expression before the ; is called the repeat operand.

r[expr.array.length-operand] The expression after the ; is called the length operand.

r[expr.array.length-restriction] It must have type usize and be a constant expression, such as a literal or a constant item.

r[expr.array.repeat-behavior] An array expression of this form creates an array with the length of the value of the length operand with each element being a copy of the repeat operand. That is, [a; b] creates an array containing b copies of the value of a.

r[expr.array.repeat-copy] If the length operand has a value greater than 1 then this requires that the type of the repeat operand is Copy or that it must be a path to a constant item.

r[expr.array.repeat-const-item] When the repeat operand is a constant item, it is evaluated the length operand's value times.

r[expr.array.repeat-evaluation-zero] If that value is 0, then the constant item is not evaluated at all.

r[expr.array.repeat-non-const] For expressions that are not a constant item, it is evaluated exactly once, and then the result is copied the length operand's value times.

[1, 2, 3, 4];
["a", "b", "c", "d"];
[0; 128];              // array with 128 zeros
[0u8, 0u8, 0u8, 0u8,];
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]; // 2D array
const EMPTY: Vec<i32> = Vec::new();
[EMPTY; 2];

r[expr.array.index]

Array and slice indexing expressions

^Syntax
IndexExpression :
   Expression [ Expression ]

r[expr.array.index.array] Array and slice-typed values can be indexed by writing a square-bracket-enclosed expression of type usize (the index) after them. When the array is mutable, the resulting memory location can be assigned to.

r[expr.array.index.trait] For other types an index expression a[b] is equivalent to *std::ops::Index::index(&a, b), or *std::ops::IndexMut::index_mut(&mut a, b) in a mutable place expression context. Just as with methods, Rust will also insert dereference operations on a repeatedly to find an implementation.

r[expr.array.index.zero-index] Indices are zero-based for arrays and slices.

r[expr.array.index.const] Array access is a constant expression, so bounds can be checked at compile-time with a constant index value. Otherwise a check will be performed at run-time that will put the thread in a panicked state if it fails.

// lint is deny by default.
#![warn(unconditional_panic)]

([1, 2, 3, 4])[2];        // Evaluates to 3

let b = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
b[1][2];                  // multidimensional array indexing

let x = (["a", "b"])[10]; // warning: index out of bounds

let n = 10;
let y = (["a", "b"])[n];  // panics

let arr = ["a", "b"];
arr[10];                  // warning: index out of bounds

r[expr.array.index.trait-impl] The array index expression can be implemented for types other than arrays and slices by implementing the Index and IndexMut traits.