To explicitly handle the possibility of overflow, you can use these families of methods provided by the standard library for primitive numeric types:

* Wrap in all modes with the wrapping_* methods, such as wrapping_add.
* Return the None value if there is overflow with the checked_* methods.
* Return the value and a boolean indicating whether there was overflow with the overflowing_* methods.
* Saturate at the value’s minimum or maximum values with the saturating_* methods.

// example of mutability
let mut x = 5;
x = x + 1;

// example of shadowing
let spaces = "    ";
let spaces = spaces.len(); // type of this variable is different from original.
// or
let x = 1;
{
	let x = 2;
	println!("x is: {x}");
}
println!("x is: {x}");

const SECONDS_IN_HOUR = 60 * 60; // this value will be comuted at compile time.

let x = 2.0; //f64
let y: f32 = 2.0; //f32

let t = true;
let f: bool = false;

let c = 'z'; let z: char = '😻';

let tup: (i8, f64, bool) = (127, 2.0, false)
let tupBool = tup.2;

let student = ("Sam", 5 , 1);
let (name, class, roll_num) = student; // Destructuring

let a = [1, 2, 3, 4];
let a: [i32; 3] = [1,2,3];
let a = [0; 2]; // [0, 0] initializes the array with same value 2 times.
let first = a[0];
let last = a[2]; // this will cause panic as a.len() == 2

fn my_function(param1: i32, param2: char) { // type annotations are required
	println!("My inputs: {param1}, {param2}");
}

let y = { let x = 3; x + 1 }; 
// this will set y to 4. Note there's no ; at the end of x+1

fn number() -> u32 {
	1
} 
// returns 1 as it's the last expression. 
// You can use return to return early.
// Note: there's no ; at the last expression.
fn plus_one(x: i32) -> i32 {
 x + 1
}

let condition = true;
let condition2 = false;
let number = if condition { 5 } else if condition2 {7}  else { 6 };

fn loopExample() {
    let mut count = 0;
    'counting_up: loop { // we are using a loop label here.
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

let mut number = 2;
while number != 0 {
	number -= 1;
}

let sum = 0;
for num in (1..5).rev(){
	sum += num;
}

let s1 = String::from("hello");
let s2 = s1; // shallow copy
println!("{}", s1); // throws compile time error as s1 is being referrenced (value borrowed) after move

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

let mut s = String::from("hello");

let r1 = &mut s;
let r2 = &mut s; // This will fail at compile time.

let r3 = &s;
let r4 = &s; // this is okay as it's unmutable reference.
// BIG PROBLEM, because we are can not have a mutable reference
// if we have an immutable reference to the same value.
let r5 = &mut s;

println!("{}, {}", r1, r2, r3, r4, r5);

// This works as the immutables have gone out of scope when we declare a 
// mutable refernce.
let mut s = String::from("hello");

let r1 = &s; // no problem
let r2 = &s; // no problem
println!("{} and {}", r1, r2);
// variables r1 and r2 will not be used after this point

let r3 = &mut s; // no problem
println!("{}", r3);

fn dangle() -> &String { // dangle returns a reference to a String

    let s = String::from("hello"); // s is a new String

    &s // we return a reference to the String, s
} // Here, s goes out of scope, and is dropped. Its memory goes away.
  // Danger!

fn no_dangle() -> String {
    let s = String::from("hello");

    s
} // we are moving ownership out, and nothing is deallocated.

let s = String::from("hello");

let slice = &s[0..2];
let slice = &s[..2];
let slice = &s[3..];

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
assert_eq!(slice, &[2, 3]);

struct User {
    active: bool, // Implements Copy trait
    username: String,
    email: String,
    sign_in_count: u64, // Implements Copy trait
}
let mut user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("[email protected]"),
        sign_in_count: 1,
};
user1.email = String::from("[email protected]");

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

let user2 = User {
    active: user1.active,
    username: "username2",
    email: String::from("[email protected]"),
    sign_in_count: user1.sign_in_count,
};
// user1 is still valid here as we have only used attributes that implement Copy trait

let user2 = User {
    email: String::from("[email protected]"),
    ..user1
};
// user1 can no longer be used here as it's contents are now moved