cargo formatted: added new keyword

working on docs
removed a lot of the .uwnrap

Author: mendelsshop

src/eval.rs

@@ -381,7 +381,7 @@ impl Scope {
         }
     }
     pub fn drop_scope(&mut self) {
-        let p_scope: Self = match  self.parent_scope.take(){
+        let p_scope: Self = match self.parent_scope.take() {
             Some(scope) => *scope,
             None => error(0, "no parent scope"),
         };
@@ -691,7 +691,13 @@ impl Eval {
                     }
                 }
                 TokenType::Type => {
-                    arg_error(1, call.arguments.len() as u32, &call.keyword, false, call.line);
+                    arg_error(
+                        1,
+                        call.arguments.len() as u32,
+                        &call.keyword,
+                        false,
+                        call.line,
+                    );
                     match self.find_pointer_in_stuff(&call.arguments[0]) {
                         LiteralOrFile::Literal(a) => {
                             LiteralOrFile::Literal(LiteralType::String(a.get_type()))

src/lexer.rs

@@ -169,18 +169,22 @@ impl Lexer {
                             y if y.is_ascii_hexdigit() => {
                                 self.insert_text(
                                     self.current,
-                                    u8::from_str_radix(format!("{x}{y}").as_str(), 16).unwrap_or_else(|_| {
-                                        error::error(self.line, "invalid hex escape sequence");
-                                    }) as char,
+                                    u8::from_str_radix(format!("{x}{y}").as_str(), 16)
+                                        .unwrap_or_else(|_| {
+                                            error::error(self.line, "invalid hex escape sequence");
+                                        }) as char,
                                 );
                                 self.advance();
                             }
                             y => {
                                 self.insert_text(
                                     self.current,
-                                    u8::from_str_radix(format!("{x}").as_str(), 16).unwrap_or_else(|_| {
-                                        error::error(self.line, "invalid hex escape sequence");
-                                    }) as char);
+                                    u8::from_str_radix(format!("{x}").as_str(), 16).unwrap_or_else(
+                                        |_| {
+                                            error::error(self.line, "invalid hex escape sequence");
+                                        },
+                                    ) as char,
+                                );
                                 self.insert_text(self.current + 1, y);
                                 self.advance();
                             }
@@ -203,11 +207,14 @@ impl Lexer {
                     }
                     self.insert_text(
                         self.current,
-                        char::from_u32(u32::from_str_radix(hex_string.as_str(), 16).unwrap_or_else(|_| {
-                                error::error(self.line, "invalid unicode escape sequence");
-                            } ) ).unwrap_or_else(|| {
+                        char::from_u32(
+                            u32::from_str_radix(hex_string.as_str(), 16).unwrap_or_else(|_| {
                                 error::error(self.line, "invalid unicode escape sequence");
-                            })
+                            }),
+                        )
+                        .unwrap_or_else(|| {
+                            error::error(self.line, "invalid unicode escape sequence");
+                        }),
                     );
                     self.current += 1;
                 } else {

src/main.rs

@@ -27,8 +27,12 @@ fn main() {
         'l: loop {
             let mut input = String::new();
             print!(">> "); // print the prompt
-            io::stdout().flush().unwrap_or_else(|_| panic!("Failed to flush stdout"));
-            io::stdin().read_line(&mut input).unwrap_or_else(|_| panic!("Failed to read stdin"));
+            io::stdout()
+                .flush()
+                .unwrap_or_else(|_| panic!("Failed to flush stdout"));
+            io::stdin()
+                .read_line(&mut input)
+                .unwrap_or_else(|_| panic!("Failed to read stdin"));
             if input.trim() == "exit" {
                 // if the input is exit, then exit
                 info!("Exiting...");
@@ -37,9 +41,13 @@ fn main() {
                     if Path::new(&parsed_args.file).exists() && !parsed_args.force {
                         // if the file exists and we are not forcing it to overwrite
                         print!("Do you want to overwrite the {}? (y/n): ", parsed_args.file); // ask the user if they want to overwrite the file
-                        io::stdout().flush().unwrap_or_else(|_| panic!("Failed to flush stdout"));
+                        io::stdout()
+                            .flush()
+                            .unwrap_or_else(|_| panic!("Failed to flush stdout"));
                         let mut y_or_n: String = String::new();
-                        io::stdin().read_line(&mut y_or_n).unwrap_or_else(|_| panic!("Failed to read stdin")); // read the input
+                        io::stdin()
+                            .read_line(&mut y_or_n)
+                            .unwrap_or_else(|_| panic!("Failed to read stdin")); // read the input
                         if y_or_n == "n" {
                             // if the user does not want to overwrite the file exit
                             exit(0);
@@ -63,11 +71,9 @@ fn main() {
         }
     } else {
         // if we are not in repl mode ie we are reading a file
-        let mut file: File = File::open(&parsed_args.file).unwrap_or_else(
-            |_| {
-                error::error(0, "Error encountered while opening file!");
-            },
-        ); // open the file
+        let mut file: File = File::open(&parsed_args.file).unwrap_or_else(|_| {
+            error::error(0, "Error encountered while opening file!");
+        }); // open the file
         let mut contents: String = String::new(); // create a string to hold the contents of the file
         match file.read_to_string(&mut contents) {
             Ok(contents) => contents,

src/parser/rules.rs

@@ -148,7 +148,7 @@ impl LiteralType {
         }
     }
 
-    pub fn get_type(&self) -> String  {
+    pub fn get_type(&self) -> String {
         match self {
             Self::Number(_) => "number".to_string(),
             Self::String(_) => "string".to_string(),

src/token.rs

@@ -83,7 +83,7 @@ pub enum TokenType {
     WriteLine,
     CreateFile,
     DeleteFile,
-    Type
+    Type,
 }
 
 impl TokenType {
@@ -196,13 +196,7 @@ impl TokenType {
                 | Self::StrToHempty
                 | Self::StrToNum
                 | Self::RunCommand => {
-                    arg_error(
-                        1,
-                        args.len() as u32,
-                        self,
-                        false,
-                        line
-                    );
+                    arg_error(1, args.len() as u32, self, false, line);
                     match &args[0] {
                         LiteralType::String(ref string) => match self {
                             Self::Error => exit(1),