diff --git a/acompare2/src/GrammarCompare.cpp b/acompare2/src/GrammarCompare.cpp
index 101d325d147be690c8e3dee19f53d98faf2a1b43..6836a3d109a297858fff7eb030266f901d89b16b 100644
--- a/acompare2/src/GrammarCompare.cpp
+++ b/acompare2/src/GrammarCompare.cpp
@@ -30,7 +30,7 @@
 #include "grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h"
 #include "grammar/Unrestricted/UnrestrictedGrammar.h"
 
-bool GrammarCompare::testCompare(const grammar::LeftLG& a, const grammar::LeftLG& b) {
+bool GrammarCompare::testCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
@@ -169,7 +169,7 @@ template <class T, class R> void GrammarCompare::mapCompare(const std::map<T, R>
 	}
 }
 
-void GrammarCompare::printCompare(const grammar::LeftLG& a, const grammar::LeftLG& b) {
+void GrammarCompare::printCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b) {
 	std::cout << "GrammarCompareer" << std::endl;
 
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
@@ -559,7 +559,7 @@ void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar& a, const g
 	}
 }
 
-int GrammarCompare::compare(const grammar::LeftLG& a, const grammar::LeftLG& b) {
+int GrammarCompare::compare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b) {
 	if(!GrammarCompare::testCompare(a, b)) {
 	  GrammarCompare::printCompare(a, b);
 	  return 1;
@@ -568,7 +568,7 @@ int GrammarCompare::compare(const grammar::LeftLG& a, const grammar::LeftLG& b)
 	}
 }
 
-auto GrammarCompareLeftLG = GrammarCompare::RegistratorWrapper<int, grammar::LeftLG, grammar::LeftLG>(GrammarCompare::compare);
+auto GrammarCompareLeftLG = GrammarCompare::RegistratorWrapper<int, grammar::LeftLG < >, grammar::LeftLG < > >(GrammarCompare::compare);
 
 int GrammarCompare::compare(const grammar::LeftRG& a, const grammar::LeftRG& b) {
 	if(!GrammarCompare::testCompare(a, b)) {
diff --git a/acompare2/src/GrammarCompare.h b/acompare2/src/GrammarCompare.h
index 8aa7a471ba48516382d33bc27a35e0abf9543944..5ca34906b32be78e778824f3e22c2128c5f068d4 100644
--- a/acompare2/src/GrammarCompare.h
+++ b/acompare2/src/GrammarCompare.h
@@ -20,8 +20,8 @@
 
 class GrammarCompare : public std::DoubleDispatch<GrammarCompare, int, const grammar::GrammarBase &, const grammar::GrammarBase &> {
 private:
-	static bool testCompare(const grammar::LeftLG& a, const grammar::LeftLG& b);
-	static void printCompare(const grammar::LeftLG& a, const grammar::LeftLG& b);
+	static bool testCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b);
+	static void printCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b);
 
 	static bool testCompare(const grammar::LeftRG& a, const grammar::LeftRG& b);
 	static void printCompare(const grammar::LeftRG& a, const grammar::LeftRG& b);
@@ -63,7 +63,7 @@ private:
 	template <class T> static void listCompare(const std::list<T> a, const std::list<T> b);
 	template <class T, class R> static void mapCompare(const std::map<T, R> a, const std::map<T, R> b);
 public:
-	static int compare(const grammar::LeftLG& a, const grammar::LeftLG& b);
+	static int compare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b);
 	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);
diff --git a/alib2algo/src/grammar/parsing/First.cpp b/alib2algo/src/grammar/parsing/First.cpp
index f09cc2e1b9e462f67cfe4340edaf3e26a3f97390..9eb3ae298a7c21706122e15ffa3edfdee5ed8254 100644
--- a/alib2algo/src/grammar/parsing/First.cpp
+++ b/alib2algo/src/grammar/parsing/First.cpp
@@ -109,7 +109,7 @@ auto FirstEpsilonFreeCFG = FirstBase1::RegistratorWrapper < FirstResult1, gramma
 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 FirstLeftLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LeftLG > ( 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 );
 auto FirstRightRG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::RightRG > ( First::first );
@@ -123,7 +123,7 @@ auto FirstEpsilonFreeCFG2 = FirstBase2::RegistratorWrapper < FirstResult2, gramm
 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 FirstLeftLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LeftLG > ( 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 );
 auto FirstRightRG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::RightRG > ( First::first );
diff --git a/alib2algo/src/grammar/parsing/Follow.cpp b/alib2algo/src/grammar/parsing/Follow.cpp
index 973d5c0e4b1ade0241f9aa42c327f3488a29c5b7..6d775de2d07890281ddd43199411b4f71e5d9906 100644
--- a/alib2algo/src/grammar/parsing/Follow.cpp
+++ b/alib2algo/src/grammar/parsing/Follow.cpp
@@ -97,7 +97,7 @@ auto FollowEpsilonFreeCFG = FollowBase1::RegistratorWrapper < FollowResult1, gra
 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 FollowLeftLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LeftLG > ( 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 );
 auto FollowRightRG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::RightRG > ( Follow::follow );
@@ -111,7 +111,7 @@ auto FollowEpsilonFreeCFG2 = FollowBase2::RegistratorWrapper < FollowResult2, gr
 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 FollowLeftLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LeftLG > ( 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 );
 auto FollowRightRG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::RightRG > ( Follow::follow );
diff --git a/alib2algo/src/grammar/parsing/LL1ParseTable.cpp b/alib2algo/src/grammar/parsing/LL1ParseTable.cpp
index 9e3fb3b0b65235d091e246f592a138af3c998209..b9e70b873f4165015fbb90e1608f3ab456117016 100644
--- a/alib2algo/src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo/src/grammar/parsing/LL1ParseTable.cpp
@@ -55,7 +55,7 @@ auto LL1ParseTableEpsilonFreeCFG = LL1ParseTable::RegistratorWrapper < std::map
 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 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 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 );
 auto LL1ParseTableRightRG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::RightRG > ( LL1ParseTable::parseTable );
diff --git a/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp b/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
index 872ebec7181b9c4e6d622b8d1759f95ad1bf5ec1..fa554d50d03f85faff6bfba243d36ad657a141e1 100644
--- a/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
+++ b/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
@@ -33,7 +33,7 @@ auto IsLanguageEmptyEpsilonFreeCFG = IsLanguageEmpty::RegistratorWrapper<bool, g
 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 IsLanguageEmptyLeftLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LeftLG>(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);
 auto IsLanguageEmptyRightRG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::RightRG>(IsLanguageEmpty::isLanguageEmpty);
diff --git a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
index d8fcc5a00f791c0496eaaec765f34cab8dd75df1..db2979e541c6509128011cee230bea9cec8b46d5 100644
--- a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
+++ b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
@@ -33,7 +33,7 @@ auto IsLanguageGeneratingEpsilonEpsilonFreeCFG = IsLanguageGeneratingEpsilon::Re
 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 IsLanguageGeneratingEpsilonLeftLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LeftLG>(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);
 auto IsLanguageGeneratingEpsilonRightRG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::RightRG>(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
diff --git a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
index 10338dab3aec7bacd4372a8dd4b6b801815a9d58..a6d3d4fad0ead9148df380ae9f6c6e0ea03a74b7 100644
--- a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
+++ b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
@@ -62,7 +62,7 @@ auto NonterminalUnitRuleCycleEpsilonFreeCFG = NonterminalUnitRuleCycle::Registra
 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 NonterminalUnitRuleCycleLeftLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(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);
 auto NonterminalUnitRuleCycleRightRG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
diff --git a/alib2algo/src/grammar/properties/NullableNonterminals.cpp b/alib2algo/src/grammar/properties/NullableNonterminals.cpp
index e92e688c74b9927beae0af58d8f7d1ce778accb0..3878b91e48b6e01bf8f3df093fbb665b4aec8f97 100644
--- a/alib2algo/src/grammar/properties/NullableNonterminals.cpp
+++ b/alib2algo/src/grammar/properties/NullableNonterminals.cpp
@@ -56,7 +56,7 @@ auto NullableNonterminalsEpsilonFreeCFG = NullableNonterminals::RegistratorWrapp
 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 NullableNonterminalsLeftLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(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);
 auto NullableNonterminalsRightRG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(NullableNonterminals::getNullableNonterminals);
diff --git a/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp b/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
index 423d1c8582623c2f39e466c5d6bbfc5ed4a62ce3..af7f3070216d45b145521ba2928eb2d46896c8db 100644
--- a/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
+++ b/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
@@ -61,7 +61,7 @@ auto ProductiveNonterminalsEpsilonFreeCFG = ProductiveNonterminals::RegistratorW
 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 ProductiveNonterminalsLeftLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(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);
 auto ProductiveNonterminalsRightRG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(ProductiveNonterminals::getProductiveNonterminals);
diff --git a/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp b/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
index a8131edc9ea208e35b048189a0b1d72d4f6ea112..26da8d7ce0576ad872c5a0de0f91feb9cecdea8f 100644
--- a/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
+++ b/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
@@ -68,7 +68,7 @@ auto RecursiveNonterminalEpsilonFreeCFG = RecursiveNonterminal::RegistratorWrapp
 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 RecursiveNonterminalLeftLG	 = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LeftLG > ( 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 );
 auto RecursiveNonterminalRightRG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::RightRG > ( RecursiveNonterminal::isNonterminalRecursive );
diff --git a/alib2algo/src/grammar/properties/UnreachableSymbols.cpp b/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
index 305299ad5f78ea1f15ba7cbb04b072adc079a11e..20fbdcbbd51a899d91c1975fe1cdff2fd0ecd915 100644
--- a/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
+++ b/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
@@ -62,7 +62,7 @@ auto UnreachableSymbolsEpsilonFreeCFG = UnreachableSymbols::RegistratorWrapper<s
 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 UnreachableSymbolsLeftLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG>(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);
 auto UnreachableSymbolsRightRG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(UnreachableSymbols::getUnreachableSymbols);
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.cpp b/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
index 70481fa8ab07530f498e606e8f851dca594f1c82..d61dfdbd654d4313a3ba8018f52f0df971bb6d93 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
@@ -82,11 +82,11 @@ grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::LG < > & origG
 
 auto EpsilonRemoverLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LG < > >(EpsilonRemover::remove);
 
-grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::LeftLG& origGrammar) {
+grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::LeftLG < > & origGrammar) {
 	return removeInternal(origGrammar);
 }
 
-auto EpsilonRemoverLeftLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LeftLG>(EpsilonRemover::remove);
+auto EpsilonRemoverLeftLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LeftLG < > >(EpsilonRemover::remove);
 
 grammar::LeftRG EpsilonRemover::remove(const grammar::LeftRG& origGrammar) {
 	return origGrammar;
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.h b/alib2algo/src/grammar/simplify/EpsilonRemover.h
index 44a8c469c908f61398111ed5fcbc4c0e08a57ef9..8516f62c00e6f80694b739e88a8158a74e9d2888 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.h
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.h
@@ -37,7 +37,7 @@ public:
 	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::LeftLG & 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 );
 	static grammar::RightRG remove( const grammar::RightRG & grammar );
diff --git a/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp b/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp
index 9e46c2a44bb326f5cbf99d17457c1abd2e40e0b4..74e0e356ab8025a75ef48679e1603398bf960e6c 100644
--- a/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp
+++ b/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp
@@ -172,11 +172,11 @@ grammar::RightRG LeftRecursionRemover::remove(const grammar::LeftRG& origGrammar
 
 auto LeftRecursionRemoverLeftRG = LeftRecursionRemover::RegistratorWrapper<grammar::RightRG, grammar::LeftRG>(LeftRecursionRemover::remove);
 
-grammar::RightLG LeftRecursionRemover::remove(const grammar::LeftLG& /* origGrammar */) {
+grammar::RightLG LeftRecursionRemover::remove(const grammar::LeftLG < > & /* origGrammar */) {
 	throw exception::CommonException("LeftRecursionRemover: Removing from LeftLG NYI"); // TODO
 }
 
-auto LeftRecursionRemoverLeftLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG, grammar::LeftLG>(LeftRecursionRemover::remove);
+auto LeftRecursionRemoverLeftLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG, grammar::LeftLG < > >(LeftRecursionRemover::remove);
 
 grammar::Grammar LeftRecursionRemover::remove(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
index 43513684e3a5dcd14033abb9bf2573b4a1adbe99..6df610bc83be7a2b724b02c01bca925b3bbb7ae2 100644
--- a/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
+++ b/alib2algo/src/grammar/simplify/LeftRecursionRemover.h
@@ -38,7 +38,7 @@ public:
 	static grammar::RightRG remove( const grammar::RightRG & grammar );
 	static grammar::RightLG remove( const grammar::RightLG & grammar );
 	static grammar::RightRG remove( const grammar::LeftRG & grammar );
-	static grammar::RightLG remove( const grammar::LeftLG & grammar );
+	static grammar::RightLG remove( const grammar::LeftLG < > & grammar );
 };
 
 } /* namespace simplify */
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp b/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
index 192af0cf0e2a335c72f4d2dc3300095d80642b2c..a9f7767ba6a52fa441dfaacb4d9f6719960a2d50 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
@@ -97,11 +97,11 @@ grammar::LG < > SimpleRulesRemover::remove(const grammar::LG < > & origGrammar)
 
 auto SimpleRulesRemoverLG = SimpleRulesRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(SimpleRulesRemover::remove);
 
-grammar::LeftLG SimpleRulesRemover::remove(const grammar::LeftLG& origGrammar) {
+grammar::LeftLG < > SimpleRulesRemover::remove(const grammar::LeftLG < > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
 
-auto SimpleRulesRemoverLeftLG = SimpleRulesRemover::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(SimpleRulesRemover::remove);
+auto SimpleRulesRemoverLeftLG = SimpleRulesRemover::RegistratorWrapper<grammar::LeftLG < >, grammar::LeftLG < > >(SimpleRulesRemover::remove);
 
 grammar::LeftRG SimpleRulesRemover::remove(const grammar::LeftRG& origGrammar) {
 	return origGrammar;
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
index fd8af31e8072947bf98bb09170139b0bf13eb6a0..834edefa66d7af5ac7b3a14566056351d7a58185 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
@@ -37,7 +37,7 @@ public:
 	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::LeftLG remove( const grammar::LeftLG & 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 );
 	static grammar::RightRG remove( const grammar::RightRG & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToCNF.cpp b/alib2algo/src/grammar/simplify/ToCNF.cpp
index 7b49972163a2627dd0e1ceca5f9690afdf9221ae..5a177a94b62ae591795e7662369b4bf58584d9fd 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToCNF.cpp
@@ -147,11 +147,11 @@ grammar::CNF < > ToCNF::convert(const grammar::LG < > & origGrammar) {
 
 auto ToCNFLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LG < > >(ToCNF::convert);
 
-grammar::CNF < > ToCNF::convert(const grammar::LeftLG& origGrammar) {
+grammar::CNF < > ToCNF::convert(const grammar::LeftLG< > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFLeftLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LeftLG>(ToCNF::convert);
+auto ToCNFLeftLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LeftLG < > >(ToCNF::convert);
 
 grammar::CNF < > ToCNF::convert(const grammar::LeftRG& origGrammar) {
 	return convertInternal(origGrammar);
diff --git a/alib2algo/src/grammar/simplify/ToCNF.h b/alib2algo/src/grammar/simplify/ToCNF.h
index 9dee0421aa833ec2a5aad4bcc76953b5adcb6428..35dc85223e738737e50b8a6f2bcc7a3205920af1 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.h
+++ b/alib2algo/src/grammar/simplify/ToCNF.h
@@ -37,7 +37,7 @@ public:
 	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::LeftLG & 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 );
 	static grammar::CNF < > convert( const grammar::RightRG & grammar );
diff --git a/alib2algo/src/grammar/simplify/ToGNF.cpp b/alib2algo/src/grammar/simplify/ToGNF.cpp
index b01001113fd09dbc91be5fd39a06eba95774acdb..254104cca11e5cf4dd1b132898e310145605c933 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToGNF.cpp
@@ -117,11 +117,11 @@ grammar::GNF < > ToGNF::convert(const grammar::LG < > & origGrammar) {
 
 auto ToGNFLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LG < > >(ToGNF::convert);
 
-grammar::GNF < > ToGNF::convert(const grammar::LeftLG& origGrammar) {
+grammar::GNF < > ToGNF::convert(const grammar::LeftLG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
 }
 
-auto ToGNFLeftLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LeftLG>(ToGNF::convert);
+auto ToGNFLeftLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LeftLG < > >(ToGNF::convert);
 
 grammar::RightRG ToGNF::convert(const grammar::LeftRG& origGrammar) {
 	return convert::ToGrammarRightRG::convert(origGrammar);
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index 27969042a51ef59c9ac537bd253dde71d72af1b5..4e935223b9566f56131140b751223e217a61f4a3 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -37,7 +37,7 @@ public:
 	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::LeftLG & 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 );
 	static grammar::RightRG convert( const grammar::RightRG & grammar );
diff --git a/alib2algo/src/grammar/simplify/Trim.cpp b/alib2algo/src/grammar/simplify/Trim.cpp
index 650d0ac8a1bfeaa3b35b6e4eddda2fdfa3445e2f..702c0f2af6796d17cad29dc05679814ba8b3c844 100644
--- a/alib2algo/src/grammar/simplify/Trim.cpp
+++ b/alib2algo/src/grammar/simplify/Trim.cpp
@@ -34,7 +34,7 @@ auto TrimEpsilonFreeCFG = Trim::RegistratorWrapper<grammar::EpsilonFreeCFG < >,
 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 TrimLeftLG = Trim::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(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);
 auto TrimRightRG = Trim::RegistratorWrapper<grammar::RightRG, grammar::RightRG>(Trim::trim);
diff --git a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
index a019e2e06488078ea6064a5a6199b8ced133c668..849b74673591c1f7d0882bbc1a951ed337d39fd9 100644
--- a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
+++ b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
@@ -65,7 +65,7 @@ auto UnproductiveSymbolsRemoverEpsilonFreeCFG = UnproductiveSymbolsRemover::Regi
 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 UnproductiveSymbolsRemoverLeftLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(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);
 auto UnproductiveSymbolsRemoverRightRG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::RightRG, grammar::RightRG>(UnproductiveSymbolsRemover::remove);
diff --git a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
index a2a5c2d556535326284396d9058389f0233fd2bf..71648bf0157937ef17faf49cdbedfdf237f899e2 100644
--- a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
+++ b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
@@ -64,7 +64,7 @@ auto UnreachableSymbolsRemoverEpsilonFreeCFG = UnreachableSymbolsRemover::Regist
 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 UnreachableSymbolsRemoverLeftLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LeftLG, grammar::LeftLG>(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);
 auto UnreachableSymbolsRemoverRightRG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::RightRG, grammar::RightRG>(UnreachableSymbolsRemover::remove);
diff --git a/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp b/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
index 757431d3f7c659d5e8a33ccc64aefec4b0eb983c..d059a755e964dca429f25f3ee69fee95ffff5b19 100644
--- a/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
+++ b/alib2algo/test-src/grammar/properties/GrammarPropertiesTest.cpp
@@ -52,7 +52,7 @@ void GrammarPropertiesTest::testUnitRules() {
 	alphabet::Symbol a = alphabet::symbolFrom('a');
 	alphabet::Symbol b = alphabet::symbolFrom('b');
 
-	grammar::LeftLG llg(S);
+	grammar::LeftLG < > llg(S);
 	llg.setTerminalAlphabet({a, b});
 	llg.setNonterminalAlphabet({S, A, B, C});
 	llg.setInitialSymbol(S);
diff --git a/alib2data/src/grammar/GrammarFeatures.h b/alib2data/src/grammar/GrammarFeatures.h
index 1766b7af7ba7bec966b8c3d806db95bf7e109366..9f702a6040f251085fe82828786cd24663324048 100644
--- a/alib2data/src/grammar/GrammarFeatures.h
+++ b/alib2data/src/grammar/GrammarFeatures.h
@@ -31,6 +31,7 @@ enum class FEATURES {
 class Grammar;
 class GrammarBase;
 
+template<class SymbolType = typename alphabet::Symbol >
 class LeftLG;
 class LeftRG;
 class RightLG;
diff --git a/alib2data/src/grammar/Regular/LeftLG.cpp b/alib2data/src/grammar/Regular/LeftLG.cpp
index 3be57f27e70b9ec06417da327fae6aa0c9f1d723..b79a962a0ceeca57eeb85ab3b391985a8bee9475 100644
--- a/alib2data/src/grammar/Regular/LeftLG.cpp
+++ b/alib2data/src/grammar/Regular/LeftLG.cpp
@@ -6,207 +6,13 @@
  */
 
 #include "LeftLG.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 {
-
-LeftLG::LeftLG ( alphabet::Symbol initialSymbol ) : LeftLG ( std::set < alphabet::Symbol > { initialSymbol }, std::set < alphabet::Symbol > ( ), initialSymbol ) {
-}
-
-LeftLG::LeftLG ( std::set < alphabet::Symbol > nonterminalAlphabet, std::set < alphabet::Symbol > terminalAlphabet, alphabet::Symbol initialSymbol ) : std::Components < LeftLG, 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 * LeftLG::clone ( ) const {
-	return new LeftLG ( * this );
-}
-
-GrammarBase * LeftLG::plunder ( ) && {
-	return new LeftLG ( std::move ( * this ) );
-}
-
-bool LeftLG::addRule ( alphabet::Symbol leftHandSide, std::variant < std::vector < alphabet::Symbol >, std::pair < 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 > > ( ) ) {
-		for ( const auto & symbol : rightHandSide.get < std::vector < alphabet::Symbol > > ( ) )
-			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::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > & rhs = rightHandSide.get < std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
-
-		if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
-			throw GrammarException ( "Symbol " + std::to_string ( rhs.first ) + " is not a nonterminal symbol" );
-
-		for ( const auto & symbol : rhs.second )
-			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 LeftLG::addRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( std::move ( rightHandSide ) );
-
-	return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
-}
-
-bool LeftLG::addRule ( alphabet::Symbol leftHandSide, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::pair < 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::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & LeftLG::getRules ( ) const {
-	return rules;
-}
-
-bool LeftLG::removeRule ( const alphabet::Symbol & leftHandSide, const std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > & rightHandSide ) {
-	return rules[leftHandSide].erase ( rightHandSide );
-}
-
-bool LeftLG::removeRule ( const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( rightHandSide );
-
-	return removeRule ( leftHandSide, rhs );
-}
-
-bool LeftLG::removeRule ( const alphabet::Symbol & leftHandSide, const std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > & rightHandSide ) {
-	std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > rhs ( rightHandSide );
-
-	return removeRule ( leftHandSide, rhs );
-}
-
-bool LeftLG::addRawRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide ) {
-	if ( rightHandSide.size ( ) == 0 )
-		return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
-	else if ( getNonterminalAlphabet ( ).count ( rightHandSide[0] ) )
-		return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( rightHandSide[0] ), std::vector < alphabet::Symbol > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( rightHandSide.end ( ) ) ) ) );
-	else
-		return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
-}
-
-std::map < alphabet::Symbol, std::set < std::vector < alphabet::Symbol > > > LeftLG::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::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
-				std::vector < alphabet::Symbol > tmp { rhsTuple.first };
-				tmp.insert ( tmp.end ( ), rhsTuple.second.begin ( ), rhsTuple.second.end ( ) );
-				res[rule.first].insert ( std::move ( tmp ) );
-			}
-		}
-
-	return res;
-}
-
-bool LeftLG::removeRawRule ( const alphabet::Symbol & leftHandSide, const std::vector < alphabet::Symbol > & rightHandSide ) {
-	if ( rightHandSide.size ( ) == 0 )
-		return removeRule ( leftHandSide, rightHandSide );
-	else if ( getNonterminalAlphabet ( ).count ( rightHandSide[0] ) )
-		return removeRule ( leftHandSide, std::make_pair ( rightHandSide[0], std::vector < alphabet::Symbol > ( rightHandSide.begin ( ) + 1, rightHandSide.end ( ) ) ) );
-	else
-		return removeRule ( leftHandSide, rightHandSide );
-}
-
-int LeftLG::compare ( const LeftLG & 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 LeftLG::operator >>( std::ostream & out ) const {
-	out << "(LeftLG " << "nonterminalAlphabet = "
-	    << getNonterminalAlphabet ( ) << "terminalAlphabet = "
-	    << getTerminalAlphabet ( ) << "initialSymbol = "
-	    << getInitialSymbol ( ) << "rules = "
-	    << rules << ")";
-}
-
-LeftLG::operator std::string ( ) const {
-	std::stringstream ss;
-	ss << * this;
-	return ss.str ( );
-}
-
-LeftLG LeftLG::parse ( std::deque < sax::Token >::iterator & input ) {
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LeftLG::getXmlTagName() );
-
-	std::set < alphabet::Symbol > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < alphabet::Symbol > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	alphabet::Symbol initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
-
-	LeftLG 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, LeftLG::getXmlTagName() );
-	return grammar;
-}
-
-void LeftLG::parseRule ( std::deque < sax::Token >::iterator & input, LeftLG & grammar ) {
-	alphabet::Symbol lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < alphabet::Symbol > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
-
-	grammar.addRawRule ( std::move ( lhs ), std::move ( rhs ) );
-}
-
-void LeftLG::compose ( std::deque < sax::Token > & out ) const {
-	out.emplace_back ( LeftLG::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 ( LeftLG::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
-}
-
-void LeftLG::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::composeRuleLeftLGRHS ( 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 LeftLGParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::LeftLG > ( );
-auto LeftLGParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::LeftLG > ( );
+auto LeftLGParserRegister = xmlApi < grammar::Grammar >::ParserRegister < grammar::LeftLG < > > ( );
+auto LeftLGParserRegister2 = xmlApi < alib::Object >::ParserRegister < grammar::LeftLG < > > ( );
 
 } /* namespace alib */
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index 06b5e4d46afdd811b247199be55741a10c74eda5..8b47b25384d94df84146e542759b094b4f5f9b36 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -8,13 +8,20 @@
 #ifndef LEFT_LG_H_
 #define LEFT_LG_H_
 
-#include "../GrammarException.h"
-#include "../GrammarBase.h"
 #include <map>
 #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 {
 
@@ -25,64 +32,65 @@ class TerminalAlphabet;
 class NonterminalAlphabet;
 class InitialSymbol;
 
-class LeftLG : public GrammarBase, public std::Components < LeftLG, alphabet::Symbol, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
-	std::map < alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > rules;
+template < class SymbolType >
+class LeftLG : public GrammarBase, public std::Components < LeftLG < SymbolType >, SymbolType, std::tuple < TerminalAlphabet, NonterminalAlphabet >, std::tuple < InitialSymbol > > {
+	std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > rules;
 
 public:
-	explicit LeftLG ( alphabet::Symbol initialSymbol );
+	explicit LeftLG ( SymbolType initialSymbol );
 
-	explicit LeftLG ( std::set < alphabet::Symbol > nonTerminalSymbols, std::set < alphabet::Symbol > terminalSymbols, alphabet::Symbol initialSymbol );
+	explicit LeftLG ( 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::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > rightHandSide );
-	bool addRule ( alphabet::Symbol leftHandSide, std::vector < alphabet::Symbol > rightHandSide );
-	bool addRule ( alphabet::Symbol leftHandSide, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > rightHandSide );
+	bool addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rightHandSide );
+	bool addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide );
+	bool addRule ( SymbolType leftHandSide, std::pair < SymbolType, std::vector < SymbolType > > rightHandSide );
 
-	const std::map < alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & getRules ( ) const;
+	const std::map < SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & getRules ( ) const;
 
-	bool removeRule ( const alphabet::Symbol & leftHandSide, const std::variant < std::vector < alphabet::Symbol >, std::pair < 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::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > & rightHandSide );
+	bool removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rightHandSide );
+	bool removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide );
+	bool removeRule ( const SymbolType & leftHandSide, const std::pair < 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 {
@@ -110,23 +118,226 @@ public:
 	void composeRules ( std::deque < sax::Token > & out ) const;
 };
 
+template < class SymbolType >
+LeftLG < SymbolType >::LeftLG ( SymbolType initialSymbol ) : LeftLG ( std::set < SymbolType > { initialSymbol }, std::set < SymbolType > ( ), initialSymbol ) {
+}
+
+template < class SymbolType >
+LeftLG < SymbolType >::LeftLG ( std::set < SymbolType > nonterminalAlphabet, std::set < SymbolType > terminalAlphabet, SymbolType initialSymbol ) : std::Components < LeftLG, 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 * LeftLG < SymbolType >::clone ( ) const {
+	return new LeftLG ( * this );
+}
+
+template < class SymbolType >
+GrammarBase * LeftLG < SymbolType >::plunder ( ) && {
+	return new LeftLG ( std::move ( * this ) );
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rightHandSide ) {
+	if ( !getNonterminalAlphabet ( ).count ( leftHandSide ) )
+		throw GrammarException ( "Rule must rewrite nonterminal symbol" );
+
+	if ( rightHandSide.template is < std::vector < SymbolType > > ( ) ) {
+		for ( const auto & symbol : rightHandSide.template get < std::vector < SymbolType > > ( ) )
+			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::pair < SymbolType, std::vector < SymbolType > > & rhs = rightHandSide.template get < std::pair < SymbolType, std::vector < SymbolType > > > ( );
+
+		if ( !getNonterminalAlphabet ( ).count ( rhs.first ) )
+			throw GrammarException ( "Symbol " + std::to_string ( rhs.first ) + " is not a nonterminal symbol" );
+
+		for ( const auto & symbol : rhs.second )
+			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 LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( std::move ( rightHandSide ) );
+
+	return addRule ( std::move ( leftHandSide ), std::move ( rhs ) );
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::addRule ( SymbolType leftHandSide, std::pair < SymbolType, std::vector < SymbolType > > rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::pair < 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::pair < SymbolType, std::vector < SymbolType > > > > > & LeftLG < SymbolType >::getRules ( ) const {
+	return rules;
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rightHandSide ) {
+	return rules[leftHandSide].erase ( rightHandSide );
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+
+	return removeRule ( leftHandSide, rhs );
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::removeRule ( const SymbolType & leftHandSide, const std::pair < SymbolType, std::vector < SymbolType > > & rightHandSide ) {
+	std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > rhs ( rightHandSide );
+
+	return removeRule ( leftHandSide, rhs );
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::addRawRule ( SymbolType leftHandSide, std::vector < SymbolType > rightHandSide ) {
+	if ( rightHandSide.size ( ) == 0 )
+		return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
+	else if ( getNonterminalAlphabet ( ).count ( rightHandSide[0] ) )
+		return addRule ( std::move ( leftHandSide ), std::make_pair ( std::move ( rightHandSide[0] ), std::vector < SymbolType > ( std::make_move_iterator ( rightHandSide.begin ( ) ), std::make_move_iterator ( rightHandSide.end ( ) ) ) ) );
+	else
+		return addRule ( std::move ( leftHandSide ), std::move ( rightHandSide ) );
+}
+
+template < class SymbolType >
+std::map < SymbolType, std::set < std::vector < SymbolType > > > LeftLG < 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::pair < SymbolType, std::vector < SymbolType > > > ( );
+				std::vector < SymbolType > tmp { rhsTuple.first };
+				tmp.insert ( tmp.end ( ), rhsTuple.second.begin ( ), rhsTuple.second.end ( ) );
+				res[rule.first].insert ( std::move ( tmp ) );
+			}
+		}
+
+	return res;
+}
+
+template < class SymbolType >
+bool LeftLG < SymbolType >::removeRawRule ( const SymbolType & leftHandSide, const std::vector < SymbolType > & rightHandSide ) {
+	if ( rightHandSide.size ( ) == 0 )
+		return removeRule ( leftHandSide, rightHandSide );
+	else if ( getNonterminalAlphabet ( ).count ( rightHandSide[0] ) )
+		return removeRule ( leftHandSide, std::make_pair ( rightHandSide[0], std::vector < SymbolType > ( rightHandSide.begin ( ) + 1, rightHandSide.end ( ) ) ) );
+	else
+		return removeRule ( leftHandSide, rightHandSide );
+}
+
+template < class SymbolType >
+int LeftLG < SymbolType >::compare ( const LeftLG & 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 LeftLG < SymbolType >::operator >>( std::ostream & out ) const {
+	out << "(LeftLG " << "nonterminalAlphabet = "
+	    << getNonterminalAlphabet ( ) << "terminalAlphabet = "
+	    << getTerminalAlphabet ( ) << "initialSymbol = "
+	    << getInitialSymbol ( ) << "rules = "
+	    << rules << ")";
+}
+
+template < class SymbolType >
+LeftLG < SymbolType >::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << * this;
+	return ss.str ( );
+}
+
+template < class SymbolType >
+LeftLG < SymbolType > LeftLG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LeftLG::getXmlTagName() );
+
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+
+	LeftLG < 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, LeftLG::getXmlTagName() );
+	return grammar;
+}
+
+template < class SymbolType >
+void LeftLG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, LeftLG & 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 LeftLG < SymbolType >::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( LeftLG::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 ( LeftLG::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
+}
+
+template < class SymbolType >
+void LeftLG < 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::composeRuleLeftLGRHS ( 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::LeftLG, alphabet::Symbol, grammar::TerminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::LeftLG < SymbolType >, SymbolType, grammar::TerminalAlphabet > {
 public:
-	static bool used ( const grammar::LeftLG & grammar, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & rule : grammar.getRules ( ) ) {
-			for ( const std::variant < std::vector < alphabet::Symbol >, std::pair < 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::LeftLG < SymbolType > & grammar, const SymbolType & symbol ) {
+		for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
+			for ( const std::variant < std::vector < SymbolType >, std::pair < 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::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > & rhs = rhsTmp.get < std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
+					const std::pair < SymbolType, std::vector < SymbolType > > & rhs = rhsTmp.template get < std::pair < SymbolType, std::vector < SymbolType > > > ( );
 
 					if ( std::find ( rhs.second.begin ( ), rhs.second.end ( ), symbol ) != rhs.second.end ( ) )
 						return true;
@@ -137,27 +348,27 @@ public:
 		return false;
 	}
 
-	static bool available ( const grammar::LeftLG &, const alphabet::Symbol & ) {
+	static bool available ( const grammar::LeftLG < SymbolType > &, const SymbolType & ) {
 		return true;
 	}
 
-	static void valid ( const grammar::LeftLG & grammar, const alphabet::Symbol & symbol ) {
-		if ( grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol ) )
+	static void valid ( const grammar::LeftLG < 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::LeftLG, alphabet::Symbol, grammar::NonterminalAlphabet > {
+template < class SymbolType >
+class ComponentConstraint< grammar::LeftLG < SymbolType >, SymbolType, grammar::NonterminalAlphabet > {
 public:
-	static bool used ( const grammar::LeftLG & grammar, const alphabet::Symbol & symbol ) {
-		for ( const std::pair < const alphabet::Symbol, std::set < std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > > > & rule : grammar.getRules ( ) ) {
+	static bool used ( const grammar::LeftLG < SymbolType > & grammar, const SymbolType & symbol ) {
+		for ( const std::pair < const SymbolType, std::set < std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > > > & rule : grammar.getRules ( ) ) {
 			if ( rule.first == symbol )
 				return true;
 
-			for ( const std::variant < std::vector < alphabet::Symbol >, std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > & rhsTmp : rule.second )
-				if ( rhsTmp.is < std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > ( ) ) {
-					const std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > & rhs = rhsTmp.get < std::pair < alphabet::Symbol, std::vector < alphabet::Symbol > > > ( );
+			for ( const std::variant < std::vector < SymbolType >, std::pair < SymbolType, std::vector < SymbolType > > > & rhsTmp : rule.second )
+				if ( rhsTmp.template is < std::pair < SymbolType, std::vector < SymbolType > > > ( ) ) {
+					const std::pair < SymbolType, std::vector < SymbolType > > & rhs = rhsTmp.template get < std::pair < SymbolType, std::vector < SymbolType > > > ( );
 
 					if ( rhs.first == symbol )
 						return true;
@@ -165,30 +376,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::LeftLG &, const alphabet::Symbol & ) {
+	static bool available ( const grammar::LeftLG < SymbolType > &, const SymbolType & ) {
 		return true;
 	}
 
-	static void valid ( const grammar::LeftLG & grammar, const alphabet::Symbol & symbol ) {
-		if ( grammar.accessComponent < grammar::TerminalAlphabet > ( ).get ( ).count ( symbol ) )
+	static void valid ( const grammar::LeftLG < 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::LeftLG, alphabet::Symbol, grammar::InitialSymbol > {
+template < class SymbolType >
+class ElementConstraint< grammar::LeftLG < SymbolType >, SymbolType, grammar::InitialSymbol > {
 public:
-	static bool available ( const grammar::LeftLG & grammar, const alphabet::Symbol & symbol ) {
-		return grammar.accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
+	static bool available ( const grammar::LeftLG < SymbolType > & grammar, const SymbolType & symbol ) {
+		return grammar.template accessComponent < grammar::NonterminalAlphabet > ( ).get ( ).count ( symbol );
 	}
 
-	static void valid ( const grammar::LeftLG &, const alphabet::Symbol & ) {
+	static void valid ( const grammar::LeftLG < SymbolType > &, const SymbolType & ) {
 	}
 };
 
diff --git a/alib2str/src/grammar/GrammarFromStringParser.cpp b/alib2str/src/grammar/GrammarFromStringParser.cpp
index 267ab49c81c80154600e2d8495349bca0529d305..4cc23fb6edba8213eae4ae8e05b77474dfa0369d 100644
--- a/alib2str/src/grammar/GrammarFromStringParser.cpp
+++ b/alib2str/src/grammar/GrammarFromStringParser.cpp
@@ -476,13 +476,13 @@ RightLG GrammarFromStringParser::parseRightLG(std::istream& input) const {
 	return parseCFLikeGrammar<RightLG>(input);
 }
 
-LeftLG GrammarFromStringParser::parseLeftLG(std::istream& input) const {
+LeftLG < > GrammarFromStringParser::parseLeftLG(std::istream& input) const {
 	GrammarFromStringLexer::Token token = m_GrammarLexer.next(input);
 	if(token.type != GrammarFromStringLexer::TokenType::LEFT_LG) {
 		throw exception::CommonException("Unrecognised LeftLG token.");
 	}
 
-	return parseCFLikeGrammar<LeftLG>(input);
+	return parseCFLikeGrammar<LeftLG < > >(input);
 }
 
 LG < > GrammarFromStringParser::parseLG(std::istream& input) const {
diff --git a/alib2str/src/grammar/GrammarFromStringParser.h b/alib2str/src/grammar/GrammarFromStringParser.h
index 86256c3c066ed75d868a48ab3ef809bbbc3f42d3..528ca9b6980a7dd7f071f3ddb91a941e0ba08e6a 100644
--- a/alib2str/src/grammar/GrammarFromStringParser.h
+++ b/alib2str/src/grammar/GrammarFromStringParser.h
@@ -48,7 +48,7 @@ private:
 	RightRG parseRightRG(std::istream& input) const;
 	LeftRG parseLeftRG(std::istream& input) const;
 	RightLG parseRightLG(std::istream& input) const;
-	LeftLG parseLeftLG(std::istream& input) const;
+	LeftLG < > parseLeftLG(std::istream& input) const;
 
 	LG < > parseLG(std::istream& input) const;
 	CFG < > parseCFG(std::istream& input) const;
diff --git a/alib2str/src/grammar/GrammarToStringComposer.cpp b/alib2str/src/grammar/GrammarToStringComposer.cpp
index d71221084f0b5d3bdd39d7b1d26f862e9554d000..193d07c8528e7f6ebec2a938f6c4eb194cb0390e 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.cpp
+++ b/alib2str/src/grammar/GrammarToStringComposer.cpp
@@ -184,12 +184,12 @@ void GrammarToStringComposer::compose(std::ostream& output, const Grammar& gramm
 	dispatch(output, grammar.getData());
 }
 
-void GrammarToStringComposer::compose(std::ostream& output, const LeftLG& grammar) {
+void GrammarToStringComposer::compose(std::ostream& output, const LeftLG < > & grammar) {
 	output << "LEFT_LG";
 	composeCFLikeGrammar(output, grammar);
 }
 
-GrammarToStringComposer::RegistratorWrapper<void, LeftLG> GrammarToStringComposerLeftLG = GrammarToStringComposer::RegistratorWrapper<void, LeftLG>(GrammarToStringComposer::compose);
+GrammarToStringComposer::RegistratorWrapper<void, LeftLG < > > GrammarToStringComposerLeftLG = GrammarToStringComposer::RegistratorWrapper<void, LeftLG < > >(GrammarToStringComposer::compose);
 
 void GrammarToStringComposer::compose(std::ostream& output, const LeftRG& grammar) {
 	output << "LEFT_RG";
diff --git a/alib2str/src/grammar/GrammarToStringComposer.h b/alib2str/src/grammar/GrammarToStringComposer.h
index 0d30cfe12550986d6f4276fd3d91b425ffc26b30..6bfdd3dcda4bb329f72bdd61bffa9d5f8d439e77 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.h
+++ b/alib2str/src/grammar/GrammarToStringComposer.h
@@ -24,7 +24,7 @@ public:
 	 */
 	static void compose(std::ostream& output, const Grammar& grammar);
 
-	static void compose(std::ostream& output, const LeftLG& grammar);
+	static void compose(std::ostream& output, const LeftLG < > & grammar);
 	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);