These are common Boolean values ​​that can be either true or false.

character

This type is characterized by bit width. The maximum length supported by Rust is 128 bits.

A signed integer of variable size (size depends on underlying pointer size).

Unsigned integer of variable size (size depends on underlying pointer size).

f32-bit floating point type

f64-bit floating point type

A fixed-size array, T represents the element type, N represents the number of elements, and is a non-negative constant at compile time.

A dynamically sized view of a contiguous sequence, T representing any type.

String slicing, mainly used as a reference, i.e. &str

Finite sequences, T and U can be of different types.

A function that receives an i32 type parameter and returns an i32 type parameter. Functions also have a type.

fn add(a: u64, b: u64) -> u64 { a b } fn main() { let a: u64 = 17; let b = 3; let result = add(a, b); println!("Result {}", result); }

fn main() { let doubler = |x| x * 2; let value = 5; let twice = doubler(value); println!("{} doubled is {}", value, twice); let big_closure = |b, c| { let z = b c; z * twice }; let some_number = big_closure(1, 2); println!("Result from closure: {}", some_number); }

fn main() { let question = "How are you?"; let person: String = "Bob".to_string(); let namaste = String::from("zd"); println!("{}! {} {}", namaste, question, person); }

In the above code, the type of person and namaste is String, and the type of question is &str. There are many ways to create String type data. String type data is allocated on the heap. &str type data is usually a pointer to an existing string. These strings are on the stack and heap, or they can be strings in the data segment of compiled object code.

fn main() { let rust_is_awesome = true; if rust_is_awesome { println!("Indeed"); } else { println!("Well, you should try Rust!"); } }

fn main() { let result = if 1 == 2 { "Wait, what?" } else { "Rust makes sense" }; println!("You know what? {}.", result); }

When the value to be assigned is returned from the if else expression, we need to use a semicolon as the end mark. For example, if is an expression, then let is a statement, which expects us to have a semicolon at the end.

fn req_status() -> u32 { 200 } fn main() { let status = req_status(); match status { 200 => println!("Success"), 404 => println!("Not Found"), other => { println!("Request failed with code: {}", other); } } }

fn main() { let mut x = 1024; loop { if x < 0 { break; } println!("{} more runs to go", x); x -= 1; } }

fn silly_sub(a: i32, b: i32) -> i32 { let mut result = 0; 'increment: loop { if result == a { let mut dec = b; 'decrement: loop { ifdec==0{ break 'increment; } else { result -= 1; dec -= 1; } } } else { result = 1; } } result } fn main() { let a = 10; let b = 4; let result = silly_sub(a, b); println!("{} minus {} is {}", a, b, result); }

fn main() { print!("Normal range: "); for i in 0..10 { print!("{},", i); } println!(); print!("Inclusive range: "); for i in 0..=10 { print!("(),", i); } }

In Rust, there are three forms of structure declaration. The simplest of these is the unit struct, which is declared using the keyword struct, followed by its name, and ending with a semicolon.

The second form of structure is the tuple struct, which has associated data. Each of these fields is not named, but is referenced based on their position in the definition.

Tuple structures are ideal when modeling data with less than 5 attributes. Any choice other than this will hinder code readability and reasoning. For data types with more than 3 fields, construct structures using C-like language. This is the third form and the most commonly used form.

Enumerations are a good way to do this when you need to model different types of things. It is created using the keyword enum, followed by the enumeration name and a pair of curly braces. Inside the curly braces we can write all possible types, i.e. variants. These variants can be defined with or without data, and the data contained can be any far type, structure, tuple structure, or even an enumeration type.

We can add behavior to a defined structure using two mechanisms: constructor-like functions and getter and setter methods.

Enumerations are widely used in state machines, and when used with match expressions, they can make state transition code very concise. They can also be used for modeling of custom error types.

Every Rust program requires a root module. For executable files, it is usually the main.rs file, and for libraries, it is usually the lib.rs file.

Modules can be declared inside other modules or organized into files and directories.

In order for the compiler to recognize our module, we need to use the keyword mod declaration. In our root module, we need to use the keyword use before the module name, which means bringing the element into the scope.

Elements defined in a module are private by default and need to be exposed to callers using the keyword pub.

Arrays have a fixed length and can store elements of the same type. They are represented by [T, N], where T represents any type and N represents the number of array elements. The size of the array cannot be represented by a variable and must be a literal value of usize.

subtopic