🦀 learning rust [wip]

let two = 2; // let some variable named 'two' be assigned the value 2
let hello = "hello";
let j = 'j';
let mut my_name = "Sam"; // let mut makes the variable mutable
let quit_program = false;
let your_half = my_half;

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

let life: i32 = 42;
println!("hello");
println!("{:?}", life);
println!("{:?} {:?}", life, life);
println!("the meaning is {life:?}"); // in line variable invocation

let a = 99;
if a > 99 {
	println!("big number");
} else {
	println!("small number");
}

let a = 201;
if a > 99 {
	if a > 200 {
		println!("huge number");
	} else {
		println!("big number");
	}
} else {
	println!("small number");
}

    if a > 200 {
        println!("huge number");
    } else if a > 99 {        
        println!("number number");
    } else {
        println!("small number");
    }

    let mut example = 0;
    loop {
        if example == 5{
            break;
        }
        println!("{example:?}");
        example = example + 1;
    }

    let mut example = 0;
    while example != 5 {
        println!("{example:?}");
        example = example + 1;
    }

// Topic: Functions
//
// Program requirements:
// * Displays your first and last name
//
// Notes:
// * Use a function to display your first name
// * Use a function to display your last name
// * Use the println macro to display messages to the terminal

fn first_name() {
    println!("Sam");
}

fn last_name() {
    println!("Bilbow");
}

fn main() {
    first_name();
    last_name();
}

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

fn main() {
	let sum = 2 + 2;
	let value = 10 - 5;
	let division = 10 / 2;
	let mult = 5 * 5;

	let five = sub(8,3);
	println!("{five:?}, {sum} {value} {division} {mult}");


	let rem = 6 % 3; // 0 remainder division (modulo)
	let rem2 = 6 % 4; // 1 (useful for even / odd ) e.g. if x % 2 !== 0 means odd
	rem2;
}

// Topic: Basic arithmetic
//
// Program requirements:
// * Displays the result of the sum of two numbers
//
// Notes:
// * Use a function to add two numbers together
// * Use a function to display the result
// * Use the "{:?}" token in the println macro to display the result

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

fn main() {
    let a = 23;
    let b = 46;
    let x = sum(a,b);
    println!("{x:?}");
}

fn main() {
    let age = 15;
    if age >= 21 {
        println!("ok to purchase");
    } else {
        println!("cannot purchase");
    }
}

// Topic: Flow control using if..else
//
// Program requirements:
// * Displays a message based on the value of a boolean variable
// * When the variable is set to true, display "hello"
// * When the variable is set to false, display "goodbye"
//
// Notes:
// * Use a variable set to either true or false
// * Use an if..else block to determine which message to display
// * Use the println macro to display messages to the terminal

fn main() {
    let mut var = true;
    eval(var);
    var = false;
    eval(var);
}

fn eval(var: bool){
    if var {
        println!("hello");
    } else {
        println!("goodbye");
    }
}

// Topic: Flow control using if..else if..else
//
// Program requirements:
// * Display ">5", "<5", or "=5" based on the value of a variable
//   is > 5, < 5, or == 5, respectively
//
// Notes:
// * Use a variable set to any integer value
// * Use an if..else if..else block to determine which message to display
// * Use the println macro to display messages to the terminal

fn main() {
    let mut var = 4;
    print_result(var);
    var = 5;
    print_result(var);
    var = 6;
    print_result(var);
    
}

fn print_result(var: i32){
    if var > 5 {
        println!("{var} is greater than 5");
    } 
    else if var == 5{
        println!("{var} is equal to 5");
    }
    else {
        println!("{var} is less than 5");
    }
}

fn main() {
    let some_bool = true;
    match some_bool {
        true => println!("its true"),
        false => println!("its false"),
    }
}

fn main() {
    let my_name = "Bob";
    match my_name {
        "Sam" => println!("that is my name"),
        "Jayson" => println!("that is his name"),
        "Bob" => println!("not my name"),
        _ => println!("nice to meet you"),
    }
}

// Topic: Decision making with match
//
// Program requirements:
// * Display "it's true" or "it's false" based on the value of a variable
//
// Notes:
// * Use a variable set to either true or false
// * Use a match expression to determine which message to display

fn main() {
    let mut var : bool = true;
    eval(var);
    var = false;
    eval(var);
}

fn eval(var: bool){
    match var {
        true => println!("it's true"),
        false => println!("it's false"),
    }
}

// Topic: Decision making with match
//
// Program requirements:
// * Display "one", "two", "three", or "other" based on whether
//   the value of a variable is 1, 2, 3, or some other number,
//   respectively
//
// Notes:
// * Use a variable set to any integer
// * Use a match expression to determine which message to display
// * Use an underscore (_) to match on any value

fn main() {
    let mut var : i32 = 0;
    eval(var);
    var = 1;
    eval(var);
    var = 2;
    eval(var);
    var = 3;
    eval(var);
    var = 4;
    eval(var);

}

fn eval(var: i32){
    match var {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        _ => println!("other"),
    }
}

fn main() {
    let mut countdown: i32 = 3;
    loop {
        println!("{countdown}");
        countdown = countdown - 1;
        if countdown == 0 {
            break;
        }
    }
    println!("GO!");
}

// Topic: Looping using the loop statement
//
// Program requirements:
// * Display "1" through "4" in the terminal
//
// Notes:
// * Use a mutable integer variable
// * Use a loop statement
// * Print the variable within the loop statement
// * Use break to exit the loop

fn main() {
    let mut i: i32 = 1;
    loop {
        println!("{i}");
        i+=1;
        if i == 5{
            break;
        }
    }

}

// Topic: Looping using the while statement
//
// Program requirements:
// * Counts down from 5 to 1, displays the countdown
//   in the terminal, then prints "done!" when complete.
//
// Notes:
// * Use a mutable integer variable
// * Use a while statement
// * Print the variable within the while loop
// * Do not use break to exit the loop

fn main() {
    let mut i = 5;
    while i !=0 {
        println!("{i}");
        i-=1;
    }
    println!("done!")
}

enum Direction {
	Up,
	Down,
	Left,
	Right
}

fn which_way(go: Direction){
    match go {
        Direction::Up => "up",
        Direction::Down => "down",
        Direction::Left => "left",
        Direction::Right => "right",
    }
}

enum Direction {
    Left,
    Right,
    Up
}

fn main(){
    let mut go = Direction::Left;
    eval(go);
    go = Direction::Right;
    eval(go);
    go = Direction::Up;
    eval(go);
}

fn eval(go: Direction){
    match go {
        Direction::Left => println!("we're going left!"),
        Direction::Right => println!("we're going right!"),
        _ => println!("we're going another direction!"),
    }
}

// Topic: Working with an enum
//
// Program requirements:
// * Prints the name of a color to the terminal
//
// Notes:
// * Use an enum with color names as variants
// * Use a function to print the color name
// * The function must use the enum as a parameter
// * Use a match expression to determine which color
//   name to print

enum Color{
    Red,
    Yellow,
    Blue,
}

fn print_color(color: Color){
    match color{
        Color::Red => println!{"The color is blood red"},
        Color::Yellow => println!{"The color is a golden yellow"},
        Color::Blue => println!{"The color is a rich blue"},
    }
}

fn main() {
    let mut color = Color::Red;
    print_color(color);
    color = Color::Yellow;
    print_color(color);
    color = Color::Blue;
    print_color(color);
}

struct CourierBox {
    weight: i32,
    depth:  i32,
    width:  i32,
    height: i32,
}

fn main(){
    let new_courier_box = CourierBox{
        weight: 5,
        depth:  432,
        width:  291, 
        height: 921,
    };

    let weight = new_courier_box.weight;
    let depth = new_courier_box.depth;
    let width = new_courier_box.width;
    let height = new_courier_box.height;
    println!("your box is {weight}kg");
    println!("your box is {depth}mm deep");
    println!("your box is {width}mm wide");
    println!("your box is {height}mm tall");
}

// Topic: Organizing similar data using structs
//
// Requirements:
// * Print the flavor of a drink and it's fluid ounces
//
// Notes:
// * Use an enum to create different flavors of drinks
// * Use a struct to store drink flavor and fluid ounce information
// * Use a function to print out the drink flavor and ounces
// * Use a match expression to print the drink flavor

enum Flavours{
    Apple,
    Orange,
    Lychee,
    Mango,
}

struct Drink{
    flavour: Flavours,
    volume: i32,
}

fn main() {
    let apple_juice_from_concentrate: Drink = Drink{
        flavour: Flavours::Apple,
        volume: 330,
    };
    print_flavour(apple_juice_from_concentrate);
    
    let fresh_orange_juice: Drink = Drink{
        flavour: Flavours::Orange,
        volume: 250,
    };
    print_flavour(fresh_orange_juice);
    
    let lychee_flavoured_water: Drink = Drink{
        flavour: Flavours::Lychee,
        volume: 500,
    };
    print_flavour(lychee_flavoured_water);
    
    let mango_nectar: Drink = Drink{
        flavour: Flavours::Mango,
        volume: 1000,
    };
    print_flavour(mango_nectar);
}

fn print_flavour(drink: Drink){
    match drink.flavour{
        Flavours::Apple => println!("The drink you've chosen has an apple flavour, and contains {}ml of liquid.", drink.volume),
        Flavours::Orange => println!("The drink you've chosen has an orange flavour, and contains {}ml of liquid.", drink.volume),
        Flavours::Lychee => println!("The drink you've chosen has a lychee flavour, and contains {}ml of liquid.", drink.volume),
        Flavours::Mango => println!("The drink you've chosen has a mango flavour, and contains {}ml of liquid.", drink.volume),
    }
}

// Enumeration containing variants based on type of access
enum Access {
    Full,
    Partial,
    Guest
}

// Structured data containing member information
struct NewMember{
    name: String,
    age: i32,
    species: String,
    access: Access,
}

// Function that creates a vector containing members, defines new members, and prints those members using a for loop that features match and tuple.
fn main(){
    let mut member_list = vec![];

    let celine = NewMember{
        name: String::from("Celine"),
        age: 94,
        species: String::from("Octopus"),
        access: Access::Full,
    };
    member_list.push(celine);

    let otto = NewMember{
        name: String::from("Otto"),
        age: 83,
        species: String::from("Octopus"),
        access: Access::Partial,
    };
    member_list.push(otto);
    
    let diane = NewMember{
        name: String::from("Diane"),
        age: 2,
        species: String::from("Cat"),
        access: Access::Guest,
    };
    member_list.push(diane);

    let george = NewMember{
        name: String::from("George"),
        age: 62,
        species: String::from("Panda"),
        access: Access::Guest,
    };
    member_list.push(george);

    println!("List of Socialist Revolutionaries:");
    
    for member in member_list {
        let access_str: &str;
        match member.access {
            Access::Full => access_str = "full",
            Access::Partial => access_str = "partial",
            Access::Guest => access_str = "guest",
        };
        let (name, age, species, access) = (member.name, member.age,member.species, access_str);
        println!("Staff member {0} ({1}), is {2}, and has {3} access.", name, species, age, access)
    }
}

// Topic: Data management using tuples
//
// Requirements:
// * Print whether the y-value of a cartesian coordinate is
//   greater than 5, less than 5, or equal to 5
//
// Notes:
// * Use a function that returns a tuple
// * Destructure the return value into two variables
// * Use an if..else if..else block to determine what to print

fn main() {
    let coordinates = tuplizer(32,2);
    print_y_value(coordinates);
}

fn tuplizer(x: i32, y: i32) -> (i32, i32){
    (x,y)
}

fn print_y_value(coordinates: (i32, i32)){
    let (_x, y) = (coordinates.0, coordinates.1);
    if y > 5 {
        println!("The y coordinate: {y} is greater than 5")
    }
    else if y < 5 {
        println!("The y coordinate: {y} is less than 5")
    }
    else {
        println!("The y coordinate: {y} is equal to 5")
    }
} 

fn main() {
    let x = 3;
    let is_x_5: bool = if x == 5{
        true
    } else {
        false
    };
    
    let y = 5;
    let is_y_5: bool = y == 5;
}

enum Access {
    Admin,
    Manager,
    User,
    Guest,
}

fn main() {
    let access_level: Access = Access::Guest;
    let can_access_file: bool = match access_level {
        Access::Admin => true,
        _ => false
    };
    println!("can access? {can_access_file}")
}

// Topic: Working with expressions
//
// Requirements:
// * Print "its big" if a variable is > 100
// * Print "its small" if a variable is <= 100
//
// Notes:
// * Use a boolean variable set to the result of
//   an if..else expression to store whether the value
//   is > 100 or <= 100
// * Use a function to print the messages
// * Use a match expression to determine which message
//   to print

fn main () {
    let var: i32 = 100;
    let var_gt_100 = var > 100;
    eval(var_gt_100);

}

fn eval (var_gt_100: bool) {
    match var_gt_100{
        true => println!("{var_gt_100}, it is bigger than 100") ,
        false => println!("{var_gt_100}, it is less than or equal to 100") ,
    }
}

enum Light {
    Bright,
    Dull
}

fn display_light(light: Light) {
    match light {
        Light::Bright => println!("light!"),
        Light:: Dull => println!("dull")
    }
}
fn main() {
    let dull = Light::Dull; // dull is owned by main()
    display_light(dull); // dull is now owned by display_light()
    display_light(dull); // Error here, as dull's ownership has moved to display_light(), and dull doesn't exist within the scope of this function anymore.
}

enum Light {
    Bright,
    Dull
}

fn display_light(light: &Light) {
    match light {
        Light::Bright => println!("bright!"),
        Light:: Dull => println!("dull")
    }
}
fn main() {
    let dull = Light::Dull; // dull is owned by main()
    display_light(&dull); // dull is now borrowed by display_light()
    display_light(&dull); // main() still owns and can lend dull a second time.
} // dull is unallocated now

// Topic: Ownership
//
// Requirements:
// * Print out the quantity and id number of a grocery item
//
// Notes:
// * Use a struct for the grocery item
// * Use two i32 fields for the quantity and id number
// * Create a function to display the quantity, with the struct as a parameter
// * Create a function to display the id number, with the struct as a parameter

struct GroceryItem {
    name: String,
    quantity: i32,
    id_number: i32,
}

fn main() {

    let mut shopping_list = vec![];

    let tofu = GroceryItem {
        name: "Tofu".to_string(),
        quantity: 6,
        id_number: 9348912,
    };
    shopping_list.push(tofu);
    
    let beansprouts = GroceryItem {
        name: "Beansprouts".to_string(),
        quantity: 14,
        id_number: 2342341,
    };
    shopping_list.push(beansprouts);
    
    let gochujang = GroceryItem {
        name: "Gochujang".to_string(),
        quantity: 1,
        id_number: 4326116,
    };
    shopping_list.push(gochujang);
    
    let peanut_butter = GroceryItem {
        name: "Peanut Butter".to_string(),
        quantity: 2,
        id_number: 343946,
    };
    shopping_list.push(peanut_butter);

    for item in shopping_list {
        display_information(&item);
    }

}

fn display_information(grocery_item: &GroceryItem) {
    let name = grocery_item.name.to_string();
    let quantity = grocery_item.quantity;
    let id_number = grocery_item.id_number;
    println!("There are {quantity} of item {id_number} ({name})");
}

struct Temperature {
    degrees_f: f64,
}

fn show_temp (temp: Temperature) {
    println!("{:?} degrees F", temp.degrees_f);
}

fn main() {
    let hot = Temperature { degrees_f: 99.9 };
    show_temp(hot);
}

struct Temperature {
    degrees_f: f64,
}

impl Temperature {
    fn show_temp (&self) {
        println!("{:?} degrees F", self.degrees_f);
    }
}

fn main() {
    let hot = Temperature { degrees_f: 99.9 };
    hot.show_temp();
}

struct Temperature {
    degrees_f: f64,
}

impl Temperature {
    fn hot() -> Self {
        Self { degrees_f: 99.9 }
    }
    fn freezing() -> Self {
        Self { degrees_f: 32.0 }
    }
    fn boiling() -> Self {
        Self { degrees_f: 212.0 }
    }
    fn show_temp(&self) {
        println!("{:?} degrees F", self.degrees_f);
    }
}

fn main() {
    Temperature::hot().show_temp();
    Temperature::freezing().show_temp();
    Temperature::boiling().show_temp();
}

// Topic: Implementing functionality with the impl keyword
//
// Requirements:
// * Print the characteristics of a shipping box
// * Must include dimensions, weight, and color
//
// Notes:
// * Use a struct to encapsulate the box characteristics
// * Use an enum for the box color
// * Implement functionality on the box struct to create a new box
// * Implement functionality on the box struct to print the characteristics

enum BoxColor{
    Blue,
    Yellow,
    Red
}

struct ShippingBox {
    dimensions: [f32;3],
    weight: f32,
    color: BoxColor,
}

impl ShippingBox {
    fn create(dimensions: [f32;3], weight: f32, color: BoxColor) -> Self {
        Self { dimensions: dimensions, weight: weight, color: color }
    }
    
    fn p_box(&self){
        println!("The box has the following characteristics");
        println!("- It is {}mm wide", self.dimensions[0]);
        println!("- It is {}mm tall", self.dimensions[1]);
        println!("- It is {}mm deep", self.dimensions[2]);
        println!("- It is {}kg", self.weight);
        let color_str = match &self.color {
            BoxColor::Blue => "blue",
            BoxColor::Yellow => "yellow",
            BoxColor::Red => "red",
        };
        println!("- It is {color_str}");
    }
}

fn main() {
    let heavy_blue_box: ShippingBox = ShippingBox::create([232.3,235.2,512.3], 65.32, BoxColor::Blue);
    heavy_blue_box.p_box();

    let tiny_yellow_box: ShippingBox = ShippingBox::create([12.2,25.5,21.2], 2.1, BoxColor::Yellow);
    tiny_yellow_box.p_box();
    
    let massive_red_box: ShippingBox = ShippingBox::create([1267.2,2567.5,2671.2], 223.1, BoxColor::Red);
    massive_red_box.p_box();
}

struct Test {
    score: i32,
}

fn main (){
     let my_scores: Vec<Test> = vec![
        Test { score: 89 },
        Test { score: 65 },
        Test { score: 74 },
        Test { score: 12 },
        Test { score: 32 },
     ];

     for test in my_scores {
        println!("score = {:?}", test.score);
     }
}

// Topic: Vectors
//
// Requirements:
// * Print 10, 20, "thirty", and 40 in a loop
// * Print the total number of elements in a vector
//
// Notes:
// * Use a vector to store 4 numbers
// * Iterate through the vector using a for..in loop
// * Determine whether to print the number or print "thirty" inside the loop
// * Use the .len() function to print the number of elements in a vector

fn main() {
    let numbers: Vec<i32> = vec![10,20,30,40];
    for i in &numbers {
        match i {
            30 => println!("thirty"),
            _ => println!("{:?}", i),
        }
    }
    println!("The vector \"numbers\" contains {:?} items", numbers.len());
}