External Lab - Ellen Hui

src/main/scala/calculator/ir/AST.scala

@@ -4,17 +4,20 @@ package calculator.ir
  * -----------
  * Grammar
  * -----------
- * 
- *                   n ∈ 𝒵 
- * 
+ *
+ *                   n ∈ 𝒵
+ *
  *       e ∈ Expr ::= e + t | e - t | t
  *       t ∈ Term ::= t * f | t / f | f
  *       f ∈ Fact ::= n | ( e )
- *  
+ *
  */
 
 sealed abstract class AST
 sealed abstract class Expr extends AST
 
 case class Num(n: Int) extends Expr
 case class Plus(left: Expr, right: Expr) extends Expr
+case class Minus(left: Expr, right: Expr) extends Expr
+case class Times(left: Expr, right: Expr) extends Expr
+case class Div(left: Expr, right: Expr) extends Expr

src/main/scala/calculator/ir/sugar.scala

@@ -7,14 +7,17 @@ package object ir {
 
   // to use a number on its own
   implicit def int2Number(i: Int): Num = Num(i)
-  
+
   // to use a number as part of a binary operation...
   implicit def intToExprBuilder(n: Int) = new ExprBuilder(Num(n))
 
   // to build up operations using infix notation from left to right...
-  // ExprBuilder saves the left operand and defines methods that 
-  //   take the right operand and returns the appropriate Expr 
+  // ExprBuilder saves the left operand and defines methods that
+  //   take the right operand and returns the appropriate Expr
   implicit class ExprBuilder(val left: Expr) {
     def |+|(right: Expr) = Plus(left, right)
+    def |-|(right: Expr) = Minus(left, right)
+    def |*|(right: Expr) = Times(left, right)
+    def |/|(right: Expr) = Div(left, right)
   }
 }

src/main/scala/calculator/parser/Parser.scala

@@ -9,15 +9,24 @@ object CalcParser extends JavaTokenParsers with PackratParsers {
     def apply(s: String): ParseResult[AST] = parseAll(expr, s)
 
     // expressions
-    lazy val expr: PackratParser[Expr] = 
-      (   expr~"+"~fact ^^ {case l~"+"~r ⇒ l |+| r}
-        | fact )
-
+    lazy val expr: PackratParser[Expr] =
+      (   expr~"+"~term ^^ {case l~"+"~r ⇒ l |+| r}
+        | expr~"-"~term ^^ {case l~"-"~r => l |-| r}
+        | term )
+
+
+    lazy val term: PackratParser[Expr] =
+      (   term~"*"~fact ^^ {case l~"*"~r => l |*| r}
+        | term~"/"~fact ^^ {case l~"/"~r => l |/| r}
+        | fact
+      )
+
     // factors
     lazy val fact: PackratParser[Expr] =
-      number
-
+    (   number
+      | "("~>expr<~")" )
+
     // numbers
     def number: Parser[Num] = wholeNumber ^^ {s ⇒ Num(s.toInt)}
-    
+
  }

src/main/scala/calculator/semantics/Interpreter.scala

@@ -6,5 +6,8 @@ package object semantics {
   def eval(ast: AST): Int = ast match {
     case Num(i) ⇒ i
     case Plus(left, right) ⇒ eval(left) + eval(right)
+    case Minus(left, right) ⇒ eval(left) - eval(right)
+    case Times(left, right) ⇒ eval(left) * eval(right)
+    case Div(left, right) ⇒ eval(left) / eval(right)
   }
-}
+}

src/test/scala/calculator/parser/ParserTest.scala

@@ -9,38 +9,82 @@ import edu.hmc.langtools._
 class CalcParserTests extends FunSpec with LangParseMatchers[AST] {
 
   override val parser = CalcParser.apply _
-  
+
   describe("A number") {
 
     it("can be a single digit") {
       program("1") should parseAs ( 1 )
     }
-    
+
     it ("can be multiple digits") {
       program("10") should parseAs ( 10 )
       program("121") should parseAs ( 121 )
     }
-    
+
     it ("can be a negative number") {
       program("-10") should parseAs ( -10 )
     }
-    
+
     it ("cannot be floating-point number") {
       program("1.1") should not (parse)
       program(" .3") should not (parse)
     }
 
   }
-  
+
   describe("Addition") {
 
     it("can add two numbers") {
       program("1+1") should parseAs ( 1 |+| 1 )
     }
-    
+
     it("can be chained (and is left-associative)") {
       program("1 + 2 + 100") should parseAs ( (1 |+| 2) |+| 100 )
     }
 
   }
+
+  describe("Subtraction") {
+
+    it("can subtract two numbers") {
+      program("1-1") should parseAs ( 1 |-| 1 )
+    }
+
+    it("can be chained (and is left-associative)") {
+      program("1 - 2 - 2") should parseAs ( (1 |-| 2) |-| 2 )
+    }
+  }
+
+  describe("Multiplication") {
+
+    it("can multiply two numbers") {
+      program("2*2") should parseAs ( 2 |*| 2 )
+    }
+
+    it("can be chained (and is left-associative)") {
+      program("1 * 2 * 2") should parseAs ( (1 |*| 2) |*| 2 )
+    }
+  }
+
+  describe("Division") {
+
+    it("can divide two numbers") {
+      program("2/2") should parseAs ( 2 |/| 2 )
+    }
+
+    it("can be chained (and is left-associative)") {
+      program("1 / 2 / 2") should parseAs ( (1 |/| 2) |/| 2 )
+    }
+  }
+
+  describe("Parentheticals") {
+    it("is legal") {
+      program("(1)") should parseAs (1)
+    }
+
+    it("changes precedence ") {
+      program("1 + (1 + 1)") should parseAs (1 |+| (1 |+| 1))
+    }
+  }
+
 }

src/test/scala/calculator/semantics/SemanticsTest.scala

@@ -40,4 +40,66 @@ class NumSemanticsTests extends FunSpec
 
   }
 
+  describe("Subtraction") {
+
+    it("can subtract two numbers") {
+      program("1 - 1") should compute (0)
+    }
+
+    it("can be chained (and is left-associative)") {
+      program("1 - 2 - 2") should compute (-3)
+    }
+
+    it("can handle negative numbers") {
+      program("1 - -1") should compute (2)
+    }
+
+  }
+
+  describe("Multiplication") {
+
+    it("can multiply two numbers") {
+      program("2 * 3") should compute (6)
+    }
+
+    it("can be chained (and is left-associative)") {
+      program("1 * 2 * 2") should compute (4)
+    }
+
+    it("can handle negative numbers") {
+      program("1 * -1") should compute (-1)
+    }
+
+    it("can handle TWO negative numbers") {
+      program("-1 * -1") should compute (1)
+    }
+
+  }
+
+  describe("Division") {
+
+    it("can divide two numbers") {
+      program("6 / 3") should compute (2)
+    }
+
+    it("can be chained (and is left-associative)") {
+      program("8 / 2 / 2") should compute (2)
+    }
+
+    it("can handle negative numbers") {
+      program("1 * -1") should compute (-1)
+    }
+
+    it("can handle TWO negative numbers") {
+      program("-1 * -1") should compute (1)
+    }
+  }
+
+  describe("Parentheticals") {
+
+    it("can change associativity") {
+      program("1 - (1 - 1)") should compute (1)
+    }
+  }
+
 }