cargo new my-project # create new project
cargo build # build the project
cargo run # run main()

rustup --version
rustup check # checks if newer version is available
rustup update

cargo fmt # runs rustfmt formatter
cargo clippy # detects and fixes problems in code

fn main() {
    println!("Hello, world!"); // '!' means this is a macro
                               // strings are enclosed in double quotes
}

fn main() {
    let x = 5; // this is binding, in other languages know as definition
               // x is immutable (constant)
    println!("Value of x is: {}", x);

    // x += 5 would throw an error
    // x = 10 also throws an error

    let y: u32 = 6;
    println!("Value of y is: {}", y);
}

fn main() {
    let x = 5;
    println!("Value of x is: {}", x);

    let x = x + 5;
    println!("Value of x is: {}", x);
}

fn main() {
    let mut x = 5; // mutable binding, uses keyword 'mut'
    println!("Value of x is: {}", x);

    x = 10;
    println!("Value of x is: {}", x);


    x += 1; // Rust does not support neither x++ nor ++x
    println!("Value of x is: {}", x);
}

const MAX_POINTS: u32 = 100_000;

fn main() {
    let x = 2.0; // f64
    println!("Value of x is: {}", x);

    let x: f32 = 10;
    println!("Value of x is: {}", x);
}

fn main() {
    let x = 2;
    let y: f64 = x as f64;
    let z: i32 = y as i32;

    let pi: f32 = 3.14;

    let u: f32 = pi.trunc();
    let v: f32 = pi.ceil();
    let w: f32 = pi.floor();

    println!("Value of u is: {}", u); // 3
    println!("Value of v is: {}", v); // 4
    println!("Value of w is: {}", w); // 3
}

fn main() {
    let t = true;

    let f: bool = false; // explicit type

    let value: i32 = f as i32; // bool is in Rust always either 0 or 1. Nothing else.
}

fn main() {
    let c = 'z'; // 'char'
    let z = 'ℤ'; // 'char'
    let heart_eyed_cat = '😻'; // 'char'; character is utf-8, 
                               // therefore it is not compatible with byte, i. e. u8
}

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);

    let five_hundred = tup.0;

    let six_point_four = tup.1;

    let one = tup.2;
}

fn main() {

    let a: [i32; 5] = [1, 2, 3, 4, 5];

    let b = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];

    let index = 2;

    let element = a[index];

    println!("The value of element is: {}", element);

    let months = ["January", "February", "March", "April", "May", "June", 
                   "July", "August", "September", "October", "November", 
                  "December"];
}

fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("The value of y is: {}", y);
}

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }

    let condition = true;
    let number2 = if condition { 5 } else { 6 };

    println!("The value of number is: {}", number2) // 5
}

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result); // 20
}

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("The value is: {}", a[index]);

        index += 1;
    }
}

use std::io;

fn main() {
    loop {
        println!("Please enter some number.");

        let mut number = String::new();

        io::stdin()
            .read_line(&mut number)
            .expect("Failed to read line");

        let number: u32 = match number.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("Your number: {}", number);

        break;
    }
}