Rust Learning Notes

# Rust Learning Notes This article is the learning notes of Rust programming language written by me. The learning materials is based on [this](https://www.youtube.com/watch?v=rQ_J9WH6CGk) lecture. <img src="https://hackmd.io/_uploads/BJHuyYqTgg.png" style="width:5%"/> > Rust logo © The Rust Foundation. Used under the Rust Logo Policy. > This is a personal study note, not affiliated with the Rust Foundation. The GitHub repository related to this article is [here](https://github.com/Hmc-1209/RustPtcs). ## Installation & Running the First Rust Program ### Install Rust To install Rust on our own computer, the easiest way is to use the following command if the operating system is Linux/Unix alike. ``` curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh ``` To check out that Rust is successfully installed, simply type `rustup --version`, if the result shows up with a version number, it indicates a success installation. After the installation, the commands `rustc --version` and `cargo --version` should also works, as they are the compiler and package manager for Rust. <hr> ### Running the First Rust Program To run Rust Program, the first method is simply create a `.rs` file. The sample code could be something like below: > **File:** `hello.rs` ```rust fn main() { println!("Hello World!"); } ``` The code shows how to define a function in Rust, and inside of main function, there's a print command that print out the string "Hello World!". #### Using Cargo The above method require us to manually compile before execution every time we update the code by using the command `rustc hello.rs`, and than execute the output file using command `./hello`. However, Rust also provides a build system and packager manager Cargo that automatically compile and run the program for us. The Cargo usage is as follow: - Create a new project using the command `cargo new PROJECT_NAME`. - Write code into the `main.rs` created by cargo. - Run the command `cargo run` to let it comiple and execute the file for us. <img src="https://hackmd.io/_uploads/rkBf2Ycagg.png" style="width:20%"/> ## Primitive Data Types ### Integer Rust has signed(+ and -) and unsigned(only +) integers, and are defined using the following type: |Signed|`i8`|`i16`|`i32`|`i64`|`i128`| |--|--|--|--|--|--| |Unsigned|`u8`|`u16`|`u32`|`u64`|`u128`| The number following represents the size of int. For example `i32` means it can store integer in range from -2³¹ to 2³¹-1. To define a variable with value and type, consider the following code: > **File:** `integer.rs` ```rust fn main() { let x: i32 = -10; let y: u64 = 100; println!("Signed integer: {}", x); println!("Unsigned integer: {}", y); } ``` <hr> ### Float Float in Rust has only two types: `f32` and `f64`. The showcase of code looks like below, almost the same as the integer. > **File:** `float.rs` ```rust fn main() { let pi: f64 = 3.14; println!("Value of pi: {}", pi); } ``` <hr> ### Boolean The boolean in Rust has only one type, `bool`. The usage is as follow: > **File:** `boolean.rs` ```rust fn main() { let today_is_workday: bool = true; println!("Today is workday? {}", today_is_workday); } ``` <hr> ### Character Character type in Rust also only has one option: `char`, and the usage is like: > **File:** `character.rs` ```rust fn main() { let letter: char = 'H'; println!("First character of last name: {}", letter); } ``` ## Compound Data Types ### Array Array are a fixed collection of elements, and the data stored in it should be the same type. There are slightly differences when defining an array in Rust in comparison to other programming languages. As it is Rust, we again needs to define the type of it, but we wrap it into a square brackets with two values, seperating using semicolon. The first element represents the type of elements in the array, and the second element represents the array length. Arrays do not implement the Display trait, but we can use the Debug trait to print them and other more complex data types. > **File:** `array.rs` ```rust fn main() { let nums: [i32; 5] = [1, 2, 3, 4, 5]; println!("Numbers: {:?}", nums); let fruits: [&str; 3] = ["Apple", "Banana", "Orange"]; println!("Fruits: {:?}", fruits); println!("First ruit: {}", fruits[0]); println!("Second ruit: {}", fruits[1]); println!("Third ruit: {}", fruits[2]); } ``` > [!Note] > &str is a string slice (a reference to a string), while String owns its data. <hr> ### Tuple The tuple in Rust can store elements with multiple types. In tuple, it can also save other compound data type elements, like the following show case: > **File:** `tuple.rs` ```rust fn main() { let human = ("Bob", 20, 175, 55.4, false, [90, 95, 81, 83, 75]); println!("Human tuple: {:?}", human); } ``` <hr> ### Slices Slices can be think of reference in Rust. If data needed to be accessed efficiently and do not want it to be accidentally modified, using slices would be a good choice. Below are the example code of slices in Rust. > **File:** `slices.rs` ```rust fn main() { let numbers: &[i32] = &[1, 2, 3, 4, 5]; println!("Number slices: {:?}", numbers); let animals: &[&str] = &["Dog", "Cat", "Mouse"]; println!("Animal slices: {:?}", animals); let books: &[&String] = &[&"IT".to_string(), &"Phy".to_string(), &"Geo".to_string()]; println!("Animal slices: {:?}", books); } ``` <hr> ### String String in Rust is growable and mutable, it own the data itself, and it is stored on heap. Below is a case showing how to define a string and extend the contents. > **File:** `string.rs` ```rust fn main() { let mut name: String = String::from("Danny "); name.push_str("Ho"); println!("My name is: {}", name); } ``` Using `.push_str()`/`.push()` to extend the string with string/char, only on mutable variables. > [!Note] > All variables in Rust is immutable by default, so we cannot change it if we just define it using let, we need to add mut into the definition code. <hr> ### String Slice String slice is a reference of a string. It did not own the data, only providing a reference to find the string. It is stored on stack. > **File:** `string_slice.rs` ```rust fn main() { let string: String = String::from("Hello, World!"); let slice: &str = &string; let slice2: &str = &string[0..5]; println!("{}", slice); println!("{}", slice2) } ``` <hr> > [!Important] > Rust clean variables automatically, so outside the scope(in the above cases, main function) those variables are not recognized by Rust. ## Functions Rust entry point function is main. If we create function that has the name more than one word, we should follow the snake case rule (e.g. `test_function`, `get_phone_number`). Variables declared outside of the main function must use const for immutable compile-time constants, or static for global variables with a fixed memory location. > **File:** `function.rs` ```rust fn main() { hello_world(); print_out_human_data("Bob", 175.5, 25); } fn hello_world() { println!("Hello, Rust!"); } fn print_out_human_data(name: &str, height: f32, age: i32) { println!("The name is {}, height is {} cm and are now {} years old.", name, height, age); } ``` <hr> ### Block Expression Another interesting feature in Rust is that we can define a variable using a block expression, allowing us to calculate its value with variables declared inside the block: > **File:** `block_expression.rs` ```rust fn main() { let x = { let price: i32 = 5; let qty: i32 = 10; price * qty }; println!("Total price: {}", x); }; ``` <hr> ### Function with return The return from function can be written as the following format, using the `->` to define the returned data type. > **File:** `function_with_return.rs` ```rust fn main() { let x = add(2, 3); let bmi = calculate_bmi(70.5, 1.802); println!("The add result is: {}", x); println!("The BMI value is: {}",bmi); } fn add(a: i32, b: i32) -> i32 { a + b } fn calculate_bmi(weight_kg: f64, height_m: f64) -> f64 { weight_kg / (height_m * height_m) } ``` ## Ownership In Rust, there is a special mechanism called ownership. Basically there are three main concepts of ownership: - Every value in Rust has an owner. - There can only be one owner at a time. - When the owner goes out of scope, the value will be dropped. This mechanism helps manage memory in a clear and efficient way, reducing the chance of keeping unused variables in the program. The following code demonstrates how function parameters relate to the original variables. If we want to keep ownership of s1, we should pass it as a reference instead. > **File:** `ownership.rs` ```rust fn main() { let s1: String = String::from("Rust"); let len = calculate_length(&s1); println!("The length of {} is {}", s1, len); } fn calculate_length(s: &String) -> usize { s.len() } ``` If we try to create another variable and assign it with the current existing variable, the original one will no longer exist, thus the following code will lead to an error. ```rust fn main() { let s1: String = String::from("Hello Rust!"); let s2: String = s1; println!("{}", s1); // <-- Error! s1 no longer exist. } ``` > [!Note] > The error happens when the variable is non-Copy type, but types like i32, bool, char are copy type, which will not lead to this error. ## Borrowing & References In Rust, variables borrowing to others means itself cannot been read/modified/borrowed anymore. If we want to make actions on it, we will have to do that on it's borrower. Here's a simple code demonstrating how to borrow value from others. > **File:** `borrowing.rs` ```rust fn main() { let mut x: i32 = 5; let y: &mut i32 = &mut x; *y += 1; // println!("{}", x); <-- Cannot read if already borrow to others println!("{}", y); } ``` > [!Tip] > Using * lets us reach the real value behind a reference so we can read or change it. <hr> ### Structure In Rust, a structure, enum, or trait needs to be defined using two types of blocks: the data definition (struct/enum) and the implementation block (impl) where methods or associated functions are defined. Here's an example of code referencing within a structure. > **File:** `struct.rs` ```rust fn main() { let mut account: BankAccount = BankAccount { owner: "Danny".to_string(), balance: 100.0, }; account.check_balance(); account.withdraw(45.3); account.check_balance(); } struct BankAccount { owner: String, balance: f64, } impl BankAccount { fn withdraw(&mut self, amount: f64) { println!("Withdrawing from {} with balance {}.", self.owner, amount); self.balance -= amount; } fn check_balance(&self) { println!("Account {} has a balance of {}", self.owner, self.balance); } } ``` ## Constants Constants cannot be declared with `mut`. Also, the best practice is to defined the constant with uppercase. Moreover, we can define constant as global, and read them in any function. > **File:** `constant.rs` ```rust fn main() { let x : i32 = 5; const Y: i32 = 10; println!("x is {}", x); println!("Y is {}", Y); println!("Z is {}", Z); } const Z: f64 = 15.0; ``` ## Shadowing Shadowing allows a variable to be redefined. Unlike marking a variable as mutable, shadowing can also change the variable’s data type. When a variable is shadowed, the original variable’s memory is released, and a new one is allocated for the new data. > **File:** `xxx.rs` ```rust fn main() { let x: i32 = 5; let x: i32 = x + 1; println!("x is {}", x); { let x: i32 = x * 2; println!("x is {}", x); } } ``` ## Conditions The condition statements in Rust work similarly to other programming languages using `if`, `else if` and `else`. It is also possible to write inline conditional expressions to assign value directly to variables. The example below demonstrates both forms of condition suage. > **File:** `conditions.rs` ```rust fn main() { let weather: String = String::from("Rainy"); if weather == "Rainy".to_string() { println!("Remember to bring the unbrella! It is raining outside."); } else if weather == "Sunny".to_string() { println!("Remember to bring the unbrella! The sun is big."); } else { println!("You don't need the umbrella now!"); } let bring_umbrella: bool = if weather == "Rainy" || weather == "Sunny" {true} else {false}; println!("Bring umbrella: {}", bring_umbrella); } ``` ## Looping Mechanisms The normal loop in Rust defined just like other programming languages, and can be used in inline definition. Below is a short demonstration of the loop mechanism. > **File:** `loop.rs` ```rust fn main() { let mut x: i32 = 10; let result: i32 = loop { x += 1; if x >= 20 { break x - 10; } }; println!("Result: {}", result); } ``` ### Label loop A label loop uses a `'label:` before a loop. It allows us to control outer loops when using break or continue. > **File:** `loop-label.rs` ```rust fn main() { let mut count = 0; 'counting_up: loop { 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; } } ``` <hr> ### While loop The while loop in Rust is pretty straight forward. Simply write `while` followed by the condition, the loop will automatically break when the condition no longer matches. > **File:** `while.rs` ```rust fn main() { let mut num: i32 = 3; while num > 0 { println!("Num: {num}"); num -= 1; } } ``` <hr> ### Looping through collection Using `for` loop in Rust can iterate elements in an array like Python. Here an example: ```rust fn main() { let a: [i32; 5] = [1, 2, 3, 4, 5]; let b: [char; 5] = ['1', '2', '3', '4', '5']; for num in a { println!("{}", num); } for chr in b { println!("{}", chr); } } ``` ## Structure Struct in Rust can be defined using the following code. The demonstration shows two ways to create instance using struct, and the clone mechanism of struct. > **File:** `struct.rs` ```rust fn main() { #[derive(Clone)] struct Book { title: String, author: String, pages: u32, available: bool } fn build_book_data(title: String, author: String, pages: u32, available: bool) -> Book { Book { title, author, pages, available } } // First method let book1: Book = Book { title: "Book1".to_string(), author: "Author1".to_string(), pages: 3, available: true }; // Second method let book2: Book = build_book_data("Book2".to_string(), "Author2".to_string(), 5, false); // If the instance want to inherit data from others let book3: Book = Book { title: "Book3".to_string(), ..book1.clone() }; println!("{} has author {}, {} pages and are now available: {}", book1.title, book1.author, book1.pages, book1.available); println!("{} has author {}, {} pages and are now available: {}", book2.title, book2.author, book2.pages, book2.available); println!("{} has author {}, {} pages and are now available: {}", book3.title, book3.author, book3.pages, book3.available); } ``` > [!Note] > The `#[derive(Clone)]` attribute before a struct is required only when we want to create new instances by cloning data from another instance. This is because of Rust’s ownership and borrowing rules. The `.clone()` method creates a duplicate of the data, ensuring that the original instance remains unchanged. <hr> ### Unit-like Struct A unit-like struct is used when we want to mark the type of an instance without storing any data. > **File:** `unit-like-struct.rs` ```rust struct Logger; impl Logger { fn log(&self, msg: &str) { println!("[LOG] {}", msg); } } fn main() { let logger = Logger; logger.log("Program started!"); } ``` ## Enum An enum is a versatile tool used to represent a type that can take on one of several possible variants. An enum can be used as the type of a variable, for example inside a struct. > **File:** `enums.rs` ```rust fn main() { #[derive(Debug)] enum IPAddr { V4(u8, u8, u8, u8), V6(String), } let home_ip: IPAddr = IPAddr::V4(127, 0, 0, 1); let loopback_ip: IPAddr = IPAddr::V6(String::from("::1")); println!("Home IP: {:?}", home_ip); println!("Loopback IP: {:?}", loopback_ip); } ``` > [!Note] > The `#[derive(Debug)]` attribute before enum is required since we did not customize a display trait. So we need to print out it using debug trait: `{:?}`. ## Error Handling In Rust, there are two important enums commonly used for handling normal and error behaviors: `Option` and `Result`. The `Option` enum is used when a value may or may not exist. If a value exists, it returns Some(value); if not, it returns None. Its structure looks like: ```rust enum Option<T> { // Define the generic Option type Some(T), // Represent a value None, // Represent no value } ``` The `Result` enum is used when an operation can either succeed or fail. It returns Ok(value) when successful, or Err(error) when something goes wrong. Its structure looks like: ```rust enum Result<T> { // Define the generic Option type Ok(T), // Represent a value Err(E), // Represent an error } ``` To demonstrate the usage of error handling, consider the code shown below. In this example, there are two functions that return the Option and Result types respectively. Depending on the return type, we can use match to handle each possible outcome accordingly. > **File:** `option-result.rs` ```rust fn divide_fnc_option(x: f32, y: f32) -> Option<f32> { if y == 0.0 { None } else { Some(x / y) } } fn divide_fnc_result(x: f32, y: f32) -> Result<f32, String> { if y == 0.0 { Err("Cannot divide by 0".to_string()) } else { Ok(x / y) } } fn main() { match divide_fnc_option(5.0, 3.0) { None => println!("Cannot divide by 0"), Some(x) => println!("Some number: {}", x), } match divide_fnc_option(5.0, 0.0) { None => println!("Cannot divide by 0"), Some(x) => println!("Some number: {}", x), } match divide_fnc_result(0.5, 0.1) { Err(e) => println!("Error: {}", e), Ok(x) => println!("Result: {}", x), } match divide_fnc_result(0.5, 0.0) { Err(e) => println!("Error: {}", e), Ok(x) => println!("Result: {}", x), } } ``` > [!Tip] > Notice that in a `Result` return type, we must provide both the `Ok` and `Err` value types explicitly. ## Vector Vector can dynamically increase or decrese the elements stored in it. We can define it using `Vec<TYPE>`, and the read action are just like arrays. > **File:** `vector.rs` ```rust fn main() { let mut v1: Vec<i32> = Vec::new(); // Defining with empty vector let mut v2: Vec<i32> = vec![1, 2, 3]; // Defining with value v1.push(1); println!("The vector v1: {:?}.", v1); println!("The third element in v2: {}.", &v2[2]); let forth = v2.get(4); match forth { Some(x) => println!("The third element in v2 is {}.", x), None => println!("There is no forth element in v2."), } } ``` ## UTF-8 Strings In Rust, if we use the `+` operator to add two strings together, the latter will be passed as reference, so we should add `&` to it. Another way to add two strings is `format!`. It will return a `String` element, so we can then save it as a string. > **File:** `utf-9-strings.rs` ```rust fn main() { let mut s1 = String::from("Hello, "); let s2 = String::from("world!"); s1 = s1 + &s2; println!("{}", s1); let s3: String = String::from("Hi "); let s4: String = String::from("there!"); println!("{}", format!("{}{}", s3, s4)); } ``` ## Hashmap Hashmap stores data with key and value pair. The following code demonstrates how to use a hashmap. > **File:** `hashmap.rs` ```rust use std::collections::HashMap; fn main() { let mut scores: HashMap<String, i32> = HashMap::new(); scores.insert(String::from("Blue"), 10); let team = String::from("Blue"); let score = scores.get(&team).copied().unwrap_or(0); for (key, value) in &scores { println!("{} team score: {}", key, value); } } ```