Support constant value expressions (#27)

Author: themisir

book/src/01_calculator/grammar_lexer_parser.md

@@ -33,7 +33,7 @@ Don't let this overwhelm you - let's break it down line by line:
 
 **`Expr = { UnaryExpr | BinaryExpr | Term }`** - An expression is either unary (`-1`), binary (`1 + 2`), or a simple term (just a number). The `|` means "or" - try each alternative in order.
 
-**`Term = _{ Int | "(" ~ Expr ~ ")" }`** - A term is either a number or a parenthesized expression. This is how we handle `(1 + 2) * 3` - the parenthesized part becomes a single term.
+**`Term = { Int | "(" ~ Expr ~ ")" }`** - A term is either a number or a parenthesized expression. This is how we handle `(1 + 2) * 3` - the parenthesized part becomes a single term.
 
 **`UnaryExpr = { Operator ~ Term }`** - A unary expression is an operator followed by a term, like `-1` or `+5`.
 

calculator/src/compiler/interpreter.rs

@@ -57,6 +57,7 @@ mod tests {
 
     #[test]
     fn basics() {
+        assert_eq!(Interpreter::from_source("1").unwrap() as i32, 1);
         assert_eq!(Interpreter::from_source("1 + 2").unwrap() as i32, 3);
         // assert_eq!(Interpreter::source("(1 + 2)").unwrap() as i32, 3);
         assert_eq!(Interpreter::from_source("2 + (2 - 1)").unwrap() as i32, 3);

calculator/src/grammar.pest

@@ -2,7 +2,7 @@ Program = _{ SOI ~ Expr ~ EOF }
 
 Expr = { BinaryExpr | UnaryExpr | Term }
 
-Term = _{ Int | "(" ~ Expr ~ ")" }
+Term = { Int | "(" ~ Expr ~ ")" }
 
 UnaryExpr = { Operator ~ Term }
 

calculator/src/parser.rs

@@ -62,11 +62,15 @@ fn build_ast_from_expr(pair: pest::iterators::Pair<Rule>) -> Node {
                 }
             }
         }
+        Rule::Term => build_ast_from_term(pair),
         unknown => panic!("Unknown expr: {:?}", unknown),
     }
 }
 
 fn build_ast_from_term(pair: pest::iterators::Pair<Rule>) -> Node {
+    assert_eq!(pair.as_rule(), Rule::Term);
+
+    let pair = pair.into_inner().next().unwrap();
     match pair.as_rule() {
         Rule::Int => {
             let int: i32 = pair.as_str().parse().unwrap();
@@ -106,6 +110,10 @@ mod tests {
     #[test]
     fn basics() {
         assert!(parse("b").is_err());
+
+        let one = parse("1");
+        assert!(one.is_ok());
+        assert_eq!(one.unwrap()[0], Node::Int(1));
     }
 
     #[test]