diff --git a/alib2algo/src/automaton/convert/ToGrammar.h b/alib2algo/src/automaton/convert/ToGrammar.h
index df34d7452db4bdf9eed13cdea67bb21b80e190ff..e67c4869a20a2b567cca3d57efa1137f58362bbc 100644
--- a/alib2algo/src/automaton/convert/ToGrammar.h
+++ b/alib2algo/src/automaton/convert/ToGrammar.h
@@ -43,27 +43,27 @@ public:
 	/**
 	 * Performs the conversion (@sa ToGrammarRightRG::convert).
 	 * @tparam SymbolType Type for symbols.
-	 * @tparam StateAndNonterminalType Type for states.
+	 * @tparam StateType Type for states.
 	 * @param automaton the automaton to convert
 	 * @return right regular grammar equivalent to the input @p automaton
 	 */
-	template < class SymbolType, class StateAndNonterminalType >
-	static grammar::RightRG < SymbolType, StateAndNonterminalType > convert(const automaton::NFA < SymbolType, StateAndNonterminalType > & automaton);
+	template < class SymbolType, class StateType >
+	static grammar::RightRG < SymbolType, StateType > convert(const automaton::NFA < SymbolType, StateType > & automaton);
 
 	/**
 	 * @overload
 	 */
-	template < class SymbolType, class StateAndNonterminalType >
-	static grammar::RightRG < SymbolType, StateAndNonterminalType > convert(const automaton::DFA < SymbolType, StateAndNonterminalType > & automaton);
+	template < class SymbolType, class StateType >
+	static grammar::RightRG < SymbolType, StateType > convert(const automaton::DFA < SymbolType, StateType > & automaton);
 };
 
-template < class SymbolType, class StateAndNonterminalType >
-grammar::RightRG < SymbolType, StateAndNonterminalType > ToGrammar::convert(const automaton::NFA < SymbolType, StateAndNonterminalType > & automaton) {
+template < class SymbolType, class StateType >
+grammar::RightRG < SymbolType, StateType > ToGrammar::convert(const automaton::NFA < SymbolType, StateType > & automaton) {
 	return ToGrammarRightRG::convert ( automaton );
 }
 
-template < class SymbolType, class StateAndNonterminalType >
-grammar::RightRG < SymbolType, StateAndNonterminalType > ToGrammar::convert(const automaton::DFA < SymbolType, StateAndNonterminalType > & automaton) {
+template < class SymbolType, class StateType >
+grammar::RightRG < SymbolType, StateType > ToGrammar::convert(const automaton::DFA < SymbolType, StateType > & automaton) {
 	return ToGrammarRightRG::convert ( automaton );
 }
 
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
index 5ecfe9e2772930e5bd9dad296f5e3578d2455b2c..8cba0df538b1398461d49e6b09d577c053c16ac1 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
@@ -6,104 +6,12 @@
  */
 
 #include "ToGrammarLeftRG.h"
-#include <alib/map>
-#include <common/createUnique.hpp>
-
-#include <alphabet/InitialSymbol.h>
 #include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace convert {
 
-grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::NFA < > & automaton) {
-	ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
-	// step 2
-	grammar::LeftRG < > grammar(alphabet::InitialSymbol::instance < DefaultSymbolType > ( ) );
-
-	// step 1
-	grammar.setTerminalAlphabet(automaton.getInputAlphabet());
-
-	for(const auto& state : automaton.getStates()) {
-		DefaultSymbolType nt = common::createUnique(DefaultSymbolType(state), grammar.getTerminalAlphabet(), grammar.getNonterminalAlphabet());
-		grammar.addNonterminalSymbol(nt);
-		nonterminalMap.insert(std::pair<DefaultStateType, DefaultSymbolType>(state, nt));
-	}
-
-
-	// step 3 - create set of P in G
-	for(const auto& transition : automaton.getTransitions()) {
-		const DefaultStateType& from = transition.first.first;
-		const DefaultSymbolType& input = transition.first.second;
-
-		for(const auto& to : transition.second)
-		{
-			// 3a
-			grammar.addRule(nonterminalMap.find(to)->second, ext::make_pair(nonterminalMap.find(from)->second, input));
-
-			if(automaton.getFinalStates().count(to) > 0)
-				grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(nonterminalMap.find(from)->second, input));
-
-
-			if(automaton.getInitialState() == from)
-			{
-				grammar.addRule(nonterminalMap.find(to)->second, input);
-
-				if(automaton.getFinalStates().count(to) > 0)
-					grammar.addRule(grammar.getInitialSymbol(), input);
-			}
-		}
-	}
-
-	if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
-		grammar.setGeneratesEpsilon(true);
-
-	return grammar;
-}
-
-grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton) {
-	ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
-	// step 2
-	grammar::LeftRG < > grammar(alphabet::InitialSymbol::instance < DefaultSymbolType > ( ) );
-
-	// step 1
-	grammar.setTerminalAlphabet(automaton.getInputAlphabet());
-
-	for(const auto& state : automaton.getStates()) {
-		DefaultSymbolType nt = common::createUnique(DefaultSymbolType(state), grammar.getTerminalAlphabet(), grammar.getNonterminalAlphabet());
-		grammar.addNonterminalSymbol(nt);
-		nonterminalMap.insert(std::pair<DefaultStateType, DefaultSymbolType>(state, nt));
-	}
-
-
-	// step 3 - create set of P in G
-	for(const auto& transition : automaton.getTransitions()) {
-		const DefaultStateType& from = transition.first.first;
-		const DefaultSymbolType& input = transition.first.second;
-		const DefaultStateType& to = transition.second;
-
-		// 3a
-		grammar.addRule(nonterminalMap.find(to)->second, ext::make_pair(nonterminalMap.find(from)->second, input));
-
-		if(automaton.getFinalStates().count(to) > 0)
-			grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(nonterminalMap.find(from)->second, input));
-
-
-		if(automaton.getInitialState() == from)
-		{
-			grammar.addRule(nonterminalMap.find(to)->second, input);
-
-			if(automaton.getFinalStates().count(to) > 0)
-				grammar.addRule(grammar.getInitialSymbol(), input);
-		}
-	}
-
-	if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
-		grammar.setGeneratesEpsilon(true);
-
-	return grammar;
-}
-
 auto ToGrammarLeftRGNFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::NFA < > & > ( ToGrammarLeftRG::convert );
 auto ToGrammarLeftRGDFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::DFA < > & > ( ToGrammarLeftRG::convert );
 
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.h b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
index 7cddacbf917570a2bfc2e7494cd8c7cdb37a3edf..afdeea729cf411b2215927dd95a28dd8e4c817c4 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
@@ -29,6 +29,11 @@
 #include <automaton/FSM/NFA.h>
 #include <automaton/FSM/DFA.h>
 
+#include <alib/map>
+#include <common/createUnique.hpp>
+
+#include <alphabet/InitialSymbol.h>
+
 namespace automaton {
 
 namespace convert {
@@ -40,17 +45,104 @@ class ToGrammarLeftRG {
 public:
 	/**
 	 * Performs the conversion of the finite automaton to left regular grammar.
-	 * @param automaton a finite automaton to convert
-	 * @return left regular grammar equivalent to the source @p automaton.
+	 *
+	 * \tparam SymbolType the type of input/terminal symbols of automaton and the resulting grammar
+	 * \tparam StateType the type of states of the automaton and nonterminal symbols of the resulting grammar
+	 *
+	 * \param automaton a finite automaton to convert
+	 *
+	 * \return left regular grammar equivalent to the source @p automaton.
 	 */
-	static grammar::LeftRG < > convert(const automaton::NFA < > & automaton);
+	template < class SymbolType, class StateType >
+	static grammar::LeftRG < SymbolType, StateType > convert(const automaton::NFA < SymbolType, StateType > & automaton);
 
 	/**
-	 * @overload
+	 * \overload
 	 */
-	static grammar::LeftRG < > convert(const automaton::DFA < > & automaton);
+	template < class SymbolType, class StateType >
+	static grammar::LeftRG < SymbolType, StateType > convert(const automaton::DFA < SymbolType, StateType > & automaton);
 };
 
+template < class SymbolType, class StateType >
+grammar::LeftRG < SymbolType, StateType > ToGrammarLeftRG::convert(const automaton::NFA < SymbolType, StateType > & automaton) {
+	// step 2
+	grammar::LeftRG < SymbolType, StateType > grammar(alphabet::InitialSymbol::instance < StateType > ( ) );
+
+	// step 1
+	grammar.setTerminalAlphabet(automaton.getInputAlphabet());
+
+	for ( const auto & state : automaton.getStates ( ) ) {
+		grammar.addNonterminalSymbol ( state );
+	}
+
+	// step 3 - create set of P in G
+	for(const auto& transition : automaton.getTransitions()) {
+		const StateType& from = transition.first.first;
+		const SymbolType& input = transition.first.second;
+
+		for(const auto& to : transition.second) {
+			// 3a
+			grammar.addRule ( to, ext::make_pair ( from, input ) );
+
+			if ( automaton.getFinalStates ( ).count ( to ) > 0)
+				grammar.addRule ( grammar.getInitialSymbol ( ), ext::make_pair ( from, input ) );
+
+
+			if ( automaton.getInitialState ( ) == from ) {
+				grammar.addRule ( to, input );
+
+				if ( automaton.getFinalStates ( ).count ( to ) > 0 )
+					grammar.addRule ( grammar.getInitialSymbol ( ), input );
+			}
+		}
+	}
+
+	if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
+		grammar.setGeneratesEpsilon(true);
+
+	return grammar;
+}
+
+template < class SymbolType, class StateType >
+grammar::LeftRG < SymbolType, StateType > ToGrammarLeftRG::convert ( const automaton::DFA < SymbolType, StateType > & automaton ) {
+	// step 2
+	grammar::LeftRG < SymbolType, StateType > grammar(alphabet::InitialSymbol::instance < StateType > ( ) );
+
+	// step 1
+	grammar.setTerminalAlphabet(automaton.getInputAlphabet());
+
+	for ( const auto & state : automaton.getStates ( ) ) {
+		grammar.addNonterminalSymbol ( state );
+	}
+
+	// step 3 - create set of P in G
+	for(const auto& transition : automaton.getTransitions()) {
+		const StateType& from = transition.first.first;
+		const SymbolType& input = transition.first.second;
+		const StateType& to = transition.second;
+
+		// 3a
+		grammar.addRule(to, ext::make_pair(from, input));
+
+		if(automaton.getFinalStates().count(to) > 0)
+			grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(from, input));
+
+
+		if(automaton.getInitialState() == from)
+		{
+			grammar.addRule(to, input);
+
+			if(automaton.getFinalStates().count(to) > 0)
+				grammar.addRule(grammar.getInitialSymbol(), input);
+		}
+	}
+
+	if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
+		grammar.setGeneratesEpsilon(true);
+
+	return grammar;
+}
+
 } /* namespace convert */
 
 } /* namespace automaton */
diff --git a/alib2algo/src/automaton/convert/ToGrammarRightRG.h b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
index f72eab3bd5f5415710c8e174bb6389aa6bde5383..b09d393262e8332d7ceef49a650d34416130d5e5 100644
--- a/alib2algo/src/automaton/convert/ToGrammarRightRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
@@ -44,26 +44,27 @@ public:
 	 * Performs the conversion of the finite automaton to right regular grammar.
 	 *
 	 * \tparam SymbolType the type of input/terminal symbols of automaton and the resulting grammar
-	 * \tparam StateNonterminalType the type of states of the automaton and nonterminal symbols of the resulting grammar
+	 * \tparam StateType the type of states of the automaton and nonterminal symbols of the resulting grammar
 	 *
 	 * \param automaton a finite automaton to convert
 	 *
 	 * \return right regular grammar equivalent to the source @p automaton.
 	 */
-	template < class SymbolType, class StateNonterminalType >
-	static grammar::RightRG < SymbolType, StateNonterminalType > convert ( const automaton::NFA < SymbolType, StateNonterminalType > & automaton );
+	template < class SymbolType, class StateType >
+	static grammar::RightRG < SymbolType, StateType > convert ( const automaton::NFA < SymbolType, StateType > & automaton );
 
 	/**
 	 * \overload
 	 */
-	template < class SymbolType, class StateNonterminalType >
-	static grammar::RightRG < SymbolType, StateNonterminalType > convert ( const automaton::DFA < SymbolType, StateNonterminalType > & automaton );
+	template < class SymbolType, class StateType >
+	static grammar::RightRG < SymbolType, StateType > convert ( const automaton::DFA < SymbolType, StateType > & automaton );
 };
 
 
-template < class SymbolType, class StateNonterminalType >
-grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ( const automaton::NFA < SymbolType, StateNonterminalType > & automaton ) {
-	grammar::RightRG < SymbolType, StateNonterminalType > grammar ( automaton.getInitialState ( ) );
+template < class SymbolType, class StateType >
+grammar::RightRG < SymbolType, StateType > ToGrammarRightRG::convert ( const automaton::NFA < SymbolType, StateType > & automaton ) {
+	// step 3 - set start symbol of G
+	grammar::RightRG < SymbolType, StateType > grammar ( automaton.getInitialState ( ) );
 
 	grammar.setTerminalAlphabet ( automaton.getInputAlphabet ( ) );
 	grammar.setNonterminalAlphabet ( automaton.getStates ( ) );
@@ -80,9 +81,6 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert
 		}
 	}
 
-	// step 3 - set start symbol of G
-	grammar.setInitialSymbol(automaton.getInitialState());
-
 	// step 4
 	if(automaton.getFinalStates().count(automaton.getInitialState()))
 		grammar.setGeneratesEpsilon(true); // okay this feature makes the algorithm a bit different but at the same time it simplifies the code :))
@@ -90,9 +88,10 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert
 	return grammar;
 }
 
-template < class SymbolType, class StateNonterminalType >
-grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ( const automaton::DFA < SymbolType, StateNonterminalType > & automaton ) {
-	grammar::RightRG < SymbolType, StateNonterminalType > grammar ( automaton.getInitialState ( ) );
+template < class SymbolType, class StateType >
+grammar::RightRG < SymbolType, StateType > ToGrammarRightRG::convert ( const automaton::DFA < SymbolType, StateType > & automaton ) {
+	// step 3 - set start symbol of G
+	grammar::RightRG < SymbolType, StateType > grammar ( automaton.getInitialState ( ) );
 
 	grammar.setTerminalAlphabet ( automaton.getInputAlphabet ( ) );
 	grammar.setNonterminalAlphabet ( automaton.getStates ( ) );
@@ -108,9 +107,6 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert
 			grammar.addRule(from, input);
 	}
 
-	// step 3 - set start symbol of G
-	grammar.setInitialSymbol ( automaton.getInitialState ( ) );
-
 	// step 4
 	if ( automaton.getFinalStates ( ).count ( automaton.getInitialState ( ) ) )
 		grammar.setGeneratesEpsilon(true); // okay this feature makes the algorithm a bit different but at the same time it simplifies the code :))
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
index 63c31922c36469aac91c9333bd0df88b11077ee1..320462b1bd0331384f7d4140821e7692dbe61b74 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.h
@@ -36,24 +36,24 @@ class SimpleRulesRemover {
 	static T removeNonEpsilonFree( const T & origGrammar );
 
 public:
-	template < class SymbolType >
-	static grammar::CFG < SymbolType > remove( const grammar::CFG < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::EpsilonFreeCFG < SymbolType > remove( const grammar::EpsilonFreeCFG < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::GNF < SymbolType > remove( const grammar::GNF < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::CNF < SymbolType > remove( const grammar::CNF < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::LG < SymbolType > remove( const grammar::LG < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::LeftLG < SymbolType > remove( const grammar::LeftLG < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::LeftRG < SymbolType > remove( const grammar::LeftRG < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::RightLG < SymbolType > remove( const grammar::RightLG < SymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::RightRG < SymbolType > remove( const grammar::RightRG < SymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::CFG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::GNF < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::CNF < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::LG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 };
 
 template < class T, class TerminalSymbolType, class NonterminalSymbolType >
@@ -82,14 +82,14 @@ T SimpleRulesRemover::removeNonEpsilonFree( const T & origGrammar ) {
 	return grammar;
 }
 
-template < class SymbolType >
-grammar::CFG < SymbolType > SimpleRulesRemover::remove(const grammar::CFG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::CFG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
 
-template < class SymbolType >
-grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar) {
-	grammar::EpsilonFreeCFG < SymbolType > grammar(origGrammar.getInitialSymbol());
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
+	grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > grammar(origGrammar.getInitialSymbol());
 
 	for( const auto & symbol : origGrammar.getNonterminalAlphabet() )
 		grammar.addNonterminalSymbol( symbol );
@@ -98,7 +98,7 @@ grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar:
 		grammar.addTerminalSymbol( symbol );
 
 	for( const auto & symbol : origGrammar.getNonterminalAlphabet() ) {
-		ext::set<SymbolType> simpleRulesClosure = grammar::properties::NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle(origGrammar, symbol);
+		ext::set < NonterminalSymbolType > simpleRulesClosure = grammar::properties::NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle ( origGrammar, symbol );
 		for( const auto & closureSymbol : simpleRulesClosure ) {
 			auto rules = origGrammar.getRules().find(closureSymbol);
 			if(rules != origGrammar.getRules().end()) for( const auto& rawRule : rules->second ) {
@@ -113,38 +113,38 @@ grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar:
 	return grammar;
 }
 
-template < class SymbolType >
-grammar::CNF < SymbolType > SimpleRulesRemover::remove(const grammar::CNF < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::CNF < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return origGrammar;
 }
 
-template < class SymbolType >
-grammar::GNF < SymbolType > SimpleRulesRemover::remove(const grammar::GNF < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return origGrammar;
 }
 
-template < class SymbolType >
-grammar::LG < SymbolType > SimpleRulesRemover::remove(const grammar::LG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::LG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
 
-template < class SymbolType >
-grammar::LeftLG < SymbolType > SimpleRulesRemover::remove(const grammar::LeftLG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
 
-template < class SymbolType >
-grammar::LeftRG < SymbolType > SimpleRulesRemover::remove(const grammar::LeftRG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return origGrammar;
 }
 
-template < class SymbolType >
-grammar::RightLG < SymbolType > SimpleRulesRemover::remove(const grammar::RightLG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
 
-template < class SymbolType >
-grammar::RightRG < SymbolType > SimpleRulesRemover::remove(const grammar::RightRG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return origGrammar;
 }
 
diff --git a/alib2algo/src/grammar/simplify/ToGNF.h b/alib2algo/src/grammar/simplify/ToGNF.h
index c233a2d6de1aad02b681e26da02c71de5909b1c4..a441a997fff77a82e1812ca7015cbb7b516c7d4c 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.h
+++ b/alib2algo/src/grammar/simplify/ToGNF.h
@@ -44,18 +44,18 @@ public:
 	static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 	template < class TerminalSymbolType, class NonterminalSymbolType >
 	static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::GNF < SymbolType > convert( const grammar::GNF < SymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::GNF < TerminalSymbolType, NonterminalSymbolType > convert( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
 	template < class TerminalSymbolType, class NonterminalSymbolType >
 	static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 	template < class TerminalSymbolType, class NonterminalSymbolType >
 	static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::RightRG < SymbolType > convert( const grammar::LeftRG < SymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > convert( const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 	template < class TerminalSymbolType, class NonterminalSymbolType >
 	static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
-	template < class SymbolType >
-	static grammar::RightRG < SymbolType > convert( const grammar::RightRG < SymbolType > & grammar );
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > convert( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 };
 
 template < class TerminalSymbolType, class NonterminalSymbolType >
@@ -145,8 +145,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina
 	return convertInternal(grammar::simplify::LeftRecursionRemover::remove(origGrammar));
 }
 
-template < class SymbolType >
-grammar::GNF < SymbolType > ToGNF::convert(const grammar::GNF < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::GNF < TerminalSymbolType, NonterminalSymbolType > ToGNF::convert(const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return origGrammar;
 }
 
@@ -160,8 +160,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
 }
 
-template < class SymbolType >
-grammar::RightRG < SymbolType > ToGNF::convert(const grammar::LeftRG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > ToGNF::convert(const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return convert::ToGrammarRightRG::convert(origGrammar);
 }
 
@@ -170,8 +170,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
 }
 
-template < class SymbolType >
-grammar::RightRG < SymbolType > ToGNF::convert(const grammar::RightRG < SymbolType > & origGrammar) {
+template < class TerminalSymbolType, class NonterminalSymbolType >
+grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > ToGNF::convert(const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
 	return origGrammar;
 }