refactor(literal): remove the Option wrapper for literal for Expr

Simplifies other aspect of the code. Having the LiteralType be wrapped
in an Option was a mistake (i was super sleepy when i was writing that
code :D)

src/ast.rs

@@ -18,7 +18,7 @@ pub enum Expr {
         expression: Box<Expr>,
     },
     Literal {
-        value: Option<LiteralType>,
+        value: LiteralType,
     },
     Unary {
         op: Token,

src/parser.rs

@@ -99,25 +99,30 @@ impl Parser<'_> {
         use LiteralType::*;
         use TokenType::*;
 
-        fn create_literal(l_type: Option<LiteralType>) -> Expr {
+        fn create_literal(l_type: LiteralType) -> Expr {
             Expr::Literal { value: l_type }
         }
 
         if self.match_token(&[False]) {
-            return Ok(create_literal(Some(Bool(false))));
+            return Ok(create_literal(Bool(false)));
         }
 
         if self.match_token(&[True]) {
-            return Ok(create_literal(Some(Bool(true))));
+            return Ok(create_literal(Bool(true)));
         }
 
         if self.match_token(&[TokenType::Number, TokenType::String]) {
-            return Ok(create_literal(self.previous().literal.clone()));
+            return Ok(create_literal(
+                self.previous()
+                    .literal
+                    .clone()
+                    .expect("The number and string token should have a literal"),
+            ));
         }
 
         // i included the enum name bcs of ambiguity of LiteralType and TokenType
         if self.match_token(&[TokenType::Nil]) {
-            return Ok(create_literal(Some(LiteralType::Nil)));
+            return Ok(create_literal(LiteralType::Nil));
         }
 
         if self.match_token(&[LeftParen]) {

src/printer.rs

@@ -5,11 +5,10 @@ pub fn pretty_print(expr: &Expr) -> String {
         Expr::Binary { left, op, right } => parenthesize(&op.lexeme, &[left, right]),
         Expr::Grouping { expression } => parenthesize("group", &[expression]),
         Expr::Literal { value } => match value {
-            Some(LiteralType::String(v)) => v.to_string(),
-            Some(LiteralType::Number(v)) => v.to_string(),
-            Some(LiteralType::Bool(v)) => v.to_string(),
-            Some(LiteralType::Nil) => "Nil".to_string(),
-            None => "None".to_string(),
+            LiteralType::String(v) => v.to_string(),
+            LiteralType::Number(v) => v.to_string(),
+            LiteralType::Bool(v) => v.to_string(),
+            LiteralType::Nil => "Nil".to_string(),
         },
         Expr::Unary { op, right } => parenthesize(&op.lexeme, &[right]),
         Expr::Ternary {
@@ -50,7 +49,7 @@ mod test {
         use TokenType::*;
         let expression = Binary {
             left: Box::new(Literal {
-                value: Some(LiteralType::Number(10.2)),
+                value: LiteralType::Number(10.2),
             }),
             op: Token {
                 t_type: Plus,
@@ -59,7 +58,7 @@ mod test {
                 line: 0,
             },
             right: Box::new(Literal {
-                value: Some(LiteralType::Number(10.2)),
+                value: LiteralType::Number(10.2),
             }),
         };
 
@@ -77,13 +76,13 @@ mod test {
             left: Box::new(Unary {
                 op: Token::new(Minus, "-", None, 0),
                 right: Box::new(Expr::Literal {
-                    value: Some(LiteralType::number_literal(123.0)),
+                    value: LiteralType::number_literal(123.0),
                 }),
             }),
             op: Token::new(Star, "*", None, 0),
             right: Box::new(Grouping {
                 expression: Box::new(Literal {
-                    value: Some(LiteralType::number_literal(45.67)),
+                    value: LiteralType::number_literal(45.67),
                 }),
             }),
         };