Concise Rust

// in main.rs
fn main() {
    ...
}

fn my_function(x: u8) {
    println!("X: {x}") // no semi-colon
}

fn main() {
    my_function(5); // manditory statement termination using ;
    my_function(6)
}

#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "println_macro")]
#[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! println {
    () => {
        $crate::print!("\n")
    };
    ($($arg:tt)*) => {
        $crate::io::_print(
            $crate::format_args_nl!($($arg)*)
        );
    };
}

/// Use `println!` only for the primary output of your program. Use
/// [`eprintln!`] instead to print error and progress messages.

const DAYS_IN_A_YEAR: u16 = 365; // constant with static type

fn my_function(x: u16) { // scope
    println!("X: {x}")
}

fn main() { // scope
let x = 0; // immutable variable with inferenced type
    { // scope
        let x = DAYS_IN_A_YEAR - 1; // shadow
        my_function(x);
    }
}

let x = 10;
let add_x = |y| { // closed with x in scope
    x + y
};
let result = add_x(5);

let x = 10;
let add_x = |y| {
    x + y
};
let x = 44;
let result = add_x(5);

let mut x = 5;
let increment = || {
    x += 1;
};
let read_x = || {
    println!("x is: {}", x);
};
increment(); // Captures `x` mutably and increments it
read_x();    // Captures `x` immutably and reads it

fn main() {
    // Arithmetic operators
    let a = 10;
    let b = 5;

    let addition = a + b;
    let subtraction = a - b;
    let multiplication = a * b;
    let division = a / b;
    let remainder = a % b;

    println!("Addition: {} + {} = {}", a, b, addition);
    println!("Subtraction: {} - {} = {}", a, b, subtraction);
    println!("Multiplication: {} * {} = {}", a, b, multiplication);
    println!("Division: {} / {} = {}", a, b, division);
    println!("Remainder: {} % {} = {}", a, b, remainder);

    // Increment and Decrement
    let mut x = 5;
    x += 1; // Increment
    println!("Increment x by 1: {}", x);

    let mut y = 10;
    y -= 1; // Decrement
    println!("Decrement y by 1: {}", y);

    // Floating-point arithmetic
    let c = 3.5;
    let d = 2.0;

    let float_addition = c + d;
    let float_subtraction = c - d;
    let float_multiplication = c * d;
    let float_division = c / d;

    println!("Floating-point Addition: {} + {} = {}", c, d, float_addition);
    println!("Floating-point Subtraction: {} - {} = {}", c, d, float_subtraction);
    println!("Floating-point Multiplication: {} * {} = {}", c, d, float_multiplication);
    println!("Floating-point Division: {} / {} = {}", c, d, float_division);
}

fn main() {
    // Conditional statements with if and else
    let number = 10;

    if number < 5 {
        println!("Number is less than 5");
    } else if number == 5 {
        println!("Number is equal to 5");
    } else {
        println!("Number is greater than 5");
    }

    // Matching values with match
    let day = "Wednesday";

    match day {
        "Monday" => println!("It's Monday!"),
        "Tuesday" => println!("It's Tuesday!"),
        "Wednesday" => println!("It's Wednesday!"),
        "Thursday" => println!("It's Thursday!"),
        "Friday" => println!("It's Friday!"),
        _ => println!("It's the weekend!"),
    }

    // Loops
    let mut count = 0;

    // While loop
    while count < 5 {
        println!("While loop: Count is {}", count);
        count += 1;
    }

    // For loop using a range
    for number in 1..6 {
        println!("For loop: Number is {}", number);
    }

    // For loop using an iterator
    let fruits = ["apple", "banana", "cherry", "date"];

    for fruit in fruits.iter() {
        println!("For loop (iterator): Fruit is {}", fruit);
    }

    // Loop with break and continue
    let mut i = 0;

    loop {
        if i == 3 {
            println!("Breaking the loop");
            break;
        }
        println!("Loop iteration: {}", i);
        i += 1;
    }
}

enum Animal {
    Cat { name: String, age: u8 },
    Dog { name: String, breed: String },
    Bird(String),
}

fn main() {
    let my_pet = Animal::Cat {
        name: String::from("Whiskers"),
        age: 3,
    };

    match my_pet {
        Animal::Cat { name, age } => { // pattern guards
            println!("I have a cat named {} who is {} years old.", name, age);
        }
        Animal::Dog { name, breed } => {
            println!("I have a dog named {} of breed {}.", name, breed);
        }
        Animal::Bird(name) if name == "Robin" => {
            println!("I have a special bird named Robin.");
        }
        Animal::Bird(name) => {
            println!("I have a bird named {}.", name);
        }
    }
}

let point = (10, 20);

match point {
    (0, 0) => println!("Origin"),
    (_, 0) => println!("On the x-axis"),
    (0, _) => println!("On the y-axis"),
    (x, y) => println!("At ({}, {})", x, y),
}

let person = ("Alice", 30);
let coordinates = (10, 20, 30);
let empty_tuple = ();

let numbers = [1, 2, 3, 4, 5];
let colors = ["red", "green", "blue"];

let numbers = [1, 2, 3, 4, 5];
let slice = &numbers[1..4]; // Borrow elements 2, 3, and 4 (more on borrowing in a bit)

let greeting = "Hello, Rust!";
let slice = &greeting[0..5]; // Borrow "Hello"

let numbers = vec![1, 2, 3, 4, 5];

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

let alice = Person {
    name: String::from("Alice"),
    age: 30,
};

enum Color {
    Red,
    Green,
    Blue,
}

let selected_color = Color::Red;

fn add(x: i32, y: i32) -> i32 {
    x + y // return keyword is optional
}
let result = add(5, 3);

#[inline]
fn factorial(n: u64) -> u64 {
    match n {
        0 | 1 => 1,
        _ => n * factorial(n - 1),
    }
}

fn main() {
    let result = factorial(5);
    println!("Factorial of 5 is: {}", result);
}

fn main() {
    let s = String::from("hello"); // 's' is the owner of the String

    // 's' is in scope and can be used here

} // 's' goes out of scope and the String is automatically deallocated

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership is moved from 's1' to 's2'

    // 's1' cannot be used here because it no longer owns the String

    println!("{}", s2); // 's2' can be used here
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Creates a new String owned by 's2'

    // Both 's1' and 's2' can be used independently here

    println!("{}", s1);
    println!("{}", s2);
}

fn main() {
    let mut original_vec = vec![1, 2, 3, 4, 5]; // Create a mutable vector

    // Clone the mutable vector
    let mut cloned_vec = original_vec.clone();

    // Modify the original vector
    original_vec.push(6);

    // Modify the cloned vector
    cloned_vec.push(7);

    println!("Original vector: {:?}", original_vec);
    println!("Cloned vector: {:?}", cloned_vec);
}

// output:
// Original vector: [1, 2, 3, 4, 5, 6]
// Cloned vector: [1, 2, 3, 4, 5, 7] // no 6, SEE!

fn main() {
    let value = 42;

    // Create an immutable reference
    let reference = &value;

    println!("Value: {}", value);
    println!("Reference: {}", *reference); // Dereference to access the value
}

fn main() {
    let mut value = 42;

    // Create a mutable reference
    let reference = &mut value;

    println!("Value before modification: {}", *reference);

    // Modify the value through the mutable reference
    *reference += 10;

    println!("Value after modification: {}", *reference);
}

fn main() {
    let mut value = 42;

    // Create an immutable reference
    let reference_immutable = &value;

    // Attempt to create a mutable reference (uncommenting this line will cause a compilation error)
    // let reference_mutable = &mut value;
    //                         ^^^^^^^^^^ mutable borrow occurs here

    println!("Value: {}", value);
    println!("Immutable Reference: {}", *reference_immutable);
}

fn main() {
    let mut value = 42;

    // Create a mutable reference
    let reference1 = &mut value;

    // Attempt to create another mutable reference (uncommenting this line will cause a compilation error)
    // let reference2 = &mut value;
    //                 ^^^^^^^^^^ second mutable borrow occurs here

    // Modify the value through the first mutable reference
    *reference1 += 10;

    println!("Value: {}", value);
}

fn main() {
    let value1 = 42;
    let value2 = 24;

    let reference1: &i32;
    let reference2: &i32;

    {
        // Create a reference with a limited scope
        reference1 = &value1;
    } // 'reference1' goes out of scope here

    // Attempt to use 'reference1' after its scope has ended (uncommenting this line will cause a compilation error)
    // println!("Value from reference1: {}", *reference1);

    {
        // Create another reference with a different lifetime
        reference2 = &value2;
    } // 'reference2' goes out of scope here

    // Use 'reference2' safely
    println!("Value from reference2: {}", *reference2);
}

fn print_value(value: &i32) {
    println!("Value: {}", value);
}

fn main() {
    let x = 42;
    print_value(&x); // Pass an immutable reference to 'x'
}

fn increment(value: &mut i32) {
    *value += 1; // Dereference and modify the value
}

fn main() {
    let mut x = 42;
    increment(&mut x); // Pass a mutable reference to 'x'
    println!("Modified Value: {}", x);
}

fn consume_value(value: String) {
    println!("Consumed: {}", value);
}

fn main() {
    let s = String::from("Hello");
    consume_value(s); // Ownership of 's' is transferred to the function
    // 's' is no longer accessible here
}

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let string1 = String::from("hello");
    let result;

    {
        let string2 = String::from("world");
        result = longest(string1.as_str(), string2.as_str());
    } // 'string2' goes out of scope

    println!("The longest string is: {}", result);
} // 'string1' goes out of scope

let mut numbers: Vec<i32> = vec![1, 2, 3];
numbers.push(4);
numbers.pop();

let days_of_week: [&str; 7] = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];

let greeting: String = String::from("Hello, World!");
let message: &str = "Rust is awesome!";

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert("Alice", 100);
scores.insert("Bob", 85);

use std::collections::HashSet;

let mut unique_numbers = HashSet::new();
unique_numbers.insert(1);
unique_numbers.insert(2);

let numbers = [1, 2, 3, 4, 5];
let slice = &numbers[1..4]; // Slice from index 1 to 3

let person: (String, i32) = ("Alice".to_string(), 30);

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

fn print_area(shape: &impl Shape) {
    println!("Area: {}", shape.area());
}

let circle = Circle { radius: 2.0 };
print_area(&circle);

trait Printable {
    fn print(&self) {
        println!("Printing from the trait");
    }
}

struct CustomType;

impl Printable for CustomType {}

fn main() {
    let custom = CustomType;
    custom.print(); // Calls the default implementation
}

#[derive(Debug, Clone)]
struct Person {
    name: String,
    age: u32,
}

fn divide(x: i32, y: i32) -> Result<i32, String> {
    if y == 0 {
        return Err("Division by zero".to_string());
    }
    Ok(x / y)
}

fn main() {
    let result = divide(10, 2);

    match result {
        Ok(value) => println!("Result: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}

fn main() {
    let numbers = vec![1, 2, 3];
    let index = 5;

    if index >= numbers.len() {
        panic!("Index out of bounds");
    }

    let value = numbers[index];
    println!("Value: {}", value);
}

let result: Result<i32, &str> = Err("Something went wrong");

// Using unwrap
let value = result.unwrap(); // Panics with a default error message

// Using expect
let value = result.expect("Custom error message"); // Panics with a custom error message

fn divide(x: i32, y: i32) -> Result<i32, String> {
    if y == 0 {
        return Err("Division by zero".to_string());
    }
    Ok(x / y)
}

fn compute(x: i32, y: i32) -> Result<i32, String> {
    let result = divide(x, y)?;
    Ok(result * 2)
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

let func: fn(i32, i32) -> i32 = add;
let result = func(2, 3); // 5

let add = |a: i32, b: i32| a + b;
let result = add(2, 3); // 5

let numbers = vec![1, 2, 3, 4, 5];
let sum: i32 = numbers.iter().filter(|&&x| x % 2 == 0).map(|&x| x * 2).sum();

use im::vector::Vector;

let vector = Vector::from(vec![1, 2, 3]);
let new_vector = vector.push_back(4);

fn apply_twice<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(f(x))
}

fn add(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

fn main() {
    let add_five = add(5);
    let result = add_five(3); // Equivalent to add(5)(3)
    println!("Result: {}", result); // 8
}

fn main() {
    // Create a boxed integer
    let boxed_value: Box<i32> = Box::new(42);

    // Access the value inside the box
    println!("Value: {}", *boxed_value);
}