tests pass with ast

Author: murzagalin

src/commonMain/kotlin/com/github/murzagalin/evaluator/Evaluator.kt

@@ -1,15 +1,20 @@
 package com.github.murzagalin.evaluator
 
+import com.github.murzagalin.evaluator.ast.BooleanAstEvaluator
+import com.github.murzagalin.evaluator.ast.DoubleAstEvaluator
+import com.github.murzagalin.evaluator.ast.Expression
+import com.github.murzagalin.evaluator.ast.Parser
+
 class Evaluator(
     functions: List<Function> = DefaultFunctions.ALL,
     constants: List<Constant> = DefaultConstants.ALL,
     doubleDelimiter: Char = '.',
     argumentsDelimiter: Char = ','
 ) {
 
-    private val booleanEvaluator = BooleanEvaluator()
-    private val doubleEvaluator = DoubleEvaluator()
-    private val converter = Converter()
+    private val booleanEvaluator = BooleanAstEvaluator()
+    private val doubleEvaluator = DoubleAstEvaluator()
+    private val parser = Parser()
     private val tokenizer = Tokenizer(
         functions = functions,
         constants = constants,
@@ -22,34 +27,34 @@ class Evaluator(
         values: Map<String, Any> = emptyMap()
     ): Double {
         val tokenized = tokenizer.tokenize(expression)
-        val converted = converter.convert(tokenized)
+        val parsed = parser.parse(tokenized)
 
-        return doubleEvaluator.evaluate(converted, values)
+        return doubleEvaluator.evaluate(parsed, values)
     }
 
     fun evaluateBoolean(
         expression: String,
         values: Map<String, Any> = emptyMap()
     ): Boolean {
         val tokenized = tokenizer.tokenize(expression)
-        val converted = converter.convert(tokenized)
+        val parsed = parser.parse(tokenized)
 
-        return booleanEvaluator.evaluate(converted, values)
+        return booleanEvaluator.evaluate(parsed, values)
     }
 
     fun evaluateDouble(
-        expression: PreprocessedExpression,
+        expression: Expression,
         values: Map<String, Any> = emptyMap()
     ) = doubleEvaluator.evaluate(expression, values)
 
     fun evaluateBoolean(
-        expression: PreprocessedExpression,
+        expression: Expression,
         values: Map<String, Any> = emptyMap()
     ) = booleanEvaluator.evaluate(expression, values)
 
-    fun preprocessExpression(expression: String): PreprocessedExpression {
+    fun preprocessExpression(expression: String): Expression {
         val tokenized = tokenizer.tokenize(expression)
 
-        return converter.convert(tokenized)
+        return parser.parse(tokenized)
     }
 }

src/commonMain/kotlin/com/github/murzagalin/evaluator/Token.kt

@@ -65,6 +65,8 @@ sealed interface Token {
             }
         }
 
+        operator fun invoke(args: List<Any>) = function(*args.toTypedArray())
+
         object Delimiter: Token
     }
 

src/commonMain/kotlin/com/github/murzagalin/evaluator/ast/BooleanAstEvaluator.kt

@@ -0,0 +1,13 @@
+package com.github.murzagalin.evaluator.ast
+
+class BooleanAstEvaluator {
+
+    fun evaluate(expression: Expression, values: Map<String, Any> = emptyMap()): Boolean {
+        val baseEvaluator = AstEvaluator(values)
+        val evaluated = baseEvaluator.evaluate(expression)
+
+        require(evaluated is Boolean)
+
+        return evaluated
+    }
+}

src/commonMain/kotlin/com/github/murzagalin/evaluator/ast/DoubleAstEvaluator.kt

@@ -0,0 +1,13 @@
+package com.github.murzagalin.evaluator.ast
+
+class DoubleAstEvaluator {
+
+    fun evaluate(expression: Expression, values: Map<String, Any> = emptyMap()): Double {
+        val baseEvaluator = AstEvaluator(values)
+        val evaluated = baseEvaluator.evaluate(expression)
+
+        require(evaluated is Number)
+
+        return evaluated.toDouble()
+    }
+}

src/commonMain/kotlin/com/github/murzagalin/evaluator/ast/Expression.kt

@@ -3,30 +3,52 @@ package com.github.murzagalin.evaluator.ast
 import com.github.murzagalin.evaluator.Token
 
 sealed class Expression {
+
+    abstract fun visit(visitor: AstVisitor): Any
+
     data class Unary(
         val token: Token.Operator,
         val expression: Expression
-    ) : Expression()
+    ) : Expression() {
+        override fun visit(visitor: AstVisitor) = visitor.visitUnary(this)
+    }
 
     data class Binary(
         val token: Token.Operator,
         val leftExpression: Expression,
         val rightExpression: Expression
-    ) : Expression()
+    ) : Expression() {
+        override fun visit(visitor: AstVisitor) = visitor.visitBinary(this)
+    }
 
     data class Ternary(
         val token: Token.Operator,
         val firstExpression: Expression,
         val secondExpression: Expression,
         val thirdExpression: Expression
-    ) : Expression()
+    ) : Expression() {
+        override fun visit(visitor: AstVisitor) = visitor.visitTernary(this)
+    }
 
     data class FunctionCall(
         val token: Token.FunctionCall,
         val arguments: List<Expression>
-    ) : Expression()
+    ) : Expression() {
+        override fun visit(visitor: AstVisitor) = visitor.visitFunctionCall(this)
+    }
 
     data class Terminal(
         val token: Token.Operand
-    ) : Expression()
+    ) : Expression() {
+        override fun visit(visitor: AstVisitor) = visitor.visitTerminal(this)
+    }
+}
+
+
+interface AstVisitor {
+    fun visitUnary(unary: Expression.Unary): Any
+    fun visitBinary(binary: Expression.Binary): Any
+    fun visitTernary(ternary: Expression.Ternary): Any
+    fun visitFunctionCall(functionCall: Expression.FunctionCall): Any
+    fun visitTerminal(terminal: Expression.Terminal): Any
 }

src/commonMain/kotlin/com/github/murzagalin/evaluator/ast/Parser.kt

@@ -2,9 +2,7 @@ package com.github.murzagalin.evaluator.ast
 
 import com.github.murzagalin.evaluator.Token
 
-
-/* the parser uses these rules
-
+/*
 expression -> ternary_if
 ternary_if -> logic_or ( "?" ternary_if ":" ternary_if )?
 logic_or   -> logic_and ( ( "or" | "||" ) logic_and )*
@@ -173,7 +171,7 @@ class Parser {
                     arguments += expression(tokens)
                     if (tokens[ix] is Token.FunctionCall.Delimiter) ix++
                 }
-                require(tokens[ix] is Token.Bracket.Right) { "expected ')' after a function call" }
+                require(tokens[ix++] is Token.Bracket.Right) { "expected ')' after a function call" }
 
                 return Expression.FunctionCall(token, arguments)
             }

src/commonTest/kotlin/com/github/murzagalin/evaluator/ast/ParserFunctionsTest.kt

@@ -78,4 +78,50 @@ class ParserFunctionsTest {
             subject.parse(expression)
         )
     }
+
+    @Test
+    fun expression_with_functions() {
+        val variable = Token.Operand.Variable("var")
+        val sin = Token.FunctionCall(1, DefaultFunctions.SIN)
+        val cos = Token.FunctionCall(1, DefaultFunctions.COS)
+
+        val expression = listOf(
+            sin,
+            Token.Bracket.Left,
+            variable,
+            Token.Bracket.Right,
+            Token.Operator.Power,
+            Token.Operand.Number(2),
+            Token.Operator.Plus,
+            cos,
+            Token.Bracket.Left,
+            variable,
+            Token.Bracket.Right,
+            Token.Operator.Power,
+            Token.Operand.Number(2),
+        )
+
+        assertEquals(
+            Expression.Binary(
+                Token.Operator.Plus,
+                Expression.Binary(
+                    Token.Operator.Power,
+                    Expression.FunctionCall(
+                        sin,
+                        arguments = listOf(Expression.Terminal(variable))
+                    ),
+                    Expression.Terminal(Token.Operand.Number(2))
+                ),
+                Expression.Binary(
+                    Token.Operator.Power,
+                    Expression.FunctionCall(
+                        cos,
+                        arguments = listOf(Expression.Terminal(variable))
+                    ),
+                    Expression.Terminal(Token.Operand.Number(2))
+                )
+            ),
+            subject.parse(expression)
+        )
+    }
 }