Migrate literal evaluators to Kotlin

src/main/kotlin/dsl/ast/model/node/AbstractIterableNode.kt

@@ -2,4 +2,7 @@ package dsl.ast.model.node
 
 import dsl.token.model.entity.TokenPosition
 
-abstract class AbstractIterableNode(items: List<Node>, position: TokenPosition) : Node(items, position)
+abstract class AbstractIterableNode(items: List<Node>, position: TokenPosition) : Node(items, position) {
+    val items: List<Node>
+    get() = children
+}

src/main/kotlin/evaluation/evaluator/BoolLiteralEvaluator.kt

@@ -0,0 +1,14 @@
+package evaluation.evaluator
+
+import data.model.Value
+import dsl.ast.model.node.BoolLiteralNode
+import dsl.ast.model.node.Node
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class BoolLiteralEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val value = (node as BoolLiteralNode).token.value as Boolean
+        return EvaluatorOutput.value(Value.bool(value))
+    }
+}

src/main/kotlin/evaluation/evaluator/Evaluator.kt

@@ -4,15 +4,16 @@ import dsl.ast.model.node.Node
 import evaluation.environment.Environment
 import evaluation.model.entity.EvaluatorOutput
 import evaluation.model.enumeration.EvaluationResult
+import kotlin.reflect.KClass
 
 interface Evaluator {
     fun evaluate(node: Node, environment: Environment): EvaluatorOutput
 
     companion object {
-        fun forward(evaluator: Evaluator, vararg nodes: Node): Evaluator {
+        fun forward(evaluator: Evaluator, vararg nodes: KClass<out Node>): Evaluator {
             return object : Evaluator {
                 override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
-                    if(nodes.map { it::class }.any { it.isInstance(node) }) {
+                    if(nodes.any { it.isInstance(node) }) {
                         return evaluator.evaluate(node, environment)
                     }
 

src/main/kotlin/evaluation/evaluator/FloatLiteralEvaluator.kt

@@ -0,0 +1,14 @@
+package evaluation.evaluator
+
+import data.model.Value
+import dsl.ast.model.node.FloatLiteralNode
+import dsl.ast.model.node.Node
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class FloatLiteralEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val value = (node as FloatLiteralNode).token.value as Float
+        return EvaluatorOutput.value(Value.float(value))
+    }
+}

src/main/kotlin/evaluation/evaluator/IntegerLiteralEvaluator.kt

@@ -0,0 +1,14 @@
+package evaluation.evaluator
+
+import data.model.Value
+import dsl.ast.model.node.IntegerLiteralNode
+import dsl.ast.model.node.Node
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class IntegerLiteralEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val value = (node as IntegerLiteralNode).token.value as Int
+        return EvaluatorOutput.value(Value.int(value))
+    }
+}

src/main/kotlin/evaluation/evaluator/ListEvaluator.kt

@@ -0,0 +1,17 @@
+package evaluation.evaluator
+
+import data.model.Value
+import dsl.ast.model.node.ListNode
+import dsl.ast.model.node.Node
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class ListEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val atomEvaluator = RootEvaluator()
+        val items = (node as ListNode).items
+            .map { atomEvaluator.evaluate(it, environment) }
+            .map { it.value!! }
+        return EvaluatorOutput.value(Value.list(items))
+    }
+}

src/main/kotlin/evaluation/evaluator/MapEvaluator.kt

@@ -0,0 +1,20 @@
+package evaluation.evaluator
+
+import data.model.Value
+import dsl.ast.model.node.MapEntryNode
+import dsl.ast.model.node.MapNode
+import dsl.ast.model.node.Node
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class MapEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val atomEvaluator = RootEvaluator()
+        val value = (node as MapNode).items
+            .map { it as MapEntryNode }
+            .map { atomEvaluator.evaluate(it.key, environment).value!! to atomEvaluator.evaluate(it.value, environment).value!! }
+            .toMap()
+
+        return EvaluatorOutput.value(Value.map(value))
+    }
+}

src/main/kotlin/evaluation/evaluator/NoteLiteralEvaluator.kt

@@ -0,0 +1,15 @@
+package evaluation.evaluator
+
+import data.entity.Note
+import data.model.Value
+import dsl.ast.model.node.Node
+import dsl.ast.model.node.NoteLiteralNode
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class NoteLiteralEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val value = (node as NoteLiteralNode).token.value as Note
+        return EvaluatorOutput.value(Value.note(value))
+    }
+}

src/main/kotlin/evaluation/evaluator/RootEvaluator.kt

@@ -0,0 +1,21 @@
+package evaluation.evaluator
+
+import dsl.ast.model.node.*
+import evaluation.environment.Environment
+import evaluation.evaluator.Evaluator.Companion.forward
+import evaluation.evaluator.Evaluator.Companion.oneOf
+import evaluation.model.entity.EvaluatorOutput
+
+class RootEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        return oneOf(
+            forward(IntegerLiteralEvaluator(), IntegerLiteralNode::class),
+            forward(FloatLiteralEvaluator(), FloatLiteralNode::class),
+            forward(StringLiteralEvaluator(), StringLiteralNode::class),
+            forward(BoolLiteralEvaluator(), BoolLiteralNode::class),
+            forward(NoteLiteralEvaluator(), NoteLiteralNode::class),
+            forward(ListEvaluator(), ListNode::class),
+            forward(MapEvaluator(), MapNode::class)
+        ).evaluate(node, environment)
+    }
+}

src/main/kotlin/evaluation/evaluator/StringLiteralEvaluator.kt

@@ -0,0 +1,14 @@
+package evaluation.evaluator
+
+import data.model.Value
+import dsl.ast.model.node.Node
+import dsl.ast.model.node.StringLiteralNode
+import evaluation.environment.Environment
+import evaluation.model.entity.EvaluatorOutput
+
+class StringLiteralEvaluator : Evaluator {
+    override fun evaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val value = (node as StringLiteralNode).token.value as String
+        return EvaluatorOutput.value(Value.string(value))
+    }
+}