From 969b0dcfcd15682672f7e95ebda660d8698dfb8c Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Wed, 14 Sep 2016 13:58:57 +0200
Subject: [PATCH] template LG grammar

---
 acompare2/src/GrammarCompare.cpp              |   8 +-
 acompare2/src/GrammarCompare.h                |   6 +-
 alib2algo/src/grammar/parsing/First.cpp       |   4 +-
 alib2algo/src/grammar/parsing/Follow.cpp      |   4 +-
 .../src/grammar/parsing/LL1ParseTable.cpp     |   2 +-
 .../grammar/properties/IsLanguageEmpty.cpp    |   2 +-
 .../IsLanguageGeneratingEpsilon.cpp           |   2 +-
 .../properties/NonterminalUnitRuleCycle.cpp   |   2 +-
 .../properties/NullableNonterminals.cpp       |   2 +-
 .../properties/ProductiveNonterminals.cpp     |   2 +-
 .../properties/RecursiveNonterminal.cpp       |   2 +-
 .../grammar/properties/UnreachableSymbols.cpp |   2 +-
 .../src/grammar/simplify/EpsilonRemover.cpp   |   4 +-
 .../src/grammar/simplify/EpsilonRemover.h     |   2 +-
 .../grammar/simplify/SimpleRulesRemover.cpp   |   4 +-
 .../src/grammar/simplify/SimpleRulesRemover.h |   2 +-
 alib2algo/src/grammar/simplify/ToCNF.cpp      |   4 +-
 alib2algo/src/grammar/simplify/ToCNF.h        |   2 +-
 alib2algo/src/grammar/simplify/ToGNF.cpp      |   4 +-
 alib2algo/src/grammar/simplify/ToGNF.h        |   2 +-
 alib2algo/src/grammar/simplify/Trim.cpp       |   2 +-
 .../simplify/UnproductiveSymbolsRemover.cpp   |   2 +-
 .../simplify/UnreachableSymbolsRemover.cpp    |   2 +-
 alib2data/src/grammar/ContextFree/LG.cpp      | 211 +----------
 alib2data/src/grammar/ContextFree/LG.h        | 348 ++++++++++++++----
 alib2data/src/grammar/GrammarFeatures.h       |   1 +
 alib2data/test-src/grammar/GrammarTest.cpp    |   4 +-
 .../src/grammar/GrammarFromStringParser.cpp   |   4 +-
 .../src/grammar/GrammarFromStringParser.h     |   2 +-
 .../src/grammar/GrammarToStringComposer.cpp   |   4 +-
 .../src/grammar/GrammarToStringComposer.h     |   2 +-
 31 files changed, 331 insertions(+), 313 deletions(-)

diff --git a/acompare2/src/GrammarCompare.cpp b/acompare2/src/GrammarCompare.cpp
index 59d88097c5..a624d97597 100644
--- a/acompare2/src/GrammarCompare.cpp
+++ b/acompare2/src/GrammarCompare.cpp
@@ -58,7 +58,7 @@ bool GrammarCompare::testCompare(const grammar::RightRG& a, const grammar::Right
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
 
-bool GrammarCompare::testCompare(const grammar::LG& a, const grammar::LG& b) {
+bool GrammarCompare::testCompare(const grammar::LG < > & a, const grammar::LG < > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
@@ -289,7 +289,7 @@ void GrammarCompare::printCompare(const grammar::RightRG& a, const grammar::Righ
 	}
 }
 
-void GrammarCompare::printCompare(const grammar::LG& a, const grammar::LG& b) {
+void GrammarCompare::printCompare(const grammar::LG < > & a, const grammar::LG < > & b) {
 	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
@@ -603,7 +603,7 @@ int GrammarCompare::compare(const grammar::RightRG& a, const grammar::RightRG& b
 
 auto GrammarCompareRightRG = GrammarCompare::RegistratorWrapper<int, grammar::RightRG, grammar::RightRG>(GrammarCompare::compare);
 
-int GrammarCompare::compare(const grammar::LG& a, const grammar::LG& b) {
+int GrammarCompare::compare(const grammar::LG < > & a, const grammar::LG < > & b) {
 	if(!GrammarCompare::testCompare(a, b)) {
 	  GrammarCompare::printCompare(a, b);
 	  return 1;
@@ -612,7 +612,7 @@ int GrammarCompare::compare(const grammar::LG& a, const grammar::LG& b) {
 	}
 }
 
-auto GrammarCompareLG = GrammarCompare::RegistratorWrapper<int, grammar::LG, grammar::LG>(GrammarCompare::compare);
+auto GrammarCompareLG = GrammarCompare::RegistratorWrapper<int, grammar::LG < >, grammar::LG < > >(GrammarCompare::compare);
 
 int GrammarCompare::compare(const grammar::CFG < > & a, const grammar::CFG < > & b) {
 	if(!GrammarCompare::testCompare(a, b)) {
diff --git a/acompare2/src/GrammarCompare.h b/acompare2/src/GrammarCompare.h
index c261c76b60..9bc332c583 100644
--- a/acompare2/src/GrammarCompare.h
+++ b/acompare2/src/GrammarCompare.h
@@ -32,8 +32,8 @@ private:
 	static bool testCompare(const grammar::RightRG& a, const grammar::RightRG& b);
 	static void printCompare(const grammar::RightRG& a, const grammar::RightRG& b);
 
-	static bool testCompare(const grammar::LG& a, const grammar::LG& b);
-	static void printCompare(const grammar::LG& a, const grammar::LG& b);
+	static bool testCompare(const grammar::LG < > & a, const grammar::LG < > & b);
+	static void printCompare(const grammar::LG < > & a, const grammar::LG < > & b);
 
 	static bool testCompare(const grammar::CFG < > & a, const grammar::CFG < > & b);
 	static void printCompare(const grammar::CFG < > & a, const grammar::CFG < > & b);
@@ -67,7 +67,7 @@ public:
 	static int compare(const grammar::LeftRG& a, const grammar::LeftRG& b);
 	static int compare(const grammar::RightLG& a, const grammar::RightLG& b);
 	static int compare(const grammar::RightRG& a, const grammar::RightRG& b);
-	static int compare(const grammar::LG& a, const grammar::LG& b);
+	static int compare(const grammar::LG < > & a, const grammar::LG < > & b);
 	static int compare(const grammar::CFG < > & a, const grammar::CFG < > & b);
 	static int compare(const grammar::EpsilonFreeCFG < > & a, const grammar::EpsilonFreeCFG < > & b);
 	static int compare(const grammar::CNF < > & a, const grammar::CNF < > & b);
diff --git a/alib2algo/src/grammar/parsing/First.cpp b/alib2algo/src/grammar/parsing/First.cpp
index ac0af059dd..f09cc2e1b9 100644
--- a/alib2algo/src/grammar/parsing/First.cpp
+++ b/alib2algo/src/grammar/parsing/First.cpp
@@ -108,7 +108,7 @@ auto FirstCFG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::CFG < >
 auto FirstEpsilonFreeCFG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::EpsilonFreeCFG < > > ( First::first );
 auto FirstGNF = FirstBase1::RegistratorWrapper < FirstResult1, grammar::GNF < > > ( First::first );
 auto FirstCNF = FirstBase1::RegistratorWrapper < FirstResult1, grammar::CNF < > > ( First::first );
-auto FirstLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LG > ( First::first );
+auto FirstLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LG < > > ( First::first );
 auto FirstLeftLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LeftLG > ( First::first );
 auto FirstLeftRG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LeftRG > ( First::first );
 auto FirstRightLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::RightLG > ( First::first );
@@ -122,7 +122,7 @@ auto FirstCFG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::CFG < >
 auto FirstEpsilonFreeCFG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::EpsilonFreeCFG < > > ( First::first );
 auto FirstGNF2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::GNF < > > ( First::first );
 auto FirstCNF2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::CNF < > > ( First::first );
-auto FirstLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LG > ( First::first );
+auto FirstLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LG < > > ( First::first );
 auto FirstLeftLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LeftLG > ( First::first );
 auto FirstLeftRG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LeftRG > ( First::first );
 auto FirstRightLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::RightLG > ( First::first );
diff --git a/alib2algo/src/grammar/parsing/Follow.cpp b/alib2algo/src/grammar/parsing/Follow.cpp
index a457091414..973d5c0e4b 100644
--- a/alib2algo/src/grammar/parsing/Follow.cpp
+++ b/alib2algo/src/grammar/parsing/Follow.cpp
@@ -96,7 +96,7 @@ auto FollowCFG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::CFG <
 auto FollowEpsilonFreeCFG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::EpsilonFreeCFG < > > ( Follow::follow );
 auto FollowGNF = FollowBase1::RegistratorWrapper < FollowResult1, grammar::GNF < > > ( Follow::follow );
 auto FollowCNF = FollowBase1::RegistratorWrapper < FollowResult1, grammar::CNF < > > ( Follow::follow );
-auto FollowLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LG > ( Follow::follow );
+auto FollowLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LG < > > ( Follow::follow );
 auto FollowLeftLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LeftLG > ( Follow::follow );
 auto FollowLeftRG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LeftRG > ( Follow::follow );
 auto FollowRightLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::RightLG > ( Follow::follow );
@@ -110,7 +110,7 @@ auto FollowCFG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::CFG
 auto FollowEpsilonFreeCFG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::EpsilonFreeCFG < > > ( Follow::follow );
 auto FollowGNF2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::GNF < > > ( Follow::follow );
 auto FollowCNF2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::CNF < > > ( Follow::follow );
-auto FollowLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LG > ( Follow::follow );
+auto FollowLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LG < > > ( Follow::follow );
 auto FollowLeftLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LeftLG > ( Follow::follow );
 auto FollowLeftRG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LeftRG > ( Follow::follow );
 auto FollowRightLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::RightLG > ( Follow::follow );
diff --git a/alib2algo/src/grammar/parsing/LL1ParseTable.cpp b/alib2algo/src/grammar/parsing/LL1ParseTable.cpp
index 0da6a227ef..9e3fb3b0b6 100644
--- a/alib2algo/src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo/src/grammar/parsing/LL1ParseTable.cpp
@@ -54,7 +54,7 @@ auto LL1ParseTableCFG = LL1ParseTable::RegistratorWrapper < std::map < std::pair
 auto LL1ParseTableEpsilonFreeCFG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
 auto LL1ParseTableGNF = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
 auto LL1ParseTableCNF = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LG > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
 auto LL1ParseTableLeftLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LeftLG > ( LL1ParseTable::parseTable );
 auto LL1ParseTableLeftRG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LeftRG > ( LL1ParseTable::parseTable );
 auto LL1ParseTableRightLG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::RightLG > ( LL1ParseTable::parseTable );
diff --git a/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp b/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
index 2c6440b9c4..872ebec718 100644
--- a/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
+++ b/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
@@ -32,7 +32,7 @@ auto IsLanguageEmptyCFG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::CFG
 auto IsLanguageEmptyEpsilonFreeCFG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::EpsilonFreeCFG < > >(IsLanguageEmpty::isLanguageEmpty);
 auto IsLanguageEmptyGNF = IsLanguageEmpty::RegistratorWrapper<bool, grammar::GNF < > >(IsLanguageEmpty::isLanguageEmpty);
 auto IsLanguageEmptyCNF = IsLanguageEmpty::RegistratorWrapper<bool, grammar::CNF < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LG>(IsLanguageEmpty::isLanguageEmpty);
+auto IsLanguageEmptyLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LG < > >(IsLanguageEmpty::isLanguageEmpty);
 auto IsLanguageEmptyLeftLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LeftLG>(IsLanguageEmpty::isLanguageEmpty);
 auto IsLanguageEmptyLeftRG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LeftRG>(IsLanguageEmpty::isLanguageEmpty);
 auto IsLanguageEmptyRightLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::RightLG>(IsLanguageEmpty::isLanguageEmpty);
diff --git a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
index 192998c3b8..d8fcc5a00f 100644
--- a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
+++ b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
@@ -32,7 +32,7 @@ auto IsLanguageGeneratingEpsilonCFG = IsLanguageGeneratingEpsilon::RegistratorWr
 auto IsLanguageGeneratingEpsilonEpsilonFreeCFG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::EpsilonFreeCFG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 auto IsLanguageGeneratingEpsilonGNF = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::GNF < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 auto IsLanguageGeneratingEpsilonCNF = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::CNF < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LG>(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
+auto IsLanguageGeneratingEpsilonLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 auto IsLanguageGeneratingEpsilonLeftLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LeftLG>(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 auto IsLanguageGeneratingEpsilonLeftRG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LeftRG>(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 auto IsLanguageGeneratingEpsilonRightLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::RightLG>(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
diff --git a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
index 459642d63d..10338dab3a 100644
--- a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
+++ b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
@@ -61,7 +61,7 @@ auto NonterminalUnitRuleCycleCFG = NonterminalUnitRuleCycle::RegistratorWrapper<
 auto NonterminalUnitRuleCycleEpsilonFreeCFG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::EpsilonFreeCFG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleGNF = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::GNF < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleCNF = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::CNF < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
+auto NonterminalUnitRuleCycleLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleLeftLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleLeftRG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleRightLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
diff --git a/alib2algo/src/grammar/properties/NullableNonterminals.cpp b/alib2algo/src/grammar/properties/NullableNonterminals.cpp
index c64dae41e7..e92e688c74 100644
--- a/alib2algo/src/grammar/properties/NullableNonterminals.cpp
+++ b/alib2algo/src/grammar/properties/NullableNonterminals.cpp
@@ -55,7 +55,7 @@ auto NullableNonterminalsCFG = NullableNonterminals::RegistratorWrapper<std::set
 auto NullableNonterminalsEpsilonFreeCFG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::EpsilonFreeCFG < > >(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsGNF = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::GNF < > >(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsCNF = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::CNF < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG>(NullableNonterminals::getNullableNonterminals);
+auto NullableNonterminalsLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsLeftLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsLeftRG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG>(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsRightLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(NullableNonterminals::getNullableNonterminals);
diff --git a/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp b/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
index 1ff0035172..423d1c8582 100644
--- a/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
+++ b/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
@@ -60,7 +60,7 @@ auto ProductiveNonterminalsCFG = ProductiveNonterminals::RegistratorWrapper<std:
 auto ProductiveNonterminalsEpsilonFreeCFG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::EpsilonFreeCFG < > >(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsGNF = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::GNF < > >(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsCNF = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::CNF < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG>(ProductiveNonterminals::getProductiveNonterminals);
+auto ProductiveNonterminalsLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsLeftLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsLeftRG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG>(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsRightLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(ProductiveNonterminals::getProductiveNonterminals);
diff --git a/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp b/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
index 9883def5b9..a8131edc9e 100644
--- a/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
+++ b/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
@@ -67,7 +67,7 @@ auto RecursiveNonterminalCFG = RecursiveNonterminal::RegistratorWrapper < bool,
 auto RecursiveNonterminalEpsilonFreeCFG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::EpsilonFreeCFG < > > ( RecursiveNonterminal::isNonterminalRecursive );
 auto RecursiveNonterminalGNF = RecursiveNonterminal::RegistratorWrapper < bool, grammar::GNF < > > ( RecursiveNonterminal::isNonterminalRecursive );
 auto RecursiveNonterminalCNF = RecursiveNonterminal::RegistratorWrapper < bool, grammar::CNF < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalLG	 = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LG > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalLG	 = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LG < > > ( RecursiveNonterminal::isNonterminalRecursive );
 auto RecursiveNonterminalLeftLG	 = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LeftLG > ( RecursiveNonterminal::isNonterminalRecursive );
 auto RecursiveNonterminalLeftRG	 = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LeftRG > ( RecursiveNonterminal::isNonterminalRecursive );
 auto RecursiveNonterminalRightLG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::RightLG > ( RecursiveNonterminal::isNonterminalRecursive );
diff --git a/alib2algo/src/grammar/properties/UnreachableSymbols.cpp b/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
index d3c0c6917b..305299ad5f 100644
--- a/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
+++ b/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
@@ -61,7 +61,7 @@ auto UnreachableSymbolsCFG = UnreachableSymbols::RegistratorWrapper<std::set<alp
 auto UnreachableSymbolsEpsilonFreeCFG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::EpsilonFreeCFG < > >(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsGNF = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::GNF < > >(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsCNF = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::CNF < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG>(UnreachableSymbols::getUnreachableSymbols);
+auto UnreachableSymbolsLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsLeftLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsLeftRG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG>(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsRightLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(UnreachableSymbols::getUnreachableSymbols);
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.cpp b/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
index cf4ba01055..70481fa8ab 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
@@ -76,11 +76,11 @@ grammar::GNF < > EpsilonRemover::remove(const grammar::GNF < > & origGrammar) {
 
 auto EpsilonRemoverGNF = EpsilonRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(EpsilonRemover::remove);
 
-grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::LG& origGrammar) {
+grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::LG < > & origGrammar) {
 	return removeInternal(origGrammar);
 }
 
-auto EpsilonRemoverLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LG>(EpsilonRemover::remove);
+auto EpsilonRemoverLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LG < > >(EpsilonRemover::remove);
 
 grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::LeftLG& origGrammar) {
 	return removeInternal(origGrammar);
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.h b/alib2algo/src/grammar/simplify/EpsilonRemover.h
index 3b9cf5d06a..44a8c469c9 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.h
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.h
@@ -36,7 +36,7 @@ public:
 	static grammar::EpsilonFreeCFG < > remove( const grammar::EpsilonFreeCFG < > & grammar );
 	static grammar::GNF < > remove( const grammar::GNF < > & grammar );
 	static grammar::CNF < > remove( const grammar::CNF < > & grammar );
-	static grammar::EpsilonFreeCFG < > remove( const grammar::LG & grammar );
+	static grammar::EpsilonFreeCFG < > remove( const grammar::LG < > & grammar );
 	static grammar::EpsilonFreeCFG < > remove( const grammar::LeftLG & grammar );
 	static grammar::LeftRG remove( const grammar::LeftRG & grammar );
 	static grammar::EpsilonFreeCFG < > remove( const grammar::RightLG & grammar );
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp b/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
index 16b9aa51e4..192af0cf0e 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
@@ -91,11 +91,11 @@ grammar::GNF < > SimpleRulesRemover::remove(const grammar::GNF < > & origGrammar
 
 auto SimpleRulesRemoverGNF = SimpleRulesRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(SimpleRulesRemover::remove);
 
-grammar::LG SimpleRulesRemover::remove(const grammar::LG& origGrammar) {
+grammar::LG < > SimpleRulesRemover::remove(const grammar::LG < > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
 
-auto SimpleRulesRemoverLG = SimpleRulesRemover::RegistratorWrapper<grammar::LG, grammar::LG>(SimpleRulesRemover::remove);
+auto SimpleRulesRemoverLG = SimpleRulesRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(SimpleRulesRemover::remove);
 
 grammar::LeftLG SimpleRulesRemover::remove(const grammar::LeftLG& origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
index 3b81011a10..fd8af31e80 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
@@ -36,7 +36,7 @@ public:
 	static grammar::EpsilonFreeCFG < > remove( const grammar::EpsilonFreeCFG < > & grammar );
 	static grammar::GNF < > remove( const grammar::GNF < > & grammar );
 	static grammar::CNF < > remove( const grammar::CNF < > & grammar );
-	static grammar::LG remove( const grammar::LG & grammar );
+	static grammar::LG < > remove( const grammar::LG < > & grammar );
 	static grammar::LeftLG remove( const grammar::LeftLG & grammar );
 	static grammar::LeftRG remove( const grammar::LeftRG & grammar );
 	static grammar::RightLG remove( const grammar::RightLG & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToCNF.cpp b/alib2algo/src/grammar/simplify/ToCNF.cpp
index f49c05ae38..7b49972163 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToCNF.cpp
@@ -141,11 +141,11 @@ grammar::CNF < > ToCNF::convert(const grammar::GNF < > & origGrammar) {
 
 auto ToCNFGNF = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::GNF < > >(ToCNF::convert);
 
-grammar::CNF < > ToCNF::convert(const grammar::LG& origGrammar) {
+grammar::CNF < > ToCNF::convert(const grammar::LG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LG>(ToCNF::convert);
+auto ToCNFLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LG < > >(ToCNF::convert);
 
 grammar::CNF < > ToCNF::convert(const grammar::LeftLG& origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
diff --git a/alib2algo/src/grammar/simplify/ToCNF.h b/alib2algo/src/grammar/simplify/ToCNF.h
index a933ce2203..9dee0421aa 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.h
+++ b/alib2algo/src/grammar/simplify/ToCNF.h
@@ -36,7 +36,7 @@ public:
 	static grammar::CNF < > convert( const grammar::EpsilonFreeCFG < > & grammar );
 	static grammar::CNF < > convert( const grammar::GNF < > & grammar );
 	static grammar::CNF < > convert( const grammar::CNF < > & grammar );
-	static grammar::CNF < > convert( const grammar::LG & grammar );
+	static grammar::CNF < > convert( const grammar::LG < > & grammar );
 	static grammar::CNF < > convert( const grammar::LeftLG & grammar );
 	static grammar::CNF < > convert( const grammar::LeftRG & grammar );
 	static grammar::CNF < > convert( const grammar::RightLG & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToGNF.cpp b/alib2algo/src/grammar/simplify/ToGNF.cpp
index 9d0138067c..b01001113f 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToGNF.cpp
@@ -111,11 +111,11 @@ grammar::GNF < > ToGNF::convert(const grammar::GNF < > & origGrammar) {
 
 auto ToGNFGNF = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(ToGNF::convert);
 
-grammar::GNF < > ToGNF::convert(const grammar::LG& origGrammar) {
+grammar::GNF < > ToGNF::convert(const grammar::LG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
 }
 
-auto ToGNFLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LG>(ToGNF::convert);
+auto ToGNFLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LG < > >(ToGNF::convert);
 
 grammar::GNF < > ToGNF::convert(const grammar::LeftLG& origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index 42ad2e2bb3..27969042a5 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -36,7 +36,7 @@ public:
 	static grammar::GNF < > convert( const grammar::EpsilonFreeCFG < > & grammar );
 	static grammar::GNF < > convert( const grammar::CNF < > & grammar );
 	static grammar::GNF < > convert( const grammar::GNF < > & grammar );
-	static grammar::GNF < > convert( const grammar::LG & grammar );
+	static grammar::GNF < > convert( const grammar::LG < > & grammar );
 	static grammar::GNF < > convert( const grammar::LeftLG & grammar );
 	static grammar::RightRG convert( const grammar::LeftRG & grammar );
 	static grammar::GNF < > convert( const grammar::RightLG & grammar );
diff --git a/alib2algo/src/grammar/simplify/Trim.cpp b/alib2algo/src/grammar/simplify/Trim.cpp
index a1cf13b050..650d0ac8a1 100644
--- a/alib2algo/src/grammar/simplify/Trim.cpp
+++ b/alib2algo/src/grammar/simplify/Trim.cpp
@@ -33,7 +33,7 @@ auto TrimCFG = Trim::RegistratorWrapper<grammar::CFG < >, grammar::CFG < > >(Tri
 auto TrimEpsilonFreeCFG = Trim::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(Trim::trim);
 auto TrimGNF = Trim::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(Trim::trim);
 auto TrimCNF = Trim::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(Trim::trim);
-auto TrimLG = Trim::RegistratorWrapper<grammar::LG, grammar::LG>(Trim::trim);
+auto TrimLG = Trim::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(Trim::trim);
 auto TrimLeftLG = Trim::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(Trim::trim);
 auto TrimLeftRG = Trim::RegistratorWrapper<grammar::LeftRG, grammar::LeftRG>(Trim::trim);
 auto TrimRightLG = Trim::RegistratorWrapper<grammar::RightLG, grammar::RightLG>(Trim::trim);
diff --git a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
index 3aa2efdaca..a019e2e064 100644
--- a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
+++ b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
@@ -64,7 +64,7 @@ auto UnproductiveSymbolsRemoverCFG = UnproductiveSymbolsRemover::RegistratorWrap
 auto UnproductiveSymbolsRemoverEpsilonFreeCFG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(UnproductiveSymbolsRemover::remove);
 auto UnproductiveSymbolsRemoverGNF = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(UnproductiveSymbolsRemover::remove);
 auto UnproductiveSymbolsRemoverCNF = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LG, grammar::LG>(UnproductiveSymbolsRemover::remove);
+auto UnproductiveSymbolsRemoverLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(UnproductiveSymbolsRemover::remove);
 auto UnproductiveSymbolsRemoverLeftLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(UnproductiveSymbolsRemover::remove);
 auto UnproductiveSymbolsRemoverLeftRG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LeftRG, grammar::LeftRG>(UnproductiveSymbolsRemover::remove);
 auto UnproductiveSymbolsRemoverRightLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::RightLG, grammar::RightLG>(UnproductiveSymbolsRemover::remove);
diff --git a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
index d9492f74b0..a2a5c2d556 100644
--- a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
+++ b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
@@ -63,7 +63,7 @@ auto UnreachableSymbolsRemoverCFG = UnreachableSymbolsRemover::RegistratorWrappe
 auto UnreachableSymbolsRemoverEpsilonFreeCFG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(UnreachableSymbolsRemover::remove);
 auto UnreachableSymbolsRemoverGNF = UnreachableSymbolsRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(UnreachableSymbolsRemover::remove);
 auto UnreachableSymbolsRemoverCNF = UnreachableSymbolsRemover::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LG, grammar::LG>(UnreachableSymbolsRemover::remove);
+auto UnreachableSymbolsRemoverLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(UnreachableSymbolsRemover::remove);
 auto UnreachableSymbolsRemoverLeftLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(UnreachableSymbolsRemover::remove);
 auto UnreachableSymbolsRemoverLeftRG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LeftRG, grammar::LeftRG>(UnreachableSymbolsRemover::remove);
 auto UnreachableSymbolsRemoverRightLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::RightLG, grammar::RightLG>(UnreachableSymbolsRemover::remove);
diff --git a/alib2data/src/grammar/ContextFree/LG.cpp b/alib2data/src/grammar/ContextFree/LG.cpp
index 19517b4b4e..f1422b907c 100644
--- a/alib2data/src/grammar/ContextFree/LG.cpp
+++ b/alib2data/src/grammar/ContextFree/LG.cpp
@@ -6,220 +6,13 @@
  */
 
 #include "LG.h"
-#include <algorithm>
-#include <sstream>
-
-#include "../../alphabet/Symbol.h"
-
-#include <sax/FromXMLParserHelper.h>
-#include "../common/GrammarFromXMLParser.h"
-#include "../common/GrammarToXMLComposer.h"
 #include "../Grammar.h"
 #include <object/Object.h>
 #include <XmlApi.hpp>
 
-namespace grammar {
-
-LG::LG ( alphabet::Symbol initialSymbol ) : LG ( std::set < alphabet::Symbol > { initialSymbol }, std::set < alphabet::Symbol > ( ), initialSymbol ) {
-}
-
-LG::LG ( std::set < alphabet::Symbol > nonterminalAlphabet, std::set < alphabet::Symbol > terminalAlphabet, alphabet::Symbol initialSymbol ) : std::Components < LG, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
-}
-
-GrammarBase * LG::clone ( ) const {
-	return new LG ( * this );
-}
-
-GrammarBase * LG::plunder ( ) && {
-	return new LG ( std::move ( * this ) );
-}
-
-bool LG::addRule ( alphabet::Symbol leftHandSide, std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > rightHandSide ) {
-	if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
-		throw GrammarException ( "Rule must rewrite nonterminal symbol" );
-
-	if ( rightHandSide.is < std::vector < alphabet::Symbol > > ( ) ) {
-		const std::vector < alphabet::Symbol > & rhs = rightHandSide.get < std::vector < alphabet::Symbol > > ( );
-
-		for ( const auto & symbol : rhs )
-			if ( !getTerminalAlphabet ( ).count ( symbol ) )
-				throw GrammarException ( "Symbol " + std::to_string ( symbol ) + " is not a terminal symbol" );
-
-		return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
-	} else {
-		const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > & rhs = rightHandSide.get < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
-
-		for ( const auto & symbol : std::get < 0 > ( rhs ) )
-			if ( !getTerminalAlphabet ( ).count ( symbol ) )
-				throw GrammarException ( "Symbol " + std::to_string ( symbol ) + " is not a terminal symbol" );
-
-		if ( !getNonterminalAlphabet ( ).count ( std::get < 1 > ( rhs ) ) )
-			throw GrammarException ( "Symbol " + std::to_string ( std::get < 1 > ( rhs ) ) + " is not a nonterminal symbol" );
-
-		for ( const auto & symbol : std::get < 2 > ( rhs ) )
-			if ( !getTerminalAlphabet ( ).count ( symbol ) )
-				throw GrammarException ( "Symbol " + std::to_string ( symbol ) + " is not a terminal symbol" );
-
-		return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
-	}
-}
-
-bool LG::addRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( std::move ( rightHandSide ) );
-
-	return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
-}
-
-bool LG::addRule ( alphabet::Symbol leftHandSide, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( std::move ( rightHandSide ) );
-
-	return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
-}
-
-const std::map < alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & LG::getRules ( ) const {
-	return rules;
-}
-
-bool LG::removeRule ( const alphabet::Symbol & leftHandSide, const std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > & rightHandSide ) {
-	return rules[leftHandSide].erase ( rightHandSide );
-}
-
-bool LG::removeRule ( const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( rightHandSide );
-
-	return removeRule ( leftHandSide, rhs );
-}
-
-bool LG::removeRule ( const alphabet::Symbol & leftHandSide, const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > & rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( rightHandSide );
-
-	return removeRule ( leftHandSide, rhs );
-}
-
-bool LG::addRawRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide ) {
-	std::vector < alphabet::Symbol >::iterator nonterminalPosition = rightHandSide.begin ( );
-
-	for ( ; nonterminalPosition != rightHandSide.end ( ); ++nonterminalPosition )
-		if ( getNonterminalAlphabet ( ).count ( * nonterminalPosition ) ) break;
-
-	if ( nonterminalPosition == rightHandSide.end ( ) )
-		return addRule ( leftHandSide, rightHandSide );
-	else
-		return addRule ( leftHandSide, std::make_tuple ( std::vector < alphabet::Symbol > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( nonterminalPosition ) ), std::move ( * nonterminalPosition ), std::vector < alphabet::Symbol > ( std::make_move_iterator ( nonterminalPosition ) + 1, std::make_move_iterator ( rightHandSide.end ( ) ) ) ) );
-}
-
-std::map < alphabet::Symbol, std::set < std::vector < alphabet::Symbol > > > LG::getRawRules ( ) const {
-	std::map < alphabet::Symbol, std::set < std::vector < alphabet::Symbol > > > res;
-
-	for ( const auto & rule : getRules ( ) )
-		for ( const auto & rhs : rule.second ) {
-			if ( rhs.is < std::vector < alphabet::Symbol > > ( ) ) {
-				res[rule.first].insert ( rhs.get < std::vector < alphabet::Symbol > > ( ) );
-			} else {
-				const auto & rhsTuple = rhs.get < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
-				std::vector < alphabet::Symbol > tmp { std::get < 0 > ( rhsTuple ).begin ( ), std::get < 0 > ( rhsTuple ).end ( ) };
-				tmp.push_back ( std::get < 1 > ( rhsTuple ) );
-				tmp.insert ( tmp.end ( ), std::get < 2 > ( rhsTuple ).begin ( ), std::get < 2 > ( rhsTuple ).end ( ) );
-				res[rule.first].insert ( std::move ( tmp ) );
-			}
-		}
-
-	return res;
-}
-
-bool LG::removeRawRule ( const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide ) {
-	std::vector < alphabet::Symbol >::const_iterator nonterminalPosition = rightHandSide.begin ( );
-
-	for ( ; nonterminalPosition != rightHandSide.end ( ); ++nonterminalPosition )
-		if ( getNonterminalAlphabet ( ).count ( * nonterminalPosition ) ) break;
-
-	if ( nonterminalPosition == rightHandSide.end ( ) )
-		return removeRule ( leftHandSide, rightHandSide );
-	else
-		return removeRule ( leftHandSide, std::make_tuple ( std::vector < alphabet::Symbol > ( rightHandSide.begin ( ), nonterminalPosition ), * nonterminalPosition, std::vector < alphabet::Symbol > ( nonterminalPosition + 1, rightHandSide.end ( ) ) ) );
-}
-
-int LG::compare ( const LG & other ) const {
-	auto first = std::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
-	auto second = std::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
-
-	std::compare < decltype ( first ) > comp;
-
-	return comp ( first, second );
-}
-
-void LG::operator >>( std::ostream & out ) const {
-	out << "(LG "
-	    << "nonterminalAlphabet = " << getNonterminalAlphabet ( )
-	    << "terminalAlphabet = " << getTerminalAlphabet ( )
-	    << "initialSymbol = " << getInitialSymbol ( )
-	    << "rules = " << rules << ")";
-}
-
-LG::operator std::string ( ) const {
-	std::stringstream ss;
-	ss << * this;
-	return ss.str ( );
-}
-
-LG LG::parse ( std::deque < sax::Token >::iterator & input ) {
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LG::getXmlTagName() );
-
-	std::set < alphabet::Symbol > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < alphabet::Symbol > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
-
-	LG grammar ( std::move ( initialSymbol ) );
-
-	grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
-	grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
-
-	GrammarFromXMLParser::parseRules ( input, grammar );
-
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, LG::getXmlTagName() );
-	return grammar;
-}
-
-void LG::parseRule ( std::deque < sax::Token >::iterator & input, LG & grammar ) {
-	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < alphabet::Symbol > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
-
-	grammar.addRawRule ( std::move ( lhs ), std::move ( rhs ) );
-}
-
-void LG::compose ( std::deque < sax::Token > & out ) const {
-	out.emplace_back ( LG::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
-
-	GrammarToXMLComposer::composeNonterminalAlphabet ( out, this->getNonterminalAlphabet ( ) );
-	GrammarToXMLComposer::composeTerminalAlphabet ( out, this->getTerminalAlphabet ( ) );
-	GrammarToXMLComposer::composeInitialSymbol ( out, this->getInitialSymbol ( ) );
-	composeRules ( out );
-
-	out.emplace_back ( LG::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
-}
-
-void LG::composeRules ( std::deque < sax::Token > & out ) const {
-	out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
-
-	for ( const auto & rule : this->getRules ( ) )
-
-		for ( const auto & rhs : rule.second ) {
-			out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
-
-			GrammarToXMLComposer::composeRuleSingleSymbolLHS ( out, rule.first );
-			GrammarToXMLComposer::composeRuleLGRHS ( out, rhs );
-
-			out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
-		}
-
-	out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
-}
-
-} /* namespace grammar */
-
 namespace alib {
 
-auto LGParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::LG > ( );
-auto LGParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::LG > ( );
+auto LGParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::LG < > > ( );
+auto LGParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::LG < > > ( );
 
 } /* namespace alib */
diff --git a/alib2data/src/grammar/ContextFree/LG.h b/alib2data/src/grammar/ContextFree/LG.h
index 77047715f2..ae7dce7999 100644
--- a/alib2data/src/grammar/ContextFree/LG.h
+++ b/alib2data/src/grammar/ContextFree/LG.h
@@ -8,14 +8,21 @@
 #ifndef LG_H_
 #define LG_H_
 
-#include "../GrammarException.h"
-#include "../GrammarBase.h"
 #include <map>
 #include <tuple>
 #include <vector>
 #include <variant>
+#include <algorithm>
+#include <sstream>
+
 #include <core/components.hpp>
-#include "../../alphabet/Symbol.h"
+#include <sax/FromXMLParserHelper.h>
+
+#include "../GrammarBase.h"
+#include "../GrammarFeatures.h"
+#include "../GrammarException.h"
+#include "../common/GrammarFromXMLParser.h"
+#include "../common/GrammarToXMLComposer.h"
 
 namespace grammar {
 
@@ -26,64 +33,65 @@ class TerminalAlphabet;
 class NonterminalAlphabet;
 class InitialSymbol;
 
-class LG : public GrammarBase, public std::Components < LG, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
-	std::map < alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > > > rules;
+template < class SymbolType >
+class LG : public GrammarBase, public std::Components < LG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+	std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > rules;
 
 public:
-	explicit LG ( alphabet::Symbol initialSymbol );
+	explicit LG ( SymbolType initialSymbol );
 
-	explicit LG ( std::set < alphabet::Symbol > nonTerminalSymbols, std::set < alphabet::Symbol > terminalSymbols, alphabet::Symbol initialSymbol );
+	explicit LG ( std::set < SymbolType > nonTerminalSymbols, std::set < SymbolType > terminalSymbols, SymbolType initialSymbol );
 
 	virtual GrammarBase * clone ( ) const;
 
 	virtual GrammarBase * plunder ( ) &&;
 
-	bool addRule ( alphabet::Symbol leftHandSide, std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > rightHandSide );
-	bool addRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide );
-	bool addRule ( alphabet::Symbol leftHandSide, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > rightHandSide );
+	bool addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rightHandSide );
+	bool addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide );
+	bool addRule ( SymbolType leftHandSide, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > rightHandSide );
 
-	const std::map < alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & getRules ( ) const;
+	const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & getRules ( ) const;
 
-	bool removeRule ( const alphabet::Symbol & leftHandSide, const std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > & rightHandSide );
-	bool removeRule ( const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide );
-	bool removeRule ( const alphabet::Symbol & leftHandSide, const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > & rightHandSide );
+	bool removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rightHandSide );
+	bool removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide );
+	bool removeRule ( const SymbolType & leftHandSide, const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rightHandSide );
 
-	bool addRawRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide );
+	bool addRawRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide );
 
-	std::map < alphabet::Symbol, std::set < std::vector < alphabet::Symbol > > > getRawRules ( ) const;
+	std::map < SymbolType, std::set < std::vector < SymbolType > > > getRawRules ( ) const;
 
-	bool removeRawRule ( const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide );
+	bool removeRawRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide );
 
-	const alphabet::Symbol & getInitialSymbol ( ) const {
-		return accessElement < InitialSymbol > ( ).get ( );
+	const SymbolType & getInitialSymbol ( ) const {
+		return this->template accessElement < InitialSymbol > ( ).get ( );
 	}
 
-	bool setInitialSymbol ( alphabet::Symbol symbol ) {
-		return accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
+	bool setInitialSymbol ( SymbolType symbol ) {
+		return this->template accessElement < InitialSymbol > ( ).set ( std::move ( symbol ) );
 	}
 
-	const std::set < alphabet::Symbol > & getNonterminalAlphabet ( ) const {
-		return accessComponent < NonterminalAlphabet > ( ).get ( );
+	const std::set < SymbolType > & getNonterminalAlphabet ( ) const {
+		return this->template accessComponent < NonterminalAlphabet > ( ).get ( );
 	}
 
-	bool addNonterminalSymbol ( alphabet::Symbol symbol ) {
-		return accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
+	bool addNonterminalSymbol ( SymbolType symbol ) {
+		return this->template accessComponent < NonterminalAlphabet > ( ).add ( std::move ( symbol ) );
 	}
 
-	void setNonterminalAlphabet ( std::set < alphabet::Symbol > symbols ) {
-		accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
+	void setNonterminalAlphabet ( std::set < SymbolType > symbols ) {
+		this->template accessComponent < NonterminalAlphabet > ( ).set ( std::move ( symbols ) );
 	}
 
-	const std::set < alphabet::Symbol > & getTerminalAlphabet ( ) const {
-		return accessComponent < TerminalAlphabet > ( ).get ( );
+	const std::set < SymbolType > & getTerminalAlphabet ( ) const {
+		return this->template accessComponent < TerminalAlphabet > ( ).get ( );
 	}
 
-	bool addTerminalSymbol ( alphabet::Symbol symbol ) {
-		return accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
+	bool addTerminalSymbol ( SymbolType symbol ) {
+		return this->template accessComponent < TerminalAlphabet > ( ).add ( std::move ( symbol ) );
 	}
 
-	void setTerminalAlphabet ( std::set < alphabet::Symbol > symbols ) {
-		accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
+	void setTerminalAlphabet ( std::set < SymbolType > symbols ) {
+		this->template accessComponent < TerminalAlphabet > ( ).set ( std::move ( symbols ) );
 	}
 
 	virtual int compare ( const ObjectBase & other ) const {
@@ -111,30 +119,246 @@ public:
 	void composeRules ( std::deque < sax::Token > & out ) const;
 };
 
+template < class SymbolType >
+LG < SymbolType >::LG ( SymbolType initialSymbol ) : LG ( std::set < SymbolType > { initialSymbol }, std::set < SymbolType > ( ), initialSymbol ) {
+}
+
+template < class SymbolType >
+LG < SymbolType >::LG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < LG, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > ( std::make_tuple ( std::move ( terminalAlphabet ), std::move ( nonterminalAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ) ) {
+}
+
+template < class SymbolType >
+GrammarBase * LG < SymbolType >::clone ( ) const {
+	return new LG ( * this );
+}
+
+template < class SymbolType >
+GrammarBase * LG < SymbolType >::plunder ( ) && {
+	return new LG ( std::move ( * this ) );
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rightHandSide ) {
+	if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
+		throw GrammarException ( "Rule must rewrite nonterminal symbol" );
+
+	if ( rightHandSide.template is < std::vector < SymbolType > > ( ) ) {
+		const std::vector < SymbolType > & rhs = rightHandSide.template get < std::vector < SymbolType > > ( );
+
+		for ( const auto & symbol : rhs )
+			if ( !getTerminalAlphabet ( ).count ( symbol ) )
+				throw GrammarException ( "Symbol " + std::to_string ( symbol ) + " is not a terminal symbol" );
+
+		return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
+	} else {
+		const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rhs = rightHandSide.template get < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( );
+
+		for ( const auto & symbol : std::get < 0 > ( rhs ) )
+			if ( !getTerminalAlphabet ( ).count ( symbol ) )
+				throw GrammarException ( "Symbol " + std::to_string ( symbol ) + " is not a terminal symbol" );
+
+		if ( !getNonterminalAlphabet ( ).count ( std::get < 1 > ( rhs ) ) )
+			throw GrammarException ( "Symbol " + std::to_string ( std::get < 1 > ( rhs ) ) + " is not a nonterminal symbol" );
+
+		for ( const auto & symbol : std::get < 2 > ( rhs ) )
+			if ( !getTerminalAlphabet ( ).count ( symbol ) )
+				throw GrammarException ( "Symbol " + std::to_string ( symbol ) + " is not a terminal symbol" );
+
+		return rules[std::move ( leftHandSide )].insert ( std::move ( rightHandSide ) ).second;
+	}
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+
+	return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::addRule ( SymbolType leftHandSide, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+
+	return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
+}
+
+template < class SymbolType >
+const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & LG < SymbolType >::getRules ( ) const {
+	return rules;
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rightHandSide ) {
+	return rules[leftHandSide].erase ( rightHandSide );
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+
+	return removeRule ( leftHandSide, rhs );
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+
+	return removeRule ( leftHandSide, rhs );
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::addRawRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
+	typename std::vector < SymbolType >::iterator nonterminalPosition = rightHandSide.begin ( );
+
+	for ( ; nonterminalPosition != rightHandSide.end ( ); ++nonterminalPosition )
+		if ( getNonterminalAlphabet ( ).count ( * nonterminalPosition ) ) break;
+
+	if ( nonterminalPosition == rightHandSide.end ( ) )
+		return addRule ( leftHandSide, rightHandSide );
+	else
+		return addRule ( leftHandSide, std::make_tuple ( std::vector < SymbolType > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( nonterminalPosition ) ), std::move ( * nonterminalPosition ), std::vector < SymbolType > ( std::make_move_iterator ( nonterminalPosition ) + 1, std::make_move_iterator ( rightHandSide.end ( ) ) ) ) );
+}
+
+template < class SymbolType >
+std::map < SymbolType, std::set < std::vector < SymbolType > > > LG < SymbolType >::getRawRules ( ) const {
+	std::map < SymbolType, std::set < std::vector < SymbolType > > > res;
+
+	for ( const auto & rule : getRules ( ) )
+		for ( const auto & rhs : rule.second ) {
+			if ( rhs.template is < std::vector < SymbolType > > ( ) ) {
+				res[rule.first].insert ( rhs.template get < std::vector < SymbolType > > ( ) );
+			} else {
+				const auto & rhsTuple = rhs.template get < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( );
+				std::vector < SymbolType > tmp { std::get < 0 > ( rhsTuple ).begin ( ), std::get < 0 > ( rhsTuple ).end ( ) };
+				tmp.push_back ( std::get < 1 > ( rhsTuple ) );
+				tmp.insert ( tmp.end ( ), std::get < 2 > ( rhsTuple ).begin ( ), std::get < 2 > ( rhsTuple ).end ( ) );
+				res[rule.first].insert ( std::move ( tmp ) );
+			}
+		}
+
+	return res;
+}
+
+template < class SymbolType >
+bool LG < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
+	typename std::vector < SymbolType >::const_iterator nonterminalPosition = rightHandSide.begin ( );
+
+	for ( ; nonterminalPosition != rightHandSide.end ( ); ++nonterminalPosition )
+		if ( getNonterminalAlphabet ( ).count ( * nonterminalPosition ) ) break;
+
+	if ( nonterminalPosition == rightHandSide.end ( ) )
+		return removeRule ( leftHandSide, rightHandSide );
+	else
+		return removeRule ( leftHandSide, std::make_tuple ( std::vector < SymbolType > ( rightHandSide.begin ( ), nonterminalPosition ), * nonterminalPosition, std::vector < SymbolType > ( nonterminalPosition + 1, rightHandSide.end ( ) ) ) );
+}
+
+template < class SymbolType >
+int LG < SymbolType >::compare ( const LG & other ) const {
+	auto first = std::tie ( getTerminalAlphabet ( ), getNonterminalAlphabet ( ), getInitialSymbol ( ), rules );
+	auto second = std::tie ( other.getTerminalAlphabet ( ), other.getNonterminalAlphabet ( ), other.getInitialSymbol ( ), other.rules );
+
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
+}
+
+template < class SymbolType >
+void LG < SymbolType >::operator >>( std::ostream & out ) const {
+	out << "(LG "
+	    << "nonterminalAlphabet = " << getNonterminalAlphabet ( )
+	    << "terminalAlphabet = " << getTerminalAlphabet ( )
+	    << "initialSymbol = " << getInitialSymbol ( )
+	    << "rules = " << rules << ")";
+}
+
+template < class SymbolType >
+LG < SymbolType >::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << * this;
+	return ss.str ( );
+}
+
+template < class SymbolType >
+LG < SymbolType > LG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LG::getXmlTagName() );
+
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+
+	LG < SymbolType > grammar ( std::move ( initialSymbol ) );
+
+	grammar.setNonterminalAlphabet ( std::move ( nonterminalAlphabet ) );
+	grammar.setTerminalAlphabet ( std::move ( terminalAlphabet ) );
+
+	GrammarFromXMLParser::parseRules ( input, grammar );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, LG::getXmlTagName() );
+	return grammar;
+}
+
+template < class SymbolType >
+void LG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, LG & grammar ) {
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+
+	grammar.addRawRule ( std::move ( lhs ), std::move ( rhs ) );
+}
+
+template < class SymbolType >
+void LG < SymbolType >::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( LG::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
+
+	GrammarToXMLComposer::composeNonterminalAlphabet ( out, this->getNonterminalAlphabet ( ) );
+	GrammarToXMLComposer::composeTerminalAlphabet ( out, this->getTerminalAlphabet ( ) );
+	GrammarToXMLComposer::composeInitialSymbol ( out, this->getInitialSymbol ( ) );
+	composeRules ( out );
+
+	out.emplace_back ( LG::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
+}
+
+template < class SymbolType >
+void LG < SymbolType >::composeRules ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "rules", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const auto & rule : this->getRules ( ) )
+
+		for ( const auto & rhs : rule.second ) {
+			out.emplace_back ( "rule", sax::Token::TokenType::START_ELEMENT );
+
+			GrammarToXMLComposer::composeRuleSingleSymbolLHS ( out, rule.first );
+			GrammarToXMLComposer::composeRuleLGRHS ( out, rhs );
+
+			out.emplace_back ( "rule", sax::Token::TokenType::END_ELEMENT );
+		}
+
+	out.emplace_back ( "rules", sax::Token::TokenType::END_ELEMENT );
+}
+
 } /* namespace grammar */
 
 namespace std {
 
-template < >
-class ComponentConstraint< grammar::LG, alphabet::Symbol, grammar::TerminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::LG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
 public:
-	static bool used ( const grammar::LG & grammar, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & rule : grammar.getRules ( ) ) {
-			for ( const std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > & rhsTmp : rule.second )
-				if ( rhsTmp.is < std::vector < alphabet::Symbol > > ( ) ) {
-					const std::vector < alphabet::Symbol > & rhs = rhsTmp.get < std::vector < alphabet::Symbol > > ( );
+	static bool used ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
+		for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+			for ( const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+				if ( rhsTmp.template is < std::vector < SymbolType > > ( ) ) {
+					const std::vector < SymbolType > & rhs = rhsTmp.template get < std::vector < SymbolType > > ( );
 
 					if ( std::find ( rhs.begin ( ), rhs.end ( ), symbol ) != rhs.end ( ) )
 						return true;
 				} else {
-					const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > & rhs = rhsTmp.get < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
+					const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rhs = rhsTmp.get < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( );
 
-					const std::vector < alphabet::Symbol > & lPart = std::get < 0 > ( rhs );
+					const std::vector < SymbolType > & lPart = std::get < 0 > ( rhs );
 
 					if ( std::find ( lPart.begin ( ), lPart.end ( ), symbol ) != lPart.end ( ) )
 						return true;
 
-					const std::vector < alphabet::Symbol > & rPart = std::get < 2 > ( rhs );
+					const std::vector < SymbolType > & rPart = std::get < 2 > ( rhs );
 
 					if ( std::find ( rPart.begin ( ), rPart.end ( ), symbol ) != rPart.end ( ) )
 						return true;
@@ -145,27 +369,27 @@ public:
 		return false;
 	}
 
-	static bool available ( const grammar::LG &, const alphabet::Symbol & ) {
+	static bool available ( const grammar::LG < SymbolType > &, const SymbolType & ) {
 		return true;
 	}
 
-	static void valid ( const grammar::LG & grammar, const alphabet::Symbol & symbol ) {
-		if ( grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
+	static void valid ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
+		if ( grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
 			throw grammar::GrammarException ( "Symbol " + std::to_string ( symbol ) + "cannot be in terminal alphabet since it is already nonterminal alphabet" );
 	}
 };
 
-template < >
-class ComponentConstraint< grammar::LG, alphabet::Symbol, grammar::NonterminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::LG < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
 public:
-	static bool used ( const grammar::LG & grammar, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & rule : grammar.getRules ( ) ) {
+	static bool used ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
+		for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
 			if ( rule.first == symbol )
 				return true;
 
-			for ( const std::variant < std::vector < alphabet::Symbol >, std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > & rhsTmp : rule.second )
-				if ( rhsTmp.is < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > ( ) ) {
-					const std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > & rhs = rhsTmp.get < std::tuple < std::vector < alphabet::Symbol >, alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
+			for ( const std::variant < std::vector < SymbolType >, std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+				if ( rhsTmp.template is < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( ) ) {
+					const std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > & rhs = rhsTmp.get < std::tuple < std::vector < SymbolType >, SymbolType, std::vector < SymbolType > > > ( );
 
 					if ( std::get < 1 > ( rhs ) == symbol )
 						return true;
@@ -173,30 +397,30 @@ public:
 
 		}
 
-		if ( grammar.accessElement < grammar::InitialSymbol > ( ).get ( ) == symbol )
+		if ( grammar.template accessElement < grammar::InitialSymbol > ( ).get ( ) == symbol )
 			return true;
 
 		return false;
 	}
 
-	static bool available ( const grammar::LG &, const alphabet::Symbol & ) {
+	static bool available ( const grammar::LG < SymbolType > &, const SymbolType & ) {
 		return true;
 	}
 
-	static void valid ( const grammar::LG & grammar, const alphabet::Symbol & symbol ) {
-		if ( grammar.accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
+	static void valid ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
+		if ( grammar.template accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
 			throw grammar::GrammarException ( "Symbol " + std::to_string ( symbol ) + "cannot be in nonterminal alphabet since it is already in terminal alphabet" );
 	}
 };
 
-template < >
-class ElementConstraint< grammar::LG, alphabet::Symbol, grammar::InitialSymbol > {
+template < class SymbolType >
+class ElementConstraint< grammar::LG < SymbolType >, SymbolType, grammar::InitialSymbol > {
 public:
-	static bool available ( const grammar::LG & grammar, const alphabet::Symbol & symbol ) {
-		return grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
+	static bool available ( const grammar::LG < SymbolType > & grammar, const SymbolType & symbol ) {
+		return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
 	}
 
-	static void valid ( const grammar::LG &, const alphabet::Symbol & ) {
+	static void valid ( const grammar::LG < SymbolType > &, const SymbolType & ) {
 	}
 };
 
diff --git a/alib2data/src/grammar/GrammarFeatures.h b/alib2data/src/grammar/GrammarFeatures.h
index 2a248b9291..e9b6134580 100644
--- a/alib2data/src/grammar/GrammarFeatures.h
+++ b/alib2data/src/grammar/GrammarFeatures.h
@@ -35,6 +35,7 @@ class LeftLG;
 class LeftRG;
 class RightLG;
 class RightRG;
+template<class SymbolType = typename alphabet::Symbol >
 class LG;
 template<class SymbolType = typename alphabet::Symbol >
 class CFG;
diff --git a/alib2data/test-src/grammar/GrammarTest.cpp b/alib2data/test-src/grammar/GrammarTest.cpp
index 1be85f15ff..0c1ee3ca20 100644
--- a/alib2data/test-src/grammar/GrammarTest.cpp
+++ b/alib2data/test-src/grammar/GrammarTest.cpp
@@ -152,7 +152,7 @@ void GrammarTest::testRegularParser() {
 
 void GrammarTest::testContextFreeParser() {
 	{
-		grammar::LG grammar(alphabet::symbolFrom(1));
+		grammar::LG < > grammar(alphabet::symbolFrom(1));
 
 		grammar.addNonterminalSymbol(alphabet::symbolFrom(1));
 		grammar.addNonterminalSymbol(alphabet::symbolFrom(2));
@@ -173,7 +173,7 @@ void GrammarTest::testContextFreeParser() {
 
 			std::deque<sax::Token> tokens2;
 			sax::SaxParseInterface::parseMemory(tmp, tokens2);
-			grammar::LG grammar2 = alib::XmlDataFactory::fromTokens<grammar::LG>(std::move(tokens2));
+			grammar::LG < > grammar2 = alib::XmlDataFactory::fromTokens<grammar::LG < > >(std::move(tokens2));
 
 			CPPUNIT_ASSERT( grammar == grammar2 );
 		}
diff --git a/alib2str/src/grammar/GrammarFromStringParser.cpp b/alib2str/src/grammar/GrammarFromStringParser.cpp
index 5943290aad..f88f326ab3 100644
--- a/alib2str/src/grammar/GrammarFromStringParser.cpp
+++ b/alib2str/src/grammar/GrammarFromStringParser.cpp
@@ -485,13 +485,13 @@ LeftLG GrammarFromStringParser::parseLeftLG(std::istream& input) const {
 	return parseCFLikeGrammar<LeftLG>(input);
 }
 
-LG GrammarFromStringParser::parseLG(std::istream& input) const {
+LG < > GrammarFromStringParser::parseLG(std::istream& input) const {
 	GrammarFromStringLexer::Token token = m_GrammarLexer.next(input);
 	if(token.type != GrammarFromStringLexer::TokenType::LG) {
 		throw exception::CommonException("Unrecognised LG token.");
 	}
 
-	return parseCFLikeGrammar<LG>(input);
+	return parseCFLikeGrammar<LG < > >(input);
 }
 
 CFG < > GrammarFromStringParser::parseCFG(std::istream& input) const {
diff --git a/alib2str/src/grammar/GrammarFromStringParser.h b/alib2str/src/grammar/GrammarFromStringParser.h
index 6c825dbf70..c4bfed0a37 100644
--- a/alib2str/src/grammar/GrammarFromStringParser.h
+++ b/alib2str/src/grammar/GrammarFromStringParser.h
@@ -50,7 +50,7 @@ private:
 	RightLG parseRightLG(std::istream& input) const;
 	LeftLG parseLeftLG(std::istream& input) const;
 
-	LG parseLG(std::istream& input) const;
+	LG < > parseLG(std::istream& input) const;
 	CFG < > parseCFG(std::istream& input) const;
 	EpsilonFreeCFG < > parseEpsilonFreeCFG(std::istream& input) const;
 	GNF < > parseGNF(std::istream& input) const;
diff --git a/alib2str/src/grammar/GrammarToStringComposer.cpp b/alib2str/src/grammar/GrammarToStringComposer.cpp
index 9b3ef3cf5c..09a990b2d0 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.cpp
+++ b/alib2str/src/grammar/GrammarToStringComposer.cpp
@@ -212,12 +212,12 @@ void GrammarToStringComposer::compose(std::ostream& output, const RightRG& gramm
 
 GrammarToStringComposer::RegistratorWrapper<void, RightRG> GrammarToStringComposerRightRG = GrammarToStringComposer::RegistratorWrapper<void, RightRG>(GrammarToStringComposer::compose);
 
-void GrammarToStringComposer::compose(std::ostream& output, const LG& grammar) {
+void GrammarToStringComposer::compose(std::ostream& output, const LG < > & grammar) {
 	output << "LG";
 	composeCFLikeGrammar(output, grammar);
 }
 
-GrammarToStringComposer::RegistratorWrapper<void, LG> GrammarToStringComposerLG = GrammarToStringComposer::RegistratorWrapper<void, LG>(GrammarToStringComposer::compose);
+GrammarToStringComposer::RegistratorWrapper<void, LG < > > GrammarToStringComposerLG = GrammarToStringComposer::RegistratorWrapper<void, LG < > >(GrammarToStringComposer::compose);
 
 void GrammarToStringComposer::compose(std::ostream& output, const CFG < > & grammar) {
 	output << "CFG";
diff --git a/alib2str/src/grammar/GrammarToStringComposer.h b/alib2str/src/grammar/GrammarToStringComposer.h
index b79246b097..db31322b84 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.h
+++ b/alib2str/src/grammar/GrammarToStringComposer.h
@@ -28,7 +28,7 @@ public:
 	static void compose(std::ostream& output, const LeftRG& grammar);
 	static void compose(std::ostream& output, const RightLG& grammar);
 	static void compose(std::ostream& output, const RightRG& grammar);
-	static void compose(std::ostream& output, const LG& grammar);
+	static void compose(std::ostream& output, const LG < > & grammar);
 	static void compose(std::ostream& output, const CFG < > & grammar);
 	static void compose(std::ostream& output, const EpsilonFreeCFG < > & grammar);
 	static void compose(std::ostream& output, const CNF < > & grammar);
-- 
GitLab