removed old implementation

Author: murzagalin

README.md

@@ -202,8 +202,8 @@ fun main() {
 
 By default, the library does the following steps to evaluate an expression:
 1. Tokenizing - splitting the expression into a list of units (operations, numbers, constants, function calls, etc.)
-2. Converting the expression from [infix](https://en.wikipedia.org/wiki/Infix_notation) to [postifx notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation).
-3. Evaluating the postfix expression.
+2. Converting the expression from [infix notation](https://en.wikipedia.org/wiki/Infix_notation) to [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+3. Evaluating the abstract syntax tree.
 
 In case you have an expression with variables, it might make sense to preprocess the expression (do steps 1 and 2 in advance) to improve the performance:
 ```kotlin

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

@@ -3,7 +3,7 @@ package com.github.murzagalin.evaluator.ast
 import com.github.murzagalin.evaluator.Token
 import kotlin.math.pow
 
-class AstEvaluator(private val values: Map<String, Any> = emptyMap()): AstVisitor {
+internal class AstEvaluator(private val values: Map<String, Any> = emptyMap()): AstVisitor {
 
     fun evaluate(expression: Expression) = expression.visit(this)
 
@@ -37,36 +37,35 @@ class AstEvaluator(private val values: Map<String, Any> = emptyMap()): AstVisito
         }
     }
 
-    override fun visitBinary(binary: Expression.Binary): Any {
-        return when (binary.token) {
-            Token.Operator.LessThan -> binaryOnNumbers(binary,"<") { left, right -> left < right }
-            Token.Operator.LessEqualThan -> binaryOnNumbers(binary,"<=") { left, right -> left <= right }
-            Token.Operator.GreaterThan -> binaryOnNumbers(binary,">") { left, right -> left > right }
-            Token.Operator.GreaterEqualThan -> binaryOnNumbers(binary,">=") { left, right -> left >= right }
-            Token.Operator.Equal -> {
-                val left = evaluate(binary.leftExpression)
-                val right = evaluate(binary.rightExpression)
-                left == right
-            }
-            Token.Operator.NotEqual -> {
-                val left = evaluate(binary.leftExpression)
-                val right = evaluate(binary.rightExpression)
-                left != right
-            }
-            Token.Operator.And -> binaryOnBooleans(binary, "&&") { left, right -> left && right}
-            Token.Operator.Or -> binaryOnBooleans(binary, "||") { left, right -> left || right}
-            Token.Operator.Plus -> binaryOnNumbers(binary, "+") { left, right -> left + right }
-            Token.Operator.Minus -> binaryOnNumbers(binary,"-") { left, right -> left - right }
-            Token.Operator.Modulo -> binaryOnNumbers(binary,"%") { left, right -> left % right }
-            Token.Operator.Multiplication -> binaryOnNumbers(binary,"*") { left, right -> left * right }
-            Token.Operator.Division -> binaryOnNumbers(binary,"/") { left, right -> left / right }
-            Token.Operator.Power -> binaryOnNumbers(binary,"^") { left, right -> left.pow(right) }
-            else -> {
-                error("${binary.token} was incorrectly parsed as a binary operator")
-            }
+    override fun visitBinary(binary: Expression.Binary) = when (binary.token) {
+        Token.Operator.LessThan -> binaryOnNumbers(binary,"<") { left, right -> left < right }
+        Token.Operator.LessEqualThan -> binaryOnNumbers(binary,"<=") { left, right -> left <= right }
+        Token.Operator.GreaterThan -> binaryOnNumbers(binary,">") { left, right -> left > right }
+        Token.Operator.GreaterEqualThan -> binaryOnNumbers(binary,">=") { left, right -> left >= right }
+        Token.Operator.Equal -> {
+            val left = evaluate(binary.leftExpression)
+            val right = evaluate(binary.rightExpression)
+            left == right
+        }
+        Token.Operator.NotEqual -> {
+            val left = evaluate(binary.leftExpression)
+            val right = evaluate(binary.rightExpression)
+            left != right
+        }
+        Token.Operator.And -> binaryOnBooleans(binary, "&&") { left, right -> left && right}
+        Token.Operator.Or -> binaryOnBooleans(binary, "||") { left, right -> left || right}
+        Token.Operator.Plus -> binaryOnNumbers(binary, "+") { left, right -> left + right }
+        Token.Operator.Minus -> binaryOnNumbers(binary,"-") { left, right -> left - right }
+        Token.Operator.Modulo -> binaryOnNumbers(binary,"%") { left, right -> left % right }
+        Token.Operator.Multiplication -> binaryOnNumbers(binary,"*") { left, right -> left * right }
+        Token.Operator.Division -> binaryOnNumbers(binary,"/") { left, right -> left / right }
+        Token.Operator.Power -> binaryOnNumbers(binary,"^") { left, right -> left.pow(right) }
+        else -> {
+            error("${binary.token} was incorrectly parsed as a binary operator")
         }
     }
 
+
     private fun binaryOnBooleans(binary: Expression.Binary, strRep: String, eval: (Boolean, Boolean) -> Any): Any {
         val left = evaluate(binary.leftExpression)
         val right = evaluate(binary.rightExpression)

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

@@ -1,6 +1,6 @@
 package com.github.murzagalin.evaluator.ast
 
-class BooleanAstEvaluator {
+internal class BooleanAstEvaluator {
 
     fun evaluate(expression: Expression, values: Map<String, Any> = emptyMap()): Boolean {
         val baseEvaluator = AstEvaluator(values)

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

@@ -1,6 +1,6 @@
 package com.github.murzagalin.evaluator.ast
 
-class DoubleAstEvaluator {
+internal class DoubleAstEvaluator {
 
     fun evaluate(expression: Expression, values: Map<String, Any> = emptyMap()): Double {
         val baseEvaluator = AstEvaluator(values)

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

@@ -23,7 +23,7 @@ boolean    -> "true" | "false" | "TRUE" | "FALSE"
 number     -> DIGIT ( DIGIT )*
 */
 
-class Parser {
+internal class Parser {
 
     private val equalityTokens = setOf(Token.Operator.Equal, Token.Operator.NotEqual)