From d54c9ad84064466da965b24c9f412b388f4c8b61 Mon Sep 17 00:00:00 2001
From: fintarin <valukevichv@gmail.com>
Date: Wed, 31 Jan 2024 13:02:23 +0300
Subject: [PATCH] Refactor Parser

---
 include/fintamath/core/IArithmetic.hpp        |  16 +-
 include/fintamath/core/IComparable.hpp        |  11 +-
 include/fintamath/core/IMathObject.hpp        |  11 +-
 include/fintamath/core/Parser.hpp             | 173 +++++-------------
 include/fintamath/expressions/Expression.hpp  |  31 ++--
 include/fintamath/expressions/IExpression.hpp |  11 +-
 .../interfaces/IPolynomExpression.hpp         |   2 +
 include/fintamath/functions/FunctionUtils.hpp |   4 +-
 include/fintamath/functions/IFunction.hpp     |  19 +-
 include/fintamath/functions/IOperator.hpp     |  11 +-
 include/fintamath/literals/ILiteral.hpp       |  15 +-
 .../literals/constants/IConstant.hpp          |   9 +-
 include/fintamath/numbers/IInteger.hpp        |  10 +-
 include/fintamath/numbers/INumber.hpp         |  15 +-
 src/fintamath/config/ExpressionConfig.cpp     | 137 +++++++-------
 src/fintamath/config/ParserConfig.cpp         |  75 ++++----
 src/fintamath/expressions/Expression.cpp      |  18 +-
 .../expressions/binary/CompExpression.hpp     |   2 +
 tests/src/core/ParserTests.cpp                |   6 +-
 19 files changed, 250 insertions(+), 326 deletions(-)

diff --git a/include/fintamath/core/IArithmetic.hpp b/include/fintamath/core/IArithmetic.hpp
index d002c353e..48dbbe829 100644
--- a/include/fintamath/core/IArithmetic.hpp
+++ b/include/fintamath/core/IArithmetic.hpp
@@ -6,6 +6,8 @@
 namespace fintamath {
 
 class IArithmetic : public IMathObject {
+  using ArithmeticParser = Parser<std::unique_ptr<IArithmetic>>;
+
 public:
   friend inline std::unique_ptr<IArithmetic> operator+(const IArithmetic &lhs, const IArithmetic &rhs) {
     return lhs.addAbstract(rhs);
@@ -32,17 +34,16 @@ class IArithmetic : public IMathObject {
   }
 
   template <std::derived_from<IArithmetic> T>
-  static void registerType() {
-    Parser::registerType<T>(getParser());
+  static void registerConstructor() {
+    getParser().registerConstructor<T>();
   }
 
-  template <std::derived_from<IArithmetic> T>
-  static void registerType(Parser::Function<std::unique_ptr<IArithmetic>, const std::string &> &&parserFunc) {
-    Parser::registerType<T>(getParser(), std::move(parserFunc));
+  static void registerConstructor(ArithmeticParser::Constructor constructor) {
+    getParser().registerConstructor(std::move(constructor));
   }
 
   static std::unique_ptr<IArithmetic> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -61,13 +62,14 @@ class IArithmetic : public IMathObject {
   virtual std::unique_ptr<IArithmetic> negateAbstract() const = 0;
 
 private:
-  static Parser::Vector<std::unique_ptr<IArithmetic>, const std::string &> &getParser();
+  static ArithmeticParser &getParser();
 };
 
 template <typename Derived>
 class IArithmeticCRTP : public IArithmetic {
 #define I_ARITHMETIC_CRTP IArithmeticCRTP<Derived>
 #include "fintamath/core/IArithmeticCRTP.hpp"
+
 #undef I_ARITHMETIC_CRTP
 };
 
diff --git a/include/fintamath/core/IComparable.hpp b/include/fintamath/core/IComparable.hpp
index 60030559a..61a152c40 100644
--- a/include/fintamath/core/IComparable.hpp
+++ b/include/fintamath/core/IComparable.hpp
@@ -6,18 +6,19 @@
 namespace fintamath {
 
 class IComparable : public IArithmetic {
+  using ComparableParser = Parser<std::unique_ptr<IComparable>>;
+
 public:
   friend inline std::strong_ordering operator<=>(const IComparable &lhs, const IComparable &rhs) {
     return lhs.compareAbstract(rhs);
   }
 
-  template <std::derived_from<IComparable> T>
-  static void registerType(Parser::Function<std::unique_ptr<IComparable>, const std::string &> &&parserFunc) {
-    Parser::registerType<T>(getParser(), std::move(parserFunc));
+  static void registerConstructor(ComparableParser::Constructor constructor) {
+    getParser().registerConstructor(std::move(constructor));
   }
 
   static std::unique_ptr<IComparable> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -28,7 +29,7 @@ class IComparable : public IArithmetic {
   virtual std::strong_ordering compareAbstract(const IComparable &rhs) const = 0;
 
 private:
-  static Parser::Vector<std::unique_ptr<IComparable>, const std::string &> &getParser();
+  static ComparableParser &getParser();
 };
 
 template <typename Derived>
diff --git a/include/fintamath/core/IMathObject.hpp b/include/fintamath/core/IMathObject.hpp
index a2862f229..93126f7fb 100644
--- a/include/fintamath/core/IMathObject.hpp
+++ b/include/fintamath/core/IMathObject.hpp
@@ -11,6 +11,8 @@
 namespace fintamath {
 
 class IMathObject {
+  using MathObjectParser = Parser<std::unique_ptr<IMathObject>>;
+
 public:
   virtual ~IMathObject() = default;
 
@@ -32,13 +34,12 @@ class IMathObject {
     return lhs.equalsAbstract(rhs);
   }
 
-  template <std::derived_from<IMathObject> T>
-  static void registerType(Parser::Function<std::unique_ptr<IMathObject>, const std::string &> &&parserFunc) {
-    Parser::registerType<T>(getParser(), std::move(parserFunc));
+  static void registerConstructor(MathObjectParser::Constructor constructor) {
+    getParser().registerConstructor(std::move(constructor));
   }
 
   static std::unique_ptr<IMathObject> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -49,7 +50,7 @@ class IMathObject {
   virtual bool equalsAbstract(const IMathObject &rhs) const = 0;
 
 private:
-  static Parser::Vector<std::unique_ptr<IMathObject>, const std::string &> &getParser();
+  static MathObjectParser &getParser();
 };
 
 template <typename Derived>
diff --git a/include/fintamath/core/Parser.hpp b/include/fintamath/core/Parser.hpp
index 886c76f5c..37c64daa7 100644
--- a/include/fintamath/core/Parser.hpp
+++ b/include/fintamath/core/Parser.hpp
@@ -10,171 +10,86 @@
 #include "fintamath/core/Tokenizer.hpp"
 #include "fintamath/exceptions/InvalidInputException.hpp"
 
+#include <algorithm>
+
 namespace fintamath {
 
+template <typename Return, typename... Args>
 class Parser final {
 public:
-  template <typename Return, typename... Args>
-  using Function = std::function<Return(Args...)>;
-
-  template <typename... Args>
-  using Comparator = std::function<bool(Args...)>;
-
-  template <typename Return, typename... Args>
-  using Map = std::unordered_multimap<std::string, Function<Return, Args...>>;
-
-  template <typename Return, typename... Args>
-  using Vector = std::vector<Function<Return, Args...>>;
-
-  template <typename Type, typename BasePtr, typename... Args>
-  static void add(Map<BasePtr, Args...> &parserMap) {
-    Function<BasePtr, Args...> constructor = [](const Args &...args) {
-      return std::make_unique<Type>(args...);
-    };
-
-    static const std::string name = Type().toString();
-    parserMap.emplace(name, constructor);
+  using Validator = std::function<bool(const Return &)>;
 
-    Tokenizer::registerToken(name);
-  }
+  using Constructor = std::function<Return(const std::string &, Args &&...)>;
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void add(Map<BasePtr, Args...> &parserMap, Function<BasePtr, Args...> &&parserFunc) {
-    static const std::string name = Type().toString();
-    parserMap.emplace(name, std::move(parserFunc));
-
-    Tokenizer::registerToken(name);
-  }
+  using TypeConstructor = std::function<Return(Args &&...)>;
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void add(Vector<BasePtr, Args...> &parserVect) {
-    Function<BasePtr, Args...> constructor = [](const Args &...args) {
-      try {
-        return std::make_unique<Type>(args...);
-      }
-      catch (const InvalidInputException &) {
-        return std::unique_ptr<Type>();
-      }
-    };
+  using ConstructorVector = std::vector<Constructor>;
 
-    parserVect.emplace_back(constructor);
-  }
+  using ConstructorMap = std::unordered_multimap<std::string, TypeConstructor>;
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void add(Vector<BasePtr, Args...> &parserVect, Function<BasePtr, Args...> &&parserFunc) {
-    parserVect.emplace_back(std::move(parserFunc));
+public:
+  Return parse(const std::string &str, Args &&...args) const {
+    static constexpr auto trueValidator = [](const Return &) { return true; };
+    return parse(trueValidator, str, std::forward<Args>(args)...);
   }
 
-  template <typename Return, typename... Args>
-  static Return parse(const Map<Return, const Args &...> &parserMap,
-                      const std::string &parsedStr,
-                      const Args &...args) {
-
-    const auto &valuePairs = parserMap.equal_range(parsedStr);
+  Return parse(const Validator &validator, const std::string &str, Args &&...args) const {
+    for (const auto &valuePairs = constructorMap.equal_range(str);
+         const auto &pair : stdv::iota(valuePairs.first, valuePairs.second)) {
 
-    for (const auto &pair : stdv::iota(valuePairs.first, valuePairs.second)) {
-      if (Return value = pair->second(args...)) {
+      if (Return value = pair->second(std::forward<Args>(args)...); value && validator(value)) {
         return value;
       }
     }
 
-    return nullptr;
-  }
-
-  template <typename Return, typename... Args>
-    requires(sizeof...(Args) > 0)
-  static Return parse(const Map<Return, Args &&...> &parserMap,
-                      const std::string &parsedStr,
-                      Args &&...args) {
-
-    const auto &valuePairs = parserMap.equal_range(parsedStr);
-
-    for (const auto &pair : stdv::iota(valuePairs.first, valuePairs.second)) {
-      if (Return value = pair->second(std::forward<Args>(args)...)) {
+    for (const auto &constructor : extraConstructors) {
+      if (Return value = constructor(str, std::forward<Args>(args)...); value && validator(value)) {
         return value;
       }
     }
 
-    return nullptr;
+    return Return{};
   }
 
-  template <typename Return, typename... Args>
-  static Return parse(const Map<Return, const Args &...> &parserMap,
-                      const Comparator<const Return &> &comp,
-                      const std::string &parsedStr,
-                      const Args &...args) {
-
-    const auto &valuePairs = parserMap.equal_range(parsedStr);
-
-    for (const auto &pair : stdv::iota(valuePairs.first, valuePairs.second)) {
-      if (Return value = pair->second(args...); value && comp(value)) {
-        return value;
-      }
-    }
+  template <typename Type>
+  void registerType() {
+    TypeConstructor constructor = [](Args &&...args) -> Return {
+      return std::make_unique<Type>(std::forward<Args>(args)...);
+    };
 
-    return nullptr;
+    registerType<Type>(std::move(constructor));
   }
 
-  template <typename Return, typename... Args>
-    requires(sizeof...(Args) > 0)
-  static Return parse(const Map<Return, Args &&...> &parserMap,
-                      const Comparator<const Return &> &comp,
-                      const std::string &parsedStr,
-                      Args &&...args) {
-
-    const auto &valuePairs = parserMap.equal_range(parsedStr);
-
-    for (const auto &pair : stdv::iota(valuePairs.first, valuePairs.second)) {
-      if (Return value = pair->second(std::forward<Args>(args)...); value && comp(value)) {
-        return value;
-      }
-    }
+  template <typename Type>
+  void registerType(TypeConstructor constructor) {
+    static const std::string name = Type().toString();
+    constructorMap.emplace(name, std::move(constructor));
 
-    return nullptr;
+    Tokenizer::registerToken(name);
   }
 
-  template <typename Return, typename... Args>
-  static Return parse(const Vector<Return, const Args &...> &parserVect, const Args &...args) {
-    for (const auto &constructor : parserVect) {
-      if (Return value = constructor(args...)) {
-        return value;
+  template <typename Type>
+  void registerConstructor() {
+    Constructor constructor = [](const std::string &str, Args &&...args) -> Return {
+      try {
+        return std::make_unique<Type>(str, std::forward<Args>(args)...);
       }
-    }
-
-    return nullptr;
-  }
-
-  template <typename Return, typename... Args>
-    requires(sizeof...(Args) > 0)
-  static Return parse(const Vector<Return, Args &&...> &parserVect, Args &&...args) {
-    for (const auto &constructor : parserVect) {
-      if (Return value = constructor(std::forward<Args>(args)...)) {
-        return value;
+      catch (const InvalidInputException &) {
+        return std::unique_ptr<Type>();
       }
-    }
-
-    return nullptr;
-  }
+    };
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void registerType(Map<BasePtr, Args...> &parserMap) {
-    add<Type>(parserMap);
+    registerConstructor(std::move(constructor));
   }
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void registerType(Map<BasePtr, Args...> &parserMap, const Function<BasePtr, Args...> &parserFunc) {
-    add<Type>(parserMap, parserFunc);
+  void registerConstructor(Constructor constructor) {
+    extraConstructors.emplace_back(std::move(constructor));
   }
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void registerType(Vector<BasePtr, Args...> &parserVect) {
-    add<Type>(parserVect);
-  }
+private:
+  ConstructorMap constructorMap;
 
-  template <typename Type, typename BasePtr, typename... Args>
-  static void registerType(Vector<BasePtr, Args...> &parserVect, Function<BasePtr, Args...> &&parserFunc) {
-    add<Type>(parserVect, std::move(parserFunc));
-  }
+  ConstructorVector extraConstructors;
 };
 
 }
diff --git a/include/fintamath/expressions/Expression.hpp b/include/fintamath/expressions/Expression.hpp
index 4f33fee9b..1bc897674 100644
--- a/include/fintamath/expressions/Expression.hpp
+++ b/include/fintamath/expressions/Expression.hpp
@@ -2,7 +2,6 @@
 
 #include <stack>
 
-#include "fintamath/core/IArithmetic.hpp"
 #include "fintamath/expressions/IExpression.hpp"
 #include "fintamath/literals/Variable.hpp"
 #include "fintamath/numbers/Real.hpp"
@@ -27,6 +26,10 @@ using TermVector = std::vector<std::unique_ptr<Term>>;
 using OperandStack = std::stack<std::unique_ptr<IMathObject>>;
 
 class Expression : public IExpressionCRTP<Expression> {
+  using TermParser = Parser<std::unique_ptr<Term>>;
+  using ExpressionParser = Parser<std::unique_ptr<IMathObject>, ArgumentPtrVector &&>;
+  using ExpressionMaker = std::function<std::unique_ptr<IMathObject>(ArgumentPtrVector &&)>;
+
 public:
   Expression();
 
@@ -53,12 +56,12 @@ class Expression : public IExpressionCRTP<Expression> {
 
   void setVariable(const Variable &var, const Expression &val);
 
-  static void registerTermMaker(Parser::Function<std::unique_ptr<Term>, const Token &> &&maker) {
-    Parser::add<Token>(getTermMakers(), std::move(maker));
+  static void registerTermParser(TermParser::Constructor constructor) {
+    getTermParser().registerConstructor(std::move(constructor));
   }
 
   template <typename Function, bool isPolynomial = false>
-  static void registerFunctionExpressionMaker(auto &&maker);
+  static void registerFunctionExpressionMaker(ExpressionMaker maker);
 
   static MathObjectType getTypeStatic() {
     return MathObjectType::Expression;
@@ -114,15 +117,13 @@ class Expression : public IExpressionCRTP<Expression> {
 
   static ArgumentPtr compress(const ArgumentPtr &child);
 
-  friend std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector &&args);
-
-  friend std::unique_ptr<IMathObject> makeExpr(const IFunction &func, const ArgumentPtrVector &args);
+  friend std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector args);
 
   friend std::unique_ptr<IMathObject> parseFintamath(const std::string &str);
 
-  static Parser::Vector<std::unique_ptr<Term>, const Token &> &getTermMakers();
+  static TermParser &getTermParser();
 
-  static Parser::Map<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> &getExpressionMakers();
+  static ExpressionParser &getExpressionParser();
 
 private:
   mutable ArgumentPtr child;
@@ -159,9 +160,9 @@ Expression operator/(const Expression &lhs, const Variable &rhs);
 Expression operator/(const Variable &lhs, const Expression &rhs);
 
 template <typename Function, bool isPolynomial>
-inline void Expression::registerFunctionExpressionMaker(auto &&maker) {
-  Parser::Function<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> constructor =
-      [maker = std::forward<decltype(maker)>(maker)](ArgumentPtrVector &&args) {
+void Expression::registerFunctionExpressionMaker(ExpressionMaker maker) {
+  ExpressionParser::TypeConstructor constructor =
+      [maker = std::forward<ExpressionMaker>(maker)](ArgumentPtrVector &&args) {
         static const IFunction::Type type = Function().getFunctionType();
         std::unique_ptr<IMathObject> res;
 
@@ -169,12 +170,12 @@ inline void Expression::registerFunctionExpressionMaker(auto &&maker) {
           res = maker(std::move(args));
         }
         else if constexpr (isPolynomial) {
-          if (size_t(type) <= args.size()) {
+          if (static_cast<size_t>(type) <= args.size()) {
             res = maker(std::move(args));
           }
         }
         else {
-          if (size_t(type) == args.size()) {
+          if (static_cast<size_t>(type) == args.size()) {
             res = maker(std::move(args));
           }
         }
@@ -182,7 +183,7 @@ inline void Expression::registerFunctionExpressionMaker(auto &&maker) {
         return res;
       };
 
-  Parser::add<Function>(getExpressionMakers(), std::move(constructor));
+  getExpressionParser().registerType<Function>(std::move(constructor));
 }
 
 }
diff --git a/include/fintamath/expressions/IExpression.hpp b/include/fintamath/expressions/IExpression.hpp
index adbaa2378..2200a085c 100644
--- a/include/fintamath/expressions/IExpression.hpp
+++ b/include/fintamath/expressions/IExpression.hpp
@@ -2,12 +2,13 @@
 
 #include "fintamath/core/IMathObject.hpp"
 #include "fintamath/functions/IFunction.hpp"
-#include "fintamath/functions/IOperator.hpp"
 #include "fintamath/literals/Variable.hpp"
 
 namespace fintamath {
 
 class IExpression : public IArithmetic {
+  using ExpressionParser = Parser<std::unique_ptr<IExpression>>;
+
 public:
   virtual const std::shared_ptr<IFunction> &getFunction() const = 0;
 
@@ -24,12 +25,12 @@ class IExpression : public IArithmetic {
   virtual std::shared_ptr<IFunction> getOutputFunction() const;
 
   template <std::derived_from<IExpression> T>
-  static void registerType() {
-    Parser::registerType<T>(getParser());
+  static void registerConstructor() {
+    getParser().registerConstructor<T>();
   }
 
   static std::unique_ptr<IExpression> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -67,7 +68,7 @@ class IExpression : public IArithmetic {
   static ArgumentPtrVector convertToApproximatedNumbers(const ArgumentPtrVector &args);
 
 private:
-  static Parser::Vector<std::unique_ptr<IExpression>, const std::string &> &getParser();
+  static ExpressionParser &getParser();
 };
 
 template <typename Derived, bool isMultiFunction = false>
diff --git a/include/fintamath/expressions/interfaces/IPolynomExpression.hpp b/include/fintamath/expressions/interfaces/IPolynomExpression.hpp
index b3f2ae137..4a9f025f2 100644
--- a/include/fintamath/expressions/interfaces/IPolynomExpression.hpp
+++ b/include/fintamath/expressions/interfaces/IPolynomExpression.hpp
@@ -7,6 +7,8 @@
 
 namespace fintamath {
 
+class IOperator;
+
 class IPolynomExpression : public IExpression {
 public:
   explicit IPolynomExpression(const IFunction &inFunc, ArgumentPtrVector args);
diff --git a/include/fintamath/functions/FunctionUtils.hpp b/include/fintamath/functions/FunctionUtils.hpp
index cf3c573b6..e2740e2ef 100644
--- a/include/fintamath/functions/FunctionUtils.hpp
+++ b/include/fintamath/functions/FunctionUtils.hpp
@@ -16,9 +16,7 @@ class IFunction;
 
 extern bool isExpression(const IMathObject &arg);
 
-extern std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector &&args);
-
-extern std::unique_ptr<IMathObject> makeExpr(const IFunction &func, const ArgumentPtrVector &args);
+extern std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector args);
 
 extern std::unique_ptr<IMathObject> makeExpr(const IFunction &func, const ArgumentRefVector &args);
 
diff --git a/include/fintamath/functions/IFunction.hpp b/include/fintamath/functions/IFunction.hpp
index 6bbb060d1..14d4aa369 100644
--- a/include/fintamath/functions/IFunction.hpp
+++ b/include/fintamath/functions/IFunction.hpp
@@ -14,8 +14,11 @@ template <typename T>
 struct IsFunctionTypeAny : std::false_type {};
 
 class IFunction : public IMathObject {
+  using FunctionOrderMap = std::unordered_map<std::string, size_t>;
+  using FunctionParser = Parser<std::unique_ptr<IFunction>>;
+
 public:
-  enum class Type : uint16_t {
+  enum class Type : uint8_t {
     None,       // 0 arguments
     Unary,      // 1 argument
     Binary,     // 2 arguments
@@ -51,17 +54,17 @@ class IFunction : public IMathObject {
 
   template <std::derived_from<IFunction> T>
   static void registerType() {
-    Parser::registerType<T>(getParser());
+    getParser().registerType<T>();
 
     getFunctionOrderMutableMap()[T().toString()] = maxFunctionOrder;
     maxFunctionOrder++;
   }
 
   static std::unique_ptr<IFunction> parse(const std::string &parsedStr, IFunction::Type type = IFunction::Type::Any) {
-    Parser::Comparator<const std::unique_ptr<IFunction> &> comp = [type](const std::unique_ptr<IFunction> &func) {
-      return type == IFunction::Type::Any || func->getFunctionType() == type;
+    const auto validator = [type](const std::unique_ptr<IFunction> &func) {
+      return type == Type::Any || func->getFunctionType() == type;
     };
-    return Parser::parse<std::unique_ptr<IFunction>>(getParser(), comp, parsedStr);
+    return getParser().parse(validator, parsedStr);
   }
 
   static MathObjectType getTypeStatic() {
@@ -71,14 +74,14 @@ class IFunction : public IMathObject {
 protected:
   virtual std::unique_ptr<IMathObject> callAbstract(const ArgumentRefVector &argVect) const = 0;
 
-  static const std::unordered_map<std::string, size_t> &getFunctionOrderMap() {
+  static const FunctionOrderMap &getFunctionOrderMap() {
     return getFunctionOrderMutableMap();
   }
 
 private:
-  static std::unordered_map<std::string, size_t> &getFunctionOrderMutableMap();
+  static FunctionOrderMap &getFunctionOrderMutableMap();
 
-  static Parser::Map<std::unique_ptr<IFunction>> &getParser();
+  static FunctionParser &getParser();
 
   static inline size_t maxFunctionOrder = 0;
 };
diff --git a/include/fintamath/functions/IOperator.hpp b/include/fintamath/functions/IOperator.hpp
index 08fc3e305..3597ca052 100644
--- a/include/fintamath/functions/IOperator.hpp
+++ b/include/fintamath/functions/IOperator.hpp
@@ -5,9 +5,10 @@
 namespace fintamath {
 
 class IOperator : public IFunction {
+  using OperatorParser = Parser<std::unique_ptr<IOperator>>;
 
 public:
-  enum class Priority : uint16_t {
+  enum class Priority : uint8_t {
     Highest,
     Exponentiation, // e.g.  a ^ b
     PostfixUnary,   // e.g.  a!
@@ -32,14 +33,14 @@ class IOperator : public IFunction {
   template <std::derived_from<IOperator> T>
   static void registerType() {
     IFunction::registerType<T>();
-    Parser::registerType<T>(getParser());
+    getParser().registerType<T>();
   }
 
   static std::unique_ptr<IOperator> parse(const std::string &parsedStr, IOperator::Priority priority = IOperator::Priority::Lowest) {
-    Parser::Comparator<const std::unique_ptr<IOperator> &> comp = [priority](const std::unique_ptr<IOperator> &oper) {
+    const auto validator = [priority](const std::unique_ptr<IOperator> &oper) {
       return priority == IOperator::Priority::Lowest || oper->getOperatorPriority() == priority;
     };
-    return Parser::parse<std::unique_ptr<IOperator>>(getParser(), comp, parsedStr);
+    return getParser().parse(validator, parsedStr);
   }
 
   static MathObjectType getTypeStatic() {
@@ -47,7 +48,7 @@ class IOperator : public IFunction {
   }
 
 private:
-  static Parser::Map<std::unique_ptr<IOperator>> &getParser();
+  static OperatorParser &getParser();
 };
 
 template <typename Return, typename Derived, typename... Args>
diff --git a/include/fintamath/literals/ILiteral.hpp b/include/fintamath/literals/ILiteral.hpp
index 33e81fb50..6351fd6fa 100644
--- a/include/fintamath/literals/ILiteral.hpp
+++ b/include/fintamath/literals/ILiteral.hpp
@@ -5,19 +5,20 @@
 namespace fintamath {
 
 class ILiteral : public IMathObject {
+  using LiteralParser = Parser<std::unique_ptr<ILiteral>>;
+
 public:
   template <std::derived_from<ILiteral> T>
-  static void registerType() {
-    Parser::registerType<T>(getParser());
+  static void registerConstructor() {
+    getParser().registerConstructor<T>();
   }
 
-  template <std::derived_from<ILiteral> T>
-  static void registerType(Parser::Function<std::unique_ptr<ILiteral>, const std::string &> &&parserFunc) {
-    Parser::registerType<T>(getParser(), std::move(parserFunc));
+  static void registerConstructor(LiteralParser::Constructor constructor) {
+    getParser().registerConstructor(std::move(constructor));
   }
 
   static std::unique_ptr<ILiteral> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -25,7 +26,7 @@ class ILiteral : public IMathObject {
   }
 
 private:
-  static Parser::Vector<std::unique_ptr<ILiteral>, const std::string &> &getParser();
+  static LiteralParser &getParser();
 };
 
 template <typename Derived>
diff --git a/include/fintamath/literals/constants/IConstant.hpp b/include/fintamath/literals/constants/IConstant.hpp
index 81437d873..679f3a843 100644
--- a/include/fintamath/literals/constants/IConstant.hpp
+++ b/include/fintamath/literals/constants/IConstant.hpp
@@ -5,6 +5,8 @@
 namespace fintamath {
 
 class IConstant : public ILiteral {
+  using ConstantParser = Parser<std::unique_ptr<IConstant>>;
+
 public:
   virtual MathObjectType getReturnType() const = 0;
 
@@ -14,11 +16,11 @@ class IConstant : public ILiteral {
 
   template <std::derived_from<IConstant> T>
   static void registerType() {
-    Parser::registerType<T>(getParser());
+    getParser().registerType<T>();
   }
 
   static std::unique_ptr<IConstant> parse(const std::string &parsedStr) {
-    return Parser::parse<std::unique_ptr<IConstant>>(getParser(), parsedStr);
+    return getParser().parse(parsedStr);
   }
 
   static MathObjectType getTypeStatic() {
@@ -29,13 +31,14 @@ class IConstant : public ILiteral {
   virtual std::unique_ptr<IMathObject> call() const = 0;
 
 private:
-  static Parser::Map<std::unique_ptr<IConstant>> &getParser();
+  static ConstantParser &getParser();
 };
 
 template <typename Return, typename Derived>
 class IConstantCRTP : public IConstant {
 #define I_CONSTANT_CRTP IConstantCRTP<Return, Derived>
 #include "fintamath/literals/constants/IConstantCRTP.hpp"
+
 #undef I_CONSTANT_CRTP
 };
 
diff --git a/include/fintamath/numbers/IInteger.hpp b/include/fintamath/numbers/IInteger.hpp
index 9ae862289..723b29598 100644
--- a/include/fintamath/numbers/IInteger.hpp
+++ b/include/fintamath/numbers/IInteger.hpp
@@ -5,6 +5,8 @@
 namespace fintamath {
 
 class IInteger : public INumber {
+  using IntegerParser = Parser<std::unique_ptr<IInteger>>;
+
 public:
   friend inline std::unique_ptr<IInteger> operator%(const IInteger &lhs, const IInteger &rhs) {
     return lhs.modAbstract(rhs);
@@ -55,12 +57,12 @@ class IInteger : public INumber {
   }
 
   template <std::derived_from<IInteger> T>
-  static void registerType() {
-    Parser::registerType<T>(getParser());
+  static void registerConstructor() {
+    getParser().registerConstructor<T>();
   }
 
   static std::unique_ptr<IInteger> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -87,7 +89,7 @@ class IInteger : public INumber {
   virtual IInteger &decreaseAbstract() = 0;
 
 private:
-  static Parser::Vector<std::unique_ptr<IInteger>, const std::string &> &getParser();
+  static IntegerParser &getParser();
 };
 
 template <typename Derived>
diff --git a/include/fintamath/numbers/INumber.hpp b/include/fintamath/numbers/INumber.hpp
index d211b582f..393ad97e8 100644
--- a/include/fintamath/numbers/INumber.hpp
+++ b/include/fintamath/numbers/INumber.hpp
@@ -6,6 +6,8 @@
 namespace fintamath {
 
 class INumber : public IComparable {
+  using NumberParser = Parser<std::unique_ptr<INumber>>;
+
 public:
   virtual bool isPrecise() const {
     return true;
@@ -16,17 +18,16 @@ class INumber : public IComparable {
   }
 
   template <std::derived_from<INumber> T>
-  static void registerType() {
-    Parser::registerType<T>(getParser());
+  static void registerConstructor() {
+    getParser().registerConstructor<T>();
   }
 
-  template <std::derived_from<INumber> T>
-  static void registerType(Parser::Function<std::unique_ptr<INumber>, const std::string &> &&parserFunc) {
-    Parser::registerType<T>(getParser(), std::move(parserFunc));
+  static void registerConstructor(NumberParser::Constructor constructor) {
+    getParser().registerConstructor(std::move(constructor));
   }
 
   static std::unique_ptr<INumber> parse(const std::string &str) {
-    return Parser::parse(getParser(), str);
+    return getParser().parse(str);
   }
 
   static MathObjectType getTypeStatic() {
@@ -34,7 +35,7 @@ class INumber : public IComparable {
   }
 
 private:
-  static Parser::Vector<std::unique_ptr<INumber>, const std::string &> &getParser();
+  static NumberParser &getParser();
 };
 
 inline std::unique_ptr<INumber> operator+(const INumber &lhs, const INumber &rhs) {
diff --git a/src/fintamath/config/ExpressionConfig.cpp b/src/fintamath/config/ExpressionConfig.cpp
index 02bd5d968..02ce84cee 100644
--- a/src/fintamath/config/ExpressionConfig.cpp
+++ b/src/fintamath/config/ExpressionConfig.cpp
@@ -87,17 +87,16 @@
 #include "fintamath/functions/trigonometry/Sin.hpp"
 #include "fintamath/functions/trigonometry/Tan.hpp"
 #include "fintamath/literals/constants/E.hpp"
-#include "fintamath/literals/constants/Pi.hpp"
 
 namespace fintamath {
 
-Parser::Vector<std::unique_ptr<Term>, const Token &> &Expression::getTermMakers() {
-  static Parser::Vector<std::unique_ptr<Term>, const Token &> maker;
-  return maker;
+Expression::TermParser &Expression::getTermParser() {
+  static TermParser parser;
+  return parser;
 }
 
-Parser::Map<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> &Expression::getExpressionMakers() {
-  static Parser::Map<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> maker;
+Parser<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> &Expression::getExpressionParser() {
+  static Parser<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> maker;
   return maker;
 }
 
@@ -110,7 +109,7 @@ namespace {
 struct ExpressionConfig final {
   ExpressionConfig() {
     // TODO! move to other file
-    static const unsigned defaultPrecision = 80;
+    constexpr unsigned defaultPrecision = 80;
     Real::setPrecision(defaultPrecision);
 
     registerTermsMakers();
@@ -118,7 +117,7 @@ struct ExpressionConfig final {
   }
 
   static void registerTermsMakers() {
-    Expression::registerTermMaker([](const Token &token) {
+    Expression::registerTermParser([](const Token &token) {
       if (auto arg = IFunction::parse(token, IFunction::Type::Binary)) {
         return std::make_unique<Term>(token, std::move(arg));
       }
@@ -130,7 +129,7 @@ struct ExpressionConfig final {
       return std::unique_ptr<Term>();
     });
 
-    Expression::registerTermMaker([](const Token &token) {
+    Expression::registerTermParser([](const Token &token) {
       if (auto arg = ILiteral::parse(token)) {
         return std::make_unique<Term>(token, std::move(arg));
       }
@@ -138,7 +137,7 @@ struct ExpressionConfig final {
       return std::unique_ptr<Term>();
     });
 
-    Expression::registerTermMaker([](const Token &token) {
+    Expression::registerTermParser([](const Token &token) {
       if (auto arg = INumber::parse(token)) {
         return std::make_unique<Term>(token, std::move(arg));
       }
@@ -152,7 +151,7 @@ struct ExpressionConfig final {
       return AddExpression(std::move(args)).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Sub>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sub>([](const ArgumentPtrVector &args) {
       ArgumentPtr lhs = args.front();
       ArgumentPtr rhs = args.back();
 
@@ -165,7 +164,7 @@ struct ExpressionConfig final {
       return MulExpression(std::move(args)).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Div>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Div>([](const ArgumentPtrVector &args) {
       return DivExpression(args.front(), args.back()).clone();
     });
 
@@ -173,7 +172,7 @@ struct ExpressionConfig final {
       return divExpr(std::move(args));
     });
 
-    Expression::registerFunctionExpressionMaker<FracMixed>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<FracMixed>([](const ArgumentPtrVector &args) {
       ArgumentPtr integ = args[0];
       ArgumentPtr numer = args[1];
       ArgumentPtr denom = args[2];
@@ -189,7 +188,7 @@ struct ExpressionConfig final {
       return OrExpression(std::move(args)).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Pow>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Pow>([](const ArgumentPtrVector &args) {
       return PowExpression(args.front(), args.back()).clone();
     });
 
@@ -197,31 +196,31 @@ struct ExpressionConfig final {
       return powExpr(std::move(args));
     });
 
-    Expression::registerFunctionExpressionMaker<Eqv>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Eqv>([](const ArgumentPtrVector &args) {
       return CompExpression(Eqv(), args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Neqv>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Neqv>([](const ArgumentPtrVector &args) {
       return CompExpression(Neqv(), args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Less>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Less>([](const ArgumentPtrVector &args) {
       return CompExpression(Less(), args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<More>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<More>([](const ArgumentPtrVector &args) {
       return CompExpression(More(), args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<LessEqv>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<LessEqv>([](const ArgumentPtrVector &args) {
       return CompExpression(LessEqv(), args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<MoreEqv>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<MoreEqv>([](const ArgumentPtrVector &args) {
       return CompExpression(MoreEqv(), args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Index>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Index>([](const ArgumentPtrVector &args) {
       static const Index func;
       ArgumentPtr lhs = args.front();
       ArgumentPtr rhs = args.back();
@@ -233,7 +232,7 @@ struct ExpressionConfig final {
       return Expression(func(*lhs, *rhs)).clone(); // TODO: looks weird
     });
 
-    Expression::registerFunctionExpressionMaker<Impl>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Impl>([](const ArgumentPtrVector &args) {
       ArgumentPtr lhs = args.front();
       ArgumentPtr rhs = args.back();
 
@@ -242,7 +241,7 @@ struct ExpressionConfig final {
       return orExpr(notLhs, rhs);
     });
 
-    Expression::registerFunctionExpressionMaker<Equiv>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Equiv>([](const ArgumentPtrVector &args) {
       ArgumentPtr lhs = args.front();
       ArgumentPtr rhs = args.back();
 
@@ -255,7 +254,7 @@ struct ExpressionConfig final {
       return orExpr(lhsAndRhs, notLhsAndNotRhs);
     });
 
-    Expression::registerFunctionExpressionMaker<Nequiv>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Nequiv>([](const ArgumentPtrVector &args) {
       ArgumentPtr lhs = args.front();
       ArgumentPtr rhs = args.back();
 
@@ -268,75 +267,75 @@ struct ExpressionConfig final {
       return orExpr(notLhsAndRhs, lhsAndNotRhs);
     });
 
-    Expression::registerFunctionExpressionMaker<Neg>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Neg>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr negOne = Integer(-1).clone();
       return mulExpr(negOne, args.front());
     });
 
-    Expression::registerFunctionExpressionMaker<UnaryPlus>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<UnaryPlus>([](const ArgumentPtrVector &args) {
       return args.front()->clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Not>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Not>([](const ArgumentPtrVector &args) {
       return NotExpression(args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Derivative>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Derivative>([](const ArgumentPtrVector &args) {
       return DerivativeExpression(args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Integral>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Integral>([](const ArgumentPtrVector &args) {
       return IntegralExpression(args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Log>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Log>([](const ArgumentPtrVector &args) {
       return LogExpression(args.front(), args.back()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Ln>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Ln>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr logBase = E().clone();
       return logExpr(logBase, args.front());
     });
 
-    Expression::registerFunctionExpressionMaker<Lb>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Lb>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr logBase = Integer(2).clone();
       return logExpr(logBase, args.front());
     });
 
-    Expression::registerFunctionExpressionMaker<Lg>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Lg>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr logBase = Integer(10).clone();
       return logExpr(logBase, args.front());
     });
 
-    Expression::registerFunctionExpressionMaker<Exp>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Exp>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr powBase = E().clone();
       return powExpr(powBase, args.front());
     });
 
-    Expression::registerFunctionExpressionMaker<Percent>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Percent>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr percentValue = Integer(100).clone();
       return divExpr(args.front(), percentValue);
     });
 
-    Expression::registerFunctionExpressionMaker<Min>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Min>([](const ArgumentPtrVector &args) {
       return MinMaxExpression(Min(), std::move(args)).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Max>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Max>([](const ArgumentPtrVector &args) {
       return MinMaxExpression(Max(), std::move(args)).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Sqr>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sqr>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr powRate = Integer(2).clone();
       return powExpr(args.front(), powRate);
     });
 
-    Expression::registerFunctionExpressionMaker<Sqrt>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sqrt>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr powRate = Rational(1, 2).clone();
       return powExpr(args.front(), powRate);
     });
 
-    Expression::registerFunctionExpressionMaker<Root>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Root>([](const ArgumentPtrVector &args) {
       ArgumentPtr lhs = args.front();
       ArgumentPtr rhs = args.back();
 
@@ -350,120 +349,120 @@ struct ExpressionConfig final {
       return powExpr(lhs, invRhs);
     });
 
-    Expression::registerFunctionExpressionMaker<Sin>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sin>([](const ArgumentPtrVector &args) {
       return TrigExpression(Sin(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Cos>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Cos>([](const ArgumentPtrVector &args) {
       return TrigExpression(Cos(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Tan>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Tan>([](const ArgumentPtrVector &args) {
       return TrigExpression(Tan(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Cot>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Cot>([](const ArgumentPtrVector &args) {
       return TrigExpression(Cot(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Sec>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sec>([](const ArgumentPtrVector &args) {
       return TrigExpression(Sec(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Csc>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Csc>([](const ArgumentPtrVector &args) {
       return TrigExpression(Csc(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Asin>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Asin>([](const ArgumentPtrVector &args) {
       return InvTrigExpression(Asin(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Acos>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Acos>([](const ArgumentPtrVector &args) {
       return InvTrigExpression(Acos(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Atan>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Atan>([](const ArgumentPtrVector &args) {
       return InvTrigExpression(Atan(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Acot>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Acot>([](const ArgumentPtrVector &args) {
       return InvTrigExpression(Acot(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Asec>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Asec>([](const ArgumentPtrVector &args) {
       return InvTrigExpression(Asec(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Acsc>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Acsc>([](const ArgumentPtrVector &args) {
       return InvTrigExpression(Acsc(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Sinh>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sinh>([](const ArgumentPtrVector &args) {
       return HyperbExpression(Sinh(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Cosh>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Cosh>([](const ArgumentPtrVector &args) {
       return HyperbExpression(Cosh(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Tanh>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Tanh>([](const ArgumentPtrVector &args) {
       return HyperbExpression(Tanh(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Coth>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Coth>([](const ArgumentPtrVector &args) {
       return HyperbExpression(Coth(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Sech>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sech>([](const ArgumentPtrVector &args) {
       return HyperbExpression(Sech(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Csch>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Csch>([](const ArgumentPtrVector &args) {
       return HyperbExpression(Csch(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Asinh>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Asinh>([](const ArgumentPtrVector &args) {
       return InvHyperbExpression(Asinh(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Acosh>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Acosh>([](const ArgumentPtrVector &args) {
       return InvHyperbExpression(Acosh(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Atanh>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Atanh>([](const ArgumentPtrVector &args) {
       return InvHyperbExpression(Atanh(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Acoth>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Acoth>([](const ArgumentPtrVector &args) {
       return InvHyperbExpression(Acoth(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Asech>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Asech>([](const ArgumentPtrVector &args) {
       return InvHyperbExpression(Asech(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Acsch>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Acsch>([](const ArgumentPtrVector &args) {
       return InvHyperbExpression(Acsch(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Deg>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Deg>([](const ArgumentPtrVector &args) {
       static const ArgumentPtr deg1 = Deg()(Integer(1));
       return mulExpr(args.front(), deg1);
     });
 
-    Expression::registerFunctionExpressionMaker<Floor>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Floor>([](const ArgumentPtrVector &args) {
       return FloorCeilExpression(Floor(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Ceil>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Ceil>([](const ArgumentPtrVector &args) {
       return FloorCeilExpression(Ceil(), args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Abs>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Abs>([](const ArgumentPtrVector &args) {
       return AbsExpression(args.front()).clone();
     });
 
-    Expression::registerFunctionExpressionMaker<Sign>([](ArgumentPtrVector &&args) {
+    Expression::registerFunctionExpressionMaker<Sign>([](const ArgumentPtrVector &args) {
       return SignExpression(args.front()).clone();
     });
   }
diff --git a/src/fintamath/config/ParserConfig.cpp b/src/fintamath/config/ParserConfig.cpp
index 361014576..65c1260f2 100644
--- a/src/fintamath/config/ParserConfig.cpp
+++ b/src/fintamath/config/ParserConfig.cpp
@@ -1,7 +1,7 @@
-#include "fintamath/core/Parser.hpp"
 #include "fintamath/core/IArithmetic.hpp"
 #include "fintamath/core/IComparable.hpp"
 #include "fintamath/core/IMathObject.hpp"
+#include "fintamath/core/Parser.hpp"
 #include "fintamath/expressions/Expression.hpp"
 #include "fintamath/expressions/IExpression.hpp"
 #include "fintamath/functions/IFunction.hpp"
@@ -91,7 +91,6 @@
 #include "fintamath/numbers/INumber.hpp"
 #include "fintamath/numbers/Integer.hpp"
 #include "fintamath/numbers/Rational.hpp"
-#include "fintamath/numbers/Real.hpp"
 
 namespace fintamath {
 
@@ -100,58 +99,58 @@ TokenVector &Tokenizer::getRegisteredTokens() {
   return registeredTokens;
 }
 
-Parser::Vector<std::unique_ptr<IMathObject>, const std::string &> &IMathObject::getParser() {
-  static Parser::Vector<std::unique_ptr<IMathObject>, const std::string &> parser;
+IMathObject::MathObjectParser &IMathObject::getParser() {
+  static MathObjectParser parser;
   return parser;
 }
 
-Parser::Vector<std::unique_ptr<IArithmetic>, const std::string &> &IArithmetic::getParser() {
-  static Parser::Vector<std::unique_ptr<IArithmetic>, const std::string &> parser;
+IArithmetic::ArithmeticParser &IArithmetic::getParser() {
+  static ArithmeticParser parser;
   return parser;
 }
 
-Parser::Vector<std::unique_ptr<IComparable>, const std::string &> &IComparable::getParser() {
-  static Parser::Vector<std::unique_ptr<IComparable>, const std::string &> parser;
+IComparable::ComparableParser &IComparable::getParser() {
+  static ComparableParser parser;
   return parser;
 }
 
-Parser::Vector<std::unique_ptr<INumber>, const std::string &> &INumber::getParser() {
-  static Parser::Vector<std::unique_ptr<INumber>, const std::string &> parser;
+INumber::NumberParser &INumber::getParser() {
+  static NumberParser parser;
   return parser;
 }
 
-Parser::Vector<std::unique_ptr<IInteger>, const std::string &> &IInteger::getParser() {
-  static Parser::Vector<std::unique_ptr<IInteger>, const std::string &> parser;
+IInteger::IntegerParser &IInteger::getParser() {
+  static IntegerParser parser;
   return parser;
 }
 
-Parser::Vector<std::unique_ptr<ILiteral>, const std::string &> &ILiteral::getParser() {
-  static Parser::Vector<std::unique_ptr<ILiteral>, const std::string &> parser;
+ILiteral::LiteralParser &ILiteral::getParser() {
+  static LiteralParser parser;
   return parser;
 }
 
-Parser::Map<std::unique_ptr<IConstant>> &IConstant::getParser() {
-  static Parser::Map<std::unique_ptr<IConstant>> parser;
+IConstant::ConstantParser &IConstant::getParser() {
+  static ConstantParser parser;
   return parser;
 }
 
-std::unordered_map<std::string, size_t> &IFunction::getFunctionOrderMutableMap() {
-  static std::unordered_map<std::string, size_t> orderMap;
+IFunction::FunctionOrderMap &IFunction::getFunctionOrderMutableMap() {
+  static FunctionOrderMap orderMap;
   return orderMap;
 }
 
-Parser::Map<std::unique_ptr<IFunction>> &IFunction::getParser() {
-  static Parser::Map<std::unique_ptr<IFunction>> parser;
+IFunction::FunctionParser &IFunction::getParser() {
+  static FunctionParser parser;
   return parser;
 }
 
-Parser::Map<std::unique_ptr<IOperator>> &IOperator::getParser() {
-  static Parser::Map<std::unique_ptr<IOperator>> parser;
+IOperator::OperatorParser &IOperator::getParser() {
+  static OperatorParser parser;
   return parser;
 }
 
-Parser::Vector<std::unique_ptr<IExpression>, const std::string &> &IExpression::getParser() {
-  static Parser::Vector<std::unique_ptr<IExpression>, const std::string &> parser;
+IExpression::ExpressionParser &IExpression::getParser() {
+  static ExpressionParser parser;
   return parser;
 }
 
@@ -163,25 +162,23 @@ namespace {
 
 struct ParserConfig final {
   ParserConfig() {
-    IMathObject::registerType<ILiteral>(&ILiteral::parse);
-    IMathObject::registerType<IFunction>([](const std::string &str) {
-      return IFunction::parse(str);
-    });
-    IMathObject::registerType<IArithmetic>(&IArithmetic::parse);
+    IMathObject::registerConstructor(&ILiteral::parse);
+    IMathObject::registerConstructor([](const std::string &str) { return IFunction::parse(str); });
+    IMathObject::registerConstructor(&IArithmetic::parse);
 
-    IArithmetic::registerType<IComparable>(&IComparable::parse);
-    IArithmetic::registerType<Expression>();
+    IArithmetic::registerConstructor(&IComparable::parse);
+    IArithmetic::registerConstructor<Expression>();
 
-    IComparable::registerType<INumber>(&INumber::parse);
+    IComparable::registerConstructor(&INumber::parse);
 
-    INumber::registerType<IInteger>(&IInteger::parse);
-    INumber::registerType<Rational>();
+    INumber::registerConstructor(&IInteger::parse);
+    INumber::registerConstructor<Rational>();
 
-    IInteger::registerType<Integer>();
+    IInteger::registerConstructor<Integer>();
 
-    ILiteral::registerType<IConstant>(&IConstant::parse);
-    ILiteral::registerType<Variable>();
-    ILiteral::registerType<Boolean>();
+    ILiteral::registerConstructor(&IConstant::parse);
+    ILiteral::registerConstructor<Variable>();
+    ILiteral::registerConstructor<Boolean>();
 
     IConstant::registerType<E>();
     IConstant::registerType<Pi>();
@@ -263,7 +260,7 @@ struct ParserConfig final {
     IOperator::registerType<Comma>();
     IOperator::registerType<Mod>();
 
-    IExpression::registerType<Expression>();
+    IExpression::registerConstructor<Expression>();
   }
 };
 
diff --git a/src/fintamath/expressions/Expression.cpp b/src/fintamath/expressions/Expression.cpp
index 085f581a6..ba6eeea4d 100644
--- a/src/fintamath/expressions/Expression.cpp
+++ b/src/fintamath/expressions/Expression.cpp
@@ -174,7 +174,7 @@ TermVector Expression::tokensToTerms(const TokenVector &tokens) {
   TermVector terms(tokens.size());
 
   for (const auto i : stdv::iota(0U, terms.size())) {
-    if (auto term = Parser::parse(getTermMakers(), (tokens[i]))) {
+    if (auto term = getTermParser().parse(tokens[i])) {
       terms[i] = std::move(term);
     }
     else {
@@ -435,21 +435,15 @@ ArgumentPtr Expression::compress(const ArgumentPtr &child) {
   return child;
 }
 
-std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector &&args) {
-  ArgumentPtrVector compressedArgs = std::move(args);
-  stdr::transform(compressedArgs, compressedArgs.begin(), &Expression::compress);
+std::unique_ptr<IMathObject> makeExpr(const IFunction &func, ArgumentPtrVector args) {
+  stdr::transform(args, args.begin(), &Expression::compress);
+  Expression::validateFunctionArgs(func, args);
 
-  Expression::validateFunctionArgs(func, compressedArgs);
-
-  if (auto expr = Parser::parse(Expression::getExpressionMakers(), func.toString(), std::move(compressedArgs))) {
+  if (auto expr = Expression::getExpressionParser().parse(func.toString(), std::move(args))) {
     return expr;
   }
 
-  return FunctionExpression(func, compressedArgs).clone();
-}
-
-std::unique_ptr<IMathObject> makeExpr(const IFunction &func, const ArgumentPtrVector &args) {
-  return makeExpr(func, ArgumentPtrVector(args));
+  return FunctionExpression(func, std::move(args)).clone();
 }
 
 std::unique_ptr<IMathObject> makeExpr(const IFunction &func, const ArgumentRefVector &args) {
diff --git a/src/fintamath/expressions/binary/CompExpression.hpp b/src/fintamath/expressions/binary/CompExpression.hpp
index 7d5eb3a95..7f5fa09ad 100644
--- a/src/fintamath/expressions/binary/CompExpression.hpp
+++ b/src/fintamath/expressions/binary/CompExpression.hpp
@@ -4,6 +4,8 @@
 
 namespace fintamath {
 
+class IOperator;
+
 class CompExpression final : public IBinaryExpressionCRTP<CompExpression, true> {
 public:
   CompExpression(const IOperator &inOper, ArgumentPtr inLhsChild, ArgumentPtr inRhsChild);
diff --git a/tests/src/core/ParserTests.cpp b/tests/src/core/ParserTests.cpp
index 2d2ce7b39..626c638d8 100644
--- a/tests/src/core/ParserTests.cpp
+++ b/tests/src/core/ParserTests.cpp
@@ -4,14 +4,14 @@
 
 using namespace fintamath;
 
-TEST(ParserTests, addTest) {
+TEST(ParserTests, parseTest) {
   // TODO: implement
 }
 
-TEST(ParserTests, parseTest) {
+TEST(ParserTests, registerTypeTest) {
   // TODO: implement
 }
 
-TEST(ParserTests, registerTypeTest) {
+TEST(ParserTests, registerConstructorTest) {
   // TODO: implement
 }