refactor identifier parsing

src/parser/parser.rs

@@ -16,11 +16,7 @@ pub fn parse<T>(tokens: &mut Tokens, parser: Parser<T>) -> Result<T, Error> {
 
 fn parse_definition(tokens: &mut Tokens) -> ParseResult<ast::Definition> {
     if let Some(_) = tokens.next_if(Token::Let) {
-        if let Some(LocatedToken {
-            token: Token::Identifier(identifier),
-            ..
-        }) = tokens.next_if(Token::Identifier("".into()))
-        {
+        if let Some(identifier) = parse_identifier_(tokens)? {
             if let Some(_eq) = tokens.next_if(Token::Equals) {
                 if let Some(expr) = parse_expr(tokens)? {
                     if let Some(_) = tokens.next_if(Token::Semicolon) {
@@ -53,7 +49,6 @@ fn parse_definition(tokens: &mut Tokens) -> ParseResult<ast::Definition> {
             })
         }
     } else {
-        println!("not let! {tokens:#?}");
         Ok(None)
     }
 }
@@ -73,7 +68,6 @@ fn parse_simple_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
 }
 
 fn parse_string(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
-    {
     if let Some(LocatedToken {
         token: Token::String(string),
         ..
@@ -83,11 +77,9 @@ fn parse_string(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
     } else {
         Ok(None)
     }
-    }
 }
 
 fn parse_number(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
-    {
     if let Some(LocatedToken {
         token: Token::Number(number),
         ..
@@ -97,21 +89,22 @@ fn parse_number(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
     } else {
         Ok(None)
     }
-    }
 }
 
 fn parse_identifier(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
-    {
+    Ok(parse_identifier_(tokens)?.map(|string| ast::Expr::Var(ast::Name(string))))
+}
+
+fn parse_identifier_(tokens: &mut Tokens) -> ParseResult<String> {
     if let Some(LocatedToken {
         token: Token::Identifier(string),
         ..
-        }) = tokens.next_if(Token::String("".into()))
+    }) = tokens.next_if(Token::Identifier("".into()))
     {
-            Ok(Some(ast::Expr::Var(ast::Name(string))))
+        Ok(Some(string))
     } else {
         Ok(None)
     }
-    }
 }
 
 fn parse_bool(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
@@ -149,6 +142,12 @@ mod tests {
         insta::assert_debug_snapshot!(result);
     }
     #[test]
+    fn paren_identifier() {
+        let program = "(hello)".to_string();
+        let result = parse(&mut scan(program), parse_expr);
+        insta::assert_debug_snapshot!(result);
+    }
+    #[test]
     fn let_number() {
         let program = "let x = 108;".to_string();
         let result = parse(&mut scan(program), parse_definition);

src/parser/snapshots/ayin__parser__parser__tests__paren_identifier.snap

@@ -0,0 +1,11 @@
+---
+source: src/parser/parser.rs
+expression: result
+---
+Ok(
+    Var(
+        Name(
+            "hello",
+        ),
+    ),
+)

src/parser/types.rs

@@ -51,10 +51,7 @@ impl Tokens {
             (Token::Identifier(_), Token::Identifier(_)) => true,
             (Token::Number(_), Token::Number(_)) => true,
             (Token::String(_), Token::String(_)) => true,
-            x => {
-                println!("next_if fail: {x:#?}");
-                false
-            }
+            x => false,
         })
     }
     pub fn between<T>(&mut self, start: Token, end: Token, parser: Parser<T>) -> ParseResult<T> {