Rust

Getting Started

# Install rustup
curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh

rustc --version

rustup update

rustup self uninstall

rustup doc

main.rs

fn main() {
    println!("Hello, world!"); // 4 tabs
}

rustc main.rs
./main.rs

cargo --version

# Source code at `src`
cargo new hello_cargo
cd hello_cargo

cargo new --help

Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

# Default debug build
cargo build

./target/debug/hello_cargo

cargo run

cargo check

cargo build --release

cargo doc --open

Common Programming Concepts

// Can not change type
let mut x = 1; mut // Mutable
x = 2;

// Constants
// `const` can not allow `mut`
// Must declare data type
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

// Shadowing
fn main() {
    let x = 5; // 5
    let x = x + 1; // 6
    {
        let x = x * 2; // 12
    }
    // 6
}

let guess: u32 = "42".parse().expect("Not a number !");

// literals
let x = 87u8; // unsigned 8 bits
let x = 1_000; // 1000
let x = 0o77; // 8 bits
let x = 0xff; // 16 bits
let x = 0b1111_0000; // 2 bits
let x = b'A'; // unsigned 8 bits

// Default f64, IEEE-754
fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

fn main() {
    let sum = 5 + 10;

    let difference = 95.5 - 4.3;

    let product = 4 * 30;

    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // -1

    let remainder = 43 % 5;
}

fn main() {
    let t = true; // 1 bit

    let f: bool = false;
}

fn main() {
    let c = 'z'; // 4 bytes Unicode
    let z: char = 'ℤ';
    let heart_eyed_cat = '😻';
}

// Truple
fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    
    // Pattern matching, destructuring
    let (x, y, z) = tup;
    
    let five_hundred = tup.0;

    let six_point_four = tup.1;

    let one = tup.2;
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    
    let a = [3; 5]; // 3, 3, 3, 3, 3
    
    let first = a[0];
    let second = a[1];
}

fn main() {
    another_function();
}

fn another_function() {
    println!("Another function.");
}

fn main() {
    another_function(5);
    another_function2(1, 'a');
}

fn another_function(x: i32) {
    println!("{x}"); // 5
}

fn another_function2(x: i32, y: char) {
    println!("x = {x}, y = {y}"); // x= 1, y = a
}

fn main() { // Statements
    let y = 6; // Statements
}

fn main() {
    let x = (let y = 6); // error: expected expression
    let x = y = 6; // error
}

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1 // Expressions, `;` will not return value
    }; // y = 4

    println!("y = {y}");
}

fn five() -> i32 { // return value and type
    5
}

fn main() {
    let x = five();

    println!("{x}"); // 5
}

fn main() {
    let x = plus_one(5);

    println!("x = {x}"); // x = 6
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

fn main() {
    let number = 6;

    if number % 4 == 0 { // `if` is Expressions
        println!("1");
    } else if number % 3 == 0 {
        println!("2");
    } else if number % 2 == 0 {
        println!("3");
    } else {
        println!("4");
    }
}

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("{number}"); // 5
}

fn main() {
    loop {
        println!("Again.");
    }
}

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Must have `;`
        }
    };

    println!("{result}");
}

fn main() {
    let mut count = 0;
    'counting_up: loop { // loop label
        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}");
}
// count = 0
// remaining = 10
// remaining = 9
// count = 1
// remaining = 10
// remaining = 9
// count = 2
// remaining = 10
// End count = 2

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("end");
}

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

    for element in a {
        println!("{element}");
    }
}

fn main() {
    for number in (1..4).rev() { // 4, 3, 2, 1
        println!("{number}!");
    }
    println!("end");
}

Ownership

Avoid garbage collector.