developer-notes/learning_rust.md at main · avalokkumar/developer-notes

Introduction

Why Rust?

Rust is a modern systems programming language that provides a number of benefits over other programming languages. Here are some of the reasons why you might want to consider using Rust for your next project:

Memory safety: Rust's ownership and borrowing model makes it possible to write code that is memory safe, without relying on garbage collection or manual memory management. This can help prevent common memory-related errors like null pointer dereferencing and buffer overflows.
Performance: Rust is designed to be a fast and efficient language, making it a good choice for systems programming and other performance-critical applications. Its performance is comparable to C or C++, but with greater safety guarantees.
Concurrency: Rust's ownership model and support for message passing make it well-suited for concurrent programming. Rust's type system and borrowing rules help prevent common concurrency errors like data races and deadlocks.
Expressiveness: Rust is a modern language with a syntax that is designed to be easy to read and write. Its features, such as pattern matching, closures, and traits, make it possible to write expressive and flexible code.
Growing ecosystem: Rust has a growing ecosystem of libraries, tools, and frameworks, making it easier to get started with the language and to build complex systems. It also has a vibrant community of developers who are working on a wide range of projects, from web development to embedded systems.

Basic Programs

Hello World

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

Example program in Rust that prompts the user to enter their name, reads the input from the command line, and then prints a personalized greeting:

use std::io;

fn main() {
    println!("Please enter your name:");

    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read line");

    println!("Hello, {}! Nice to meet you.", name.trim());
}

Getting Started

Basic Formatting

In Rust, basic formatting can be done using the println! macro, which works similarly to the printf function in C and other languages.

The println! macro takes a format string as its first argument, followed by any number of values to be formatted and printed. The format string is a string literal that can contain placeholders for the values to be printed. Here's an example:

let x = 42;
let y = 3.14;
let name = "Alice";

println!("x = {}, y = {:.2}, name = {}", x, y, name);

In this example, the format string contains three placeholders:

{} is a placeholder for the first value, x, which will be printed as an integer.
{:.2} is a placeholder for the second value, y, which will be printed as a floating-point number with two decimal places.
{} is a placeholder for the third value, name, which will be printed as a string.

The values to be printed are passed as additional arguments to the println! macro, in the order they appear in the format string.

Here are some more examples of using the println! macro with various formatting options:

Using the `println!` macro with formatting

let x = 42;
let y = 3.14159265;
let s = "hello, world!";
let arr = [1, 2, 3];

println!("x = {}", x);                    // x = 42
println!("y = {:.2}", y);                  // y = 3.14
println!("s = {}", s);                     // s = hello, world!
println!("arr = {:?}", arr);               // arr = [1, 2, 3]
println!("arr = {:#?}", arr);              // arr = [
                                           //     1,
                                           //     2,
                                           //     3,
                                           // ]

In these examples, the format string contains placeholders for the values x, y, s, and arr. The {:} syntax is used to format the values as strings, with {:.2} used to format the y value as a floating-point number with two decimal places. The {:?} syntax is used to format the arr value as a debug string, which prints the array with square brackets and commas. The :#? syntax is used to print the array with each element on its own line, indented with two spaces and surrounded by square brackets.

Using the `format!` macro and `std::fmt`

The format! macro and std::fmt module provide a more powerful and flexible way to format values in Rust. Here's an example that defines a custom Person struct and implements the std::fmt::Display trait to customize how instances of the Person struct are formatted:

use std::fmt;

struct Person {
    name: String,
    age: u32,
}

impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} ({} years old)", self.name, self.age)
    }
}

fn main() {
    let alice = Person { name: "Alice".to_string(), age: 25 };
    let bob = Person { name: "Bob".to_string(), age: 30 };

    println!("{} and {}", alice, bob);
}

n this example, the Person struct has two fields, name and age, and the std::fmt::Display trait is implemented for the struct. The fmt() method is called when a value of the Person type is formatted using the println! macro or other formatting macros. In this case, the fmt() method formats the name and age fields using the write!() `macro, which writes the formatted string to a buffer.

When the println! macro is called with alice and bob as arguments, the fmt() method is called for each value, and the resulting formatted strings are printed to the console. The output should look like this:

Custom formatting traits

Here's an example that defines a custom Color struct and implements the std::fmt::Display trait to customize how instances of the Color struct are formatted:

use std::fmt;

struct Color {
    red: u8,
    green: u8,
    blue: u8,
}

impl fmt::Display for Color {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {}, {})", self.red, self.green, self.blue)
    }
}

fn main() {
    let c = Color { red: 255, green: 165, blue: 0 };
    println!("The color is {}", c);
}

In this example, the Color struct has three fields, red, green, and blue, and the std::fmt::Display trait is implemented for the struct. The fmt() method is called when a value of the Color type is formatted using the println! macro or other formatting macros. In this case, the fmt() method formats the red, green, and blue fields using the write!() macro.

When the println! macro is called with c as an argument, the fmt() method is called for the Color value, and the resulting formatted string is printed to the console. The output should look like this:

Output:

The color is (255, 165, 0)

Alignment and padding

Here's an example that demonstrates how to use alignment and padding with the println! macro:

let x = 42;
let y = 3.14159265;
let s = "hello, world!";

println!("{:8}", x);                      // "      42"
println!("{:>8}", x);                     // "      42"
println!("{:<8}", x);                     // "42      "
println!("{:^8}", x);                     // "   42   "
println!("{:08}", x);                     // "00000042"
println!("{:+8}", x);                     // "     +42"
println

Different printing styles in rust

println!(): The println!() macro prints output to the console and automatically adds a newline character (\n) to the end of the output.

Example:

let name = "Alice";
let age = 30;
println!("Hello, {}! You are {} years old.", name, age);

Output:

Hello, Alice! You are 30 years old.

print!(): The print!() macro is similar to println!(), but it does not add a newline character to the end of the output. Example:

let name = "Bob";
let age = 25;
print!("{} is {} years old. ", name, age);
print!("He is a software developer.");

Output Bob is 25 years old. He is a software developer.

format!(): The format!() macro formats a string and returns the resulting string as a value. This is useful if you want to create a formatted string and then use it in a context where you cannot use the println!() or print!() macros, such as when returning a value from a function. Example:

let name = "Charlie";
let age = 20;
let message = format!("{} is {} years old.", name, age);
println!("{}", message);

Output

Charlie is 20 years old.

eprintln!() and eprint!(): These macros work like println!() and print!(), but print to the standard error stream instead of standard output.

Example:

let error_message = "File not found";
eprintln!("Error: {}", error_message);

Output

Error: File not found

dbg!(): This macro is used for debugging purposes and prints the expression that is passed to it, along with the file name and line number where it was called. Example:

let x = 42;
let y = 3.14;
let z = "Hello";
dbg!(x, y, z);

Output

[src/main.rs:4] x = 42
[src/main.rs:4] y = 3.14
[src/main.rs:4] z = "Hello"

Adding Comments

In Rust, there are two ways to add comments: single-line comments and multi-line comments.

Single-line comments: A single-line comment starts with // and continues to the end of the line. It can be used to add a short comment on a single line of code.

// This is a single-line comment
let x = 42; // You can also add a comment at the end of a line

Multi-line comments: A multi-line comment starts with /* and ends with */. It can be used to add a longer comment that spans multiple lines of code.

/*
This is a multi-line comment.
It can span multiple lines of code.
*/
let x = 42;

Rust also supports Rustdoc-style comments, which are used to generate documentation for your code. These comments start with /// or //!, and are explained in more detail in the Rust documentation.

Variables

In Rust, a variable is a named memory location that can hold a value. The value stored in a variable can be of a particular type, and its type is determined at the time of declaration.

In Rust, variables are immutable by default, which means that their value cannot be changed after they have been assigned. To make a variable mutable, you need to use the mut keyword when declaring it.

Here's an example of how to declare a variable in Rust:

let x: i32 = 42;

In this example, x is a variable of type i32 (a 32-bit signed integer), and it is initialized to the value 42. Since we didn't use the mut keyword, x is an immutable variable, which means that we cannot change its value later in the code.

If we want to make x mutable, we can use the mut keyword:

let mut x: i32 = 42;
x = 10; // This is allowed because x is now mutable

In this example, x is declared as a mutable variable using the mut keyword. We can then assign a new value to x later in the code.

Rust also supports shadowing, which is a way to re-declare a variable with the same name as an existing variable. When you shadow a variable, the new variable takes precedence over the previous one, and the old variable becomes inaccessible.

Here's an example of variable shadowing in Rust:

let x: i32 = 42;
let x: f64 = 3.14; // This shadows the previous variable x

In this example, we first declare x as a variable of type i32. We then declare a new variable with the same name x, but this time it's of type f64. This shadows the previous variable x, and we can no longer access its value or type.

Categories of types: scalar types and compound types. Each category includes several types that can be used to declare variables.

Scalar types: Scalar types represent a single value. Rust has four primary scalar types: integers, floating-point numbers, booleans, and characters.

Integers: Integers are whole numbers. Rust supports signed and unsigned integers of various sizes, from 8 bits to 128 bits.

let a: i8 = -128; // signed 8-bit integer
let b: u16 = 65535; // unsigned 16-bit integer
let c: i32 = 42; // signed 32-bit integer
let d: u64 = 1000000; // unsigned 64-bit integer

Floating-point numbers: Floating-point numbers are numbers with a decimal point. Rust supports f32 (single-precision) and f64 (double-precision) floating-point numbers.

let a: f32 = 3.14; // single-precision floating-point number
let b: f64 = 3.141592653589793238; // double-precision floating-point number

Booleans: Booleans represent a value of either true or false.

let a: bool = true; // boolean with value true
let b: bool = false; // boolean with value false

Characters: Characters represent a single Unicode scalar value, and are declared using single quotes.

let a: char = 'a'; // character 'a'
let b: char = '😀'; // character '😀' (a smiley face)

Compound types: Compound types are types that group multiple values into one type. Rust has two primary compound types: tuples and arrays.

Tuples: Tuples are a fixed-length sequence of values of different types. You can access individual elements of a tuple using indexing, starting at 0.

let a: (i32, f64, char) = (42, 3.14, 'a'); // a tuple with three values
let b = a.0; // the first element of the tuple (42)
let c = a.1; // the second element of the tuple (3.14)
let d = a.2; // the third element of the tuple ('a')

Arrays: Arrays are a fixed-length sequence of values of the same type. You can access individual elements of an array using indexing, starting at 0.

let a: [i32; 3] = [1, 2, 3]; // an array with three elements
let b = a[0]; // the first element of the array (1)
let c = a[1]; // the second element of the array (2)
let d = a[2]; // the third element of the array (3)

Scope

In Rust, scope refers to the area of the code where a variable is valid and can be accessed. A variable's scope is determined by where it is declared in the code. When a variable is declared, it is valid from that point forward until the end of the block in which it is declared.

a variable's scope refers to the part of the code where it is valid and can be accessed. The scope of a variable is determined by the block in which it is declared.

A block is defined as a section of code that is delimited by a pair of curly braces {}. In Rust, variables declared inside a block are only valid and accessible within that block, and they are dropped (or destroyed) when the block ends. This is known as the variable's lifetime.

Here's an example that illustrates variable scope and lifetime in Rust:

fn main() {
    let x = 42; // Declare a variable named 'x' with a value of 42.
    { // This is a new block.
        let y = "hello"; // Declare a variable named 'y' with a value of "hello".
        println!("x = {}, y = {}", x, y); // Print both 'x' and 'y'.
    } // 'y' goes out of scope and is dropped here.
    println!("x = {}", x); // Print 'x'.
} // 'x' goes out of scope and is dropped here.

In this example, the variable x is declared in the outer block and is valid throughout the entire main function. The variable y is declared inside a new block and is only valid within that block. Once the block ends, the variable y goes out of scope and is dropped. The variable x remains in scope until the end of the main function.

Blocks can be nested, and variables declared in an outer block can be accessed by an inner block, but variables declared in an inner block cannot be accessed by an outer block. Here's an example:

fn main() {
    let x = 42; // Declare a variable named 'x' with a value of 42.
    { // This is an outer block.
        let y = "hello"; // Declare a variable named 'y' with a value of "hello".
        { // This is an inner block.
            let z = true; // Declare a variable named 'z' with a value of true.
            println!("x = {}, y = {}, z = {}", x, y, z); // Print all three variables.
        } // 'z' goes out of scope and is dropped here.
        println!("x = {}, y = {}", x, y); // Print 'x' and 'y'.
    } // 'y' goes out of scope and is dropped here.
    println!("x = {}", x); // Print 'x'.
} // 'x' goes out of scope and is dropped here.

In this example, the variable x is declared in the outermost block and is valid throughout the entire main function. The variable y is declared in the outer block and is valid within that block and any inner blocks. The variable z is declared in the inner block and is only valid within that block. Once the inner block ends, the variable z goes out of scope and is dropped. The variable y remains in scope until the outer block ends, and the variable x remains in scope until the end of the main function.

Shadowing

Shadowing is a feature in Rust that allows you to declare a new variable with the same name as an existing variable, effectively shadowing the existing variable. The new variable temporarily replaces the old variable within its scope.

Here's an example that illustrates shadowing in Rust:

fn main() {
    let x = 42; // Declare a variable named 'x' with a value of 42.
    println!("x = {}", x); // Print 'x'.
    let x = "hello"; // Declare a new variable named 'x' with a value of "hello". This shadows the previous 'x' variable.
    println!("x = {}", x); // Print 'x'.
}

In this example, the variable x is declared with an initial value of 42. We then print the value of x, which is 42. We then declare a new variable named x with a value of "hello". This new variable shadows the previous x variable, effectively hiding it from view. We then print the value of x again, which is now "hello".

Shadowing can also be used to change the type of a variable. Here's an example:

fn main() {
    let x = 42; // Declare a variable named 'x' with a value of 42.
    println!("x = {}", x); // Print 'x'.
    let x = x.to_string(); // Declare a new variable named 'x' that shadows the previous 'x' variable, and convert it to a string.
    println!("x = {}", x); // Print 'x'.
}

In this example, we start with a variable named x that has a value of 42. We then declare a new variable also named x, which shadows the previous x variable. We convert the new x variable to a string using the to_string() method, and then print its value, which is now a string.

Here's an example that illustrates both scope and shadowing:

fn main() {
    let x = 42; // Declare a variable named 'x' with a value of 42.
    {
        let y = 3.14; // Declare a variable named 'y' with a value of 3.14.
        println!("x = {}, y = {}", x, y); // Print both 'x' and 'y'.
        let x = "hello"; // Shadow the 'x' variable with a new value of "hello".
        println!("x = {}, y = {}", x, y); // Print the shadowed 'x' and 'y'.
    }
    // The 'y' variable is no longer valid outside of its scope.
    // The original 'x' variable is still valid outside of its shadowed scope.
    println!("x = {}", x); // Print the original 'x' variable.
}

In this example, the variable x is declared outside of the block, so it is valid throughout the entire main function. The variable y is declared inside the block, so it is only valid within that block.

We then shadow the variable x with a new value of "hello" inside the block. This new value of x is only valid within the block, so it doesn't affect the original value of x declared outside the block.

Finally, we print the original value of x outside of the block.

Data types

In Rust, data types specify the kinds of values that can be stored and manipulated within a program. Rust is a statically typed language, which means that data types must be explicitly defined before they can be used.

Here are the list of data types in Rust:

1. Numeric types: i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, and f64.

i8: A signed 8-bit integer that can represent values in the range of -128 to 127. Example: let my_num: i8 = -42;
i16: A signed 16-bit integer that can represent values in the range of -32,768 to 32,767. Example: let my_num: i16 = 1234;
i32: A signed 32-bit integer that can represent values in the range of -2,147,483,648 to 2,147,483,647. Example: let my_num: i32 = -987654321;
i64: A signed 64-bit integer that can represent values in the range of -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Example: let my_num: i64 = 123456789012345;
i128: A signed 128-bit integer that can represent values in the range of -170,141,183,460,469,231,731,687,303,715,884,105,728 to 170,141,183,460,469,231,731,687,303,715,884,105,727. Example: let my_num: i128 = -12345678901234567890;
isize: A signed integer whose size is the same as the architecture's pointer size. On most modern machines, this is equivalent to i64. Example: let my_num: isize = -42;
u8: An unsigned 8-bit integer that can represent values in the range of 0 to 255. Example: let my_num: u8 = 42;
u16: An unsigned 16-bit integer that can represent values in the range of 0 to 65,535. Example: let my_num: u16 = 12345;
u32: An unsigned 32-bit integer that can represent values in the range of 0 to 4,294,967,295. Example: let my_num: u32 = 987654321;
u64: An unsigned 64-bit integer that can represent values in the range of 0 to 18,446,744,073,709,551,615. Example: let my_num: u64 = 123456789012345;
u128: An unsigned 128-bit integer that can represent values in the range of 0 to 340,282,366,920,938,463,463,374,607,431,768,211,455. Example: let my_num: u128 = 12345678901234567890;
usize: An unsigned integer whose size is the same as the architecture's pointer size. On most modern machines, this is equivalent to u64. Example: let my_num: usize = 42;
f32: A 32-bit floating-point number. Example: let my_num: f32 = 3.14159;
f64: A 64-bit floating-point number. Example: `let my_num: f64 = 3.141592653589793;

fn main() {
    // Signed integer types (i8, i16, i32, i64, i128, isize)
    let a: i8 = -10;
    let b: i16 = -20;
    let c: i32 = -30;
    let d: i64 = -40;
    let e: i128 = -50;
    let f: isize = -60;

    // Unsigned integer types (u8, u16, u32, u64, u128, usize)
    let g: u8 = 10;
    let h: u16 = 20;
    let i: u32 = 30;
    let j: u64 = 40;
    let k: u128 = 50;
    let l: usize = 60;

    // Floating-point types (f32, f64)
    let m: f32 = 3.14159;
    let n: f64 = 2.71828;

    println!("Signed integers: {}, {}, {}, {}, {}, {}", a, b, c, d, e, f);
    println!("Unsigned integers: {}, {}, {}, {}, {}, {}", g, h, i, j, k, l);
    println!("Floating-point numbers: {}, {}", m, n);
}

Output

Signed integers: -10, -20, -30, -40, -50, -60
Unsigned integers: 10, 20, 30, 40, 50, 60
Floating-point numbers: 3.14159, 2.71828

2. Boolean type: bool.

bool is a built-in data type that can only have one of two values: true or false. This data type is often used in conditional statements and logic expressions.

Here is an example that demonstrates the usage of the bool type in Rust:

fn main() {
    let x = 5;
    let y = 10;
    let is_greater = x > y; // is_greater has type bool

    if is_greater {
        println!("x is greater than y");
    } else {
        println!("x is not greater than y");
    }
}

In this example, the variables x and y are assigned integer values. The variable is_greater is assigned the result of the expression x > y, which will evaluate to false since x is not greater than y. The if statement uses is_greater as a condition, and prints a message to the console depending on its value.

The bool type can also be used in conjunction with logical operators like && (logical AND), || (logical OR), and ! (logical NOT). Here is an example that demonstrates their usage:

fn main() {
    let a = true;
    let b = false;
    let c = true;

    println!("a AND b = {}", a && b); // prints "a AND b = false"
    println!("a OR b = {}", a || b); // prints "a OR b = true"
    println!("NOT a = {}", !a);      // prints "NOT a = false"
    println!("NOT b = {}", !b);      // prints "NOT b = true"
    println!("a AND b OR c = {}", a && b || c); // prints "a AND b OR c = true"
}

In this example, three boolean variables are defined with values of true, false, and true, respectively. The program then uses logical operators to combine these values and print the result to the console.

3. Character type: char.

the char type represents a single Unicode scalar value, which can be a letter, number, symbol, or whitespace character. char values are enclosed in single quotes, like this: 'a'.

Here is an example that demonstrates the usage of the char type in Rust:

fn main() {
    let c1 = 'a';
    let c2 = 'B';
    let c3 = '💻'; // Unicode scalar value for computer emoji

    println!("c1 = {}", c1); // prints "c1 = a"
    println!("c2 = {}", c2); // prints "c2 = B"
    println!("c3 = {}", c3); // prints "c3 = 💻"
}

In this example, the char type is used to define three variables, c1, c2, and c3. The first two variables hold ASCII characters, while the third variable holds a non-ASCII character represented by a Unicode scalar value.

The char type can also be used in loops and iteration. Here is an example that demonstrates this:

fn main() {
    let word = "hello";
    for c in word.chars() {
        println!("{}", c);
    }
}

In this example, the chars method is called on a string value to create an iterator over its char values. The program then uses a for loop to iterate over the char values and print each one to the console on a separate line.

Example of using the char type and the chars method to count the occurrences of each letter in a string:

fn main() {
    let sentence = "The quick brown fox jumps over the lazy dog";
    let mut letter_count = [0; 26];

    for c in sentence.chars() {
        if c.is_ascii_alphabetic() {
            let index = (c.to_ascii_lowercase() as u8 - b'a') as usize;
            letter_count[index] += 1;
        }
    }

    for (i, count) in letter_count.iter().enumerate() {
        let letter = (b'a' + i as u8) as char;
        println!("{}: {}", letter, count);
    }
}

In this example, the program counts the occurrences of each letter in the string sentence. It uses the chars method to iterate over each char value in the string, and checks if the char is an ASCII alphabetic character using the is_ascii_alphabetic method. If the char is a letter, the program converts it to lowercase using the to_ascii_lowercase method and subtracts the ASCII value of 'a' to determine the index in the letter_count array to increment.

Finally, the program uses a second for loop to iterate over the letter_count array and print the count of each letter to the console.

This example demonstrates a few important features of working with char values in Rust, including handling of Unicode characters, case conversion, and byte manipulation using the u8 type.

4. String type: String, &str.

String and &str are used to represent text or string data.

String is a growable, heap-allocated string type, and is typically used when you need to build up a string dynamically or when you want to own a string value. You can create a new String by using the String::new() method, or by converting from a string literal using the String::from() method:

let s1 = String::new();
let s2 = String::from("hello, world");

You can also append to a String using the push_str() or push() methods:

let mut s = String::from("hello");
s.push_str(", world");
s.push('!');

In addition to the basic operations, you can also use String methods like split() and join() to split or join strings:

let words = "The quick brown fox".split(" ");
let joined = words.collect::<Vec<&str>>().join("-");
assert_eq!(joined, "The-quick-brown-fox");

&str, on the other hand, is a borrowed string slice type, and is typically used when you want to reference an existing string value without owning it. &str is often used as function parameters to accept string arguments without copying the original string. You can create a new &str by using string literals:

let s = "hello, world";

You can also create a &str from a String by using the & operator to create a reference:

let s1 = String::from("hello");
let s2: &str = &s1;

&str values are often used as function arguments to accept string input without taking ownership of the input string. For example, the println!() macro accepts &str arguments:

let name = "Alice";
println!("Hello, {}!", name);

Using String and &str allows Rust programs to work with text in a flexible and efficient way, and is an important part of Rust's string handling capabilities.

5. Array type: [T; N].

An array is a collection of values of the same type stored in contiguous memory locations. The size of an array is fixed and specified at the time of declaration, and it cannot be changed later. The syntax for declaring an array in Rust is [T; N], where T is the type of the elements in the array and N is the number of elements in the array.

Here is an example of how to declare and use an array in Rust:

// Declare an array of four integers
let numbers: [i32; 4] = [1, 2, 3, 4];

// Access the elements of the array using indexing
println!("The first number is {}", numbers[0]); // prints "The first number is 1"
println!("The second number is {}", numbers[1]); // prints "The second number is 2"

// Arrays can be initialized with the same value for all elements
let zeros: [i32; 5] = [0; 5]; // creates an array of 5 integers, all set to 0

// We can also initialize an array with default value
let mut nums = [0; 5]; // This creates an array of 5 integers, all set to 0

// We can mutate the array as well
nums[2] = 5; // Set the value of the third element to 5

// Iterate through the array using a loop
for i in 0..numbers.len() {
    println!("The {}th number is {}", i+1, numbers[i]);
}

In the example above, we declare an array numbers of type i32 with 4 elements and initialize it with values. We then access the elements of the array using indexing and print them. We also declare an array zeros of type i32 with 5 elements and initialize all the elements to 0. We mutate the nums array and set the value of the third element to 5. Finally, we iterate through the numbers array using a loop and print the values of the elements.

Example of using arrays in Rust to count the frequency of numbers in a given array.

fn count_frequency(arr: [i32; 10]) -> [i32; 10] {
    let mut freq = [0; 10];
    for &num in arr.iter() {
        freq[num as usize] += 1;
    }
    freq
}

fn main() {
    let arr = [1, 3, 5, 2, 5, 1, 2, 3, 4, 4];
    let freq = count_frequency(arr);
    for (i, &count) in freq.iter().enumerate() {
        println!("{} occurs {} times", i, count);
    }
}

In this example, we define a function called count_frequency that takes an array of 10 integers ([i32; 10]) as input and returns an array of 10 integers as output. The function uses another array called freq to keep track of the frequency of each number in the input array. It then iterates over the input array using the iter() method and updates the corresponding frequency count in freq. Finally, it returns the freq array.

In the main function, we define an input array arr and call the count_frequency function with arr as the argument. We then iterate over the resulting freq array using the iter().enumerate() method, which returns a sequence of tuples containing the index and value of each element in the array. We use the enumerate() method to print out the frequency of each number in a human-readable format.

6. Slice type: &[T], &mut [T].

Slices are another data type in Rust that allows to reference a contiguous sequence of elements in a collection. Slices are similar to arrays but they are dynamically sized and allow to reference a part of the original array. There are two types of slices in Rust: immutable slices represented by &[T] and mutable slices represented by &mut [T].

Immutable slices allow read-only access to the data, while mutable slices allow read and write access to the data. They are commonly used as function parameters and return types, as they allow to work with a part of the original data without copying it.

Here's an example of using slices:

fn main() {
    let my_array = [1, 2, 3, 4, 5];

    // Create a slice that references the entire array
    let slice1 = &my_array[..];

    // Create a slice that references the last three elements of the array
    let slice2 = &my_array[2..];

    // Create a mutable slice that references the middle three elements of the array
    let mut_slice = &mut my_array[1..4];

    println!("slice1: {:?}", slice1); // [1, 2, 3, 4, 5]
    println!("slice2: {:?}", slice2); // [3, 4, 5]

    mut_slice[0] = 9; // Change the first element of the mutable slice
    println!("my_array: {:?}", my_array); // [1, 9, 4, 5, 5]
}

In this example, we first create an array my_array containing five integers. We then create two immutable slices: slice1, which references the entire array, and slice2, which references the last three elements of the array. We also create a mutable slice mut_slice, which references the middle three elements of the array.

We then print the contents of slice1 and slice2 using the println! macro. Next, we change the first element of the mut_slice to 9. Finally, we print the contents of my_array again to demonstrate that the change to the mutable slice has modified the original array.

Example:

Suppose we want to implement a function that takes in a vector of integers and returns the maximum and minimum values in the vector. We can use slices to pass a reference to the vector instead of passing the entire vector to the function.

fn find_min_max(numbers: &[i32]) -> (i32, i32) {
    let mut min = numbers[0];
    let mut max = numbers[0];
    for &num in numbers {
        if num < min {
            min = num;
        }
        if num > max {
            max = num;
        }
    }
    (min, max)
}

fn main() {
    let numbers = vec![4, 6, 2, 8, 5, 10, 3];
    let (min, max) = find_min_max(&numbers);
    println!("Minimum: {}", min);
    println!("Maximum: {}", max);
}

In this example, the find_min_max function takes a slice of integers (&[i32]) as its argument. Inside the function, we initialize two variables, min and max, to the first element of the slice. We then iterate over the slice using a for loop, comparing each element to the current values of min and max. If we find an element that is smaller than min, we update min. If we find an element that is larger than max, we update max.

In main, we create a vector of integers and pass a reference to it (&numbers) to the find_min_max function. We then use destructuring to assign the return values to the min and max variables, and print out the results.

7. Tuple type: (T1, T2, ..., Tn).

A tuple is a collection of values of different types. Tuples are created by enclosing the values within parentheses and separating them with commas.

Here's an example of a simple tuple:

let my_tuple = (1, "hello", 4.2);

In the above example, my_tuple is a tuple that contains an integer with value 1, a string with value "hello", and a float with value 4.2.

We can access the elements of the tuple using dot notation and the index of the element we want to access, starting from 0. For example, to access the second element of the tuple my_tuple, we would use the following code:

let second_element = my_tuple.1;

In this case, second_element would be the string "hello", since it is the second element of the tuple.

Tuples can also be used to return multiple values from a function, as in the following example:

fn split_name(name: &str) -> (&str, &str) {
    let parts: Vec<&str> = name.split(' ').collect();
    (parts[0], parts[1])
}

fn main() {
    let full_name = "John Smith";
    let (first_name, last_name) = split_name(full_name);
    println!("First name: {}", first_name);
    println!("Last name: {}", last_name);
}

In the above example, the split_name function takes a string and returns a tuple containing the first and last names. The main function calls split_name with a full name, and then uses pattern matching to extract the first and last names from the tuple, which are then printed to the console.

8. Struct type: struct.

A struct is a custom data type that allows you to group multiple values of different types under a single name. It is similar to a class in object-oriented programming languages.

A struct is defined using the struct keyword followed by the name of the struct and the body of the struct, which contains the fields or members of the struct. Each field is declared with a name and a type separated by a colon. You can also define methods on a struct.

Here's an example of a struct that represents a point in 2D space:

struct Point {
    x: f32,
    y: f32,
}

impl Point {
    fn distance(&self, other: &Point) -> f32 {
        ((other.x - self.x).powi(2) + (other.y - self.y).powi(2)).sqrt()
    }
}

In this example, the Point struct has two fields of type f32: x and y. The impl block defines a method named distance that takes a reference to another Point and returns the Euclidean distance between the two points.

You can create instances of the Point struct using the struct literal syntax:

let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 3.0, y: 4.0 };

You can access the fields of a struct using the dot notation:

println!("p1.x = {}", p1.x); // prints "p1.x = 0"
println!("p2.y = {}", p2.y); // prints "p2.y = 4"

You can also call methods on a struct:

println!("distance between p1 and p2 = {}", p1.distance(&p2)); // prints "distance between p1 and p2 = 5"

In addition to defining methods, you can also implement traits on a struct, which allows you to define behavior that is shared across multiple types. Rust provides a derive attribute that allows you to automatically generate implementations of common traits like Debug, Clone, and Copy. For example, you can add #[derive(Debug)] to the Point struct to make it printable with the {:?} format specifier:

#[derive(Debug)]
struct Point {
    x: f32,
    y: f32,
}

fn main() {
    let p = Point { x: 1.0, y: 2.0 };
    println!("p = {:?}", p); // prints "p = Point { x: 1.0, y: 2.0 }"
}

9. Enum type: enum.

An enum is a data type that allows you to define a type by enumerating its possible values. An enum consists of a set of named constants called variants. Each variant can have zero or more fields associated with it.

Here is the syntax for defining an enum in Rust:

enum MyEnum {
    Variant1,
    Variant2,
    Variant3(u32, String),
    Variant4 {x: i32, y: i32}
}

In this example, MyEnum is the name of the enum. It has four variants:

Variant1 has no associated data.
Variant2 has no associated data.
Variant3 has two associated fields: a u32 and a String.
Variant4 has one associated field: a struct with two fields, x and y.

Here is an example of how to use the enum:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        },
    }
}

fn main() {
    let coin = Coin::Quarter(UsState::Alaska);
    let value = value_in_cents(coin);
    println!("The value of the coin is {} cents.", value);
}

In this example, Coin is an enum with four variants: Penny, Nickel, Dime, and Quarter. Quarter has one field, which is an instance of the UsState enum. The value_in_cents function takes a Coin as an argument, matches on the variant, and returns the corresponding value in cents. The main function creates a Coin instance and passes it to value_in_cents.

10. Pointer types: const T, mut T, Box, Rc, Arc, Cell, RefCell.

Pointer types in Rust allow you to manage and manipulate memory in different ways.

Here are some of the pointer types in Rust and their usage:

** Raw pointers:** Raw pointers in Rust are similar to C-style pointers, but with a few safety features. There are two kinds of raw pointers: *const T and *mut T. *const T is an immutable raw pointer, while *mut T is a mutable raw pointer. Raw pointers allow you to access and manipulate memory directly, which can be useful for working with low-level code or when interfacing with other languages. However, they can also be unsafe, as Rust can't guarantee that the memory being pointed to is valid or initialized. Here is an example of using raw pointers:

let mut x = 10;
let raw_ptr = &mut x as *mut i32;
unsafe {
    *raw_ptr = 20;
}
println!("{}", x); // prints 20

Box: Box is a smart pointer that provides heap allocation of memory for a value. It is a common way to create a reference to a value that can be allocated on the heap. It provides a convenient way to create and use recursive data structures, among other things. Box is similar to std::unique_ptr in C++. Here's an example of using Box:

struct Node {
    value: i32,
    next: Option<Box<Node>>,
}

let mut node = Node {
    value: 1,
    next: Some(Box::new(Node {
        value: 2,
        next: None,
    })),
};

println!("{}", node.value); // prints 1
if let Some(next_node) = node.next {
    println!("{}", next_node.value); // prints 2
}

Rc: Rc is a reference-counted smart pointer, which allows multiple ownership of a value. It is a common way to share data between multiple parts of a program that need to read the data. The Rc type provides a way to share a value between different parts of the program. Here's an example of using Rc:

use std::rc::Rc;

struct Node {
    value: i32,
    next: Option<Rc<Node>>,
}

let node = Rc::new(Node {
    value: 1,
    next: Some(Rc::new(Node {
        value: 2,
        next: None,
    })),
});

println!("{}", node.value); // prints 1
if let Some(next_node) = node.next.as_ref() {
    println!("{}", next_node.value); // prints 2
}

Arc: Arc is an atomically reference-counted smart pointer, which allows multiple ownership of a value across multiple threads. It is similar to Rc, but is thread-safe. Here's an example of using Arc:

use std::sync::Arc;
use std::thread;

struct Node {
    value: i32,
    next: Option<Arc<Node>>,
}

let node = Arc::new(Node {
    value: 1,
    next: Some(Arc::new(Node {
        value: 2,
        next: None,
    })),
});

let node1 = Arc::clone(&node);
let handle = thread::spawn(move || {
    println!("{}", node1.value); // prints 1
    if let Some(next_node) = node1.next.as_ref() {
        println!("{}", next_node.value); // prints 2
    }
});

handle.join().unwrap();

Cell and RefCell: Cell and RefCell are two types in Rust that are used for interior mutability. They allow you to mutate the contents of a value, even if that value is immutable.

Cell provides interior mutability for a single value, while RefCell provides interior mutability for a value with dynamically checked borrow rules.

Here's how they work:

- Cell:

Cell is a simple type that holds a single value of type T. The value can be accessed and modified via the get and set methods, respectively. The get method returns a copy of the value, while the set method takes a new value and replaces the current one.

Cell is useful for cases where you need to mutate a value that is otherwise immutable. For example, you may have an immutable configuration object that is used throughout your program, but you need to be able to update certain fields of the configuration at runtime. In this case, you could use a Cell to hold the configuration object and update the necessary fields using the set method.

Here's an example:

use std::cell::Cell;

struct Config {
    max_connections: Cell<usize>,
    timeout: Cell<u64>,
}

impl Config {
    fn new(max_connections: usize, timeout: u64) -> Config {
        Config {
            max_connections: Cell::new(max_connections),
            timeout: Cell::new(timeout),
        }
    }

    fn set_max_connections(&self, max_connections: usize) {
        self.max_connections.set(max_connections);
    }

    fn set_timeout(&self, timeout: u64) {
        self.timeout.set(timeout);
    }
}

- RefCell: RefCell<T> is a more complex type that provides interior mutability with dynamic borrow checking. It allows you to borrow a reference to the value, either as mutable or immutable, and Rust will enforce the borrowing rules at runtime.

RefCell<T> is useful in cases where you need to mutate a value that is shared between multiple parts of your program. For example, you may have a cache that is accessed by multiple threads, and you need to update the cache without causing data races. In this case, you could use a RefCell<T> to hold the cache and borrow references to it as needed.

Here's an example:

use std::cell::RefCell;

struct Cache {
    data: RefCell<Vec<u32>>,
}

impl Cache {
    fn new() -> Cache {
        Cache {
            data: RefCell::new(Vec::new()),
        }
    }

    fn add_item(&self, item: u32) {
        self.data.borrow_mut().push(item);
    }

    fn get_items(&self) -> Vec<u32> {
        self.data.borrow().clone()
    }
}

In this example, the Cache struct holds a Vec that is wrapped in a RefCell. The add_item method borrows a mutable reference to the Vec and adds an item to it, while the get_items method borrows an immutable reference to the Vec and returns a clone of it. Rust will ensure that the borrowing rules are enforced at runtime, preventing data races.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Introduction

Why Rust?

Basic Programs

Getting Started

Basic Formatting

Using the `println!` macro with formatting

Using the `format!` macro and `std::fmt`

Custom formatting traits

Alignment and padding

Different printing styles in rust

Adding Comments

Variables

Categories of types: scalar types and compound types. Each category includes several types that can be used to declare variables.

Scope

Shadowing

Data types

1. Numeric types: i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, and f64.

2. Boolean type: bool.

3. Character type: char.

Example of using the char type and the chars method to count the occurrences of each letter in a string:

4. String type: String, &str.

5. Array type: [T; N].

6. Slice type: &[T], &mut [T].

7. Tuple type: (T1, T2, ..., Tn).

8. Struct type: struct.

9. Enum type: enum.

10. Pointer types: const T, mut T, Box, Rc, Arc, Cell, RefCell.

11. Function types: fn(T1, T2, ..., Tn) -> R.

12. Unit type: ().

13. Never type: !.

14. Option type: Option.

15. Result type: Result<T, E>.

16. Closure type: <F as Fn<(T1, T2, ..., Tn)>>.

FilesExpand file tree

learning_rust.md

Latest commit

History

learning_rust.md

File metadata and controls

Introduction

Why Rust?

Basic Programs

Getting Started

Basic Formatting

Using the println! macro with formatting

Using the format! macro and std::fmt

Custom formatting traits

Alignment and padding

Different printing styles in rust

Adding Comments

Variables

Categories of types: scalar types and compound types. Each category includes several types that can be used to declare variables.

Scope

Shadowing

Data types

1. Numeric types: i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, and f64.

2. Boolean type: bool.

3. Character type: char.

Example of using the char type and the chars method to count the occurrences of each letter in a string:

4. String type: String, &str.

5. Array type: [T; N].

6. Slice type: &[T], &mut [T].

7. Tuple type: (T1, T2, ..., Tn).

8. Struct type: struct.

9. Enum type: enum.

10. Pointer types: *const T, *mut T, Box, Rc, Arc, Cell, RefCell.

11. Function types: fn(T1, T2, ..., Tn) -> R.

12. Unit type: ().

13. Never type: !.

14. Option type: Option.

15. Result type: Result<T, E>.

16. Closure type: <F as Fn<(T1, T2, ..., Tn)>>.

Using the `println!` macro with formatting

Using the `format!` macro and `std::fmt`

10. Pointer types: const T, mut T, Box, Rc, Arc, Cell, RefCell.