Added two new helper methods in LoxValue and refactored switch in `…

…handleBinaryExpression()`.
quephird · Mar 23, 2024 · c7b620e · c7b620e
1 parent 26e5d1f
commit c7b620e
Show file tree

Hide file tree

Showing 4 changed files with 40 additions and 54 deletions.
diff --git a/slox/Interpreter.swift b/slox/Interpreter.swift
@@ -379,7 +379,10 @@ class Interpreter {
             default:
                 break
             }
-        case (.double(let leftNumber), .double(let rightNumber)):
+        case (.int, .double), (.double, .int), (.double, .double):
+            let leftNumber = try leftValue.convertToRawDouble()
+            let rightNumber = try rightValue.convertToRawDouble()
+
             switch oper.type {
             case .plus:
                 return .double(leftNumber + rightNumber)
@@ -400,67 +403,25 @@ class Interpreter {
             default:
                 break
             }
-        case (.int(let leftNumber), .double(let rightNumber)):
-            let leftNumber = Double(leftNumber)
+        case (.string(let leftString), .string(let rightString)):
             switch oper.type {
             case .plus:
-                return .double(leftNumber + rightNumber)
-            case .minus:
-                return .double(leftNumber - rightNumber)
-            case .star:
-                return .double(leftNumber * rightNumber)
-            case .slash:
-                return .double(leftNumber / rightNumber)
-            case .greater:
-                return .boolean(leftNumber > rightNumber)
-            case .greaterEqual:
-                return .boolean(leftNumber >= rightNumber)
-            case .less:
-                return .boolean(leftNumber < rightNumber)
-            case .lessEqual:
-                return .boolean(leftNumber <= rightNumber)
+                return .string(leftString + rightString)
             default:
                 break
             }
-        case (.double(let leftNumber), .int(let rightNumber)):
-            let rightNumber = Double(rightNumber)
+        case (.instance(let leftList as LoxList), .instance(let rightList as LoxList)):
             switch oper.type {
             case .plus:
-                return .double(leftNumber + rightNumber)
-            case .minus:
-                return .double(leftNumber - rightNumber)
-            case .star:
-                return .double(leftNumber * rightNumber)
-            case .slash:
-                return .double(leftNumber / rightNumber)
-            case .greater:
-                return .boolean(leftNumber > rightNumber)
-            case .greaterEqual:
-                return .boolean(leftNumber >= rightNumber)
-            case .less:
-                return .boolean(leftNumber < rightNumber)
-            case .lessEqual:
-                return .boolean(leftNumber <= rightNumber)
+                let newElements = leftList.elements + rightList.elements
+                return try makeList(elements: newElements)
             default:
                 break
             }
         default:
             break
         }
 
-        if case .string(let leftString) = leftValue,
-           case .string(let rightString) = rightValue,
-           case .plus = oper.type {
-            return .string(leftString + rightString)
-        }
-
-        if case .instance(let leftList as LoxList) = leftValue,
-           case .instance(let rightList as LoxList) = rightValue,
-           case .plus = oper.type {
-            let newElements = leftList.elements + rightList.elements
-            return try makeList(elements: newElements)
-        }
-
         switch oper.type {
         case .bangEqual:
             return .boolean(!leftValue.isEqual(to: rightValue))

diff --git a/slox/LoxValue.swift b/slox/LoxValue.swift
@@ -83,4 +83,26 @@ enum LoxValue: CustomStringConvertible, Equatable {
             return true
         }
     }
+
+    func convertToRawInt() throws -> Int {
+        switch self {
+        case .int(let number):
+            return number
+        case .double(let number):
+            return Int(number)
+        default:
+            throw RuntimeError.notANumber
+        }
+    }
+
+    func convertToRawDouble() throws -> Double {
+        switch self {
+        case .int(let number):
+            return Double(number)
+        case .double(let number):
+            return number
+        default:
+            throw RuntimeError.notANumber
+        }
+    }
 }
diff --git a/slox/RuntimeError.swift b/slox/RuntimeError.swift
@@ -18,6 +18,7 @@ enum RuntimeError: CustomStringConvertible, Equatable, LocalizedError {
     case notACallableObject
     case notAnInstance
     case notAList
+    case notANumber
     case onlyInstancesHaveProperties
     case undefinedProperty(String)
     case wrongArity(Int, Int)
@@ -48,6 +49,8 @@ enum RuntimeError: CustomStringConvertible, Equatable, LocalizedError {
             return "Error: expected an instance"
         case .notAList:
             return "Error: expected a list"
+        case .notANumber:
+            return "Error: expected a number"
         case .onlyInstancesHaveProperties:
             return "Error: can only get/set properties of instances"
         case .undefinedProperty(let name):

diff --git a/sloxTests/InterpreterTests.swift b/sloxTests/InterpreterTests.swift
@@ -521,12 +521,12 @@ xyzzy
         }
         let actual = list.elements
         let expected: [LoxValue] = [
-            .number(1),
-            .number(2),
-            .number(3),
-            .number(4),
-            .number(5),
-            .number(6),
+            .int(1),
+            .int(2),
+            .int(3),
+            .int(4),
+            .int(5),
+            .int(6),
         ]
         XCTAssertEqual(actual, expected)
     }