• Table Of Contents

Introduction

• A high level language without performance penalties
• Program behaviours can be enforced at compile time and a very strong type-checking during the compilation phase
• Has built-in dependency management, similar to how it’s done for npm, called cargo
• Has multi-threading support, and the compiler give errors when we’re trying to improperly access shard data
• Supports code-modularity
• Has tooling to automate documentation generation, linting the code (RLS), auto formatting (rustfmt, can also be configured by .rustfmt.toml) etc

Comments

//This is a comment

/* This is a block comment
	 Nice to meet you */

The println macro

• Used to display information to the terminal
• The ! is what denotes the difference b/w a function and a MACRO
• {:?} is used to signify to the MACRO we’re going to display something in debug mode

Basic cargo usage

//Starting a new rust project
cargo new <projectName>
cargo new --lib <projectName>

//Running the code
cargo run --bin <fileName>

//Building our project
cargo build
cargo build --release //optimised binary

//check if everything is fine
cargo check

//Take suggestions from the compiler
cargo check --bin <fileName>

//Update the dependencies
cargo update

let life = 42;
println!("hello");
println!("{:?}", life);

Reading documentation

///The following code adds two numbers and returns the result
//The above is not a comment, but rather it will be used to document our code
fn add (a: i32, b: i32) -> i32 {
	a + b
}

cargo doc --open //This would generate the basic documentation including that of any crates that we have included in the TOML file 

Rust development

#clippy
cargo clippy --bin <binary>

#rust-analyzer

#rustfmlt and .rustfmt.toml
cargo fmt

#cargo-outdated: Find outdated dependencies which can't be updated with **cargo update**.
cargo install --locked cargo-outdated
cargo outdated

#cargo-audit: Audit the dependency for vulnerabilities
cargo install -f cargo-audit
cargo audit

Expressions

• Rust is an expression based language, almost everything returns something
• Calling a function, calling a macro, a new scope block is an expression.

//In C, an assignment of a variable to its value returns the value of the assignnent
//By which, x = y = 6 becomes legal. In Rust, it's not the case so

let x = (let y = 6); /illegal

let some_variable = 5;

let bool_var = if some_variable < 5 {
	true
} else {
	false // "rohit" here instead of false will lead to compile time error because of the type binding confusion during static type checking
};

let boolB_var = some_variable < 5;

Writing Unit Tests

• For testing certain functions, we can create a test inline module and #[cfg(test)] to let the compiler know this module is specifically for testing
• In the mod inline-module, we will specify a test function and specify that this function is for testing purposes only by the use of #[test] macro
• If the program is aborted during testing, it means the test has failed, otherwise the test is successful, and this is achieved via the assert_eq! macro, it takes in three arguments, what is the result, what result is to be expected and what the error message should be.

//Testing a certain program
cargo test --bin <name>
//Testing all the programs
cargo test

fn all_caps(word: &str) -> String {
	word.to_uppercase()
}

#[cfg(test)]
mod test {
	use crate::all_caps;
	#[test] 
	fn check_all_caps() {
		let result = all_caps("hello");
		let expected = "HELLO".to_owned()
		assert_eq!(result, expected, "String should be all uppercase");
	}
}

Variables and data types

Constants and variables

Variables

<aside> 👉 Immutable Variables

</aside>

Their values can’t be changed after they have been assigned a value, and this behaviour is enforced by default.

<aside> 👉 Mutable Variables

</aside>

Their values can be changed after they have been assigned a value, and we can enforce this behaviour by using the mut keyword.

//Implicit Type Declaration
let two = 2;
let hello = "hello";
let j = 'j';
let my_half = 0.5;
let mut my_name = "Bill"
let quit_program = false;

//Explicit Type Declaration
let num: i32 = 10;

//Constant declaration
const NAME_OF_CONSTANT: u32 = 50;

<aside> 👉 Shadowing and compile time binding

</aside>

• If we say, let x = 5, it means x is a immutable variable and is bound to 5 during compile time.
• Shadowing is different from making a variable as mutable, because we’ll get a compile time error if we try to change the binding of a immutable variable, while on the other hand, in case of mutable variables, it’s possbile.

let x = 10; // x is immutable
x += 5;     // this would lead to a compile time error as we can't change the binding
let x = 15  //this is perfectly legal as the new x variable shadows the previous x variable. This x is different from the previous x.

let spaces = "   ";
let spaces = spaces.len(); //new shadowing the previous spaces

let spaces = "   ";
spaces = spaces.len(); //compile time error because the type binding of spaces is a String, and now we're trying to change

Constants

• Constants are always immutable in nature, they’re different from immutable variables,
• They can only set to be equal to expressions, not the result of something that could be computed at runtime.
• They must always be type annotated
• Their lifetime is same as that of the program and they’re accessible within the scope they’re defined it

Primitive data types