From 7e384a335c22088a5ec8f545b457704a57c5b7ca Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Wed, 16 Mar 2022 20:44:59 +0100
Subject: [PATCH 1/8] Use PHP 8.1 features

---
 .gitignore                                    |   2 +
 .travis.yml                                   |   2 +-
 README.md                                     |  24 ++-
 composer.json                                 |   6 +-
 src/Compiler/CompilerInterface.php            |   6 +-
 src/Compiler/StandardCompiler.php             |  41 ++--
 src/Evaluator/Boolean.php                     |  14 ++
 src/Evaluator/Evaluator.php                   |  41 ++--
 .../Exception/UnknownSymbolException.php      |   2 +-
 src/Evaluator/Operator.php                    |  83 ++++++++
 src/Expression/ExpressionFactory.php          |   8 +-
 src/Expression/ExpressionFactoryInterface.php |   4 +-
 src/Grammar/CallableFunction.php              |   5 +-
 src/Grammar/Definition.php                    |  20 ++
 src/Grammar/Grammar.php                       |  48 ++++-
 src/Grammar/InternalFunction.php              |  17 ++
 src/Grammar/InternalMethod.php                |  17 ++
 src/Grammar/JavaScript/JavaScript.php         |  93 ++++-----
 src/Grammar/JavaScript/Methods/CharAt.php     |   6 +-
 src/Grammar/JavaScript/Methods/Substr.php     |   2 +-
 src/Grammar/JavaScript/Methods/Test.php       |   4 +-
 src/Highlighter/Highlighter.php               |  55 +++--
 src/Parser/EvaluatableExpression.php          |  68 +++++++
 src/Parser/EvaluatableExpressionFactory.php   |  20 ++
 src/Parser/Exception/ParserException.php      |  10 +-
 src/Parser/Parser.php                         |  92 ++++-----
 src/Rule.php                                  |   4 +-
 src/TokenStream/AST.php                       | 132 ------------
 src/TokenStream/CallableUserMethod.php        |  21 +-
 src/TokenStream/CallableUserMethodFactory.php |   6 +-
 .../CallableUserMethodFactoryInterface.php    |   7 +-
 src/TokenStream/Node/BaseNode.php             |  25 +--
 src/TokenStream/Token/BaseToken.php           |  50 +----
 src/TokenStream/Token/Token.php               |  64 +++---
 src/TokenStream/Token/TokenAnd.php            |   6 +-
 src/TokenStream/Token/TokenArray.php          |   6 +-
 src/TokenStream/Token/TokenBool.php           |   6 +-
 src/TokenStream/Token/TokenClosingArray.php   |   2 +-
 .../Token/TokenClosingParenthesis.php         |   6 +-
 src/TokenStream/Token/TokenComma.php          |   2 +-
 src/TokenStream/Token/TokenComment.php        |   6 +-
 src/TokenStream/Token/TokenEqual.php          |   6 +-
 src/TokenStream/Token/TokenEqualStrict.php    |   6 +-
 src/TokenStream/Token/TokenFactory.php        |   8 +-
 src/TokenStream/Token/TokenFloat.php          |   6 +-
 src/TokenStream/Token/TokenFunction.php       |   6 +-
 src/TokenStream/Token/TokenGreater.php        |   6 +-
 src/TokenStream/Token/TokenGreaterEqual.php   |   6 +-
 src/TokenStream/Token/TokenIn.php             |   6 +-
 src/TokenStream/Token/TokenInteger.php        |   8 +-
 src/TokenStream/Token/TokenMethod.php         |   6 +-
 src/TokenStream/Token/TokenNewline.php        |   6 +-
 src/TokenStream/Token/TokenNotEqual.php       |   6 +-
 src/TokenStream/Token/TokenNotEqualStrict.php |   6 +-
 src/TokenStream/Token/TokenNotIn.php          |   6 +-
 src/TokenStream/Token/TokenNull.php           |   6 +-
 src/TokenStream/Token/TokenObject.php         |   6 +-
 src/TokenStream/Token/TokenOpeningArray.php   |   6 +-
 .../Token/TokenOpeningParenthesis.php         |   6 +-
 src/TokenStream/Token/TokenOr.php             |   6 +-
 src/TokenStream/Token/TokenRegex.php          |   9 +-
 src/TokenStream/Token/TokenSmaller.php        |   6 +-
 src/TokenStream/Token/TokenSmallerEqual.php   |   6 +-
 src/TokenStream/Token/TokenSpace.php          |   6 +-
 src/TokenStream/Token/TokenString.php         |   9 +-
 src/TokenStream/Token/TokenType.php           |  32 +--
 src/TokenStream/Token/TokenUnknown.php        |   2 +-
 src/TokenStream/Token/TokenVariable.php       |   9 +-
 .../Token/Type/Logical.php}                   |   4 +-
 src/TokenStream/Token/Type/Method.php         |  12 ++
 src/TokenStream/Token/Type/Operator.php       |  12 ++
 src/TokenStream/Token/Type/Parenthesis.php    |  12 ++
 src/TokenStream/Token/Type/Value.php          |  12 ++
 src/TokenStream/Token/Type/Whitespace.php     |  12 ++
 src/TokenStream/TokenIterator.php             |  92 +++++++++
 ...amFactory.php => TokenIteratorFactory.php} |   8 +-
 src/TokenStream/TokenStream.php               | 132 ++++++++----
 src/Tokenizer/Tokenizer.php                   |  74 ++-----
 src/Tokenizer/TokenizerInterface.php          |  15 +-
 src/container.php                             |  26 +--
 tests/integration/HighlighterTest.php         |  13 --
 tests/integration/TokenizerTest.php           |   4 +-
 tests/integration/methods/SyntaxErrorTest.php |   2 +-
 tests/unit/Grammar/GrammarTest.php            |  12 +-
 tests/unit/Parser/ParserTest.php              |  43 +---
 tests/unit/Token/TokenFactoryTest.php         |  12 +-
 tests/unit/TokenStream/ASTTest.php            |  89 --------
 .../unit/TokenStream/Token/BaseTokenTest.php  | 101 +--------
 tests/unit/TokenStream/TokenIteratorTest.php  | 132 ++++++++++++
 tests/unit/TokenStream/TokenStreamTest.php    | 191 ++++++++++--------
 tests/unit/Tokenizer/TokenizerTest.php        |  33 +--
 91 files changed, 1251 insertions(+), 1022 deletions(-)
 create mode 100644 src/Evaluator/Boolean.php
 create mode 100644 src/Evaluator/Operator.php
 create mode 100644 src/Grammar/Definition.php
 create mode 100644 src/Grammar/InternalFunction.php
 create mode 100644 src/Grammar/InternalMethod.php
 create mode 100644 src/Parser/EvaluatableExpression.php
 create mode 100644 src/Parser/EvaluatableExpressionFactory.php
 delete mode 100644 src/TokenStream/AST.php
 rename src/{Highlighter/Exception/InvalidGroupException.php => TokenStream/Token/Type/Logical.php} (66%)
 create mode 100644 src/TokenStream/Token/Type/Method.php
 create mode 100644 src/TokenStream/Token/Type/Operator.php
 create mode 100644 src/TokenStream/Token/Type/Parenthesis.php
 create mode 100644 src/TokenStream/Token/Type/Value.php
 create mode 100644 src/TokenStream/Token/Type/Whitespace.php
 create mode 100644 src/TokenStream/TokenIterator.php
 rename src/TokenStream/{TokenStreamFactory.php => TokenIteratorFactory.php} (57%)
 delete mode 100755 tests/unit/TokenStream/ASTTest.php
 create mode 100755 tests/unit/TokenStream/TokenIteratorTest.php

diff --git a/.gitignore b/.gitignore
index 35f8f3f..3e04865 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@
 /coverage.clover
 /.phpunit.result.cache
 /vendor/
+/.idea
+/.composer
diff --git a/.travis.yml b/.travis.yml
index fa2e489..cf159f4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,7 @@
 language: php
 
 php:
-  - 8.0
+  - 8.1
 
 script:
   - composer install --dev
diff --git a/README.md b/README.md
index a656d84..00aca1d 100644
--- a/README.md
+++ b/README.md
@@ -18,8 +18,6 @@ Find me on Twitter: @[nicoSWD](https://twitter.com/nicoSWD)
 
 (If you're using PHP 5, you might want to take a look at [version 0.4.0](https://github.com/nicoSWD/php-rule-parser/tree/0.4.0))
 
-[![SensioLabsInsight](https://insight.sensiolabs.com/projects/67203389-970c-419c-9430-a7f9a005bd94/big.png)](https://insight.sensiolabs.com/projects/67203389-970c-419c-9430-a7f9a005bd94)
-
 ## Install
 
 Via Composer
@@ -40,23 +38,29 @@ This library works best with one of these bundles below, but they're not require
 
 Test if a value is in a given array
 ```php
-$variables = ['foo' => 6];
+$variables = [
+    'coupon_code' => $_POST['coupon_code'],
+];
 
-$rule = new Rule('foo in [4, 6, 7]', $variables);
+$rule = new Rule('coupon_code in ["summer_discount", "summer21"]', $variables);
 var_dump($rule->isTrue()); // bool(true)
 ```
 
-Simple array manipulation 
+Performing a regular expression
 ```php
-$rule = new Rule('[1, 4, 3].join(".") === "1.4.3"');
+$variables = [
+    'coupon_code' => $_POST['coupon_code'],
+];
+
+$rule = new Rule('coupon_code.test(/^summer20[0-9]{2}$/) == true', $variables);
 var_dump($rule->isTrue()); // bool(true)
 ```
 
 Test if a value is between a given range
 ```php
-$variables = ['threshold' => 80];
+$variables = ['points' => 80];
 
-$rule = new Rule('threshold >= 50 && threshold <= 100', $variables);
+$rule = new Rule('points >= 50 && points <= 100', $variables);
 var_dump($rule->isTrue()); // bool(true)
 ```
 
@@ -64,8 +68,6 @@ Call methods on objects from within rules
 ```php
 class User
 {
-    // ...
-
     public function points(): int
     {
         return 1337;    
@@ -180,7 +182,7 @@ $highlighter = new Rule\Highlighter\Highlighter(new Rule\Tokenizer());
 
 // Optional custom styles
 $highlighter->setStyle(
-    Rule\Constants::GROUP_VARIABLE,
+    TokenType::VARIABLE,
     'color: #007694; font-weight: 900;'
 );
 
diff --git a/composer.json b/composer.json
index eabf79b..8ce7073 100644
--- a/composer.json
+++ b/composer.json
@@ -33,11 +33,11 @@
     }
   },
   "require": {
-    "php": ">=8.0"
+    "php": ">=8.1"
   },
   "require-dev": {
-    "phpunit/phpunit": "^7.0|^9.0",
-    "mockery/mockery": "^1.0|^1.4"
+    "phpunit/phpunit": "^9.5",
+    "mockery/mockery": "^1.4"
   },
   "scripts": {
     "test": "vendor/bin/phpunit"
diff --git a/src/Compiler/CompilerInterface.php b/src/Compiler/CompilerInterface.php
index 90a2121..f60cb76 100644
--- a/src/Compiler/CompilerInterface.php
+++ b/src/Compiler/CompilerInterface.php
@@ -8,14 +8,16 @@
 namespace nicoSWD\Rule\Compiler;
 
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\Type\Logical;
+use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;
 
 interface CompilerInterface
 {
     public function getCompiledRule(): string;
 
-    public function addParentheses(BaseToken $token): void;
+    public function addParentheses(BaseToken & Parenthesis $token): void;
 
-    public function addLogical(BaseToken $token): void;
+    public function addLogical(BaseToken & Logical $token): void;
 
     public function addBoolean(bool $bool): void;
 }
diff --git a/src/Compiler/StandardCompiler.php b/src/Compiler/StandardCompiler.php
index 2d1d7f4..2202296 100644
--- a/src/Compiler/StandardCompiler.php
+++ b/src/Compiler/StandardCompiler.php
@@ -8,19 +8,17 @@
 namespace nicoSWD\Rule\Compiler;
 
 use nicoSWD\Rule\Compiler\Exception\MissingOperatorException;
+use nicoSWD\Rule\Evaluator\Boolean;
+use nicoSWD\Rule\Evaluator\Operator;
 use nicoSWD\Rule\Parser\Exception\ParserException;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenAnd;
 use nicoSWD\Rule\TokenStream\Token\TokenOpeningParenthesis;
+use nicoSWD\Rule\TokenStream\Token\Type\Logical;
+use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;
 
-class StandardCompiler implements CompilerInterface
+final class StandardCompiler implements CompilerInterface
 {
-    private const BOOL_TRUE = '1';
-    private const BOOL_FALSE = '0';
-
-    private const LOGICAL_AND = '&';
-    private const LOGICAL_OR = '|';
-
     private const OPENING_PARENTHESIS = '(';
     private const CLOSING_PARENTHESIS = ')';
 
@@ -58,7 +56,7 @@ private function closeParenthesis(): void
     }
 
     /** @throws ParserException */
-    public function addParentheses(BaseToken $token): void
+    public function addParentheses(BaseToken & Parenthesis $token): void
     {
         if ($token instanceof TokenOpeningParenthesis) {
             if (!$this->expectOpeningParenthesis()) {
@@ -71,31 +69,27 @@ public function addParentheses(BaseToken $token): void
     }
 
     /** @throws ParserException */
-    public function addLogical(BaseToken $token): void
+    public function addLogical(BaseToken & Logical $token): void
     {
-        $lastChar = $this->getLastChar();
-
-        if ($lastChar === self::LOGICAL_AND || $lastChar === self::LOGICAL_OR) {
+        if (Operator::tryFrom($this->getLastChar()) !== null) {
             throw ParserException::unexpectedToken($token);
         }
 
         if ($token instanceof TokenAnd) {
-            $this->output .= self::LOGICAL_AND;
+            $this->output .= Operator::LOGICAL_AND->value;
         } else {
-            $this->output .= self::LOGICAL_OR;
+            $this->output .= Operator::LOGICAL_OR->value;
         }
     }
 
     /** @throws MissingOperatorException */
     public function addBoolean(bool $bool): void
     {
-        $lastChar = $this->getLastChar();
-
-        if ($lastChar === self::BOOL_TRUE || $lastChar === self::BOOL_FALSE) {
+        if (Boolean::tryFrom($this->getLastChar()) !== null) {
             throw new MissingOperatorException();
         }
 
-        $this->output .= $bool ? self::BOOL_TRUE : self::BOOL_FALSE;
+        $this->output .= Boolean::fromBool($bool)->value;
     }
 
     private function numParenthesesMatch(): bool
@@ -105,11 +99,7 @@ private function numParenthesesMatch(): bool
 
     private function isIncompleteCondition(): bool
     {
-        $lastChar = $this->getLastChar();
-
-        return
-            $lastChar === self::LOGICAL_AND ||
-            $lastChar === self::LOGICAL_OR;
+        return Operator::tryFrom($this->getLastChar()) !== null;
     }
 
     private function expectOpeningParenthesis(): bool
@@ -118,9 +108,8 @@ private function expectOpeningParenthesis(): bool
 
         return
             $lastChar === '' ||
-            $lastChar === self::LOGICAL_AND ||
-            $lastChar === self::LOGICAL_OR ||
-            $lastChar === self::OPENING_PARENTHESIS;
+            $lastChar === self::OPENING_PARENTHESIS ||
+            Operator::tryFrom($lastChar) !== null;
     }
 
     private function getLastChar(): string
diff --git a/src/Evaluator/Boolean.php b/src/Evaluator/Boolean.php
new file mode 100644
index 0000000..7d068bd
--- /dev/null
+++ b/src/Evaluator/Boolean.php
@@ -0,0 +1,14 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Evaluator;
+
+enum Operator: string
+{
+    case LOGICAL_AND = '&';
+    case LOGICAL_OR = '|';
+}
diff --git a/src/Evaluator/Evaluator.php b/src/Evaluator/Evaluator.php
index 4d1797a..badcac1 100644
--- a/src/Evaluator/Evaluator.php
+++ b/src/Evaluator/Evaluator.php
@@ -7,14 +7,10 @@
  */
 namespace nicoSWD\Rule\Evaluator;
 
+use Closure;
+
 final class Evaluator implements EvaluatorInterface
 {
-    private const LOGICAL_AND = '&';
-    private const LOGICAL_OR = '|';
-
-    private const BOOL_TRUE = '1';
-    private const BOOL_FALSE = '0';
-
     public function evaluate(string $group): bool
     {
         $evalGroup = $this->evalGroup();
@@ -22,7 +18,7 @@ public function evaluate(string $group): bool
 
         do {
             $group = preg_replace_callback(
-                '~\(([^()]+)\)~',
+                '~\((?<match>[^()]+)\)~',
                 $evalGroup,
                 $group,
                 limit: -1,
@@ -30,22 +26,23 @@ public function evaluate(string $group): bool
             );
         } while ($count > 0);
 
-        return (bool) $evalGroup([1 => $group]);
+        return (bool) $evalGroup(['match' => $group]);
     }
 
-    private function evalGroup(): callable
+    private function evalGroup(): Closure
     {
         return function (array $group): ?int {
             $result = null;
             $operator = null;
             $offset = 0;
 
-            while (isset($group[1][$offset])) {
-                $value = $group[1][$offset++];
+            while (isset($group['match'][$offset])) {
+                $value = $group['match'][$offset++];
+                $possibleOperator = Operator::tryFrom($value);
 
-                if ($this->isLogical($value)) {
-                    $operator = $value;
-                } elseif ($this->isBoolean($value)) {
+                if ($possibleOperator) {
+                    $operator = $possibleOperator;
+                } elseif (Boolean::tryFrom($value)) {
                     $result = $this->setResult($result, (int) $value, $operator);
                 } else {
                     throw new Exception\UnknownSymbolException(sprintf('Unexpected "%s"', $value));
@@ -56,26 +53,16 @@ private function evalGroup(): callable
         };
     }
 
-    private function setResult(?int $result, int $value, ?string $operator): int
+    private function setResult(?int $result, int $value, ?Operator $operator): int
     {
         if (!isset($result)) {
             $result = $value;
-        } elseif ($operator === self::LOGICAL_AND) {
+        } elseif (Operator::isAnd($operator)) {
             $result &= $value;
-        } elseif ($operator === self::LOGICAL_OR) {
+        } elseif (Operator::isOr($operator)) {
             $result |= $value;
         }
 
         return $result;
     }
-
-    private function isLogical(string $value): bool
-    {
-        return $value === self::LOGICAL_AND || $value === self::LOGICAL_OR;
-    }
-
-    private function isBoolean(string $value): bool
-    {
-        return $value === self::BOOL_TRUE || $value === self::BOOL_FALSE;
-    }
 }
diff --git a/src/Evaluator/Exception/UnknownSymbolException.php b/src/Evaluator/Exception/UnknownSymbolException.php
index 0737f50..05b3659 100644
--- a/src/Evaluator/Exception/UnknownSymbolException.php
+++ b/src/Evaluator/Exception/UnknownSymbolException.php
@@ -7,6 +7,6 @@
  */
 namespace nicoSWD\Rule\Evaluator\Exception;
 
-class UnknownSymbolException extends \Exception
+final class UnknownSymbolException extends \Exception
 {
 }
diff --git a/src/Evaluator/Operator.php b/src/Evaluator/Operator.php
new file mode 100644
index 0000000..55c7c62
--- /dev/null
+++ b/src/Evaluator/Operator.php
@@ -0,0 +1,83 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Evaluator;
+
+use Closure;
+
+final class Evaluator implements EvaluatorInterface
+{
+    private const LOGICAL_AND = '&';
+    private const LOGICAL_OR = '|';
+
+    private const BOOL_TRUE = '1';
+    private const BOOL_FALSE = '0';
+
+    public function evaluate(string $group): bool
+    {
+        $evalGroup = $this->evalGroup();
+        $count = 0;
+
+        do {
+            $group = preg_replace_callback(
+                '~\((?<match>[^()]+)\)~',
+                $evalGroup,
+                $group,
+                limit: -1,
+                count: $count
+            );
+        } while ($count > 0);
+
+        return (bool) $evalGroup(['match' => $group]);
+    }
+
+    private function evalGroup(): Closure
+    {
+        return function (array $group): ?int {
+            $result = null;
+            $operator = null;
+            $offset = 0;
+
+            while (isset($group['match'][$offset])) {
+                $value = $group['match'][$offset++];
+
+                if ($this->isLogical($value)) {
+                    $operator = $value;
+                } elseif ($this->isBoolean($value)) {
+                    $result = $this->setResult($result, (int) $value, $operator);
+                } else {
+                    throw new Exception\UnknownSymbolException(sprintf('Unexpected "%s"', $value));
+                }
+            }
+
+            return $result;
+        };
+    }
+
+    private function setResult(?int $result, int $value, ?string $operator): int
+    {
+        if (!isset($result)) {
+            $result = $value;
+        } elseif ($operator === self::LOGICAL_AND) {
+            $result &= $value;
+        } elseif ($operator === self::LOGICAL_OR) {
+            $result |= $value;
+        }
+
+        return $result;
+    }
+
+    private function isLogical(string $value): bool
+    {
+        return $value === self::LOGICAL_AND || $value === self::LOGICAL_OR;
+    }
+
+    private function isBoolean(string $value): bool
+    {
+        return $value === self::BOOL_TRUE || $value === self::BOOL_FALSE;
+    }
+}
diff --git a/src/Expression/ExpressionFactory.php b/src/Expression/ExpressionFactory.php
index 9a3ba34..e474bd9 100644
--- a/src/Expression/ExpressionFactory.php
+++ b/src/Expression/ExpressionFactory.php
@@ -9,14 +9,14 @@
 
 use nicoSWD\Rule\Parser\Exception\ParserException;
 use nicoSWD\Rule\TokenStream\Token;
-use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
-class ExpressionFactory implements ExpressionFactoryInterface
+final class ExpressionFactory implements ExpressionFactoryInterface
 {
     /** @throws ParserException */
-    public function createFromOperator(BaseToken $operator): BaseExpression
+    public function createFromOperator(Operator $operator): BaseExpression
     {
-        return match (get_class($operator)) {
+        return match ($operator::class) {
             Token\TokenEqual::class => new EqualExpression(),
             Token\TokenEqualStrict::class => new EqualStrictExpression(),
             Token\TokenNotEqual::class => new NotEqualExpression(),
diff --git a/src/Expression/ExpressionFactoryInterface.php b/src/Expression/ExpressionFactoryInterface.php
index 0f12bfc..1750cc4 100644
--- a/src/Expression/ExpressionFactoryInterface.php
+++ b/src/Expression/ExpressionFactoryInterface.php
@@ -7,9 +7,9 @@
  */
 namespace nicoSWD\Rule\Expression;
 
-use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
 interface ExpressionFactoryInterface
 {
-    public function createFromOperator(BaseToken $operator): BaseExpression;
+    public function createFromOperator(Operator $operator): BaseExpression;
 }
diff --git a/src/Grammar/CallableFunction.php b/src/Grammar/CallableFunction.php
index 5ac80da..6396edc 100644
--- a/src/Grammar/CallableFunction.php
+++ b/src/Grammar/CallableFunction.php
@@ -11,8 +11,9 @@
 
 abstract class CallableFunction implements CallableUserFunctionInterface
 {
-    public function __construct(protected ?BaseToken $token = null)
-    {
+    public function __construct(
+        protected readonly ?BaseToken $token = null,
+    ) {
     }
 
     protected function parseParameter(array $parameters, int $numParam): ?BaseToken
diff --git a/src/Grammar/Definition.php b/src/Grammar/Definition.php
new file mode 100644
index 0000000..e2c3157
--- /dev/null
+++ b/src/Grammar/Definition.php
@@ -0,0 +1,20 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Grammar;
+
+use nicoSWD\Rule\TokenStream\Token\Token;
+
+final class Definition
+{
+    public function __construct(
+        public readonly Token $token,
+        public readonly string $regex,
+        public readonly int $priority,
+    ) {
+    }
+}
diff --git a/src/Grammar/Grammar.php b/src/Grammar/Grammar.php
index 63a9572..12822a8 100644
--- a/src/Grammar/Grammar.php
+++ b/src/Grammar/Grammar.php
@@ -7,20 +7,54 @@
  */
 namespace nicoSWD\Rule\Grammar;
 
+use SplPriorityQueue;
+
 abstract class Grammar
 {
-    /** @return array<int, <mixed>> */
+    private string $compiledRegex = '';
+    /** @var Definition[] */
+    private array $tokens = [];
+
+    /** @return Definition[] */
     abstract public function getDefinition(): array;
 
-    /** @return array<string, string> */
-    public function getInternalFunctions(): array
+    /** @return InternalFunction[] */
+    abstract public function getInternalFunctions(): array;
+
+    /** @return InternalMethod[] */
+    abstract public function getInternalMethods(): array;
+
+    public function buildRegex(): string
+    {
+        if (!$this->compiledRegex) {
+            $this->registerTokens();
+            $regex = [];
+
+            foreach ($this->getQueue() as $token) {
+                $regex[] = "(?<{$token->token->value}>{$token->regex})";
+            }
+
+            $this->compiledRegex = '~(' . implode('|', $regex) . ')~As';
+        }
+
+        return $this->compiledRegex;
+    }
+
+    private function getQueue(): SplPriorityQueue
     {
-        return [];
+        $queue = new SplPriorityQueue();
+
+        foreach ($this->tokens as $token) {
+            $queue->insert($token, $token->priority);
+        }
+
+        return $queue;
     }
 
-    /** @return array<string, string> */
-    public function getInternalMethods(): array
+    private function registerTokens(): void
     {
-        return [];
+        foreach ($this->getDefinition() as $definition) {
+            $this->tokens[$definition->token->value] = $definition;
+        }
     }
 }
diff --git a/src/Grammar/InternalFunction.php b/src/Grammar/InternalFunction.php
new file mode 100644
index 0000000..fcfc6a9
--- /dev/null
+++ b/src/Grammar/InternalFunction.php
@@ -0,0 +1,17 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MITz<
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Grammar;
+
+final class InternalFunction
+{
+    public function __construct(
+        public readonly string $name,
+        public readonly string $class,
+    ) {
+    }
+}
diff --git a/src/Grammar/InternalMethod.php b/src/Grammar/InternalMethod.php
new file mode 100644
index 0000000..052a0d7
--- /dev/null
+++ b/src/Grammar/InternalMethod.php
@@ -0,0 +1,17 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MITz<
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Grammar;
+
+final class InternalMethod
+{
+    public function __construct(
+        public readonly string $name,
+        public readonly string $class,
+    ) {
+    }
+}
diff --git a/src/Grammar/JavaScript/JavaScript.php b/src/Grammar/JavaScript/JavaScript.php
index 6314217..10370f7 100644
--- a/src/Grammar/JavaScript/JavaScript.php
+++ b/src/Grammar/JavaScript/JavaScript.php
@@ -7,7 +7,10 @@
  */
 namespace nicoSWD\Rule\Grammar\JavaScript;
 
+use nicoSWD\Rule\Grammar\Definition;
 use nicoSWD\Rule\Grammar\Grammar;
+use nicoSWD\Rule\Grammar\InternalFunction;
+use nicoSWD\Rule\Grammar\InternalMethod;
 use nicoSWD\Rule\TokenStream\Token\Token;
 
 final class JavaScript extends Grammar
@@ -15,63 +18,63 @@ final class JavaScript extends Grammar
     public function getDefinition(): array
     {
         return [
-            [Token::AND, '&&', 145],
-            [Token::OR, '\|\|', 140],
-            [Token::NOT_EQUAL_STRICT, '!==', 135],
-            [Token::NOT_EQUAL, '<>|!=', 130],
-            [Token::EQUAL_STRICT, '===', 125],
-            [Token::EQUAL, '==', 120],
-            [Token::IN, '\bin\b', 115],
-            [Token::NOT_IN, '\bnot\s+in\b', 116],
-            [Token::BOOL_TRUE, '\btrue\b', 110],
-            [Token::BOOL_FALSE, '\bfalse\b', 111],
-            [Token::NULL, '\bnull\b', 105],
-            [Token::METHOD, '\.\s*[a-zA-Z_]\w*\s*\(', 100],
-            [Token::FUNCTION, '[a-zA-Z_]\w*\s*\(', 95],
-            [Token::FLOAT, '-?\d+(?:\.\d+)', 90],
-            [Token::INTEGER, '-?\d+', 85],
-            [Token::ENCAPSED_STRING, '"[^"]*"|\'[^\']*\'', 80],
-            [Token::SMALLER_EQUAL, '<=', 75],
-            [Token::GREATER_EQUAL, '>=', 70],
-            [Token::SMALLER, '<', 65],
-            [Token::GREATER, '>', 60],
-            [Token::OPENING_PARENTHESIS, '\(', 55],
-            [Token::CLOSING_PARENTHESIS, '\)', 50],
-            [Token::OPENING_ARRAY, '\[', 45],
-            [Token::CLOSING_ARRAY, '\]', 40],
-            [Token::COMMA, ',', 35],
-            [Token::REGEX, '/[^/\*].*/[igm]{0,3}', 30],
-            [Token::COMMENT, '//[^\r\n]*|/\*.*?\*/', 25],
-            [Token::NEWLINE, '\r?\n', 20],
-            [Token::SPACE, '\s+', 15],
-            [Token::VARIABLE, '[a-zA-Z_]\w*', 10],
-            [Token::UNKNOWN, '.', 5],
+            new Definition(Token::AND, '&&', 145),
+            new Definition(Token::OR, '\|\|', 140),
+            new Definition(Token::NOT_EQUAL_STRICT, '!==', 135),
+            new Definition(Token::NOT_EQUAL, '<>|!=', 130),
+            new Definition(Token::EQUAL_STRICT, '===', 125),
+            new Definition(Token::EQUAL, '==', 120),
+            new Definition(Token::IN, '\bin\b', 115),
+            new Definition(Token::NOT_IN, '\bnot\s+in\b', 116),
+            new Definition(Token::BOOL_TRUE, '\btrue\b', 110),
+            new Definition(Token::BOOL_FALSE, '\bfalse\b', 111),
+            new Definition(Token::NULL, '\bnull\b', 105),
+            new Definition(Token::METHOD, '\.\s*[a-zA-Z_]\w*\s*\(', 100),
+            new Definition(Token::FUNCTION, '[a-zA-Z_]\w*\s*\(', 95),
+            new Definition(Token::FLOAT, '-?\d+(?:\.\d+)', 90),
+            new Definition(Token::INTEGER, '-?\d+', 85),
+            new Definition(Token::ENCAPSED_STRING, '"[^"]*"|\'[^\']*\'', 80),
+            new Definition(Token::SMALLER_EQUAL, '<=', 75),
+            new Definition(Token::GREATER_EQUAL, '>=', 70),
+            new Definition(Token::SMALLER, '<', 65),
+            new Definition(Token::GREATER, '>', 60),
+            new Definition(Token::OPENING_PARENTHESIS, '\(', 55),
+            new Definition(Token::CLOSING_PARENTHESIS, '\)', 50),
+            new Definition(Token::OPENING_ARRAY, '\[', 45),
+            new Definition(Token::CLOSING_ARRAY, '\]', 40),
+            new Definition(Token::COMMA, ',', 35),
+            new Definition(Token::REGEX, '/[^/\*].*/[igm]{0,3}', 30),
+            new Definition(Token::COMMENT, '//[^\r\n]*|/\*.*?\*/', 25),
+            new Definition(Token::NEWLINE, '\r?\n', 20),
+            new Definition(Token::SPACE, '\s+', 15),
+            new Definition(Token::VARIABLE, '[a-zA-Z_]\w*', 10),
+            new Definition(Token::UNKNOWN, '.', 5),
         ];
     }
 
     public function getInternalFunctions(): array
     {
         return [
-            'parseInt' => Functions\ParseInt::class,
-            'parseFloat' => Functions\ParseFloat::class,
+            new InternalFunction('parseInt', Functions\ParseInt::class),
+            new InternalFunction('parseFloat', Functions\ParseFloat::class),
         ];
     }
 
     public function getInternalMethods(): array
     {
         return [
-            'charAt' => Methods\CharAt::class,
-            'concat' => Methods\Concat::class,
-            'indexOf' => Methods\IndexOf::class,
-            'join' => Methods\Join::class,
-            'replace' => Methods\Replace::class,
-            'split' => Methods\Split::class,
-            'substr' => Methods\Substr::class,
-            'test' => Methods\Test::class,
-            'toLowerCase' => Methods\ToLowerCase::class,
-            'toUpperCase' => Methods\ToUpperCase::class,
-            'startsWith' => Methods\StartsWith::class,
-            'endsWith' => Methods\EndsWith::class,
+            new InternalMethod('charAt', Methods\CharAt::class),
+            new InternalMethod('concat', Methods\Concat::class),
+            new InternalMethod('indexOf', Methods\IndexOf::class),
+            new InternalMethod('join', Methods\Join::class),
+            new InternalMethod('replace', Methods\Replace::class),
+            new InternalMethod('split', Methods\Split::class),
+            new InternalMethod('substr', Methods\Substr::class),
+            new InternalMethod('test', Methods\Test::class),
+            new InternalMethod('toLowerCase', Methods\ToLowerCase::class),
+            new InternalMethod('toUpperCase', Methods\ToUpperCase::class),
+            new InternalMethod('startsWith', Methods\StartsWith::class),
+            new InternalMethod('endsWith', Methods\EndsWith::class),
         ];
     }
 }
diff --git a/src/Grammar/JavaScript/Methods/CharAt.php b/src/Grammar/JavaScript/Methods/CharAt.php
index 2276caa..0bd9f98 100644
--- a/src/Grammar/JavaScript/Methods/CharAt.php
+++ b/src/Grammar/JavaScript/Methods/CharAt.php
@@ -27,11 +27,7 @@ public function call(?BaseToken ...$parameters): BaseToken
             $offset = $offset->getValue();
         }
 
-        if (!isset($tokenValue[$offset])) {
-            $char = '';
-        } else {
-            $char = $tokenValue[$offset];
-        }
+        $char = $tokenValue[$offset] ?? '';
 
         return new TokenString($char);
     }
diff --git a/src/Grammar/JavaScript/Methods/Substr.php b/src/Grammar/JavaScript/Methods/Substr.php
index 14b2722..5902cca 100644
--- a/src/Grammar/JavaScript/Methods/Substr.php
+++ b/src/Grammar/JavaScript/Methods/Substr.php
@@ -32,6 +32,6 @@ public function call(?BaseToken ...$parameters): BaseToken
 
         $value = substr($this->token->getValue(), ...$params);
 
-        return new TokenString((string) $value);
+        return new TokenString($value);
     }
 }
diff --git a/src/Grammar/JavaScript/Methods/Test.php b/src/Grammar/JavaScript/Methods/Test.php
index 1701e77..df7bcc6 100644
--- a/src/Grammar/JavaScript/Methods/Test.php
+++ b/src/Grammar/JavaScript/Methods/Test.php
@@ -19,7 +19,7 @@ final class Test extends CallableFunction
     public function call(?BaseToken ...$parameters): BaseToken
     {
         if (!$this->token instanceof TokenRegex) {
-            throw new ParserException('undefined is not a function');
+            throw new ParserException('test() is not a function');
         }
 
         $string = $this->parseParameter($parameters, numParam: 0);
@@ -31,7 +31,7 @@ public function call(?BaseToken ...$parameters): BaseToken
             // It's also irrelevant in .test() but allowed in JS here
             $pattern = preg_replace_callback(
                 '~/[igm]{0,3}$~',
-                fn (array $modifiers) => str_replace('g', '', $modifiers[0]),
+                static fn (array $modifiers): string => str_replace('g', '', $modifiers[0]),
                 $this->token->getValue()
             );
 
diff --git a/src/Highlighter/Highlighter.php b/src/Highlighter/Highlighter.php
index f1bd01a..f5ddc4a 100644
--- a/src/Highlighter/Highlighter.php
+++ b/src/Highlighter/Highlighter.php
@@ -9,40 +9,30 @@
 
 use ArrayIterator;
 use nicoSWD\Rule\Tokenizer\TokenizerInterface;
+use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
+use SplObjectStorage;
 
 final class Highlighter
 {
-    /** @var string[] */
-    private array $styles = [
-        TokenType::COMMENT => 'color: #948a8a; font-style: italic;',
-        TokenType::LOGICAL => 'color: #c72d2d;',
-        TokenType::OPERATOR => 'color: #000;',
-        TokenType::PARENTHESIS => 'color: #000;',
-        TokenType::SPACE => '',
-        TokenType::UNKNOWN => '',
-        TokenType::VALUE => 'color: #e36700; font-style: italic;',
-        TokenType::VARIABLE => 'color: #007694; font-weight: 900;',
-        TokenType::METHOD => 'color: #000',
-        TokenType::SQUARE_BRACKET => '',
-        TokenType::COMMA => '',
-        TokenType::FUNCTION => '',
-        TokenType::INT_VALUE => '',
-    ];
+    private readonly SplObjectStorage $styles;
 
-    public function __construct(private TokenizerInterface $tokenizer)
-    {
+    public function __construct(
+        private readonly TokenizerInterface $tokenizer,
+    ) {
+        $this->styles = new SplObjectStorage();
+        $this->styles[TokenType::COMMENT] = 'color: #948a8a; font-style: italic;';
+        $this->styles[TokenType::LOGICAL] = 'color: #c72d2d;';
+        $this->styles[TokenType::OPERATOR] = 'color: #000;';
+        $this->styles[TokenType::PARENTHESIS] = 'color: #000;';
+        $this->styles[TokenType::VALUE] = 'color: #e36700; font-style: italic;';
+        $this->styles[TokenType::VARIABLE] = 'color: #007694; font-weight: 900;';
+        $this->styles[TokenType::METHOD] = 'color: #000';
     }
 
-    public function setStyle(int $group, string $style): void
+    public function setStyle(TokenType $group, string $style): void
     {
-        if (!isset($this->styles[$group])) {
-            throw new Exception\InvalidGroupException(
-                'Invalid group'
-            );
-        }
-
-        $this->styles[$group] = (string) $style;
+        $this->styles[$group] = $style;
     }
 
     public function highlightString(string $string): string
@@ -55,9 +45,11 @@ public function highlightTokens(ArrayIterator $tokens): string
         $string = '';
 
         foreach ($tokens as $token) {
-            if ($style = $this->styles[$token->getType()]) {
-                $value = htmlentities($token->getOriginalValue(), ENT_QUOTES, 'utf-8');
-                $string .= '<span style="' . $style . '">' . $value . '</span>';
+            /** @var BaseToken $token */
+            $tokenType = $token->getType();
+
+            if (isset($this->styles[$tokenType])) {
+                $string .= '<span style="' . $this->styles[$tokenType] . '">' . $this->encode($token) . '</span>';
             } else {
                 $string .= $token->getOriginalValue();
             }
@@ -65,4 +57,9 @@ public function highlightTokens(ArrayIterator $tokens): string
 
         return '<pre><code>' . $string . '</code></pre>';
     }
+
+    private function encode(BaseToken $token): string
+    {
+        return htmlentities($token->getOriginalValue(), ENT_QUOTES, 'utf-8');
+    }
 }
diff --git a/src/Parser/EvaluatableExpression.php b/src/Parser/EvaluatableExpression.php
new file mode 100644
index 0000000..c40fdab
--- /dev/null
+++ b/src/Parser/EvaluatableExpression.php
@@ -0,0 +1,68 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Parser;
+
+use nicoSWD\Rule\Expression\BaseExpression;
+use nicoSWD\Rule\Expression\ExpressionFactoryInterface;
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class EvaluatableExpression
+{
+    public ?Operator $operator = null;
+    public array $values = [];
+
+    public function __construct(
+        private readonly ExpressionFactoryInterface $expressionFactory,
+    ) {
+    }
+
+    /** @throws Exception\ParserException */
+    public function evaluate(): bool
+    {
+        $result = $this->expression()->evaluate(...$this->values);
+        $this->clear();
+
+        return $result;
+    }
+
+    public function isComplete(): bool
+    {
+        return $this->hasOperator() && $this->hasBothValues();
+    }
+
+    public function addValue(mixed $value): void
+    {
+        $this->values[] = $value;
+    }
+
+    public function hasBothValues(): bool
+    {
+        return count($this->values) === 2;
+    }
+
+    public function hasNoValues(): bool
+    {
+        return count($this->values) === 0;
+    }
+
+    public function hasOperator(): bool
+    {
+        return $this->operator !== null;
+    }
+
+    private function clear(): void
+    {
+        $this->operator = null;
+        $this->values = [];
+    }
+
+    private function expression(): BaseExpression
+    {
+        return $this->expressionFactory->createFromOperator($this->operator);
+    }
+}
diff --git a/src/Parser/EvaluatableExpressionFactory.php b/src/Parser/EvaluatableExpressionFactory.php
new file mode 100644
index 0000000..de42ba1
--- /dev/null
+++ b/src/Parser/EvaluatableExpressionFactory.php
@@ -0,0 +1,20 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\Parser;
+
+use nicoSWD\Rule\Expression\ExpressionFactory;
+
+final class EvaluatableExpressionFactory
+{
+    public function create(): EvaluatableExpression
+    {
+        return new EvaluatableExpression(
+            new ExpressionFactory()
+        );
+    }
+}
diff --git a/src/Parser/Exception/ParserException.php b/src/Parser/Exception/ParserException.php
index 84a909a..c50bbe1 100644
--- a/src/Parser/Exception/ParserException.php
+++ b/src/Parser/Exception/ParserException.php
@@ -8,8 +8,9 @@
 namespace nicoSWD\Rule\Parser\Exception;
 
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
-class ParserException extends \Exception
+final class ParserException extends \Exception
 {
     public static function unexpectedToken(BaseToken $token): self
     {
@@ -61,15 +62,10 @@ public static function unsupportedType(string $type): self
         return new self(sprintf('Unsupported PHP type: "%s"', $type));
     }
 
-    public static function unknownOperator(BaseToken $token): self
+    public static function unknownOperator(BaseToken & Operator $token): self
     {
         return new self(
             sprintf('Unexpected operator %s at position %d', $token->getOriginalValue(), $token->getOffset())
         );
     }
-
-    public static function unknownTokenName(string $tokenName): self
-    {
-        return new self("Unknown token $tokenName");
-    }
 }
diff --git a/src/Parser/Parser.php b/src/Parser/Parser.php
index f572781..b1537e4 100644
--- a/src/Parser/Parser.php
+++ b/src/Parser/Parser.php
@@ -10,111 +10,87 @@
 use Closure;
 use nicoSWD\Rule\Compiler\CompilerFactoryInterface;
 use nicoSWD\Rule\Compiler\CompilerInterface;
-use nicoSWD\Rule\Expression\ExpressionFactoryInterface;
-use nicoSWD\Rule\TokenStream\AST;
+use nicoSWD\Rule\TokenStream\TokenStream;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
-class Parser
+final class Parser
 {
-    private ?BaseToken $operator;
-    private array $values = [];
-
     public function __construct(
-        private AST $ast,
-        private ExpressionFactoryInterface $expressionFactory,
-        private CompilerFactoryInterface $compilerFactory
+        private readonly TokenStream $tokenStream,
+        private readonly EvaluatableExpressionFactory $expressionFactory,
+        private readonly CompilerFactoryInterface $compilerFactory,
     ) {
     }
 
+    /** @throws Exception\ParserException */
     public function parse(string $rule): string
     {
         $compiler = $this->compilerFactory->create();
-        $this->resetState();
+        $expression = $this->expressionFactory->create();
 
-        foreach ($this->ast->getStream($rule) as $token) {
-            $handler = $this->getHandlerForType($token->getType());
-            $handler($token, $compiler);
+        foreach ($this->tokenStream->getStream($rule) as $token) {
+            $handler = $this->getHandlerForToken($token, $expression);
+            $handler($compiler);
 
-            if ($this->expressionCanBeEvaluated()) {
-                $this->evaluateExpression($compiler);
+            if ($expression->isComplete()) {
+                $compiler->addBoolean($expression->evaluate());
             }
         }
 
         return $compiler->getCompiledRule();
     }
 
-    private function getHandlerForType(int $tokenType): Closure
+    private function getHandlerForToken(BaseToken $token, EvaluatableExpression $expression): Closure
     {
-        return match ($tokenType) {
-            TokenType::VALUE, TokenType::INT_VALUE => $this->handleValueToken(),
-            TokenType::OPERATOR => $this->handleOperatorToken(),
-            TokenType::LOGICAL => $this->handleLogicalToken(),
-            TokenType::PARENTHESIS => $this->handleParenthesisToken(),
+        return match ($token->getType()) {
+            TokenType::VALUE => $this->handleValueToken($token, $expression),
+            TokenType::OPERATOR => $this->handleOperatorToken($token, $expression),
+            TokenType::LOGICAL => $this->handleLogicalToken($token),
+            TokenType::PARENTHESIS => $this->handleParenthesisToken($token),
             TokenType::COMMENT, TokenType::SPACE => $this->handleDummyToken(),
-            default => $this->handleUnknownToken(),
+            default => $this->handleUnknownToken($token),
         };
     }
 
-    private function evaluateExpression(CompilerInterface $compiler): void
-    {
-        $expression = $this->expressionFactory->createFromOperator($this->operator);
-
-        $compiler->addBoolean(
-            $expression->evaluate(...$this->values)
-        );
-
-        $this->resetState();
-    }
-
-    private function expressionCanBeEvaluated(): bool
+    private function handleValueToken(BaseToken $token, EvaluatableExpression $expression): Closure
     {
-        return count($this->values) === 2;
+        return static fn () => $expression->addValue($token->getValue());
     }
 
-    private function handleValueToken(): Closure
+    private function handleLogicalToken(BaseToken $token): Closure
     {
-        return fn (BaseToken $token) => $this->values[] = $token->getValue();
+        return static fn (CompilerInterface $compiler) => $compiler->addLogical($token);
     }
 
-    private function handleLogicalToken(): Closure
+    private function handleParenthesisToken(BaseToken $token): Closure
     {
-        return fn (BaseToken $token, CompilerInterface $compiler) => $compiler->addLogical($token);
+        return static fn (CompilerInterface $compiler) => $compiler->addParentheses($token);
     }
 
-    private function handleParenthesisToken(): Closure
+    private function handleUnknownToken(BaseToken $token): Closure
     {
-        return fn (BaseToken $token, CompilerInterface $compiler) => $compiler->addParentheses($token);
+        return static fn () => throw Exception\ParserException::unknownToken($token);
     }
 
-    private function handleUnknownToken(): Closure
+    private function handleOperatorToken(BaseToken & Operator $token, EvaluatableExpression $expression): Closure
     {
-        return fn (BaseToken $token) => throw Exception\ParserException::unknownToken($token);
-    }
-
-    private function handleOperatorToken(): Closure
-    {
-        return function (BaseToken $token): void {
-            if (isset($this->operator)) {
+        return static function () use ($token, $expression): void {
+            if ($expression->hasOperator()) {
                 throw Exception\ParserException::unexpectedToken($token);
-            } elseif (empty($this->values)) {
+            } elseif ($expression->hasNoValues()) {
                 throw Exception\ParserException::incompleteExpression($token);
             }
 
-            $this->operator = $token;
+            $expression->operator = $token;
         };
     }
 
     private function handleDummyToken(): Closure
     {
-        return function (): void {
+        return static function (): void {
             // Do nothing
         };
     }
-
-    private function resetState(): void
-    {
-        $this->operator = null;
-        $this->values = [];
-    }
 }
diff --git a/src/Rule.php b/src/Rule.php
index b860482..8482a2f 100644
--- a/src/Rule.php
+++ b/src/Rule.php
@@ -12,8 +12,8 @@
 
 class Rule
 {
+    private readonly Parser\Parser $parser;
     private string $rule;
-    private Parser\Parser $parser;
     private string $parsedRule = '';
     private string $error = '';
     private static object $container;
@@ -28,6 +28,7 @@ public function __construct(string $rule, array $variables = [])
         $this->rule = $rule;
     }
 
+    /** @throws Parser\Exception\ParserException */
     public function isTrue(): bool
     {
         /** @var EvaluatorInterface $evaluator */
@@ -39,6 +40,7 @@ public function isTrue(): bool
         );
     }
 
+    /** @throws Parser\Exception\ParserException */
     public function isFalse(): bool
     {
         return !$this->isTrue();
diff --git a/src/TokenStream/AST.php b/src/TokenStream/AST.php
deleted file mode 100644
index 41b72d0..0000000
--- a/src/TokenStream/AST.php
+++ /dev/null
@@ -1,132 +0,0 @@
-<?php declare(strict_types=1);
-
-/**
- * @license     http://opensource.org/licenses/mit-license.php MIT
- * @link        https://github.com/nicoSWD
- * @author      Nicolas Oelgart <nico@oelgart.com>
- */
-namespace nicoSWD\Rule\TokenStream;
-
-use Closure;
-use InvalidArgumentException;
-use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
-use nicoSWD\Rule\Parser\Exception\ParserException;
-use nicoSWD\Rule\TokenStream\Exception\UndefinedVariableException;
-use nicoSWD\Rule\TokenStream\Token\BaseToken;
-use nicoSWD\Rule\TokenStream\Token\TokenFactory;
-use nicoSWD\Rule\Tokenizer\TokenizerInterface;
-use nicoSWD\Rule\TokenStream\Token\TokenObject;
-
-class AST
-{
-    private array $functions = [];
-    private array $methods = [];
-    private array $variables = [];
-
-    public function __construct(
-        private TokenizerInterface $tokenizer,
-        private TokenFactory $tokenFactory,
-        private TokenStreamFactory $tokenStreamFactory,
-        private CallableUserMethodFactoryInterface $userMethodFactory
-    ) {
-    }
-
-    public function getStream(string $rule): TokenStream
-    {
-        return $this->tokenStreamFactory->create($this->tokenizer->tokenize($rule), $this);
-    }
-
-    /**
-     * @throws Exception\UndefinedMethodException
-     * @throws Exception\ForbiddenMethodException
-     */
-    public function getMethod(string $methodName, BaseToken $token): CallableUserFunctionInterface
-    {
-        if ($token instanceof TokenObject) {
-            return $this->getCallableUserMethod($token, $methodName);
-        }
-
-        if (empty($this->methods)) {
-            $this->registerMethods();
-        }
-
-        if (!isset($this->methods[$methodName])) {
-            throw new Exception\UndefinedMethodException();
-        }
-
-        return new $this->methods[$methodName]($token);
-    }
-
-    public function setVariables(array $variables): void
-    {
-        $this->variables = $variables;
-    }
-
-    /**
-     * @throws UndefinedVariableException
-     * @throws ParserException
-     */
-    public function getVariable(string $variableName): BaseToken
-    {
-        if (!$this->variableExists($variableName)) {
-            throw new UndefinedVariableException($variableName);
-        }
-
-        return $this->tokenFactory->createFromPHPType($this->variables[$variableName]);
-    }
-
-    public function variableExists(string $variableName): bool
-    {
-        return array_key_exists($variableName, $this->variables);
-    }
-
-    /** @throws Exception\UndefinedFunctionException */
-    public function getFunction(string $functionName): Closure
-    {
-        if (empty($this->functions)) {
-            $this->registerFunctions();
-        }
-
-        if (!isset($this->functions[$functionName])) {
-            throw new Exception\UndefinedFunctionException($functionName);
-        }
-
-        return $this->functions[$functionName];
-    }
-
-    private function registerMethods(): void
-    {
-        $this->methods = $this->tokenizer->getGrammar()->getInternalMethods();
-    }
-
-    private function registerFunctionClass(string $functionName, string $className): void
-    {
-        $this->functions[$functionName] = function (...$args) use ($className) {
-            $function = new $className();
-
-            if (!$function instanceof CallableUserFunctionInterface) {
-                throw new InvalidArgumentException(
-                    sprintf(
-                        "%s must be an instance of %s",
-                        $className,
-                        CallableUserFunctionInterface::class
-                    )
-                );
-            }
-
-            return $function->call(...$args);
-        };
-    }
-
-    private function registerFunctions(): void
-    {
-        foreach ($this->tokenizer->getGrammar()->getInternalFunctions() as $functionName => $className) {
-            $this->registerFunctionClass($functionName, $className);
-        }
-    }
-
-    private function getCallableUserMethod(BaseToken $token, string $methodName): CallableUserFunctionInterface
-    {
-        return $this->userMethodFactory->create($token, $this->tokenFactory, $methodName);
-    }
-}
diff --git a/src/TokenStream/CallableUserMethod.php b/src/TokenStream/CallableUserMethod.php
index 27c14a1..0f1803f 100644
--- a/src/TokenStream/CallableUserMethod.php
+++ b/src/TokenStream/CallableUserMethod.php
@@ -16,8 +16,9 @@ final class CallableUserMethod implements CallableUserFunctionInterface
 {
     private const MAGIC_METHOD_PREFIX = '__';
 
-    private TokenFactory $tokenFactory;
-    private Closure $callable;
+    private readonly TokenFactory $tokenFactory;
+    private readonly Closure $callable;
+
     private array $methodPrefixes = ['', 'get', 'is', 'get_', 'is_'];
 
     /**
@@ -32,10 +33,10 @@ public function __construct(BaseToken $token, TokenFactory $tokenFactory, string
 
     public function call(?BaseToken ...$param): BaseToken
     {
-        $callableCopy = $this->callable;
+        $callable = $this->callable;
 
         return $this->tokenFactory->createFromPHPType(
-            $callableCopy(...$param)
+            $callable(...$param)
         );
     }
 
@@ -48,12 +49,12 @@ private function getCallable(BaseToken $token, string $methodName): Closure
         $object = $token->getValue();
 
         if (property_exists($object, $methodName)) {
-            return fn () => $object->{$methodName};
+            return static fn (): mixed => $object->{$methodName};
         }
 
         $method = $this->findCallableMethod($object, $methodName);
 
-        return fn (?BaseToken ...$params) => $method(
+        return fn (?BaseToken ...$params): mixed => $method(
             ...$this->getTokenValues($params)
         );
     }
@@ -80,13 +81,7 @@ private function findCallableMethod(object $object, string $methodName): callabl
 
     private function getTokenValues(array $params): array
     {
-        $values = [];
-
-        foreach ($params as $token) {
-            $values[] = $token->getValue();
-        }
-
-        return $values;
+        return array_map(static fn (BaseToken $token): mixed => $token->getValue(), $params);
     }
 
     /** @throws Exception\ForbiddenMethodException */
diff --git a/src/TokenStream/CallableUserMethodFactory.php b/src/TokenStream/CallableUserMethodFactory.php
index cae71bb..067c773 100644
--- a/src/TokenStream/CallableUserMethodFactory.php
+++ b/src/TokenStream/CallableUserMethodFactory.php
@@ -7,12 +7,16 @@
  */
 namespace nicoSWD\Rule\TokenStream;
 
+use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenFactory;
 
 final class CallableUserMethodFactory implements CallableUserMethodFactoryInterface
 {
-    public function create(BaseToken $token, TokenFactory $tokenFactory, string $methodName): CallableUserMethod
+    /**
+     * {@inheritDoc}
+     */
+    public function create(BaseToken $token, TokenFactory $tokenFactory, string $methodName): CallableUserFunctionInterface
     {
         return new CallableUserMethod($token, $tokenFactory, $methodName);
     }
diff --git a/src/TokenStream/CallableUserMethodFactoryInterface.php b/src/TokenStream/CallableUserMethodFactoryInterface.php
index 2601617..e3fc352 100644
--- a/src/TokenStream/CallableUserMethodFactoryInterface.php
+++ b/src/TokenStream/CallableUserMethodFactoryInterface.php
@@ -7,10 +7,15 @@
  */
 namespace nicoSWD\Rule\TokenStream;
 
+use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenFactory;
 
 interface CallableUserMethodFactoryInterface
 {
-    public function create(BaseToken $token, TokenFactory $tokenFactory, string $methodName): CallableUserMethod;
+    /**
+     * @throws Exception\ForbiddenMethodException
+     * @throws Exception\UndefinedMethodException
+     */
+    public function create(BaseToken $token, TokenFactory $tokenFactory, string $methodName): CallableUserFunctionInterface;
 }
diff --git a/src/TokenStream/Node/BaseNode.php b/src/TokenStream/Node/BaseNode.php
index c9748e8..9b4e56e 100644
--- a/src/TokenStream/Node/BaseNode.php
+++ b/src/TokenStream/Node/BaseNode.php
@@ -10,20 +10,21 @@
 use Closure;
 use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\Type\Method;
+use nicoSWD\Rule\TokenStream\Token\Type\Whitespace;
 use nicoSWD\Rule\TokenStream\TokenCollection;
 use nicoSWD\Rule\Parser\Exception\ParserException;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
 
 abstract class BaseNode
 {
-    protected TokenStream $tokenStream;
-    private string $methodName = '';
+    private string $methodName;
     private int $methodOffset = 0;
 
-    public function __construct(TokenStream $tokenStream)
-    {
-        $this->tokenStream = $tokenStream;
+    public function __construct(
+        protected readonly TokenIterator $tokenStream,
+    ) {
     }
 
     /** @throws ParserException */
@@ -43,12 +44,12 @@ protected function hasMethodCall(): bool
 
             if (!$token) {
                 break;
-            } elseif ($token->isMethod()) {
+            } elseif ($token instanceof Method) {
                 $this->methodName = $token->getValue();
                 $this->methodOffset = $stack->key();
                 $hasMethod = true;
                 break;
-            } elseif (!$token->isWhitespace()) {
+            } elseif (!$token instanceof Whitespace) {
                 break;
             }
         }
@@ -100,7 +101,7 @@ protected function getCurrentNode(): BaseToken
     }
 
     /** @throws ParserException */
-    private function getCommaSeparatedValues(int $stopAt): TokenCollection
+    private function getCommaSeparatedValues(TokenType $stopAt): TokenCollection
     {
         $items = new TokenCollection();
         $commaExpected = false;
@@ -108,14 +109,14 @@ private function getCommaSeparatedValues(int $stopAt): TokenCollection
         do {
             $token = $this->getNextToken();
 
-            if ($token->isValue()) {
+            if (TokenType::isValue($token)) {
                 if ($commaExpected) {
                     throw ParserException::unexpectedToken($token);
                 }
 
                 $commaExpected = true;
                 $items->attach($token);
-            } elseif ($token->isComma()) {
+            } elseif ($token->isOfType(TokenType::COMMA)) {
                 if (!$commaExpected) {
                     throw ParserException::unexpectedComma($token);
                 }
@@ -123,7 +124,7 @@ private function getCommaSeparatedValues(int $stopAt): TokenCollection
                 $commaExpected = false;
             } elseif ($token->isOfType($stopAt)) {
                 break;
-            } elseif (!$token->isWhitespace()) {
+            } elseif (!$token->canBeIgnored()) {
                 throw ParserException::unexpectedToken($token);
             }
         } while (true);
diff --git a/src/TokenStream/Token/BaseToken.php b/src/TokenStream/Token/BaseToken.php
index 4456fff..2ced4fd 100644
--- a/src/TokenStream/Token/BaseToken.php
+++ b/src/TokenStream/Token/BaseToken.php
@@ -8,15 +8,15 @@
 namespace nicoSWD\Rule\TokenStream\Token;
 
 use nicoSWD\Rule\Parser\Exception\ParserException;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 
 abstract class BaseToken
 {
-    abstract public function getType(): int;
+    abstract public function getType(): TokenType;
 
     public function __construct(
-        private mixed $value,
-        private int $offset = 0
+        private readonly mixed $value,
+        private readonly int $offset = 0,
     ) {
     }
 
@@ -36,48 +36,20 @@ public function getOffset(): int
     }
 
     /** @throws ParserException */
-    public function createNode(TokenStream $tokenStream): self
+    public function createNode(TokenIterator $tokenStream): self
     {
         return $this;
     }
 
-    public function isOfType(int $type): bool
+    public function isOfType(TokenType $type): bool
     {
-        return ($this->getType() | $type) === $type;
+        return $this->getType() === $type;
     }
 
-    public function isValue(): bool
+    public function canBeIgnored(): bool
     {
-        return $this->isOfType(TokenType::VALUE | TokenType::INT_VALUE);
-    }
-
-    public function isWhitespace(): bool
-    {
-        return $this->isOfType(TokenType::SPACE | TokenType::COMMENT);
-    }
-
-    public function isMethod(): bool
-    {
-        return $this->isOfType(TokenType::METHOD);
-    }
-
-    public function isComma(): bool
-    {
-        return $this->isOfType(TokenType::COMMA);
-    }
-
-    public function isOperator(): bool
-    {
-        return $this->isOfType(TokenType::OPERATOR);
-    }
-
-    public function isLogical(): bool
-    {
-        return $this->isOfType(TokenType::LOGICAL);
-    }
-
-    public function isParenthesis(): bool
-    {
-        return $this->isOfType(TokenType::PARENTHESIS);
+        return
+            $this->isOfType(TokenType::SPACE) ||
+            $this->isOfType(TokenType::COMMENT);
     }
 }
diff --git a/src/TokenStream/Token/Token.php b/src/TokenStream/Token/Token.php
index 8112716..2f1bb3f 100644
--- a/src/TokenStream/Token/Token.php
+++ b/src/TokenStream/Token/Token.php
@@ -7,37 +7,37 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-class Token
+enum Token: string
 {
-    public const AND = 'And';
-    public const OR = 'Or';
-    public const NOT_EQUAL_STRICT = 'NotEqualStrict';
-    public const NOT_EQUAL = 'NotEqual';
-    public const EQUAL_STRICT = 'EqualStrict';
-    public const EQUAL = 'Equal';
-    public const IN = 'In';
-    public const NOT_IN = 'NotIn';
-    public const BOOL_TRUE = 'True';
-    public const BOOL_FALSE = 'False';
-    public const NULL = 'Null';
-    public const METHOD = 'Method';
-    public const FUNCTION = 'Function';
-    public const VARIABLE = 'Variable';
-    public const FLOAT = 'Float';
-    public const INTEGER = 'Integer';
-    public const ENCAPSED_STRING = 'EncapsedString';
-    public const SMALLER_EQUAL = 'SmallerEqual';
-    public const GREATER_EQUAL = 'GreaterEqual';
-    public const SMALLER = 'Smaller';
-    public const GREATER = 'Greater';
-    public const OPENING_PARENTHESIS = 'OpeningParentheses';
-    public const CLOSING_PARENTHESIS = 'ClosingParentheses';
-    public const OPENING_ARRAY = 'OpeningArray';
-    public const CLOSING_ARRAY = 'ClosingArray';
-    public const COMMA = 'Comma';
-    public const REGEX = 'Regex';
-    public const COMMENT = 'Comment';
-    public const NEWLINE = 'Newline';
-    public const SPACE = 'Space';
-    public const UNKNOWN = 'Unknown';
+    case AND = 'And';
+    case OR = 'Or';
+    case NOT_EQUAL_STRICT = 'NotEqualStrict';
+    case NOT_EQUAL = 'NotEqual';
+    case EQUAL_STRICT = 'EqualStrict';
+    case EQUAL = 'Equal';
+    case IN = 'In';
+    case NOT_IN = 'NotIn';
+    case BOOL_TRUE = 'True';
+    case BOOL_FALSE = 'False';
+    case NULL = 'Null';
+    case METHOD = 'Method';
+    case FUNCTION = 'Function';
+    case VARIABLE = 'Variable';
+    case FLOAT = 'Float';
+    case INTEGER = 'Integer';
+    case ENCAPSED_STRING = 'EncapsedString';
+    case SMALLER_EQUAL = 'SmallerEqual';
+    case GREATER_EQUAL = 'GreaterEqual';
+    case SMALLER = 'Smaller';
+    case GREATER = 'Greater';
+    case OPENING_PARENTHESIS = 'OpeningParentheses';
+    case CLOSING_PARENTHESIS = 'ClosingParentheses';
+    case OPENING_ARRAY = 'OpeningArray';
+    case CLOSING_ARRAY = 'ClosingArray';
+    case COMMA = 'Comma';
+    case REGEX = 'Regex';
+    case COMMENT = 'Comment';
+    case NEWLINE = 'Newline';
+    case SPACE = 'Space';
+    case UNKNOWN = 'Unknown';
 }
diff --git a/src/TokenStream/Token/TokenAnd.php b/src/TokenStream/Token/TokenAnd.php
index fc6f7dd..1f0e2e2 100644
--- a/src/TokenStream/Token/TokenAnd.php
+++ b/src/TokenStream/Token/TokenAnd.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenAnd extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Logical;
+
+final class TokenAnd extends BaseToken implements Logical
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::LOGICAL;
     }
diff --git a/src/TokenStream/Token/TokenArray.php b/src/TokenStream/Token/TokenArray.php
index 1201b06..4687123 100644
--- a/src/TokenStream/Token/TokenArray.php
+++ b/src/TokenStream/Token/TokenArray.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenArray extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+
+final class TokenArray extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
diff --git a/src/TokenStream/Token/TokenBool.php b/src/TokenStream/Token/TokenBool.php
index 1e35584..49fba5d 100644
--- a/src/TokenStream/Token/TokenBool.php
+++ b/src/TokenStream/Token/TokenBool.php
@@ -7,7 +7,9 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-abstract class TokenBool extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+
+abstract class TokenBool extends BaseToken implements Value
 {
     public static function fromBool(bool $bool): TokenBool
     {
@@ -17,7 +19,7 @@ public static function fromBool(bool $bool): TokenBool
         };
     }
 
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
diff --git a/src/TokenStream/Token/TokenClosingArray.php b/src/TokenStream/Token/TokenClosingArray.php
index 3bae87f..2f209d1 100644
--- a/src/TokenStream/Token/TokenClosingArray.php
+++ b/src/TokenStream/Token/TokenClosingArray.php
@@ -9,7 +9,7 @@
 
 final class TokenClosingArray extends BaseToken
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::SQUARE_BRACKET;
     }
diff --git a/src/TokenStream/Token/TokenClosingParenthesis.php b/src/TokenStream/Token/TokenClosingParenthesis.php
index c77e898..7b378a6 100644
--- a/src/TokenStream/Token/TokenClosingParenthesis.php
+++ b/src/TokenStream/Token/TokenClosingParenthesis.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenClosingParenthesis extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;
+
+final class TokenClosingParenthesis extends BaseToken implements Parenthesis
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::PARENTHESIS;
     }
diff --git a/src/TokenStream/Token/TokenComma.php b/src/TokenStream/Token/TokenComma.php
index ff39217..3732e9c 100644
--- a/src/TokenStream/Token/TokenComma.php
+++ b/src/TokenStream/Token/TokenComma.php
@@ -9,7 +9,7 @@
 
 final class TokenComma extends BaseToken
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::COMMA;
     }
diff --git a/src/TokenStream/Token/TokenComment.php b/src/TokenStream/Token/TokenComment.php
index e48c7ff..5b8426d 100644
--- a/src/TokenStream/Token/TokenComment.php
+++ b/src/TokenStream/Token/TokenComment.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenComment extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Whitespace;
+
+final class TokenComment extends BaseToken implements Whitespace
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::COMMENT;
     }
diff --git a/src/TokenStream/Token/TokenEqual.php b/src/TokenStream/Token/TokenEqual.php
index 3a2fb64..0fca76a 100644
--- a/src/TokenStream/Token/TokenEqual.php
+++ b/src/TokenStream/Token/TokenEqual.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenEqual extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenEqual extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenEqualStrict.php b/src/TokenStream/Token/TokenEqualStrict.php
index b60e244..b58feb8 100644
--- a/src/TokenStream/Token/TokenEqualStrict.php
+++ b/src/TokenStream/Token/TokenEqualStrict.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenEqualStrict extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenEqualStrict extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenFactory.php b/src/TokenStream/Token/TokenFactory.php
index 4b7a1be..780d95f 100644
--- a/src/TokenStream/Token/TokenFactory.php
+++ b/src/TokenStream/Token/TokenFactory.php
@@ -23,14 +23,13 @@ public function createFromPHPType(mixed $value): BaseToken
             'double' => new TokenFloat($value),
             'object' => new TokenObject($value),
             'array' => $this->buildTokenCollection($value),
-            default => throw ParserException::unsupportedType(gettype($value))
+            default => throw ParserException::unsupportedType(gettype($value)),
         };
     }
 
-    /** @throws ParserException */
-    public function createFromTokenName(string $tokenName): string
+    public function createFromToken(Token $token): string
     {
-        return match ($tokenName) {
+        return match ($token) {
             Token::AND => TokenAnd::class,
             Token::OR => TokenOr::class,
             Token::NOT_EQUAL_STRICT => TokenNotEqualStrict::class,
@@ -62,7 +61,6 @@ public function createFromTokenName(string $tokenName): string
             Token::NEWLINE => TokenNewline::class,
             Token::SPACE => TokenSpace::class,
             Token::UNKNOWN => TokenUnknown::class,
-            default => throw ParserException::unknownTokenName($tokenName)
         };
     }
 
diff --git a/src/TokenStream/Token/TokenFloat.php b/src/TokenStream/Token/TokenFloat.php
index 018c92b..d50e26a 100644
--- a/src/TokenStream/Token/TokenFloat.php
+++ b/src/TokenStream/Token/TokenFloat.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenFloat extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+
+final class TokenFloat extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
diff --git a/src/TokenStream/Token/TokenFunction.php b/src/TokenStream/Token/TokenFunction.php
index c93fed1..518285c 100644
--- a/src/TokenStream/Token/TokenFunction.php
+++ b/src/TokenStream/Token/TokenFunction.php
@@ -8,16 +8,16 @@
 namespace nicoSWD\Rule\TokenStream\Token;
 
 use nicoSWD\Rule\TokenStream\Node\NodeFunction;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 
 final class TokenFunction extends BaseToken
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::FUNCTION;
     }
 
-    public function createNode(TokenStream $tokenStream): BaseToken
+    public function createNode(TokenIterator $tokenStream): BaseToken
     {
         return (new NodeFunction($tokenStream))->getNode();
     }
diff --git a/src/TokenStream/Token/TokenGreater.php b/src/TokenStream/Token/TokenGreater.php
index a306b88..2fcae4a 100644
--- a/src/TokenStream/Token/TokenGreater.php
+++ b/src/TokenStream/Token/TokenGreater.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenGreater extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenGreater extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenGreaterEqual.php b/src/TokenStream/Token/TokenGreaterEqual.php
index faed030..c70262f 100644
--- a/src/TokenStream/Token/TokenGreaterEqual.php
+++ b/src/TokenStream/Token/TokenGreaterEqual.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenGreaterEqual extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenGreaterEqual extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenIn.php b/src/TokenStream/Token/TokenIn.php
index 88334b9..692521e 100644
--- a/src/TokenStream/Token/TokenIn.php
+++ b/src/TokenStream/Token/TokenIn.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenIn extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenIn extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenInteger.php b/src/TokenStream/Token/TokenInteger.php
index 45c950e..1f2b90e 100644
--- a/src/TokenStream/Token/TokenInteger.php
+++ b/src/TokenStream/Token/TokenInteger.php
@@ -7,11 +7,13 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenInteger extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+
+final class TokenInteger extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
-        return TokenType::INT_VALUE;
+        return TokenType::VALUE;
     }
 
     public function getValue(): int
diff --git a/src/TokenStream/Token/TokenMethod.php b/src/TokenStream/Token/TokenMethod.php
index 18c0684..e01b971 100644
--- a/src/TokenStream/Token/TokenMethod.php
+++ b/src/TokenStream/Token/TokenMethod.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenMethod extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Method;
+
+final class TokenMethod extends BaseToken implements Method
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::METHOD;
     }
diff --git a/src/TokenStream/Token/TokenNewline.php b/src/TokenStream/Token/TokenNewline.php
index 955ba39..f6a6471 100644
--- a/src/TokenStream/Token/TokenNewline.php
+++ b/src/TokenStream/Token/TokenNewline.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenNewline extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Whitespace;
+
+final class TokenNewline extends BaseToken implements Whitespace
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::SPACE;
     }
diff --git a/src/TokenStream/Token/TokenNotEqual.php b/src/TokenStream/Token/TokenNotEqual.php
index 163a1b9..48d2922 100644
--- a/src/TokenStream/Token/TokenNotEqual.php
+++ b/src/TokenStream/Token/TokenNotEqual.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenNotEqual extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenNotEqual extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenNotEqualStrict.php b/src/TokenStream/Token/TokenNotEqualStrict.php
index e913d18..fd6da30 100644
--- a/src/TokenStream/Token/TokenNotEqualStrict.php
+++ b/src/TokenStream/Token/TokenNotEqualStrict.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenNotEqualStrict extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenNotEqualStrict extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenNotIn.php b/src/TokenStream/Token/TokenNotIn.php
index 79a213a..a54d8b4 100644
--- a/src/TokenStream/Token/TokenNotIn.php
+++ b/src/TokenStream/Token/TokenNotIn.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenNotIn extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenNotIn extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenNull.php b/src/TokenStream/Token/TokenNull.php
index 452719c..d475b81 100644
--- a/src/TokenStream/Token/TokenNull.php
+++ b/src/TokenStream/Token/TokenNull.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenNull extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+
+final class TokenNull extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
diff --git a/src/TokenStream/Token/TokenObject.php b/src/TokenStream/Token/TokenObject.php
index c6c3e0a..adb58cd 100644
--- a/src/TokenStream/Token/TokenObject.php
+++ b/src/TokenStream/Token/TokenObject.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenObject extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+
+final class TokenObject extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
diff --git a/src/TokenStream/Token/TokenOpeningArray.php b/src/TokenStream/Token/TokenOpeningArray.php
index b2d5275..e6ba45b 100644
--- a/src/TokenStream/Token/TokenOpeningArray.php
+++ b/src/TokenStream/Token/TokenOpeningArray.php
@@ -8,16 +8,16 @@
 namespace nicoSWD\Rule\TokenStream\Token;
 
 use nicoSWD\Rule\TokenStream\Node\NodeArray;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 
 final class TokenOpeningArray extends BaseToken
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::SQUARE_BRACKET;
     }
 
-    public function createNode(TokenStream $tokenStream): BaseToken
+    public function createNode(TokenIterator $tokenStream): BaseToken
     {
         return (new NodeArray($tokenStream))->getNode();
     }
diff --git a/src/TokenStream/Token/TokenOpeningParenthesis.php b/src/TokenStream/Token/TokenOpeningParenthesis.php
index a3d4058..cb2efae 100644
--- a/src/TokenStream/Token/TokenOpeningParenthesis.php
+++ b/src/TokenStream/Token/TokenOpeningParenthesis.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenOpeningParenthesis extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;
+
+final class TokenOpeningParenthesis extends BaseToken implements Parenthesis
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::PARENTHESIS;
     }
diff --git a/src/TokenStream/Token/TokenOr.php b/src/TokenStream/Token/TokenOr.php
index b4dcfdc..499d305 100644
--- a/src/TokenStream/Token/TokenOr.php
+++ b/src/TokenStream/Token/TokenOr.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenOr extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Logical;
+
+final class TokenOr extends BaseToken implements Logical
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::LOGICAL;
     }
diff --git a/src/TokenStream/Token/TokenRegex.php b/src/TokenStream/Token/TokenRegex.php
index ad93008..9e1de40 100644
--- a/src/TokenStream/Token/TokenRegex.php
+++ b/src/TokenStream/Token/TokenRegex.php
@@ -8,16 +8,17 @@
 namespace nicoSWD\Rule\TokenStream\Token;
 
 use nicoSWD\Rule\TokenStream\Node\NodeString;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 
-final class TokenRegex extends BaseToken
+final class TokenRegex extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
 
-    public function createNode(TokenStream $tokenStream): BaseToken
+    public function createNode(TokenIterator $tokenStream): BaseToken
     {
         return (new NodeString($tokenStream))->getNode();
     }
diff --git a/src/TokenStream/Token/TokenSmaller.php b/src/TokenStream/Token/TokenSmaller.php
index 91b7617..5084fe4 100644
--- a/src/TokenStream/Token/TokenSmaller.php
+++ b/src/TokenStream/Token/TokenSmaller.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenSmaller extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenSmaller extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenSmallerEqual.php b/src/TokenStream/Token/TokenSmallerEqual.php
index 045aac7..a728ecf 100644
--- a/src/TokenStream/Token/TokenSmallerEqual.php
+++ b/src/TokenStream/Token/TokenSmallerEqual.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenSmallerEqual extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Operator;
+
+final class TokenSmallerEqual extends BaseToken implements Operator
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::OPERATOR;
     }
diff --git a/src/TokenStream/Token/TokenSpace.php b/src/TokenStream/Token/TokenSpace.php
index 170b17b..30f2afd 100644
--- a/src/TokenStream/Token/TokenSpace.php
+++ b/src/TokenStream/Token/TokenSpace.php
@@ -7,9 +7,11 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-final class TokenSpace extends BaseToken
+use nicoSWD\Rule\TokenStream\Token\Type\Whitespace;
+
+final class TokenSpace extends BaseToken implements Whitespace
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::SPACE;
     }
diff --git a/src/TokenStream/Token/TokenString.php b/src/TokenStream/Token/TokenString.php
index c320852..a02dfe6 100644
--- a/src/TokenStream/Token/TokenString.php
+++ b/src/TokenStream/Token/TokenString.php
@@ -8,16 +8,17 @@
 namespace nicoSWD\Rule\TokenStream\Token;
 
 use nicoSWD\Rule\TokenStream\Node\NodeString;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 
-class TokenString extends BaseToken
+class TokenString extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VALUE;
     }
 
-    public function createNode(TokenStream $tokenStream): BaseToken
+    public function createNode(TokenIterator $tokenStream): BaseToken
     {
         return (new NodeString($tokenStream))->getNode();
     }
diff --git a/src/TokenStream/Token/TokenType.php b/src/TokenStream/Token/TokenType.php
index 76c79e0..0f966ab 100644
--- a/src/TokenStream/Token/TokenType.php
+++ b/src/TokenStream/Token/TokenType.php
@@ -7,19 +7,23 @@
  */
 namespace nicoSWD\Rule\TokenStream\Token;
 
-class TokenType
+enum TokenType
 {
-    public const OPERATOR = 1;
-    public const INT_VALUE = 2;
-    public const VALUE = 4;
-    public const LOGICAL = 8;
-    public const VARIABLE = 16;
-    public const COMMENT = 32;
-    public const SPACE = 64;
-    public const UNKNOWN = 128;
-    public const PARENTHESIS = 256;
-    public const SQUARE_BRACKET = 512;
-    public const COMMA = 1024;
-    public const METHOD = 2048;
-    public const FUNCTION = 4098;
+    case OPERATOR;
+    case VALUE;
+    case LOGICAL;
+    case VARIABLE;
+    case COMMENT;
+    case SPACE;
+    case UNKNOWN;
+    case PARENTHESIS;
+    case SQUARE_BRACKET;
+    case COMMA;
+    case METHOD;
+    case FUNCTION;
+
+    public static function isValue(BaseToken $token): bool
+    {
+        return $token->getType() === self::VALUE;
+    }
 }
diff --git a/src/TokenStream/Token/TokenUnknown.php b/src/TokenStream/Token/TokenUnknown.php
index f2747b5..fec4686 100644
--- a/src/TokenStream/Token/TokenUnknown.php
+++ b/src/TokenStream/Token/TokenUnknown.php
@@ -9,7 +9,7 @@
 
 final class TokenUnknown extends BaseToken
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::UNKNOWN;
     }
diff --git a/src/TokenStream/Token/TokenVariable.php b/src/TokenStream/Token/TokenVariable.php
index 6a6b0f1..46db1ba 100644
--- a/src/TokenStream/Token/TokenVariable.php
+++ b/src/TokenStream/Token/TokenVariable.php
@@ -8,16 +8,17 @@
 namespace nicoSWD\Rule\TokenStream\Token;
 
 use nicoSWD\Rule\TokenStream\Node\NodeVariable;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\Token\Type\Value;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 
-final class TokenVariable extends BaseToken
+final class TokenVariable extends BaseToken implements Value
 {
-    public function getType(): int
+    public function getType(): TokenType
     {
         return TokenType::VARIABLE;
     }
 
-    public function createNode(TokenStream $tokenStream): BaseToken
+    public function createNode(TokenIterator $tokenStream): BaseToken
     {
         return (new NodeVariable($tokenStream))->getNode();
     }
diff --git a/src/Highlighter/Exception/InvalidGroupException.php b/src/TokenStream/Token/Type/Logical.php
similarity index 66%
rename from src/Highlighter/Exception/InvalidGroupException.php
rename to src/TokenStream/Token/Type/Logical.php
index a06295d..6cad197 100644
--- a/src/Highlighter/Exception/InvalidGroupException.php
+++ b/src/TokenStream/Token/Type/Logical.php
@@ -5,8 +5,8 @@
  * @link        https://github.com/nicoSWD
  * @author      Nicolas Oelgart <nico@oelgart.com>
  */
-namespace nicoSWD\Rule\Highlighter\Exception;
+namespace nicoSWD\Rule\TokenStream\Token\Type;
 
-class InvalidGroupException extends \Exception
+interface Logical
 {
 }
diff --git a/src/TokenStream/Token/Type/Method.php b/src/TokenStream/Token/Type/Method.php
new file mode 100644
index 0000000..32dd908
--- /dev/null
+++ b/src/TokenStream/Token/Type/Method.php
@@ -0,0 +1,12 @@
+<?php
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\TokenStream\Token\Type;
+
+interface Method
+{
+}
diff --git a/src/TokenStream/Token/Type/Operator.php b/src/TokenStream/Token/Type/Operator.php
new file mode 100644
index 0000000..27dbc59
--- /dev/null
+++ b/src/TokenStream/Token/Type/Operator.php
@@ -0,0 +1,12 @@
+<?php
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\TokenStream\Token\Type;
+
+interface Operator
+{
+}
diff --git a/src/TokenStream/Token/Type/Parenthesis.php b/src/TokenStream/Token/Type/Parenthesis.php
new file mode 100644
index 0000000..50c6102
--- /dev/null
+++ b/src/TokenStream/Token/Type/Parenthesis.php
@@ -0,0 +1,12 @@
+<?php
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\TokenStream\Token\Type;
+
+interface Parenthesis
+{
+}
diff --git a/src/TokenStream/Token/Type/Value.php b/src/TokenStream/Token/Type/Value.php
new file mode 100644
index 0000000..525f77f
--- /dev/null
+++ b/src/TokenStream/Token/Type/Value.php
@@ -0,0 +1,12 @@
+<?php
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\TokenStream\Token\Type;
+
+interface Value
+{
+}
diff --git a/src/TokenStream/Token/Type/Whitespace.php b/src/TokenStream/Token/Type/Whitespace.php
new file mode 100644
index 0000000..0391066
--- /dev/null
+++ b/src/TokenStream/Token/Type/Whitespace.php
@@ -0,0 +1,12 @@
+<?php
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\TokenStream\Token\Type;
+
+interface Whitespace
+{
+}
diff --git a/src/TokenStream/TokenIterator.php b/src/TokenStream/TokenIterator.php
new file mode 100644
index 0000000..05750ef
--- /dev/null
+++ b/src/TokenStream/TokenIterator.php
@@ -0,0 +1,92 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\TokenStream;
+
+use Closure;
+use Iterator;
+use nicoSWD\Rule\Parser\Exception\ParserException;
+use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
+use nicoSWD\Rule\TokenStream\Token\BaseToken;
+
+class TokenIterator implements Iterator
+{
+    public function __construct(
+        private readonly Iterator $stack,
+        private readonly TokenStream $tokenStream,
+    ) {
+    }
+
+    public function next(): void
+    {
+        $this->stack->next();
+    }
+
+    public function valid(): bool
+    {
+        return $this->stack->valid();
+    }
+
+    /** @throws ParserException */
+    public function current(): BaseToken
+    {
+        return $this->getCurrentToken()->createNode($this);
+    }
+
+    public function key(): int
+    {
+        return $this->stack->key();
+    }
+
+    public function rewind(): void
+    {
+        $this->stack->rewind();
+    }
+
+    /** @return Iterator<BaseToken> */
+    public function getStack(): Iterator
+    {
+        return $this->stack;
+    }
+
+    private function getCurrentToken(): BaseToken
+    {
+        return $this->stack->current();
+    }
+
+    /** @throws ParserException */
+    public function getVariable(string $variableName): BaseToken
+    {
+        try {
+            return $this->tokenStream->getVariable($variableName);
+        } catch (Exception\UndefinedVariableException) {
+            throw ParserException::undefinedVariable($variableName, $this->getCurrentToken());
+        }
+    }
+
+    /** @throws ParserException */
+    public function getFunction(string $functionName): Closure
+    {
+        try {
+            return $this->tokenStream->getFunction($functionName);
+        } catch (Exception\UndefinedFunctionException) {
+            throw ParserException::undefinedFunction($functionName, $this->getCurrentToken());
+        }
+    }
+
+    /** @throws ParserException */
+    public function getMethod(string $methodName, BaseToken $token): CallableUserFunctionInterface
+    {
+        try {
+            return $this->tokenStream->getMethod($methodName, $token);
+        } catch (Exception\UndefinedMethodException) {
+            throw ParserException::undefinedMethod($methodName, $this->getCurrentToken());
+        } catch (Exception\ForbiddenMethodException) {
+            throw ParserException::forbiddenMethod($methodName, $this->getCurrentToken());
+        }
+    }
+}
diff --git a/src/TokenStream/TokenStreamFactory.php b/src/TokenStream/TokenIteratorFactory.php
similarity index 57%
rename from src/TokenStream/TokenStreamFactory.php
rename to src/TokenStream/TokenIteratorFactory.php
index 1a1db0b..9f1cf2e 100644
--- a/src/TokenStream/TokenStreamFactory.php
+++ b/src/TokenStream/TokenIteratorFactory.php
@@ -7,12 +7,12 @@
  */
 namespace nicoSWD\Rule\TokenStream;
 
-use ArrayIterator;
+use Iterator;
 
-class TokenStreamFactory
+final class TokenIteratorFactory
 {
-    public function create(ArrayIterator $stack, AST $ast): TokenStream
+    public function create(Iterator $stack, TokenStream $tokenStream): TokenIterator
     {
-        return new TokenStream($stack, $ast);
+        return new TokenIterator($stack, $tokenStream);
     }
 }
diff --git a/src/TokenStream/TokenStream.php b/src/TokenStream/TokenStream.php
index 14ba919..ac6e36d 100644
--- a/src/TokenStream/TokenStream.php
+++ b/src/TokenStream/TokenStream.php
@@ -7,86 +7,132 @@
  */
 namespace nicoSWD\Rule\TokenStream;
 
-use ArrayIterator;
 use Closure;
-use nicoSWD\Rule\Parser\Exception\ParserException;
+use InvalidArgumentException;
 use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
+use nicoSWD\Rule\Parser\Exception\ParserException;
+use nicoSWD\Rule\TokenStream\Exception\UndefinedVariableException;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\TokenFactory;
+use nicoSWD\Rule\Tokenizer\TokenizerInterface;
+use nicoSWD\Rule\TokenStream\Token\TokenObject;
 
-class TokenStream extends ArrayIterator
+class TokenStream
 {
+    private array $functions = [];
+    private array $methods = [];
+    private array $variables = [];
+
     public function __construct(
-        private ArrayIterator $stack,
-        private AST $ast
+        private readonly TokenizerInterface $tokenizer,
+        private readonly TokenFactory $tokenFactory,
+        private readonly TokenIteratorFactory $tokenIteratorFactory,
+        private readonly CallableUserMethodFactoryInterface $userMethodFactory,
     ) {
     }
 
-    public function next(): void
+    public function getStream(string $rule): TokenIterator
     {
-        $this->stack->next();
+        return $this->tokenIteratorFactory->create($this->tokenizer->tokenize($rule), $this);
     }
 
-    public function valid(): bool
+    /**
+     * @throws Exception\UndefinedMethodException
+     * @throws Exception\ForbiddenMethodException
+     */
+    public function getMethod(string $methodName, BaseToken $token): CallableUserFunctionInterface
     {
-        return $this->stack->valid();
+        if ($token instanceof TokenObject) {
+            return $this->getCallableUserMethod($token, $methodName);
+        }
+
+        if (empty($this->methods)) {
+            $this->registerMethods();
+        }
+
+        if (!isset($this->methods[$methodName])) {
+            throw new Exception\UndefinedMethodException();
+        }
+
+        return new $this->methods[$methodName]($token);
     }
 
-    /** @throws ParserException */
-    public function current(): BaseToken
+    public function setVariables(array $variables): void
     {
-        return $this->getCurrentToken()->createNode($this);
+        $this->variables = $variables;
     }
 
-    public function key(): int
+    /**
+     * @throws UndefinedVariableException
+     * @throws ParserException
+     */
+    public function getVariable(string $variableName): BaseToken
     {
-        return $this->stack->key();
+        if (!$this->variableExists($variableName)) {
+            throw new UndefinedVariableException($variableName);
+        }
+
+        return $this->tokenFactory->createFromPHPType($this->variables[$variableName]);
     }
 
-    public function rewind(): void
+    public function variableExists(string $variableName): bool
     {
-        $this->stack->rewind();
+        return array_key_exists($variableName, $this->variables);
     }
 
-    /** @return ArrayIterator<BaseToken> */
-    public function getStack(): ArrayIterator
+    /** @throws Exception\UndefinedFunctionException */
+    public function getFunction(string $functionName): Closure
     {
-        return $this->stack;
+        if (empty($this->functions)) {
+            $this->registerFunctions();
+        }
+
+        if (!isset($this->functions[$functionName])) {
+            throw new Exception\UndefinedFunctionException($functionName);
+        }
+
+        return $this->functions[$functionName];
     }
 
-    private function getCurrentToken(): BaseToken
+    private function registerMethods(): void
     {
-        return $this->stack->current();
+        foreach ($this->tokenizer->grammar->getInternalMethods() as $internalMethod) {
+            $this->methods[$internalMethod->name] = $internalMethod->class;
+        }
     }
 
-    /** @throws ParserException */
-    public function getVariable(string $variableName): BaseToken
+    private function registerFunctions(): void
     {
-        try {
-            return $this->ast->getVariable($variableName);
-        } catch (Exception\UndefinedVariableException) {
-            throw ParserException::undefinedVariable($variableName, $this->getCurrentToken());
+        foreach ($this->tokenizer->grammar->getInternalFunctions() as $function)  {
+            $this->registerFunctionClass($function->name, $function->class);
         }
     }
 
-    /** @throws ParserException */
-    public function getFunction(string $functionName): Closure
+    private function registerFunctionClass(string $functionName, string $className): void
     {
-        try {
-            return $this->ast->getFunction($functionName);
-        } catch (Exception\UndefinedFunctionException) {
-            throw ParserException::undefinedFunction($functionName, $this->getCurrentToken());
-        }
+        $this->functions[$functionName] = function (?BaseToken ...$args) use ($className) {
+            $function = new $className();
+
+            if (!$function instanceof CallableUserFunctionInterface) {
+                throw new InvalidArgumentException(
+                    sprintf(
+                        '%s must be an instance of %s',
+                        $className,
+                        CallableUserFunctionInterface::class
+                    )
+                );
+            }
+
+            return $function->call(...$args);
+        };
     }
 
-    /** @throws ParserException */
-    public function getMethod(string $methodName, BaseToken $token): CallableUserFunctionInterface
+    /**
+     * @throws Exception\ForbiddenMethodException
+     * @throws Exception\UndefinedMethodException
+     */
+    private function getCallableUserMethod(BaseToken $token, string $methodName): CallableUserFunctionInterface
     {
-        try {
-            return $this->ast->getMethod($methodName, $token);
-        } catch (Exception\UndefinedMethodException) {
-            throw ParserException::undefinedMethod($methodName, $this->getCurrentToken());
-        } catch (Exception\ForbiddenMethodException) {
-            throw ParserException::forbiddenMethod($methodName, $this->getCurrentToken());
-        }
+        return $this->userMethodFactory->create($token, $this->tokenFactory, $methodName);
     }
 }
diff --git a/src/Tokenizer/Tokenizer.php b/src/Tokenizer/Tokenizer.php
index 702394c..2e8a90b 100644
--- a/src/Tokenizer/Tokenizer.php
+++ b/src/Tokenizer/Tokenizer.php
@@ -8,92 +8,44 @@
 namespace nicoSWD\Rule\Tokenizer;
 
 use ArrayIterator;
+use Iterator;
 use nicoSWD\Rule\Grammar\Grammar;
+use nicoSWD\Rule\TokenStream\Token\Token;
 use nicoSWD\Rule\TokenStream\Token\TokenFactory;
-use SplPriorityQueue;
 
-final class Tokenizer implements TokenizerInterface
+final class Tokenizer extends TokenizerInterface
 {
-    private array $tokens = [];
-    private string $compiledRegex = '';
-
     public function __construct(
-        private Grammar $grammar,
-        private TokenFactory $tokenFactory
+        public readonly Grammar $grammar,
+        private readonly TokenFactory $tokenFactory,
     ) {
-        foreach ($grammar->getDefinition() as [$class, $regex, $priority]) {
-            $this->registerToken($class, $regex, $priority);
-        }
     }
 
-    public function tokenize(string $string): ArrayIterator
+    public function tokenize(string $string): Iterator
     {
-        $regex = $this->getRegex();
+        $regex = $this->grammar->buildRegex();
         $stack = [];
         $offset = 0;
 
-        while (preg_match($regex, $string, $matches, 0, $offset)) {
+        while (preg_match($regex, $string, $matches, offset: $offset)) {
             $token = $this->getMatchedToken($matches);
-            $className = $this->tokenFactory->createFromTokenName($token);
+            $className = $this->tokenFactory->createFromToken($token);
 
-            $stack[] = new $className($matches[$token], $offset);
+            $stack[] = new $className($matches[$token->value], $offset);
             $offset += strlen($matches[0]);
         }
 
         return new ArrayIterator($stack);
     }
 
-    public function getGrammar(): Grammar
-    {
-        return $this->grammar;
-    }
-
-    private function registerToken(string $class, string $regex, int $priority): void
-    {
-        $this->tokens[$class] = new class($class, $regex, $priority) {
-            public function __construct(
-                public string $class,
-                public string $regex,
-                public int $priority
-            ) {
-            }
-        };
-    }
-
-    private function getMatchedToken(array $matches): string
+    private function getMatchedToken(array $matches): Token
     {
         foreach ($matches as $key => $value) {
             if ($value !== '' && !is_int($key)) {
-                return $key;
+                return Token::from($key);
             }
         }
 
-        return 'Unknown';
-    }
-
-    private function getRegex(): string
-    {
-        if (!$this->compiledRegex) {
-            $regex = [];
-
-            foreach ($this->getQueue() as $token) {
-                $regex[] = "(?<$token->class>$token->regex)";
-            }
-
-            $this->compiledRegex = '~(' . implode('|', $regex) . ')~As';
-        }
-
-        return $this->compiledRegex;
-    }
-
-    private function getQueue(): SplPriorityQueue
-    {
-        $queue = new SplPriorityQueue();
-
-        foreach ($this->tokens as $class) {
-            $queue->insert($class, $class->priority);
-        }
-
-        return $queue;
+        return Token::UNKNOWN;
     }
 }
diff --git a/src/Tokenizer/TokenizerInterface.php b/src/Tokenizer/TokenizerInterface.php
index e49b05d..f3f9a65 100644
--- a/src/Tokenizer/TokenizerInterface.php
+++ b/src/Tokenizer/TokenizerInterface.php
@@ -1,4 +1,4 @@
-<?php
+<?php declare(strict_types=1);
 
 /**
  * @license     http://opensource.org/licenses/mit-license.php MIT
@@ -7,14 +7,17 @@
  */
 namespace nicoSWD\Rule\Tokenizer;
 
-use ArrayIterator;
+use Iterator;
 use nicoSWD\Rule\Grammar\Grammar;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 
-interface TokenizerInterface
+abstract class TokenizerInterface
 {
-    /** @return ArrayIterator<int, BaseToken> */
-    public function tokenize(string $string): ArrayIterator;
+    public readonly Grammar $grammar;
 
-    public function getGrammar(): Grammar;
+    /**
+     * @param string $string
+     * @return Iterator<int, BaseToken>
+     */
+    abstract public function tokenize(string $string): Iterator;
 }
diff --git a/src/container.php b/src/container.php
index c356af5..aa273ef 100644
--- a/src/container.php
+++ b/src/container.php
@@ -8,22 +8,22 @@
 namespace nicoSWD\Rule;
 
 use nicoSWD\Rule\Grammar\JavaScript\JavaScript;
-use nicoSWD\Rule\TokenStream\AST;
+use nicoSWD\Rule\Parser\EvaluatableExpressionFactory;
+use nicoSWD\Rule\TokenStream\TokenStream;
 use nicoSWD\Rule\Compiler\CompilerFactory;
 use nicoSWD\Rule\Evaluator\Evaluator;
 use nicoSWD\Rule\Evaluator\EvaluatorInterface;
-use nicoSWD\Rule\Expression\ExpressionFactory;
 use nicoSWD\Rule\Tokenizer\Tokenizer;
 use nicoSWD\Rule\TokenStream\Token\TokenFactory;
-use nicoSWD\Rule\TokenStream\TokenStreamFactory;
+use nicoSWD\Rule\TokenStream\TokenIteratorFactory;
 use nicoSWD\Rule\TokenStream\CallableUserMethodFactory;
 
 return new class {
-    private static TokenStreamFactory $tokenStreamFactory;
+    private static TokenIteratorFactory $tokenStreamFactory;
     private static TokenFactory $tokenFactory;
     private static CompilerFactory $compiler;
     private static JavaScript $javaScript;
-    private static ExpressionFactory $expressionFactory;
+    private static EvaluatableExpressionFactory $expressionFactory;
     private static CallableUserMethodFactory $userMethodFactory;
     private static Tokenizer $tokenizer;
     private static Evaluator $evaluator;
@@ -64,12 +64,12 @@ private static function compiler(): CompilerFactory
         return self::$compiler;
     }
 
-    private static function ast(array $variables): AST
+    private static function ast(array $variables): TokenStream
     {
-        $ast = new AST(self::tokenizer(), self::tokenFactory(), self::tokenStreamFactory(), self::userMethodFactory());
-        $ast->setVariables($variables);
+        $tokenStream = new TokenStream(self::tokenizer(), self::tokenFactory(), self::tokenStreamFactory(), self::userMethodFactory());
+        $tokenStream->setVariables($variables);
 
-        return $ast;
+        return $tokenStream;
     }
 
     private static function tokenizer(): Tokenizer
@@ -90,19 +90,19 @@ private static function javascript(): JavaScript
         return self::$javaScript;
     }
 
-    private static function tokenStreamFactory(): TokenStreamFactory
+    private static function tokenStreamFactory(): TokenIteratorFactory
     {
         if (!isset(self::$tokenStreamFactory)) {
-            self::$tokenStreamFactory = new TokenStreamFactory();
+            self::$tokenStreamFactory = new TokenIteratorFactory();
         }
 
         return self::$tokenStreamFactory;
     }
 
-    private static function expressionFactory(): ExpressionFactory
+    private static function expressionFactory(): EvaluatableExpressionFactory
     {
         if (!isset(self::$expressionFactory)) {
-            self::$expressionFactory = new ExpressionFactory();
+            self::$expressionFactory = new EvaluatableExpressionFactory();
         }
 
         return self::$expressionFactory;
diff --git a/tests/integration/HighlighterTest.php b/tests/integration/HighlighterTest.php
index 3f44e1a..4c03b01 100755
--- a/tests/integration/HighlighterTest.php
+++ b/tests/integration/HighlighterTest.php
@@ -7,7 +7,6 @@
  */
 namespace nicoSWD\Rule\tests\integration;
 
-use Exception;
 use nicoSWD\Rule;
 use nicoSWD\Rule\Grammar\JavaScript\JavaScript;
 use nicoSWD\Rule\Highlighter\Highlighter;
@@ -36,16 +35,4 @@ public function givenAStyleForATokenGroupItShouldBeUsed(): void
 
         $this->assertStringContainsString('<span style="color: gray;">[</span>', $code);
     }
-
-    /** @test */
-    public function invalidGroupThrowsException(): void
-    {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Invalid group');
-
-        $this->highlighter->setStyle(
-            99,
-            'color: test-color;'
-        );
-    }
 }
diff --git a/tests/integration/TokenizerTest.php b/tests/integration/TokenizerTest.php
index 614e031..69c5e74 100755
--- a/tests/integration/TokenizerTest.php
+++ b/tests/integration/TokenizerTest.php
@@ -9,6 +9,7 @@
 
 use nicoSWD\Rule\Grammar\JavaScript\JavaScript;
 use nicoSWD\Rule\Tokenizer\Tokenizer;
+use nicoSWD\Rule\TokenStream\Token\Token;
 use nicoSWD\Rule\TokenStream\Token\TokenFactory;
 use PHPUnit\Framework\TestCase;
 use ReflectionMethod;
@@ -26,10 +27,9 @@ protected function setUp(): void
     public function getMatchedTokenReturnsFalseOnFailure(): void
     {
         $reflection = new ReflectionMethod($this->tokenizer, 'getMatchedToken');
-        $reflection->setAccessible(true);
         $result = $reflection->invoke($this->tokenizer, []);
 
-        $this->assertSame('Unknown', $result);
+        $this->assertSame(Token::UNKNOWN, $result);
     }
 
     /** @test */
diff --git a/tests/integration/methods/SyntaxErrorTest.php b/tests/integration/methods/SyntaxErrorTest.php
index 6af16a9..31b3da9 100755
--- a/tests/integration/methods/SyntaxErrorTest.php
+++ b/tests/integration/methods/SyntaxErrorTest.php
@@ -90,6 +90,6 @@ public function exceptionIsThrownOnTypeError(): void
         $rule = new Rule('"foo".test("foo") === false');
 
         $this->assertFalse($rule->isValid());
-        $this->assertSame('undefined is not a function', $rule->getError());
+        $this->assertSame('test() is not a function', $rule->getError());
     }
 }
diff --git a/tests/unit/Grammar/GrammarTest.php b/tests/unit/Grammar/GrammarTest.php
index f0d1b13..cabd738 100755
--- a/tests/unit/Grammar/GrammarTest.php
+++ b/tests/unit/Grammar/GrammarTest.php
@@ -5,7 +5,7 @@
  * @link        https://github.com/nicoSWD
  * @author      Nicolas Oelgart <nico@oelgart.com>
  */
-namespace nicoSWD\Rule\tests\unit\Parser;
+namespace nicoSWD\Rule\tests\unit\Grammar;
 
 use nicoSWD\Rule\Grammar\Grammar;
 use PHPUnit\Framework\TestCase;
@@ -19,6 +19,16 @@ public function getDefinition(): array
             {
                 return [];
             }
+
+            public function getInternalFunctions(): array
+            {
+                return [];
+            }
+
+            public function getInternalMethods(): array
+            {
+                return [];
+            }
         };
 
         $this->assertSame([], $grammar->getDefinition());
diff --git a/tests/unit/Parser/ParserTest.php b/tests/unit/Parser/ParserTest.php
index 95546c2..956d8bf 100755
--- a/tests/unit/Parser/ParserTest.php
+++ b/tests/unit/Parser/ParserTest.php
@@ -9,32 +9,30 @@
 
 use Mockery as m;
 use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
-use nicoSWD\Rule\TokenStream\AST;
+use nicoSWD\Rule\Compiler\StandardCompiler;
+use nicoSWD\Rule\Parser\EvaluatableExpressionFactory;
+use nicoSWD\Rule\TokenStream\TokenStream;
 use nicoSWD\Rule\Compiler\CompilerFactoryInterface;
-use nicoSWD\Rule\Compiler\CompilerInterface;
-use nicoSWD\Rule\Expression\BaseExpression;
-use nicoSWD\Rule\Expression\ExpressionFactoryInterface;
 use nicoSWD\Rule\Parser\Parser;
 use nicoSWD\Rule\TokenStream\Token;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 use PHPUnit\Framework\TestCase;
 
 final class ParserTest extends TestCase
 {
     use MockeryPHPUnitIntegration;
 
-    private AST|m\Mock $ast;
-    private ExpressionFactoryInterface|m\Mock $expressionFactory;
+    private TokenStream|m\Mock $tokenStream;
+    private EvaluatableExpressionFactory $expressionFactory;
     private CompilerFactoryInterface|m\Mock $compilerFactory;
     private Parser $parser;
 
     protected function setUp(): void
     {
-        $this->ast = m::mock(AST::class);
-        $this->expressionFactory = m::mock(ExpressionFactoryInterface::class);
+        $this->tokenStream = m::mock(TokenStream::class);
         $this->compilerFactory = m::mock(CompilerFactoryInterface::class);
 
-        $this->parser = new Parser($this->ast, $this->expressionFactory, $this->compilerFactory);
+        $this->parser = new Parser($this->tokenStream, new EvaluatableExpressionFactory(), $this->compilerFactory);
     }
 
     /** @test */
@@ -54,14 +52,10 @@ public function givenARuleStringWhenValidItShouldReturnTheCompiledRule(): void
             new Token\TokenComment('// true dat!')
         ];
 
-        $compiler = m::mock(CompilerInterface::class);
-        $compiler->shouldReceive('addLogical')->once();
-        $compiler->shouldReceive('addParentheses')->twice();
-        $compiler->shouldReceive('addBoolean')->twice();
-        $compiler->shouldReceive('getCompiledRule')->once()->andReturn('(1)&1');
+        $compiler = new StandardCompiler();
 
         /** @var m\MockInterface $tokenStream */
-        $tokenStream = \Mockery::mock(TokenStream::class);
+        $tokenStream = \Mockery::mock(TokenIterator::class);
         $tokenStream->shouldReceive('rewind')->once();
         $tokenStream->shouldReceive('next');
         $tokenStream->shouldReceive('current')->andReturn(...$tokens);
@@ -70,22 +64,7 @@ public function givenARuleStringWhenValidItShouldReturnTheCompiledRule(): void
         });
 
         $this->compilerFactory->shouldReceive('create')->once()->andReturn($compiler);
-        $this->ast->shouldReceive('getStream')->once()->andReturn($tokenStream);
-
-        $equalExpression = m::mock(BaseExpression::class);
-        $equalExpression->shouldReceive('evaluate')->once()->with(1, '1');
-
-        $greaterExpression = m::mock(BaseExpression::class);
-        $greaterExpression->shouldReceive('evaluate')->once()->with(2, 1);
-
-        $this->expressionFactory
-            ->shouldReceive('createFromOperator')
-            ->twice()
-            ->with(m::type(Token\BaseToken::class))
-            ->andReturn(
-                $equalExpression,
-                $greaterExpression
-            );
+        $this->tokenStream->shouldReceive('getStream')->once()->andReturn($tokenStream);
 
         $this->assertSame('(1)&1', $this->parser->parse('(1=="1")&&2>1 // true dat!'));
     }
diff --git a/tests/unit/Token/TokenFactoryTest.php b/tests/unit/Token/TokenFactoryTest.php
index fcf59f3..d67ea17 100755
--- a/tests/unit/Token/TokenFactoryTest.php
+++ b/tests/unit/Token/TokenFactoryTest.php
@@ -14,7 +14,7 @@
 
 final class TokenFactoryTest extends TestCase
 {
-    private Token\TokenFactory $tokenFactory;
+    private readonly Token\TokenFactory $tokenFactory;
 
     protected function setUp(): void
     {
@@ -41,17 +41,9 @@ public function unsupportedTypeThrowsException(): void
         $this->tokenFactory->createFromPHPType(tmpfile());
     }
 
-    /** @test */
-    public function givenAnInvalidTokenNameItShouldThrowAnException(): void
-    {
-        $this->expectException(ParserException::class);
-
-        $this->tokenFactory->createFromTokenName('betrunken');
-    }
-
     /** @test */
     public function givenAValidTokenNameItShouldReturnItsCorrespondingClassName(): void
     {
-        $this->assertSame(TokenEqualStrict::class, $this->tokenFactory->createFromTokenName(Token\Token::EQUAL_STRICT));
+        $this->assertSame(TokenEqualStrict::class, $this->tokenFactory->createFromToken(Token\Token::EQUAL_STRICT));
     }
 }
diff --git a/tests/unit/TokenStream/ASTTest.php b/tests/unit/TokenStream/ASTTest.php
deleted file mode 100755
index 04f2281..0000000
--- a/tests/unit/TokenStream/ASTTest.php
+++ /dev/null
@@ -1,89 +0,0 @@
-<?php declare(strict_types=1);
-
-/**
- * @license     http://opensource.org/licenses/mit-license.php MIT
- * @link        https://github.com/nicoSWD
- * @author      Nicolas Oelgart <nico@oelgart.com>
- */
-namespace nicoSWD\Rule\tests\unit\TokenStream;
-
-use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
-use Mockery\MockInterface;
-use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
-use nicoSWD\Rule\Grammar\Grammar;
-use nicoSWD\Rule\Tokenizer\TokenizerInterface;
-use nicoSWD\Rule\TokenStream\AST;
-use nicoSWD\Rule\TokenStream\Exception\UndefinedFunctionException;
-use nicoSWD\Rule\TokenStream\Node\BaseNode;
-use nicoSWD\Rule\TokenStream\Token\BaseToken;
-use nicoSWD\Rule\TokenStream\Token\TokenFactory;
-use nicoSWD\Rule\TokenStream\TokenStreamFactory;
-use nicoSWD\Rule\TokenStream\CallableUserMethodFactory;
-use PHPUnit\Framework\TestCase;
-
-final class ASTTest extends TestCase
-{
-    use MockeryPHPUnitIntegration;
-
-    private TokenizerInterface|MockInterface $tokenizer;
-    private TokenFactory|MockInterface $tokenFactory;
-    private TokenStreamFactory|MockInterface $tokenStreamFactory;
-    private AST $ast;
-    private CallableUserMethodFactory $userMethodFactory;
-
-    protected function setUp(): void
-    {
-        $this->tokenizer = \Mockery::mock(TokenizerInterface::class);
-        $this->tokenFactory = \Mockery::mock(TokenFactory::class);
-        $this->tokenStreamFactory = \Mockery::mock(TokenStreamFactory::class);
-        $this->userMethodFactory = new CallableUserMethodFactory();
-
-        $this->ast = new AST(
-            $this->tokenizer,
-            $this->tokenFactory,
-            $this->tokenStreamFactory,
-            $this->userMethodFactory
-        );
-    }
-
-    /** @test */
-    public function givenAFunctionNameWhenValidItShouldReturnTheCorrespondingFunction(): void
-    {
-        $grammar = \Mockery::mock(Grammar::class);
-        $grammar->shouldReceive('getInternalFunctions')->once()->andReturn(['test' => TestFunc::class]);
-        $this->tokenizer->shouldReceive('getGrammar')->once()->andReturn($grammar);
-
-        /** @var BaseToken $result */
-        $result = $this->ast->getFunction('test')->call(\Mockery::mock(BaseNode::class));
-
-        $this->assertSame(234, $result->getValue());
-    }
-
-    /** @test */
-    public function givenAFunctionNameWhenItDoesNotImplementTheInterfaceItShouldThrowAnException(): void
-    {
-        $this->expectExceptionMessage(sprintf(
-            'stdClass must be an instance of %s',
-            CallableUserFunctionInterface::class
-        ));
-
-        $grammar = \Mockery::mock(Grammar::class);
-        $grammar->shouldReceive('getInternalFunctions')->once()->andReturn(['test' => \stdClass::class]);
-        $this->tokenizer->shouldReceive('getGrammar')->once()->andReturn($grammar);
-
-        $this->ast->getFunction('test')->call(\Mockery::mock(BaseNode::class));
-    }
-
-    /** @test */
-    public function givenAFunctionNameNotDefinedItShouldThrowAnException(): void
-    {
-        $this->expectException(UndefinedFunctionException::class);
-        $this->expectExceptionMessage('pineapple_pizza');
-
-        $grammar = \Mockery::mock(Grammar::class);
-        $grammar->shouldReceive('getInternalFunctions')->once()->andReturn([]);
-        $this->tokenizer->shouldReceive('getGrammar')->once()->andReturn($grammar);
-
-        $this->ast->getFunction('pineapple_pizza')->call(\Mockery::mock(BaseNode::class));
-    }
-}
diff --git a/tests/unit/TokenStream/Token/BaseTokenTest.php b/tests/unit/TokenStream/Token/BaseTokenTest.php
index 0033d3d..d1753d4 100755
--- a/tests/unit/TokenStream/Token/BaseTokenTest.php
+++ b/tests/unit/TokenStream/Token/BaseTokenTest.php
@@ -5,12 +5,12 @@
  * @link        https://github.com/nicoSWD
  * @author      Nicolas Oelgart <nico@oelgart.com>
  */
-namespace nicoSWD\Rule\tests\unit\TokenStream;
+namespace nicoSWD\Rule\tests\unit\TokenStream\Token;
 
 use Mockery\MockInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\TokenIterator;
 use PHPUnit\Framework\TestCase;
 
 final class BaseTokenTest extends TestCase
@@ -21,7 +21,7 @@ final class BaseTokenTest extends TestCase
     protected function setUp(): void
     {
         $this->token = new class('&&', 1337) extends BaseToken {
-            public function getType(): int
+            public function getType(): TokenType
             {
                 return TokenType::LOGICAL;
             }
@@ -49,8 +49,8 @@ public function getOriginalValue(): void
     /** @test */
     public function createNode(): void
     {
-        /** @var TokenStream|MockInterface $tokenStream */
-        $tokenStream = \Mockery::mock(TokenStream::class);
+        /** @var TokenIterator|MockInterface $tokenStream */
+        $tokenStream = \Mockery::mock(TokenIterator::class);
         $this->assertSame($this->token, $this->token->createNode($tokenStream));
     }
 
@@ -60,95 +60,4 @@ public function isOfType(): void
         $this->assertTrue($this->token->isOfType(TokenType::LOGICAL));
         $this->assertFalse($this->token->isOfType(TokenType::COMMA));
     }
-
-    /** @test */
-    public function isValue(): void
-    {
-        $token = new class('123', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::VALUE;
-            }
-        };
-
-        $this->assertTrue($token->isValue());
-    }
-
-    /** @test */
-    public function isWhitespace(): void
-    {
-        $token = new class(' ', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::SPACE;
-            }
-        };
-
-        $this->assertTrue($token->isWhitespace());
-    }
-
-    /** @test */
-    public function isMethod(): void
-    {
-        $token = new class('.derp(', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::METHOD;
-            }
-        };
-
-        $this->assertTrue($token->isMethod());
-    }
-
-    /** @test */
-    public function isComma(): void
-    {
-        $token = new class(',', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::COMMA;
-            }
-        };
-
-        $this->assertTrue($token->isComma());
-    }
-
-    /** @test */
-    public function isOperator(): void
-    {
-        $token = new class('>', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::OPERATOR;
-            }
-        };
-
-        $this->assertTrue($token->isOperator());
-    }
-
-    /** @test */
-    public function isLogical(): void
-    {
-        $token = new class('&&', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::LOGICAL;
-            }
-        };
-
-        $this->assertTrue($token->isLogical());
-    }
-
-    /** @test */
-    public function isParenthesis(): void
-    {
-        $token = new class('(', 1337) extends BaseToken {
-            public function getType(): int
-            {
-                return TokenType::PARENTHESIS;
-            }
-        };
-
-        $this->assertTrue($token->isParenthesis());
-    }
 }
diff --git a/tests/unit/TokenStream/TokenIteratorTest.php b/tests/unit/TokenStream/TokenIteratorTest.php
new file mode 100755
index 0000000..8871126
--- /dev/null
+++ b/tests/unit/TokenStream/TokenIteratorTest.php
@@ -0,0 +1,132 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <nico@oelgart.com>
+ */
+namespace nicoSWD\Rule\tests\unit\TokenStream;
+
+use ArrayIterator;
+use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
+use Mockery\MockInterface;
+use nicoSWD\Rule\Grammar\CallableFunction;
+use nicoSWD\Rule\Parser\Exception\ParserException;
+use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\Exception\UndefinedFunctionException;
+use nicoSWD\Rule\TokenStream\Exception\UndefinedMethodException;
+use nicoSWD\Rule\TokenStream\Exception\UndefinedVariableException;
+use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\TokenFunction;
+use nicoSWD\Rule\TokenStream\Token\TokenMethod;
+use nicoSWD\Rule\TokenStream\Token\TokenString;
+use nicoSWD\Rule\TokenStream\Token\TokenVariable;
+use nicoSWD\Rule\TokenStream\TokenIterator;
+use PHPUnit\Framework\TestCase;
+
+final class TokenIteratorTest extends TestCase
+{
+    use MockeryPHPUnitIntegration;
+    
+    private ArrayIterator|MockInterface $stack;
+    private TokenStream|MockInterface $tokenStream;
+    private TokenIterator $tokenIterator;
+
+    protected function setUp(): void
+    {
+        $this->stack = \Mockery::mock(ArrayIterator::class);
+        $this->tokenStream = \Mockery::mock(TokenStream::class);
+
+        $this->tokenIterator = new TokenIterator($this->stack, $this->tokenStream);
+    }
+
+    /** @test */
+    public function givenAStackWhenNotEmptyItShouldBeIterable()
+    {
+        $this->stack->shouldReceive('rewind');
+        $this->stack->shouldReceive('valid')->andReturn(true, true, true, false);
+        $this->stack->shouldReceive('key')->andReturn(1, 2, 3);
+        $this->stack->shouldReceive('next');
+        $this->stack->shouldReceive('seek');
+        $this->stack->shouldReceive('current')->times(5)->andReturn(
+            new TokenString('a'),
+            new TokenMethod('.foo('),
+            new TokenString('b')
+        );
+
+        foreach ($this->tokenIterator as $value) {
+            $this->assertInstanceOf(BaseToken::class, $value);
+        }
+    }
+
+    /** @test */
+    public function givenATokenStackItShouldBeAccessibleViaGetter()
+    {
+        $this->assertInstanceOf(ArrayIterator::class, $this->tokenIterator->getStack());
+    }
+
+    /** @test */
+    public function givenAVariableNameWhenFoundItShouldReturnItsValue()
+    {
+        $this->tokenStream->shouldReceive('getVariable')->once()->with('foo')->andReturn(new TokenVariable('bar'));
+
+        $token = $this->tokenIterator->getVariable('foo');
+        $this->assertInstanceOf(TokenVariable::class, $token);
+    }
+
+    /** @test */
+    public function givenAVariableNameWhenNotFoundItShouldThrowAnException()
+    {
+        $this->expectException(ParserException::class);
+
+        $this->tokenStream->shouldReceive('getVariable')->once()->with('foo')->andThrow(new UndefinedVariableException());
+        $this->stack->shouldReceive('current')->once()->andReturn(new TokenVariable('nope'));
+
+        $this->tokenIterator->getVariable('foo');
+    }
+
+    /** @test */
+    public function givenAFunctionNameWhenFoundItShouldACallableClosure()
+    {
+        $this->tokenStream->shouldReceive('getFunction')->once()->with('foo')->andReturn(fn () => 42);
+
+        $function = $this->tokenIterator->getFunction('foo');
+        $this->assertSame(42, $function());
+    }
+
+    /** @test */
+    public function givenAFunctionNameWhenNotFoundItShouldThrowAnException()
+    {
+        $this->expectException(ParserException::class);
+
+        $this->tokenStream->shouldReceive('getFunction')->once()->with('foo')->andThrow(new UndefinedFunctionException());
+        $this->stack->shouldReceive('current')->once()->andReturn(new TokenFunction('nope('));
+
+        $this->tokenIterator->getFunction('foo');
+    }
+
+    /** @test */
+    public function givenAMethodNameWhenFoundItShouldReturnAnInstanceOfCallableFunction()
+    {
+        $token = new TokenString('bar');
+        $callableFunction = \Mockery::mock(CallableFunction::class);
+
+        $this->tokenStream->shouldReceive('getMethod')->once()->with('foo', $token)->andReturn($callableFunction);
+
+        $method = $this->tokenIterator->getMethod('foo', $token);
+
+        $this->assertInstanceOf(CallableFunction::class, $method);
+    }
+
+    /** @test */
+    public function givenAMethodNameWhenNotFoundItShouldThrowAnException()
+    {
+        $this->expectException(ParserException::class);
+
+        $token = new TokenString('bar');
+        $this->tokenStream->shouldReceive('getMethod')->once()->with('foo', $token)->andThrow(new UndefinedMethodException());
+        $this->stack->shouldReceive('current')->once()->andReturn(new TokenFunction('bar'));
+
+        $this->tokenIterator->getMethod('foo', $token);
+    }
+}
diff --git a/tests/unit/TokenStream/TokenStreamTest.php b/tests/unit/TokenStream/TokenStreamTest.php
index 757a634..815c8de 100755
--- a/tests/unit/TokenStream/TokenStreamTest.php
+++ b/tests/unit/TokenStream/TokenStreamTest.php
@@ -8,125 +8,156 @@
 namespace nicoSWD\Rule\tests\unit\TokenStream;
 
 use ArrayIterator;
+use Iterator;
+use Mockery;
 use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use Mockery\MockInterface;
-use nicoSWD\Rule\Grammar\CallableFunction;
-use nicoSWD\Rule\Parser\Exception\ParserException;
-use nicoSWD\Rule\TokenStream\AST;
+use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
+use nicoSWD\Rule\Grammar\Grammar;
+use nicoSWD\Rule\Grammar\InternalFunction;
+use nicoSWD\Rule\Tokenizer\Tokenizer;
+use nicoSWD\Rule\Tokenizer\TokenizerInterface;
+use nicoSWD\Rule\TokenStream\CallableUserMethodFactoryInterface;
+use nicoSWD\Rule\TokenStream\TokenStream;
 use nicoSWD\Rule\TokenStream\Exception\UndefinedFunctionException;
-use nicoSWD\Rule\TokenStream\Exception\UndefinedMethodException;
-use nicoSWD\Rule\TokenStream\Exception\UndefinedVariableException;
+use nicoSWD\Rule\TokenStream\Node\BaseNode;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
-use nicoSWD\Rule\TokenStream\Token\TokenFunction;
-use nicoSWD\Rule\TokenStream\Token\TokenMethod;
-use nicoSWD\Rule\TokenStream\Token\TokenString;
-use nicoSWD\Rule\TokenStream\Token\TokenVariable;
-use nicoSWD\Rule\TokenStream\TokenStream;
+use nicoSWD\Rule\TokenStream\Token\TokenFactory;
+use nicoSWD\Rule\TokenStream\TokenIteratorFactory;
+use nicoSWD\Rule\TokenStream\CallableUserMethodFactory;
 use PHPUnit\Framework\TestCase;
+use stdClass;
 
 final class TokenStreamTest extends TestCase
 {
     use MockeryPHPUnitIntegration;
-    
-    private ArrayIterator|MockInterface $stack;
-    private AST|MockInterface $ast;
-    private TokenStream $tokenStream;
+
+    private readonly TokenStream $tokenStream;
+    private readonly TokenFactory|MockInterface $tokenFactory;
+    private readonly CallableUserMethodFactory $userMethodFactory;
+    private readonly TokenIteratorFactory $tokenStreamFactory;
 
     protected function setUp(): void
     {
-        $this->stack = \Mockery::mock(ArrayIterator::class);
-        $this->ast = \Mockery::mock(AST::class);
-
-        $this->tokenStream = new TokenStream($this->stack, $this->ast);
+        $this->tokenFactory = Mockery::mock(TokenFactory::class);
+        $this->userMethodFactory = new CallableUserMethodFactory();
+        $this->tokenStreamFactory = new TokenIteratorFactory();
     }
 
     /** @test */
-    public function givenAStackWhenNotEmptyItShouldBeIterable()
+    public function givenAFunctionNameWhenValidItShouldReturnTheCorrespondingFunction(): void
     {
-        $this->stack->shouldReceive('rewind');
-        $this->stack->shouldReceive('valid')->andReturn(true, true, true, false);
-        $this->stack->shouldReceive('key')->andReturn(1, 2, 3);
-        $this->stack->shouldReceive('next');
-        $this->stack->shouldReceive('seek');
-        $this->stack->shouldReceive('current')->times(5)->andReturn(
-            new TokenString('a'),
-            new TokenMethod('.foo('),
-            new TokenString('b')
+        $grammar = $this->createGrammarWithInternalFunctions([new InternalFunction('test', TestFunc::class)]);
+        $tokenizer = new Tokenizer($grammar, $this->tokenFactory);
+
+        $tokenStream = new TokenStream(
+            $tokenizer,
+            $this->tokenFactory,
+            $this->tokenStreamFactory,
+            $this->userMethodFactory
         );
 
-        foreach ($this->tokenStream as $key => $value) {
-            $this->assertInstanceOf(BaseToken::class, $value);
-        }
-    }
+        /** @var BaseToken $result */
+        $result = $tokenStream->getFunction('test')->call(Mockery::mock(BaseNode::class));
 
-    /** @test */
-    public function givenATokenStackItShouldBeAccessibleViaGetter()
-    {
-        $this->assertInstanceOf(ArrayIterator::class, $this->tokenStream->getStack());
+        $this->assertSame(234, $result->getValue());
     }
 
     /** @test */
-    public function givenAVariableNameWhenFoundItShouldReturnItsValue()
+    public function givenAFunctionNameWhenItDoesNotImplementTheInterfaceItShouldThrowAnException(): void
     {
-        $this->ast->shouldReceive('getVariable')->once()->with('foo')->andReturn(new TokenVariable('bar'));
+        $this->expectExceptionMessage(sprintf(
+            'stdClass must be an instance of %s',
+            CallableUserFunctionInterface::class
+        ));
+
+        $grammar = $this->createGrammarWithInternalFunctions([new InternalFunction('test', stdClass::class)]);
+        $tokenizer = new Tokenizer($grammar, $this->tokenFactory);
+
+        $tokenStream = new TokenStream(
+            $tokenizer,
+            $this->tokenFactory,
+            $this->tokenStreamFactory,
+            $this->userMethodFactory
+        );
 
-        $token = $this->tokenStream->getVariable('foo');
-        $this->assertInstanceOf(TokenVariable::class, $token);
+        $tokenStream->getFunction('test')->call(Mockery::mock(BaseNode::class));
     }
 
     /** @test */
-    public function givenAVariableNameWhenNotFoundItShouldThrowAnException()
+    public function givenAFunctionNameNotDefinedItShouldThrowAnException(): void
     {
-        $this->expectException(ParserException::class);
-
-        $this->ast->shouldReceive('getVariable')->once()->with('foo')->andThrow(new UndefinedVariableException());
-        $this->stack->shouldReceive('current')->once()->andReturn(new TokenVariable('nope'));
+        $this->expectException(UndefinedFunctionException::class);
+        $this->expectExceptionMessage('pineapple_pizza');
 
-        $this->tokenStream->getVariable('foo');
-    }
+        $tokenizer = $this->createDummyTokenizer();
+        $userMethodFactory = $this->createCallableUserMethodFactory();
 
-    /** @test */
-    public function givenAFunctionNameWhenFoundItShouldACallableClosure()
-    {
-        $this->ast->shouldReceive('getFunction')->once()->with('foo')->andReturn(fn () => 42);
+        $tokenStream = new TokenStream(
+            $tokenizer,
+            new TokenFactory(),
+            $this->tokenStreamFactory,
+            $userMethodFactory,
+        );
 
-        $function = $this->tokenStream->getFunction('foo');
-        $this->assertSame(42, $function());
+        $tokenStream->getFunction('pineapple_pizza');
     }
 
-    /** @test */
-    public function givenAFunctionNameWhenNotFoundItShouldThrowAnException()
+    private function createDummyTokenizer(): TokenizerInterface
     {
-        $this->expectException(ParserException::class);
-
-        $this->ast->shouldReceive('getFunction')->once()->with('foo')->andThrow(new UndefinedFunctionException());
-        $this->stack->shouldReceive('current')->once()->andReturn(new TokenFunction('nope('));
-
-        $this->tokenStream->getFunction('foo');
+        return new class ($this->createGrammarWithInternalFunctions()) extends TokenizerInterface {
+            public function __construct(
+                public readonly Grammar $grammar,
+            ) {
+            }
+
+            public function tokenize(string $string): Iterator
+            {
+                return new ArrayIterator([]);
+            }
+        };
     }
 
-    /** @test */
-    public function givenAMethodNameWhenFoundItShouldReturnAnInstanceOfCallableFunction()
+    private function createGrammarWithInternalFunctions(array $internalFunctions = []): Grammar
     {
-        $token = new TokenString('bar');
-        $callableFunction = \Mockery::mock(CallableFunction::class);
-
-        $this->ast->shouldReceive('getMethod')->once()->with('foo', $token)->andReturn($callableFunction);
-
-        $method = $this->tokenStream->getMethod('foo', $token);
-
-        $this->assertInstanceOf(CallableFunction::class, $method);
+        return new class ($internalFunctions) extends Grammar {
+            public function __construct(
+                private array $internalFunctions,
+            ) {
+            }
+
+            public function getDefinition(): array
+            {
+                return [];
+            }
+
+            public function getInternalFunctions(): array
+            {
+                return $this->internalFunctions;
+            }
+
+            public function getInternalMethods(): array
+            {
+                return [];
+            }
+        };
     }
 
-    /** @test */
-    public function givenAMethodNameWhenNotFoundItShouldThrowAnException()
+    private function createCallableUserMethodFactory(): CallableUserMethodFactoryInterface
     {
-        $this->expectException(ParserException::class);
-
-        $token = new TokenString('bar');
-        $this->ast->shouldReceive('getMethod')->once()->with('foo', $token)->andThrow(new UndefinedMethodException());
-        $this->stack->shouldReceive('current')->once()->andReturn(new TokenFunction('bar'));
-
-        $this->tokenStream->getMethod('foo', $token);
+        return new class implements CallableUserMethodFactoryInterface {
+            public function create(
+                BaseToken $token,
+                TokenFactory $tokenFactory,
+                string $methodName
+            ): CallableUserFunctionInterface {
+                return new class implements CallableUserFunctionInterface {
+                    public function call(?BaseToken ...$param): BaseToken
+                    {
+                        return Mockery::mock(BaseToken::class);
+                    }
+                };
+            }
+        };
     }
 }
diff --git a/tests/unit/Tokenizer/TokenizerTest.php b/tests/unit/Tokenizer/TokenizerTest.php
index 6d93527..c0565f1 100755
--- a/tests/unit/Tokenizer/TokenizerTest.php
+++ b/tests/unit/Tokenizer/TokenizerTest.php
@@ -7,6 +7,7 @@
  */
 namespace nicoSWD\Rule\tests\unit\Tokenizer;
 
+use nicoSWD\Rule\Grammar\Definition;
 use nicoSWD\Rule\Grammar\Grammar;
 use nicoSWD\Rule\TokenStream\Token;
 use nicoSWD\Rule\Tokenizer\Tokenizer;
@@ -18,9 +19,9 @@ final class TokenizerTest extends TestCase
     public function givenAGrammarWithCollidingRegexItShouldTakeThePriorityIntoAccount(): void
     {
         $tokens = $this->tokenizeWithGrammar('yes   somevar', [
-            [Token\Token::BOOL_TRUE, '\byes\b', 20],
-            [Token\Token::VARIABLE, '\b[a-z]+\b', 10],
-            [Token\Token::SPACE, '\s+', 5],
+            new Definition(Token\Token::BOOL_TRUE, '\byes\b', 20),
+            new Definition(Token\Token::VARIABLE, '\b[a-z]+\b', 10),
+            new Definition(Token\Token::SPACE, '\s+', 5),
         ]);
 
         $this->assertCount(3, $tokens);
@@ -42,9 +43,9 @@ public function givenAGrammarWithCollidingRegexItShouldTakeThePriorityIntoAccoun
     public function givenAGrammarWithCollidingRegexWhenPriorityIsWrongItShouldNeverMatchTheOneWithLowerPriority(): void
     {
         $tokens = $this->tokenizeWithGrammar('somevar   yes', [
-            [Token\Token::VARIABLE, '\b[a-z]+\b', 20],
-            [Token\Token::BOOL_TRUE, '\byes\b', 10],
-            [Token\Token::SPACE, '\s+', 5],
+            new Definition(Token\Token::VARIABLE, '\b[a-z]+\b', 20),
+            new Definition(Token\Token::BOOL_TRUE, '\byes\b', 10),
+            new Definition(Token\Token::SPACE, '\s+', 5),
         ]);
 
         $this->assertCount(3, $tokens);
@@ -62,16 +63,6 @@ public function givenAGrammarWithCollidingRegexWhenPriorityIsWrongItShouldNeverM
         $this->assertInstanceOf(Token\TokenVariable::class, $tokens[2]);
     }
 
-    /** @test */
-    public function givenAGrammarItShouldBeAvailableThroughGetter(): void
-    {
-        $grammar = $this->getTokenizer([[Token\Token::BOOL_TRUE, '\byes\b', 10]])->getGrammar();
-
-        $this->assertInstanceOf(Grammar::class, $grammar);
-        $this->assertIsArray($grammar->getDefinition());
-        $this->assertCount(1, $grammar->getDefinition());
-    }
-
     /** @return Token\BaseToken[] */
     private function tokenizeWithGrammar(string $rule, array $definition): array
     {
@@ -100,6 +91,16 @@ public function getDefinition(): array
             {
                 return $this->definition;
             }
+
+            public function getInternalFunctions(): array
+            {
+                return [];
+            }
+
+            public function getInternalMethods(): array
+            {
+                return [];
+            }
         };
 
         return new Tokenizer($grammar, new Token\TokenFactory());

From d62064b5b29cea6232dd3f436e7e27c6672b44f2 Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Wed, 16 Mar 2022 21:02:30 +0100
Subject: [PATCH 2/8] Use PHP 8.1 features

---
 .styleci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.styleci.yml b/.styleci.yml
index 03b0848..eb60c1b 100644
--- a/.styleci.yml
+++ b/.styleci.yml
@@ -1,7 +1,7 @@
 ---
 preset: psr2
 risky: true
-version: 8
+version: 8.1
 finder:
   name:
     - "*.php"

From 7942b6ec8439575824a6a4af6a454ea973328696 Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Wed, 16 Mar 2022 21:05:35 +0100
Subject: [PATCH 3/8] Use PHP 8.1 features

---
 .scrutinizer.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.scrutinizer.yml b/.scrutinizer.yml
index 37f56a0..f52c501 100644
--- a/.scrutinizer.yml
+++ b/.scrutinizer.yml
@@ -36,7 +36,7 @@ tools:
     excluded_dirs: [tests]
 build:
   environment:
-    php: 8.0.1
+    php: 8.1
   nodes:
     analysis:
       tests:

From 04fabef81e261523e805ac7b10400fe562a94c12 Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Wed, 16 Mar 2022 21:22:33 +0100
Subject: [PATCH 4/8] Use PHP 8.1 features

---
 .scrutinizer.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.scrutinizer.yml b/.scrutinizer.yml
index f52c501..d9aa1b1 100644
--- a/.scrutinizer.yml
+++ b/.scrutinizer.yml
@@ -36,7 +36,7 @@ tools:
     excluded_dirs: [tests]
 build:
   environment:
-    php: 8.1
+    php: 8.1.0
   nodes:
     analysis:
       tests:

From 59bb941ed27d2a2b1340eb5dc9128a2b91298a53 Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Thu, 17 Mar 2022 21:43:00 +0100
Subject: [PATCH 5/8] Use PHP 8.1 features

---
 .github/workflows/phpqa.yml |  6 +--
 src/Evaluator/Boolean.php   | 11 ++++--
 src/Evaluator/Operator.php  | 73 ++++---------------------------------
 3 files changed, 18 insertions(+), 72 deletions(-)

diff --git a/.github/workflows/phpqa.yml b/.github/workflows/phpqa.yml
index 661b9e4..d626ce2 100644
--- a/.github/workflows/phpqa.yml
+++ b/.github/workflows/phpqa.yml
@@ -8,14 +8,14 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: PHPStan
-        uses: docker://jakzal/phpqa:php8.0-alpine
+        uses: docker://jakzal/phpqa:php8.1
         with:
           args: phpstan analyze src/ -l 1
       - name: PHP-CS-Fixer
-        uses: docker://jakzal/phpqa:php8.0-alpine
+        uses: docker://jakzal/phpqa:php8.1
         with:
           args: php-cs-fixer --dry-run --allow-risky=yes --no-interaction --ansi fix
       - name: Deptrac
-        uses: docker://jakzal/phpqa:php8.0-alpine
+        uses: docker://jakzal/phpqa:php8.1
         with:
           args: deptrac --no-interaction --ansi --formatter-graphviz-display=0
diff --git a/src/Evaluator/Boolean.php b/src/Evaluator/Boolean.php
index 7d068bd..26db253 100644
--- a/src/Evaluator/Boolean.php
+++ b/src/Evaluator/Boolean.php
@@ -7,8 +7,13 @@
  */
 namespace nicoSWD\Rule\Evaluator;
 
-enum Operator: string
+enum Boolean: string
 {
-    case LOGICAL_AND = '&';
-    case LOGICAL_OR = '|';
+    case TRUE = '1';
+    case FALSE = '0';
+
+    final public static function fromBool(bool $bool): self
+    {
+        return $bool ? self::TRUE : self::FALSE;
+    }
 }
diff --git a/src/Evaluator/Operator.php b/src/Evaluator/Operator.php
index 55c7c62..e500242 100644
--- a/src/Evaluator/Operator.php
+++ b/src/Evaluator/Operator.php
@@ -7,77 +7,18 @@
  */
 namespace nicoSWD\Rule\Evaluator;
 
-use Closure;
-
-final class Evaluator implements EvaluatorInterface
+enum Operator: string
 {
-    private const LOGICAL_AND = '&';
-    private const LOGICAL_OR = '|';
-
-    private const BOOL_TRUE = '1';
-    private const BOOL_FALSE = '0';
-
-    public function evaluate(string $group): bool
-    {
-        $evalGroup = $this->evalGroup();
-        $count = 0;
-
-        do {
-            $group = preg_replace_callback(
-                '~\((?<match>[^()]+)\)~',
-                $evalGroup,
-                $group,
-                limit: -1,
-                count: $count
-            );
-        } while ($count > 0);
-
-        return (bool) $evalGroup(['match' => $group]);
-    }
-
-    private function evalGroup(): Closure
-    {
-        return function (array $group): ?int {
-            $result = null;
-            $operator = null;
-            $offset = 0;
-
-            while (isset($group['match'][$offset])) {
-                $value = $group['match'][$offset++];
-
-                if ($this->isLogical($value)) {
-                    $operator = $value;
-                } elseif ($this->isBoolean($value)) {
-                    $result = $this->setResult($result, (int) $value, $operator);
-                } else {
-                    throw new Exception\UnknownSymbolException(sprintf('Unexpected "%s"', $value));
-                }
-            }
-
-            return $result;
-        };
-    }
-
-    private function setResult(?int $result, int $value, ?string $operator): int
-    {
-        if (!isset($result)) {
-            $result = $value;
-        } elseif ($operator === self::LOGICAL_AND) {
-            $result &= $value;
-        } elseif ($operator === self::LOGICAL_OR) {
-            $result |= $value;
-        }
-
-        return $result;
-    }
+    case LOGICAL_AND = '&';
+    case LOGICAL_OR = '|';
 
-    private function isLogical(string $value): bool
+    public static function isAnd(self $operator): bool
     {
-        return $value === self::LOGICAL_AND || $value === self::LOGICAL_OR;
+        return $operator === self::LOGICAL_AND;
     }
 
-    private function isBoolean(string $value): bool
+    public static function isOr(self $operator): bool
     {
-        return $value === self::BOOL_TRUE || $value === self::BOOL_FALSE;
+        return $operator === self::LOGICAL_OR;
     }
 }

From e18401e190f93b97559e25b3f12e7837ef8f8a49 Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Thu, 17 Mar 2022 21:48:49 +0100
Subject: [PATCH 6/8] Use PHP 8.1 features

---
 .styleci.yml                               | 2 ++
 src/TokenStream/TokenStream.php            | 2 +-
 tests/unit/TokenStream/TokenStreamTest.php | 4 ++--
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/.styleci.yml b/.styleci.yml
index eb60c1b..c94744a 100644
--- a/.styleci.yml
+++ b/.styleci.yml
@@ -8,3 +8,5 @@ finder:
 enabled:
   - short_array_syntax
   - cast_spaces
+disabled:
+  - lowercase_constants
diff --git a/src/TokenStream/TokenStream.php b/src/TokenStream/TokenStream.php
index ac6e36d..6872822 100644
--- a/src/TokenStream/TokenStream.php
+++ b/src/TokenStream/TokenStream.php
@@ -103,7 +103,7 @@ private function registerMethods(): void
 
     private function registerFunctions(): void
     {
-        foreach ($this->tokenizer->grammar->getInternalFunctions() as $function)  {
+        foreach ($this->tokenizer->grammar->getInternalFunctions() as $function) {
             $this->registerFunctionClass($function->name, $function->class);
         }
     }
diff --git a/tests/unit/TokenStream/TokenStreamTest.php b/tests/unit/TokenStream/TokenStreamTest.php
index 815c8de..2ce5dfe 100755
--- a/tests/unit/TokenStream/TokenStreamTest.php
+++ b/tests/unit/TokenStream/TokenStreamTest.php
@@ -105,7 +105,7 @@ public function givenAFunctionNameNotDefinedItShouldThrowAnException(): void
 
     private function createDummyTokenizer(): TokenizerInterface
     {
-        return new class ($this->createGrammarWithInternalFunctions()) extends TokenizerInterface {
+        return new class($this->createGrammarWithInternalFunctions()) extends TokenizerInterface {
             public function __construct(
                 public readonly Grammar $grammar,
             ) {
@@ -120,7 +120,7 @@ public function tokenize(string $string): Iterator
 
     private function createGrammarWithInternalFunctions(array $internalFunctions = []): Grammar
     {
-        return new class ($internalFunctions) extends Grammar {
+        return new class($internalFunctions) extends Grammar {
             public function __construct(
                 private array $internalFunctions,
             ) {

From 8fdde942160a30baf6c338b7be7b63edef7f374d Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Sun, 20 Mar 2022 23:09:00 +0100
Subject: [PATCH 7/8] Use PHP 8.1 features

---
 .scrutinizer.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.scrutinizer.yml b/.scrutinizer.yml
index d9aa1b1..3511120 100644
--- a/.scrutinizer.yml
+++ b/.scrutinizer.yml
@@ -35,6 +35,7 @@ tools:
     enabled: true
     excluded_dirs: [tests]
 build:
+  image: default-bionic
   environment:
     php: 8.1.0
   nodes:

From 07c4d8beade2100d240b6e632fd1c44b7b7cc69b Mon Sep 17 00:00:00 2001
From: Nico <nicoswd@pm.me>
Date: Sun, 20 Mar 2022 23:20:22 +0100
Subject: [PATCH 8/8] Use PHP 8.1 features

---
 src/Highlighter/Highlighter.php            | 23 ++++++++++++++--------
 src/Tokenizer/Tokenizer.php                |  2 +-
 src/Tokenizer/TokenizerInterface.php       |  2 +-
 tests/unit/TokenStream/TokenStreamTest.php |  2 +-
 4 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/Highlighter/Highlighter.php b/src/Highlighter/Highlighter.php
index f5ddc4a..6e6d9fa 100644
--- a/src/Highlighter/Highlighter.php
+++ b/src/Highlighter/Highlighter.php
@@ -20,14 +20,7 @@ final class Highlighter
     public function __construct(
         private readonly TokenizerInterface $tokenizer,
     ) {
-        $this->styles = new SplObjectStorage();
-        $this->styles[TokenType::COMMENT] = 'color: #948a8a; font-style: italic;';
-        $this->styles[TokenType::LOGICAL] = 'color: #c72d2d;';
-        $this->styles[TokenType::OPERATOR] = 'color: #000;';
-        $this->styles[TokenType::PARENTHESIS] = 'color: #000;';
-        $this->styles[TokenType::VALUE] = 'color: #e36700; font-style: italic;';
-        $this->styles[TokenType::VARIABLE] = 'color: #007694; font-weight: 900;';
-        $this->styles[TokenType::METHOD] = 'color: #000';
+        $this->styles = $this->defaultStyles();
     }
 
     public function setStyle(TokenType $group, string $style): void
@@ -62,4 +55,18 @@ private function encode(BaseToken $token): string
     {
         return htmlentities($token->getOriginalValue(), ENT_QUOTES, 'utf-8');
     }
+
+    private function defaultStyles(): SplObjectStorage
+    {
+        $styles = new SplObjectStorage();
+        $styles[TokenType::COMMENT] = 'color: #948a8a; font-style: italic;';
+        $styles[TokenType::LOGICAL] = 'color: #c72d2d;';
+        $styles[TokenType::OPERATOR] = 'color: #000;';
+        $styles[TokenType::PARENTHESIS] = 'color: #000;';
+        $styles[TokenType::VALUE] = 'color: #e36700; font-style: italic;';
+        $styles[TokenType::VARIABLE] = 'color: #007694; font-weight: 900;';
+        $styles[TokenType::METHOD] = 'color: #000';
+
+        return $styles;
+    }
 }
diff --git a/src/Tokenizer/Tokenizer.php b/src/Tokenizer/Tokenizer.php
index 2e8a90b..62723ae 100644
--- a/src/Tokenizer/Tokenizer.php
+++ b/src/Tokenizer/Tokenizer.php
@@ -16,7 +16,7 @@
 final class Tokenizer extends TokenizerInterface
 {
     public function __construct(
-        public readonly Grammar $grammar,
+        public Grammar $grammar,
         private readonly TokenFactory $tokenFactory,
     ) {
     }
diff --git a/src/Tokenizer/TokenizerInterface.php b/src/Tokenizer/TokenizerInterface.php
index f3f9a65..409798c 100644
--- a/src/Tokenizer/TokenizerInterface.php
+++ b/src/Tokenizer/TokenizerInterface.php
@@ -13,7 +13,7 @@
 
 abstract class TokenizerInterface
 {
-    public readonly Grammar $grammar;
+    public Grammar $grammar;
 
     /**
      * @param string $string
diff --git a/tests/unit/TokenStream/TokenStreamTest.php b/tests/unit/TokenStream/TokenStreamTest.php
index 2ce5dfe..5d98abd 100755
--- a/tests/unit/TokenStream/TokenStreamTest.php
+++ b/tests/unit/TokenStream/TokenStreamTest.php
@@ -107,7 +107,7 @@ private function createDummyTokenizer(): TokenizerInterface
     {
         return new class($this->createGrammarWithInternalFunctions()) extends TokenizerInterface {
             public function __construct(
-                public readonly Grammar $grammar,
+                public Grammar $grammar,
             ) {
             }