diff --git a/alib2algo/src/grammar/convert/ToRegExp.h b/alib2algo/src/grammar/convert/ToRegExp.h
index 4fde2da9231a4f8ec7951fbbc14128db31ec6d54..88a8ed8aa390817f94bbf2bebda41a3ac3b26ba5 100644
--- a/alib2algo/src/grammar/convert/ToRegExp.h
+++ b/alib2algo/src/grammar/convert/ToRegExp.h
@@ -23,20 +23,20 @@ public:
 	 * @return regexp equivalent to source right regular grammar.
 	 * @param grammar Grammar to convert
 	 */
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static regexp::UnboundedRegExp < TerminalSymbolType > convert ( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
 	template < class SymbolType >
-	static regexp::UnboundedRegExp < > convert(const grammar::RightRG < SymbolType > & grammar);
-	template < class SymbolType >
-	static regexp::UnboundedRegExp < > convert(const grammar::LeftRG < SymbolType > & grammar);
+	static regexp::UnboundedRegExp < > convert ( const grammar::LeftRG < SymbolType > & grammar );
 };
 
-template < class SymbolType >
-regexp::UnboundedRegExp < > ToRegExp::convert(const grammar::RightRG < SymbolType > & grammar) {
-	return ToRegExpAlgebraic::convert(grammar);
+template < class TerminalSymbolType, class NonterminalSymbolType >
+regexp::UnboundedRegExp < TerminalSymbolType > ToRegExp::convert ( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar ) {
+	return ToRegExpAlgebraic::convert ( grammar );
 }
 
 template < class SymbolType >
-regexp::UnboundedRegExp < > ToRegExp::convert(const grammar::LeftRG < SymbolType > & grammar) {
-	return ToRegExpAlgebraic::convert(grammar);
+regexp::UnboundedRegExp < > ToRegExp::convert ( const grammar::LeftRG < SymbolType > & grammar ) {
+	return ToRegExpAlgebraic::convert ( grammar );
 }
 
 } /* namespace covert */
diff --git a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
index 3818fe096524ff5677a3f4312fd6bb02e7042e78..923585981370d781bac96f76943568b829c631e0 100644
--- a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
@@ -27,8 +27,8 @@ public:
 	 * @return regexp equivalent to source right regular grammar.
 	 * @param grammar Grammar to convert
 	 */
-	template < class SymbolType >
-	static regexp::UnboundedRegExp < SymbolType > convert(const grammar::RightRG < SymbolType > & grammar);
+	template < class TerminalSymbolType, class NonterminalSymbolType >
+	static regexp::UnboundedRegExp < TerminalSymbolType > convert ( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar);
 	template < class SymbolType >
 	static regexp::UnboundedRegExp < SymbolType > convert(const grammar::LeftRG < SymbolType > & grammar);
 };
@@ -58,29 +58,29 @@ regexp::UnboundedRegExp < SymbolType > ToRegExpAlgebraic::convert(const grammar:
 	return solver.solve(grammar.getInitialSymbol());
 }
 
-template < class SymbolType >
-regexp::UnboundedRegExp < SymbolType > ToRegExpAlgebraic::convert(const grammar::RightRG < SymbolType > & grammar) {
-	equations::RightRegularEquationSolver < SymbolType, SymbolType > solver;
+template < class TerminalSymbolType, class NonterminalSymbolType >
+regexp::UnboundedRegExp < TerminalSymbolType > ToRegExpAlgebraic::convert ( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar) {
+	equations::RightRegularEquationSolver < TerminalSymbolType, NonterminalSymbolType > solver;
 
 	solver.setVariableSymbols(grammar.getNonterminalAlphabet());
 
 	for(const auto & rule : grammar.getRules()) {
-		const SymbolType& lhs = rule.first;
+		const NonterminalSymbolType & lhs = rule.first;
 
 		for(const auto& ruleRHS : rule.second) {
-			if(ruleRHS.template is<SymbolType>()) {
-				const SymbolType& rhs = ruleRHS.template get<SymbolType>();
-				solver.addEquation(lhs, regexp::UnboundedRegExpSymbol < SymbolType > (rhs));
+			if ( ruleRHS.template is < TerminalSymbolType > ( ) ) {
+				const TerminalSymbolType & rhs = ruleRHS.template get < TerminalSymbolType > ( );
+				solver.addEquation ( lhs, regexp::UnboundedRegExpSymbol < TerminalSymbolType > ( rhs ) );
 			} else {
-				const ext::pair<SymbolType, SymbolType>& rhs = ruleRHS.template get<ext::pair<SymbolType, SymbolType>>();
-				solver.addEquation(lhs, rhs.second, regexp::UnboundedRegExpSymbol < SymbolType > (rhs.first));
+				const ext::pair < TerminalSymbolType, NonterminalSymbolType > & rhs = ruleRHS.template get < ext::pair < TerminalSymbolType, NonterminalSymbolType > > ( );
+				solver.addEquation ( lhs, rhs.second, regexp::UnboundedRegExpSymbol < TerminalSymbolType > ( rhs.first ) );
 			}
 		}
 	}
 	if(grammar.getGeneratesEpsilon())
-		solver.addEquation(grammar.getInitialSymbol(), regexp::UnboundedRegExpEpsilon < SymbolType > ());
+		solver.addEquation ( grammar.getInitialSymbol ( ), regexp::UnboundedRegExpEpsilon < TerminalSymbolType > ( ) );
 
-	return solver.solve(grammar.getInitialSymbol());
+	return solver.solve ( grammar.getInitialSymbol ( ) );
 }
 
 } /* namespace covert */