added exercises

stack_slice/Cargo.toml

+[package]
+name = "stack_slice"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

stack_slice/src/main.rs

+use crate::stack_slice::Stack;
+
+pub mod stack_slice;
+
+fn main() {
+    let mut new_stack: Stack<i32> = Stack::new();
+
+    for i in 0..9 {
+        match new_stack.push(i) {
+            Ok(_) => continue,
+            Err(_) => break,
+        }
+    }
+    print!("Hello");
+
+    println!("{}", new_stack.next().unwrap());
+    println!("{}", new_stack);
+}

stack_slice/src/stack_slice.rs

+const SIZE: usize = 10;
+
+#[derive(Debug)]
+pub enum StackError {
+    StackFull,
+    StackEmpty,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Stack<T>
+where
+    T: Clone + Copy,
+{
+    data: [Option<T>; SIZE],
+    len: usize,
+}
+
+impl<T: Copy + std::fmt::Display> std::fmt::Display for Stack<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Stack capacity: {}", self.data.len())?;
+        if self.len == 0 {
+            write!(f, "Stack is empty")?;
+            return Ok(());
+        }
+
+        self.data.iter().rev().for_each(|item| match item {
+            Some(v) => writeln!(f, "{}", v).unwrap(),
+            None => writeln!(f, "Empty slot").unwrap(),
+        });
+
+        Ok(())
+    }
+}
+
+impl<T: Copy> Iterator for Stack<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.len != 0 {
+            true => {
+                let curr = self.data[self.len]?;
+                self.len -= 1;
+                println!("{}", self.len);
+
+                Some(curr)
+            }
+            false => None,
+        }
+    }
+}
+
+// impl<T: Copy> Iterator for Stack<T> {
+//     type Item = Option<T>;
+//
+//     fn next(&mut self) -> Option<Self::Item> {
+//         if self.len <= self.data.len() {
+//            let result = Some(&self.data[self.len]);
+//             self.len += 1;
+//
+//             result
+//         }
+//     }
+// }
+
+impl<T> Stack<T>
+where
+    T: Clone + Copy,
+{
+    pub fn new() -> Self {
+        Self {
+            data: [None; SIZE],
+            len: 0,
+        }
+    }
+
+    pub fn push(&mut self, value: T) -> Result<(), StackError> {
+        match self.len == SIZE {
+            true => Err(StackError::StackFull),
+            false => {
+                self.data[self.len] = Some(value);
+                self.len += 1;
+                Ok(())
+            }
+        }
+    }
+
+    pub fn pop(&mut self) -> Result<Option<T>, StackError> {
+        match self.len == 0 {
+            true => Err(StackError::StackEmpty),
+            false => {
+                let val = self.data[self.len];
+                self.data[self.len] = None;
+                self.len -= 1;
+                Ok(val)
+            }
+        }
+    }
+}

vec_rs/.gitignore

+/target

vec_rs/Cargo.toml

+[package]
+name = "vec_rs"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.75"

vec_rs/src/main.rs

+use crate::vec::Vector;
+
+mod vec;
+
+fn main() {
+    let lhs = Vector::new(3423, -34);
+    let rhs = Vector::new(24, 69420);
+
+    println!("Result is: {:?}", lhs * rhs);
+}

vec_rs/src/vec.rs

+use std::ops::{Add, Sub, Mul};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Vector {
+    x: i128,
+    y: i128,
+}
+
+
+impl Vector {
+    pub fn new(x: i128, y: i128) -> Vector {
+        Vector { x, y }
+    }
+}
+
+
+impl Add for Vector {
+    type Output = Vector;
+
+    fn add(self, rhs: Self) -> Vector {
+        Vector {
+            x: self.x + rhs.x,
+            y: self.y + rhs.y,
+        }
+    }
+}
+
+impl Sub for Vector {
+    type Output = Vector;
+
+    fn sub(self, rhs: Self) -> Vector {
+        Vector {
+            x: self.x - rhs.x,
+            y: self.y - rhs.y,
+        }
+    }
+}
+
+
+impl Mul for Vector {
+    type Output = i128;
+
+    fn mul(self, rhs: Self) -> i128 {
+        self.x * rhs.x + self.y * rhs.y
+    }
+}