Migrate minus operator evaluator to Kotlin

src/main/kotlin/io/smnp/dsl/ast/model/node/UnaryOperatorAbstractNode.kt

@@ -1,6 +1,9 @@
 package io.smnp.dsl.ast.model.node
 
 abstract class UnaryOperatorAbstractNode(operator: Node, operand: Node) : Node(2, operator.position) {
+    operator fun component1() = children[0]
+    operator fun component2() = children[1]
+
     val operator: Node
     get() = children[0]
 

src/main/kotlin/io/smnp/error/EvaluationException.kt

@@ -0,0 +1,8 @@
+package io.smnp.error
+
+import io.smnp.dsl.token.model.entity.TokenPosition
+
+class EvaluationException(message: String?, val position: TokenPosition?) : Exception(message) {
+    override val message: String?
+        get() = super.message + if(position != null) " $position" else ""
+}

src/main/kotlin/io/smnp/evaluation/evaluator/DefaultEvaluator.kt

@@ -15,7 +15,9 @@ class DefaultEvaluator : Evaluator {
             forward(BoolLiteralEvaluator(), BoolLiteralNode::class),
             forward(NoteLiteralEvaluator(), NoteLiteralNode::class),
             forward(ListEvaluator(), ListNode::class),
-            forward(MapEvaluator(), MapNode::class)
+            forward(MapEvaluator(), MapNode::class),
+
+            forward(MinusOperatorEvaluator(), MinusOperatorNode::class)
         ).evaluate(node, environment)
     }
 }

src/main/kotlin/io/smnp/evaluation/evaluator/MinusOperatorEvaluator.kt

@@ -0,0 +1,25 @@
+package io.smnp.evaluation.evaluator
+
+import io.smnp.data.enumeration.DataType
+import io.smnp.data.model.Value
+import io.smnp.dsl.ast.model.node.MinusOperatorNode
+import io.smnp.dsl.ast.model.node.Node
+import io.smnp.error.EvaluationException
+import io.smnp.evaluation.environment.Environment
+import io.smnp.evaluation.model.entity.EvaluatorOutput
+
+class MinusOperatorEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val evaluator = DefaultEvaluator()
+        val (_, operandNode) = (node as MinusOperatorNode)
+        val operand = evaluator.evaluate(operandNode, environment)
+
+        return EvaluatorOutput.value(when(operand.value!!.type) {
+            DataType.INT -> Value.int(-1 * operand.value.value as Int)
+            DataType.FLOAT -> Value.float(-1.0f * operand.value.value as Float)
+            DataType.STRING -> Value.string((operand.value.value as String).reversed())
+            DataType.LIST -> Value.list((operand.value.value as List<Value>).reversed())
+            else -> throw EvaluationException("Type ${operand.value.type.name.toLowerCase()} does not support minus operator", node.position)
+        })
+    }
+}