closure

Author: yogithesymbian

src/_29_yo_overloadable_operator.rs

@@ -0,0 +1,28 @@
+use std::ops::Add;
+
+// Define a custom struct to represent a point in 2D space.
+#[derive(Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+// Implement the Add trait to allow adding two Points together.
+impl Add for Point {
+    type Output = Point;
+
+    fn add(self, other: Self) -> Point {
+        Point {
+            x: self.x + other.x,
+            y: self.y + other.y,
+        }
+    }
+}
+
+pub fn main() {
+    let point1 = Point { x: 1, y: 2 };
+    let point2 = Point { x: 3, y: 4 };
+
+    let result = point1 + point2; // Overloaded operator
+    println!("{:?}", result); // Expected output: Point { x: 4, y: 6 }
+}

src/_30_yo_optional.rs

@@ -0,0 +1,16 @@
+fn find_item(value: i32) -> Option<String> {
+    if value > 10 {
+        Some("Item found!".to_string())
+    } else {
+        None
+    }
+}
+
+pub fn main() {
+    let result = find_item(15);
+
+    match result {
+        Some(message) => println!("{}", message), // Output: Item found !
+        None => println!("No item found."),
+    }
+}

src/_31_yo_comparing.rs

@@ -0,0 +1,24 @@
+use std::cmp::Ordering;
+
+#[derive(Debug, PartialOrd, PartialEq)]
+struct Product {
+    price: f64,
+    name: String,
+}
+
+pub fn main() {
+    let product1 = Product {
+        price: 19.99,
+        name: "Laptop".to_string(),
+    };
+    let product2 = Product {
+        price: 29.99,
+        name: "Smartphone".to_string(),
+    };
+
+    if product1 < product2 {
+        println!("{} is cheaper than {}", product1.name, product2.name);
+    } else {
+        println!("{} is more expensive than {}", product1.name, product2.name);
+    }
+}

src/_32_yo_string_manipulation.rs

@@ -0,0 +1,12 @@
+pub fn main() {
+    let first_name = "Yogi";
+    let last_name = "Arif Widodo";
+
+    // Concatenate strings
+    let full_name = format!("{} {}", first_name, last_name);
+    println!("{}", full_name); // Output: Yogi Arif Widodo
+
+    // String manipulation: slicing
+    let first_char = &full_name[0..1];
+    println!("{}", first_char); // Output: Y
+}

src/_33_yo_formatting.rs

@@ -0,0 +1,21 @@
+use std::fmt;
+
+struct Product {
+    name: String,
+    price: f64,
+}
+
+impl fmt::Display for Product {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}: ${:.2}", self.name, self.price)
+    }
+}
+
+pub fn main() {
+    let product = Product {
+        name: "Laptop".to_string(),
+        price: 999.99,
+    };
+
+    println!("{}", product); // Output: Laptop: $999.99
+}

src/_34_yo_closure.rs

@@ -0,0 +1,9 @@
+// A closure is an anonymous function that can capture its environment. They are useful for things like callbacks or operations that require an external context.
+
+// Example: Using Closure for Summation
+pub fn main() {
+    let add = |x, y| x + y;
+
+    let result = add(5, 10);
+    println!("{}", result); // Output: 15
+}

src/main.rs

@@ -19,7 +19,13 @@ mod _25_yo_module;
 mod _26_yo_crate;
 mod _27_yo_trait;
 mod _28_generic;
+mod _29_yo_overloadable_operator;
 mod _2_data_types;
+mod _30_yo_optional;
+mod _31_yo_comparing;
+mod _32_yo_string_manipulation;
+mod _33_yo_formatting;
+mod _34_yo_closure;
 mod _3_numbers;
 mod _4_operators_comparison;
 mod _5_operator_boolean;
@@ -75,4 +81,10 @@ fn main() {
     _26_yo_crate::main();
     _27_yo_trait::main();
     _28_generic::main();
+    _29_yo_overloadable_operator::main();
+    _30_yo_optional::main();
+    _31_yo_comparing::main();
+    _32_yo_string_manipulation::main();
+    _33_yo_formatting::main();
+    _34_yo_closure::main();
 }