Rust Tutorial : Arrays
from tutorialspoint.com

Features of an Array
an array is a homogeneous collection of values
  • an array declaration allocates sequential memory blocks
  • arrays are static
    an array once initialized cannot be resized
  • each memory block represents an array element
  • array elements are identified by a unique integer called the subscript/ index of the element.
  • populating the array elements is known as array initialization
  • array element values can be updated or modified but cannot be deleted
Declaring and Initializing Arrays
Initialize a simple array
the syntax given below to declare and initialize an array in Rust 
//Syntax1
let variable_name = [value1,value2,value3];

//Syntax2
let variable_name:[dataType;size] = [value1,value2,value3];

//Syntax3
let variable_name:[dataType;size] = [default_value_for_elements,size];
example of a simple array 
fn main(){
   let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}
output 
array is [10, 20, 30, 40]
array size is :4
Initialize an array without data type
example 
fn main(){
   let arr = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}
output 
array is [10, 20, 30, 40]
array size is :4
Initialize an array with default values
example creates an array and initializes all its elements with a default value of -1 
fn main() {
   let arr:[i32;4] = [-1;4];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());
}
output 
array is [-1, -1, -1, -1]
array size is :4
Iterating an array
example iterates through an array and prints the indexes and their corresponding values
the loop retrieves values from index 0 to 4 (index of the last array element) 
fn main(){
   let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());

   for index in 0..4 {
      println!("index is: {} & value is : {}",index,arr[index]);
   }
}
output 
array is [10, 20, 30, 40]
array size is :4
index is: 0 & value is : 10
index is: 1 & value is : 20
index is: 2 & value is : 30
index is: 3 & value is : 40
the iter() function fetches values of all elements in an array 
fn main(){

let arr:[i32;4] = [10,20,30,40];
   println!("array is {:?}",arr);
   println!("array size is :{}",arr.len());

   for val in arr.iter(){
      println!("value is :{}",val);
   }
}
output 
array is [10, 20, 30, 40]
array size is :4
index is: 0 & value is : 10
index is: 1 & value is : 20
index is: 2 & value is : 30
index is: 3 & value is : 40
Mutable array
example 
fn main(){
   let mut arr:[i32;4] = [10,20,30,40];
   arr[1] = 0;
   println!("{:?}",arr);
}
output 
[10, 0, 30, 40]
Passing Arrays as Parameters to Functions
Passing by value
example 
fn main() {
   let arr = [10,20,30];
   update(arr);

   print!("Inside main {:?}",arr);
}
fn update(mut arr:[i32;3]){
   for i in 0..3 {
      arr[i] = 0;
   }
   println!("Inside update {:?}",arr);
}
output 
Inside update [0, 0, 0]
Inside main [10, 20, 30]
Passing by reference
example 
fn main() {
   let mut arr = [10,20,30];
   update(&mut arr);
   print!("Inside main {:?}",arr);
}
fn update(arr:&mut [i32;3]){
   for i in 0..3 {
      arr[i] = 0;
   }
   println!("Inside update {:?}",arr);
}
output 
Inside update [0, 0, 0]
Inside main [0, 0, 0]
Array Declaration and Constants
the example below will raise a compiler error
an array's length must be known at compile time
the value of the variable "N" will be determined at runtime
variables cannot be used to define the size of an array 
fn main() {
   let N: usize = 20;
   let arr = [0; N]; //Error: non-constant used with constant
   print!("{}",arr[10])
}
this version will compile 
fn main() {
   const N: usize = 20; 
   // pointer sized
   let arr = [0; N];

   print!("{}",arr[10])
}
the value of an identifier prefixed with the const keyword is defined at compile time and cannot be changed at runtime
usize is pointer-sized, thus its actual size depends on the architecture used to compile the application
index