Add comparison operators

nicklockwood · nicklockwood · commit 066f831e279a · 2021-11-01T23:45:09.000Z
diff --git a/Help/expressions.md b/Help/expressions.md
@@ -14,7 +14,18 @@ Operators are used in conjunction with individual values to perform calculations
 5 + 3 * 4
 ```
 
-ShapeScript supports common [infix](https://en.wikipedia.org/wiki/Infix_notation) math operators such as +, -, * and /. Unary + and - are also supported:
+ShapeScript supports all the standard [infix](https://en.wikipedia.org/wiki/Infix_notation) arithmetic operators:
+
+Symbol         | Name                  | Function
+:------------- | :-------------------- | :--------------------------------------------------------------------
+&plus;         | plus                  | Adds the left and right values
+&dash;         | minus                 | Subtracts the right value from the left value
+&ast;          | times                 | Multiplies the left value by the right value
+&sol;          | divide                | Divides the left value by the right value
+
+<br>
+
+Unary + and - are also supported:
 
 ```swift
 -5 * +7
@@ -41,6 +52,40 @@ Whereas this expression would be interpreted as a 2D vector of 5 and -1:
 5 -1
 ```
 
+## Equality and Comparison
+
+In addition to the standard arithmetic operators, ShapeScript also has equality and comparison operators, which can be used in [conditional logic](control-flow.md#if-else). The following infix comparison operators are supported:
+
+Symbol         | Name                  | Function
+:------------- | :-------------------- |:--------------------------------------
+=              | equal                 | Compares two values and returns `true` if they are equal
+<>             | not equal             | Compares two values and returns `false` if they are equal
+<              | less than             | Returns `true` if the left value is less than the value on the right
+<=             | less than or equal    | Returns `true` if the left value is less than or equal to the right
+&gt;           | greater than          | Returns `true` if the left value is greater than the value on the right
+&gt;=          | greater than or equal | Returns `true` if the left value is greater than or equal to the right
+
+<br>
+
+**Note:** You may have used other languages where `=` is written as `==`. This is generally because in such languages the `=` operator is used for assignment, and re-using the same symbol would cause ambiguity. This is not a problem in ShapeScript.
+
+While these operators are typically used with numeric inputs, the *output* is a boolean value (`true` or `false`). These values are most commonly used in conjunction with with the `if/else` control flow statement. For example:
+
+```swift
+if rnd > 0.5 {
+    print "heads"
+} else {
+    print "tails"
+}
+```
+
+But they can also be assigned to a symbol and passed around:
+
+```swift
+define averageColor (color.red + color.green + color.blue) / 3
+define isBrightColor averageColor >= 0.5
+print isBrightColor // true or false
+```
 
 ## Members
 
@@ -57,7 +102,7 @@ print yComponent 0.2
 Like other operators, the dot operator can be used as part of a larger expression:
 
 ```swift
-define color 1 0.5 0.2
+color 1 0.5 0.2
 define averageColor (color.red + color.green + color.blue) / 3
 print averageColor // 0.5667
 ```
diff --git a/Help/index.md b/Help/index.md
@@ -64,6 +64,7 @@ ShapeScript Help
     - [Symbols](symbols.md)
     - [Expressions](expressions.md)
         - [Operators](expressions.md#operators)
+        - [Equality and Comparison](expressions.md#equality-and-comparison)
         - [Members](expressions.md#members)
         - [Ranges](expressions.md#ranges)
     - [Functions](functions.md)
diff --git a/ShapeScript/Interpreter.swift b/ShapeScript/Interpreter.swift
@@ -395,6 +395,7 @@ enum Value {
         case let .path(path): return path
         case let .mesh(mesh): return mesh
         case let .point(point): return point
+        case let .tuple(values) where values.count == 1: return values[0].value
         case let .tuple(values): return values.map { $0.value }
         case let .range(range): return range
         case let .bounds(bounds): return bounds
@@ -435,6 +436,13 @@ enum Value {
         }
     }
 
+    var tupleValue: [AnyHashable] {
+        if case let .tuple(values) = self {
+            return values.map { $0.value }
+        }
+        return [value]
+    }
+
     var type: ValueType {
         switch self {
         case .color: return .color
@@ -1216,6 +1224,14 @@ extension Expression {
                 )
             }
             return .range(value)
+        case let .infix(lhs, .equal, rhs):
+            let lhs = try lhs.evaluate(in: context)
+            let rhs = try rhs.evaluate(in: context)
+            return .boolean(lhs.value == rhs.value)
+        case let .infix(lhs, .unequal, rhs):
+            let lhs = try lhs.evaluate(in: context)
+            let rhs = try rhs.evaluate(in: context)
+            return .boolean(lhs.value != rhs.value)
         case let .infix(lhs, op, rhs):
             let lhs = try lhs.evaluate(as: .number, for: String(op.rawValue), index: 0, in: context)
             let rhs = try rhs.evaluate(as: .number, for: String(op.rawValue), index: 1, in: context)
@@ -1228,7 +1244,15 @@ extension Expression {
                 return .number(lhs.doubleValue * rhs.doubleValue)
             case .divide:
                 return .number(lhs.doubleValue / rhs.doubleValue)
-            case .to, .step:
+            case .lt:
+                return .boolean(lhs.doubleValue < rhs.doubleValue)
+            case .gt:
+                return .boolean(lhs.doubleValue > rhs.doubleValue)
+            case .lte:
+                return .boolean(lhs.doubleValue <= rhs.doubleValue)
+            case .gte:
+                return .boolean(lhs.doubleValue >= rhs.doubleValue)
+            case .to, .step, .equal, .unequal:
                 preconditionFailure("\(op.rawValue) should be handled by earlier case")
             }
         case let .member(expression, member):
diff --git a/ShapeScript/Lexer.swift b/ShapeScript/Lexer.swift
@@ -59,6 +59,13 @@ public enum InfixOperator: String {
     case minus = "-"
     case times = "*"
     case divide = "/"
+    // Comparison operators
+    case lt = "<"
+    case gt = ">"
+    case lte = "<="
+    case gte = ">="
+    case equal = "="
+    case unequal = "<>"
     // Range operators
     case to, step
 }
diff --git a/ShapeScript/Parser.swift b/ShapeScript/Parser.swift
@@ -383,7 +383,7 @@ private extension ArraySlice where Element == Token {
         )
     }
 
-    mutating func readExpression() throws -> Expression? {
+    mutating func readStep() throws -> Expression? {
         guard let lhs = try readRange() else {
             return nil
         }
@@ -407,6 +407,27 @@ private extension ArraySlice where Element == Token {
         )
     }
 
+    mutating func readComparison() throws -> Expression? {
+        guard let lhs = try readStep() else {
+            return nil
+        }
+        guard case let .infix(op) = nextToken.type, [
+            .lt, .lte, .gt, .gte, .equal, .unequal,
+        ].contains(op) else {
+            return lhs
+        }
+        removeFirst()
+        let rhs = try require(readSum(), as: "operand")
+        return Expression(
+            type: .infix(lhs, op, rhs),
+            range: lhs.range.lowerBound ..< rhs.range.upperBound
+        )
+    }
+
+    mutating func readExpression() throws -> Expression? {
+        try readComparison()
+    }
+
     mutating func readExpressions(allowLinebreaks: Bool = false) throws -> Expression? {
         var expressions = [Expression]()
         while var expression = try readExpression() {
diff --git a/ShapeScript/StandardLibrary.swift b/ShapeScript/StandardLibrary.swift
@@ -66,7 +66,7 @@ extension Dictionary where Key == String, Value == Symbol {
 
     static let materials: Symbols = color + [
         "opacity": .property(.number, { parameter, context in
-            context.material.opacity = (parameter.value as! Double) * context.opacity
+            context.material.opacity = parameter.doubleValue * context.opacity
         }, { context in
             .number(context.material.opacity / context.opacity)
         }),
@@ -309,7 +309,7 @@ extension Dictionary where Key == String, Value == Symbol {
         }),
         // Debug
         "print": .command(.tuple) { value, context in
-            context.debugLog(value.value as! [AnyHashable])
+            context.debugLog(value.tupleValue)
             return .void
         },
     ])
diff --git a/ShapeScriptTests/InterpreterTests.swift b/ShapeScriptTests/InterpreterTests.swift
@@ -1707,7 +1707,7 @@ class InterpreterTests: XCTestCase {
         }
     }
 
-    // MARK: Functions
+    // MARK: Math functions
 
     func testInvokeMonadicFunction() {
         let program = "print cos pi"
@@ -1871,6 +1871,185 @@ class InterpreterTests: XCTestCase {
         XCTAssertEqual(delegate.log, [2])
     }
 
+    // MARK: Numeric comparison
+
+    func testGT() {
+        let program = "print 5 > 1"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testGT2() {
+        let program = "print 5 > 6"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testGT3() {
+        let program = "print 5 > 5"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testGTE() {
+        let program = "print 2 >= 1"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testGTE2() {
+        let program = "print 2 >= 5"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testGTE3() {
+        let program = "print -2 >= -2"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testLT() {
+        let program = "print 1 < 2"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testLT2() {
+        let program = "print 5 < 4"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testLT3() {
+        let program = "print -2 < -2"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testLTE() {
+        let program = "print 1 <= 2"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testLTE2() {
+        let program = "print 5 <= 4"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testLTE3() {
+        let program = "print -2 <= -2"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    // MARK: Equality
+
+    func testNumbersEqual() {
+        let program = "print 5 = 5"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testNumbersEqual2() {
+        let program = "print 5 = 2"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testNumbersUnequal() {
+        let program = "print 5 <> 5"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testNumbersUnequal2() {
+        let program = "print 5 <> 4"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testStringsEqual() {
+        let program = "print \"foo\" = \"foo\""
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testStringsEqual2() {
+        let program = "print \"foo\" = \"bar\""
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testStringsUnequal() {
+        let program = "print \"foo\" <> \"foo\""
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testStringsUnequal2() {
+        let program = "print \"foo\" <> \"bar\""
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testTuplesEqual() {
+        let program = "print 1 2 3 = 1 2 3"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [1, 2, false, 2, 3])
+    }
+
+    func testTuplesEqual2() {
+        let program = "print (1 2 3) = (1 2 3)"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testFunctionResultsEqual() {
+        let program = "print min(1 2) = 1"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
+    func testMismatchedTypesEqual() {
+        let program = "print \"foo\" = 5"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [false])
+    }
+
+    func testMismatchedTypesUnequal() {
+        let program = "print \"foo\" <> 5"
+        let delegate = TestDelegate()
+        XCTAssertNoThrow(try evaluate(parse(program), delegate: delegate))
+        XCTAssertEqual(delegate.log, [true])
+    }
+
     // MARK: Member lookup
 
     func testTupleVectorLookup() {
diff --git a/ShapeScriptTests/ParserTests.swift b/ShapeScriptTests/ParserTests.swift
