Rust

Rust is a general-purpose programming language emphasizing performance, type safety, and concurrency. It enforces memory safety, meaning that all references point to valid memory, without a garbage collector.

Getting Started

Like Java, the main function is the entry point of a rust program.

main.rs

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

Rust must be compiled first and then ran.

mac

rustc main.rs && ./main

windows

rustc main.rs
.\main.exe

Comments

// hello, world

// So we’re doing something complicated here, long enough that we need
// multiple lines of comments to do it! Whew! Hopefully, this comment will
// explain what’s going on.

Data Types & Data Structures

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
arch	isize	usize

Compound Types

tuple.rs

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}");
}

array.rs

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

Learn more about Types

Variables

immutable.rs

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

mutable.rs

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

constants.rs

fn main() {
    const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}

Learn more about Variables

Statements

let

expression

Learn more about Statements

Control Flow

conditionals.rs

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Learn more about Control Flow

Error Handling (Panic)

panic.rs

fn main() {
    panic!("crash and burn");
}

Learn more about Error Handling

Loops

For Loop

list_loop.rs

fn main() {
    let v = &["apples", "cake", "coffee"];

    for text in v {
        println!("I like {}.", text);
    }
}

number_loop.rs

fn main() {
    let mut sum = 0;
    for n in 1..11 {
        sum += n;
    }
    assert_eq!(sum, 55);
}

loop_label.rs

fn main() {
    'a: loop {
        'a: loop {
            break 'a;
        }
        print!("outer loop");
        break 'a;
    }
}

block_expression.rs

let result = 'block: {
    do_thing();
    if condition_not_met() {
        break 'block 1;
    }
    do_next_thing();
    if condition_not_met() {
        break 'block 2;
    }
    do_last_thing();
    3
};

Predicate Loop

while.rs

fn main(){
    let mut i = 0;
    while i < 10 {
        println!("hello");
        i = i + 1;
    }
}

Learn more about Loops

Functions

functions.rs

fn main() {
    println!("Hello, world!");

    another_function();
}

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

measurements.rs

fn main() {
    print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {value}{unit_label}");
}

return_value.rs

fn five() -> i32 {
    5
}

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

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

Learn more about Functions

Structs

struct.rs

fn main(){
    struct Point {x: i32, y: i32}
    let p = Point {x: 10, y: 11};
    let px: i32 = p.x;
}

struct_2.rs

fn main(){
    struct Cookie;
    let c = [Cookie, Cookie {}, Cookie, Cookie {}];
}

Learn more about Structs

Libraries

Package Management with Cargo

To check the Cargo version

cargo --version

To create a new project

cargo new hello_cargo
cd hello_cargo

Build the project

cargo build

To run the project

cargo run

Learn more about Cargo

Resources

• 🎥 Getting Started with Rust
• Documentation
• Derek Banas