1
2
3
4
5
6
7
8
9
10
11
// Single-line comment
/* Multi-line
   comment */

// Main function - entry point of Rust program
fn main() {
    println!("Hello, Rust!");
}

// Semicolons are required to end statements
let x = 5; // Variable declaration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Integers
let integer_8: i8 = -128;      // Signed 8-bit integer
let unsigned_16: u16 = 65535;  // Unsigned 16-bit integer
let integer_64: i64 = 1_000_000; // Underscores for readability

// Floating point
let float_32: f32 = 3.14;
let float_64: f64 = 2.71828;

// Boolean
let is_true: bool = true;
let is_false: bool = false;

// Character (single Unicode scalar value)
let character: char = 'A';

// Tuple
let tuple: (i32, f64, char) = (500, 6.4, '😊');

// Unit type (similar to void in other languages)
let unit: () = ();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Vector (dynamic array)
let mut vec: Vec<i32> = vec![1, 2, 3];
vec.push(4);

// Array (fixed-size)
let array: [i32; 5] = [1, 2, 3, 4, 5];

// HashMap
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", "value");

// HashSet
use std::collections::HashSet;
let mut set = HashSet::new();
set.insert(1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Immutable variable (default)
let x = 5;
// x = 6; // This would cause a compile-time error

// Mutable variable
let mut y = 10;
y = 15; // This is allowed

// Constants (always immutable, must be type annotated)
const MAX_POINTS: u32 = 100_000;

// Shadowing (creating a new variable with same name)
let x = 5;
let x = x + 1; // x is now 6
let x = "six"; // x can change type

1
2
3
4
5
6
let sum = 5 + 10;
let difference = 95.5 - 4.3;
let product = 4 * 30;
let quotient = 56.7 / 32.2;
let remainder = 43 % 5;

1
2
3
4
5
6
7
let a = 5;
let b = 10;
let is_equal = a == b;
let is_not_equal = a != b;
let is_greater = a > b;
let is_less_or_equal = a <= b;

1
2
3
4
5
6
let x = true;
let y = false;
let and_result = x && y;  // Logical AND
let or_result = x || y;   // Logical OR
let not_result = !x;      // Logical NOT

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// If-Else
let number = 7;
if number < 5 {
    println!("Less than 5");
} else if number == 5 {
    println!("Equal to 5");
} else {
    println!("Greater than 5");
}

// Ternary-like with match
let result = match number {
    1 => "one",
    2 => "two",
    _ => "other",
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Infinite loop
loop {
    // do something
    break; // Exit loop
}

// While loop
let mut counter = 0;
while counter < 5 {
    println!("{}", counter);
    counter += 1;
}

// For loop (range)
for number in 1..5 {
    println!("{}", number);
}

// For loop with iterator
let array = [10, 20, 30, 40, 50];
for element in array.iter() {
    println!("{}", element);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Basic function
fn add(a: i32, b: i32) -> i32 {
    a + b  // Implicit return
}

// Function with explicit return
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

// Closure (lambda-like function)
let multiply = |a: i32, b: i32| a * b;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Result type for error handling
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

// Option type for nullable values
fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some("User Found".to_string())
    } else {
        None
    }
}

// Unwrapping Results and Options
let result = divide(10.0, 2.0).unwrap(); // Panics if Err
let safe_result = divide(10.0, 2.0).unwrap_or(0.0); // Default value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Basic struct
struct Rectangle {
    width: u32,
    height: u32,
}

// Struct with methods
impl Rectangle {
    // Constructor-like method
    fn new(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }

    // Method
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

// Creating and using struct
let rect = Rectangle::new(10, 20);
println!("Area: {}", rect.area());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
trait Drawable {
    fn draw(&self);
}

struct Circle {
    radius: f64,
}

impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Ownership example
fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 is moved, no longer valid
    // println!("{}", s1); // This would cause a compile error

    // Borrowing
    let s3 = String::from("world");
    let len = calculate_length(&s3); // Borrowing with reference
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
use std::thread;
use std::sync::mpsc;

fn main() {
    // Creating a thread
    let handle = thread::spawn(|| {
        println!("Thread work");
    });

    // Channels for thread communication
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });
}

// Async/Await (requires tokio runtime)
async fn async_example() {
    // Asynchronous code
}

1
2
3
4
5
6
7
8
9
10
11
12
// Built-in macros
println!("Hello, {}!", "world");

// Custom macro
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}

say_hello!();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Unit test
#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    #[should_panic]
    fn it_fails() {
        panic!("This test should panic");
    }
}