diff --git a/alib2abstraction/src/abstraction/NormalizeAbstraction.hpp b/alib2abstraction/src/abstraction/NormalizeAbstraction.hpp
index a007a0a43eeaacbf87611556e7c8ffa0e0052e43..e81156b1d5b715243923754db5f3f5b4057a5534 100644
--- a/alib2abstraction/src/abstraction/NormalizeAbstraction.hpp
+++ b/alib2abstraction/src/abstraction/NormalizeAbstraction.hpp
@@ -10,7 +10,7 @@
 
 #include <abstraction/UnaryOperationAbstraction.hpp>
 
-#include <core/normalize.hpp>
+#include <factory/NormalizeFactory.hpp>
 
 namespace abstraction {
 
@@ -24,7 +24,10 @@ public:
 		if ( this->cached ( ) )
 			return true;
 
-		this->m_data = core::normalize < ParamType >::eval ( std::get < 0 > ( this->m_params )->getValue ( std::get < 0 > ( this->m_moves ) ) );
+		ParamType && param = std::get < 0 > ( this->m_params )->getValue ( std::get < 0 > ( this->m_moves ) );
+		ReturnType res = factory::NormalizeFactory::normalize ( std::move ( param ) );
+
+		this->m_data = std::move ( res );
 
 		return true;
 	}
diff --git a/alib2abstraction/src/core/normalize.hpp b/alib2abstraction/src/core/normalize.hpp
index 29b83061cb983ed4217f351a8f7d81c76a6c5e5b..3e56351d05da79cd0dd5daf3befdd8e1ad610e5b 100644
--- a/alib2abstraction/src/core/normalize.hpp
+++ b/alib2abstraction/src/core/normalize.hpp
@@ -10,15 +10,11 @@
 
 namespace core {
 
-template < typename T, typename Enable = void >
+template < typename T >
 struct normalize { };
 
-template < typename Type >
-struct normalize < Type, typename std::enable_if < std::is_same < Type, typename Type::normalized_type >::value >::type > {
-	static Type && eval ( Type && value ) {
-		return std::move ( value );
-	}
-};
+template < class ReturnType >
+using normalizationResult = typename std::decay < typename std::result_of < decltype ( & core::normalize < ReturnType >::eval ) ( ReturnType && ) >::type >::type;
 
 } /* namespace core */
 
diff --git a/alib2abstraction/src/factory/NormalizeFactory.hpp b/alib2abstraction/src/factory/NormalizeFactory.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f4be5e06b38dd6ab79c500722035863ce793ccd2
--- /dev/null
+++ b/alib2abstraction/src/factory/NormalizeFactory.hpp
@@ -0,0 +1,48 @@
+/*
+ * NormalizeFactory.hpp
+ *
+ *  Created on: Jan 1, 2014
+ *      Author: Jan Travnicek
+ */
+
+#ifndef NORMALIZE_FACTORY_HPP
+#define NORMALIZE_FACTORY_HPP
+
+#include <alib/type_traits>
+#include <utility>
+
+#include <core/normalize.hpp>
+
+namespace factory {
+
+class NormalizeFactory {
+public:
+	template < class SourceType >
+	class normalizer {
+		SourceType && m_source;
+
+	public:
+		normalizer ( SourceType && source ) : m_source ( std::move ( source ) ) {
+		}
+
+		template < class TargetType, typename std::enable_if < std::is_same < TargetType, SourceType >::value >::type * = nullptr >
+		operator TargetType ( ) {
+			return TargetType ( std::move ( m_source ) );
+		}
+
+		template < class TargetType, typename std::enable_if < ! std::is_same < TargetType, SourceType >::value >::type * = nullptr >
+		operator TargetType ( ) {
+			return core::normalize < SourceType >::eval ( std::move ( m_source ) );
+		}
+	};
+
+	template < class SourceType >
+	static normalizer < SourceType > normalize ( SourceType && source ) {
+		return normalizer < SourceType > ( std::move ( source ) );
+	}
+
+};
+
+} /* namespace factory */
+
+#endif /* NORMALIZE_FACTORY_HPP */
diff --git a/alib2abstraction/src/registration/NormalizationRegistration.hpp b/alib2abstraction/src/registration/NormalizationRegistration.hpp
index c15c02771661be0f98f49a91c4cb5b401db3a071..78a41442220a177489e3488f3cd9eed8c2f0f96a 100644
--- a/alib2abstraction/src/registration/NormalizationRegistration.hpp
+++ b/alib2abstraction/src/registration/NormalizationRegistration.hpp
@@ -17,7 +17,7 @@ public:
 };
 
 template < class ReturnType >
-class NormalizationRegister < ReturnType, typename std::enable_if < ! std::is_same < ReturnType, typename ReturnType::normalized_type >::value >::type > {
+class NormalizationRegister < ReturnType, typename std::enable_if < ! std::is_same < ReturnType, core::normalizationResult < ReturnType > >::value >::type > {
 public:
 	NormalizationRegister ( ) {
 		abstraction::NormalizeRegistry::registerNormalize < ReturnType > ( );
diff --git a/alib2abstraction/src/registry/NormalizeRegistry.hpp b/alib2abstraction/src/registry/NormalizeRegistry.hpp
index bd545349b5b32cbfbcc99f3b2e1e56f82b9721e3..33e2e963dbeadcc6cc3c604e2b4f40a32591dd9e 100644
--- a/alib2abstraction/src/registry/NormalizeRegistry.hpp
+++ b/alib2abstraction/src/registry/NormalizeRegistry.hpp
@@ -14,6 +14,8 @@
 
 #include <abstraction/OperationAbstraction.hpp>
 
+#include <core/normalize.hpp>
+
 namespace abstraction {
 
 class NormalizeRegistry {
@@ -68,7 +70,7 @@ namespace abstraction {
 
 template < class Param >
 std::shared_ptr < abstraction::OperationAbstraction > NormalizeRegistry::EntryImpl < Param >::getAbstraction ( ) const {
-	return std::make_shared < NormalizeAbstraction < typename Param::normalized_type, Param > > ( );
+	return std::make_shared < NormalizeAbstraction < core::normalizationResult < Param >, Param > > ( );
 }
 
 } /* namespace abstraction */
diff --git a/alib2common/src/container/ObjectsDeque.h b/alib2common/src/container/ObjectsDeque.h
index fa84ce3d973c6dcfc3911f0cacfccb48b0cbd461..aa421c50eccd4652fb80e9538a16b6d1a9fe562d 100644
--- a/alib2common/src/container/ObjectsDeque.h
+++ b/alib2common/src/container/ObjectsDeque.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -49,8 +49,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsDeque < > normalized_type;
 };
 
 template < class ElementType >
@@ -99,27 +97,20 @@ object::ObjectBase* ObjectsDeque < ElementType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::deque < object::Object > > {
-	static ext::deque < object::Object > && eval ( ext::deque < object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class ElementType >
 struct normalize < ext::deque < ElementType > > {
 	static ext::deque < object::Object > eval ( ext::deque < ElementType > && source ) {
 		ext::deque < object::Object > res;
 
 		for ( ElementType & element : source )
-			res.push_back ( object::Object ( object::AnyObject < ElementType > ( std::move ( element ) ) ) );
+			res.push_back ( object::ObjectFactory::make ( std::move ( element ) ) );
 
 		return res;
 	}
 };
 
 template < class ElementType >
-struct normalize < container::ObjectsDeque < ElementType >, typename std::enable_if < ! std::is_same < container::ObjectsDeque < ElementType >, container::ObjectsDeque < > >::value >::type > {
+struct normalize < container::ObjectsDeque < ElementType > > {
 	static container::ObjectsDeque < > eval ( container::ObjectsDeque < ElementType > && value ) {
 		return container::ObjectsDeque < > ( normalize < ext::deque < ElementType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsList.h b/alib2common/src/container/ObjectsList.h
index e01f4be00852a8825ff3c8f3968ec5636fc81be1..693dbc2a8e7324473a5e5517d7f6ad2fe6fec7c2 100644
--- a/alib2common/src/container/ObjectsList.h
+++ b/alib2common/src/container/ObjectsList.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -49,8 +49,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsList < > normalized_type;
 };
 
 template < class ElementType >
@@ -99,27 +97,20 @@ object::ObjectBase* ObjectsList < ElementType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::list < object::Object > > {
-	static ext::list < object::Object > && eval ( ext::list < object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class ElementType >
 struct normalize < ext::list < ElementType > > {
 	static ext::list < object::Object > eval ( ext::list < ElementType > && source ) {
 		ext::list < object::Object > res;
 
 		for ( ElementType & element : source )
-			res.push_back ( object::Object ( object::AnyObject < ElementType > ( std::move ( element ) ) ) );
+			res.push_back ( object::ObjectFactory::make ( std::move ( element ) ) );
 
 		return res;
 	}
 };
 
 template < class ElementType >
-struct normalize < container::ObjectsList < ElementType >, typename std::enable_if < ! std::is_same < container::ObjectsList < ElementType >, container::ObjectsList < > >::value >::type > {
+struct normalize < container::ObjectsList < ElementType > > {
 	static container::ObjectsList < > eval ( container::ObjectsList < ElementType > && value ) {
 		return container::ObjectsList < > ( normalize < ext::list < ElementType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsMap.h b/alib2common/src/container/ObjectsMap.h
index dbb006dfabba7b8ba085fb385edaecf89c6c3e04..5f07f1c730fbdd5233c7c9d855988705dcad48d5 100644
--- a/alib2common/src/container/ObjectsMap.h
+++ b/alib2common/src/container/ObjectsMap.h
@@ -16,9 +16,10 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
+#include <container/ObjectsPair.h>
 
 namespace container {
 
@@ -49,8 +50,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsMap < > normalized_type;
 };
 
 template < class KeyType, class ValueType >
@@ -100,13 +99,6 @@ object::ObjectBase* ObjectsMap < KeyType, ValueType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::map < object::Object, object::Object > > {
-	static ext::map < object::Object, object::Object > && eval ( ext::map < object::Object, object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class KeyType, class ValueType >
 struct normalize < ext::map < KeyType, ValueType > > {
 	static ext::map < object::Object, object::Object > eval ( ext::map < KeyType, ValueType > && source ) {
@@ -120,7 +112,7 @@ struct normalize < ext::map < KeyType, ValueType > > {
 };
 
 template < class KeyType, class ValueType >
-struct normalize < container::ObjectsMap < KeyType, ValueType >, typename std::enable_if < ! std::is_same < container::ObjectsMap < KeyType, ValueType >, container::ObjectsMap < > >::value >::type > {
+struct normalize < container::ObjectsMap < KeyType, ValueType > > {
 	static container::ObjectsMap < > eval ( container::ObjectsMap < KeyType, ValueType > && value ) {
 		return container::ObjectsMap < > ( normalize < ext::map < KeyType, ValueType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsPair.h b/alib2common/src/container/ObjectsPair.h
index a33f7b39763c75b6829ed09409f9cdb00f6bae3d..138bd26edb35204ccbb00cc016d5eaa7a9adbed1 100644
--- a/alib2common/src/container/ObjectsPair.h
+++ b/alib2common/src/container/ObjectsPair.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -49,8 +49,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsPair < > normalized_type;
 };
 
 template < class FirstType, class SecondType >
@@ -100,36 +98,22 @@ object::ObjectBase* ObjectsPair < FirstType, SecondType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < std::pair < object::Object, object::Object > > {
-	static std::pair < object::Object, object::Object > && eval ( std::pair < object::Object, object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class FirstType, class SecondType >
 struct normalize < std::pair < FirstType, SecondType > > {
 	static std::pair < object::Object, object::Object > eval ( std::pair < FirstType, SecondType > && source ) {
-		return std::make_pair ( object::Object ( object::AnyObject < FirstType > ( std::move ( source.first ) ) ), object::Object ( object::AnyObject < SecondType > ( std::move ( source.second ) ) ) );
-	}
-};
-
-template < >
-struct normalize < ext::pair < object::Object, object::Object > > {
-	static ext::pair < object::Object, object::Object > && eval ( ext::pair < object::Object, object::Object > && source ) {
-		return std::move ( source );
+		return std::make_pair ( object::ObjectFactory::make ( std::move ( source.first ) ), object::ObjectFactory::make ( std::move ( source.second ) ) );
 	}
 };
 
 template < class FirstType, class SecondType >
 struct normalize < ext::pair < FirstType, SecondType > > {
 	static ext::pair < object::Object, object::Object > eval ( ext::pair < FirstType, SecondType > && source ) {
-		return ext::make_pair ( object::Object ( object::AnyObject < FirstType > ( std::move ( source.first ) ) ), object::Object ( object::AnyObject < SecondType > ( std::move ( source.second ) ) ) );
+		return ext::make_pair ( object::ObjectFactory::make ( std::move ( source.first ) ), object::ObjectFactory::make ( std::move ( source.second ) ) );
 	}
 };
 
 template < class FirstType, class SecondType >
-struct normalize < container::ObjectsPair < FirstType, SecondType >, typename std::enable_if < ! std::is_same < container::ObjectsPair < FirstType, SecondType >, container::ObjectsPair < > >::value >::type > {
+struct normalize < container::ObjectsPair < FirstType, SecondType > > {
 	static container::ObjectsPair < > eval ( container::ObjectsPair < FirstType, SecondType > && value ) {
 		return container::ObjectsPair < > ( normalize < ext::pair < FirstType, SecondType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsSet.h b/alib2common/src/container/ObjectsSet.h
index b885f931d9b11893b72ef3b0a88a92b8719483f8..0bddd728ddba652c5f7c817a923f36c270ad10f2 100644
--- a/alib2common/src/container/ObjectsSet.h
+++ b/alib2common/src/container/ObjectsSet.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -49,8 +49,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsSet < > normalized_type;
 };
 
 template < class ElementType >
@@ -100,27 +98,20 @@ object::ObjectBase* ObjectsSet < ElementType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::set < object::Object > > {
-	static ext::set < object::Object > && eval ( ext::set < object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class ElementType >
 struct normalize < ext::set < ElementType > > {
 	static ext::set < object::Object > eval ( ext::set < ElementType > && source ) {
 		ext::set < object::Object > res;
 
 		for ( ElementType && element : ext::make_moveable_set ( source ) )
-			res.insert ( object::Object ( object::AnyObject < ElementType > ( std::move ( element ) ) ) );
+			res.insert ( object::ObjectFactory::make ( std::move ( element ) ) );
 
 		return res;
 	}
 };
 
 template < class ElementType >
-struct normalize < container::ObjectsSet < ElementType >, typename std::enable_if < ! std::is_same < container::ObjectsSet < ElementType >, container::ObjectsSet < > >::value >::type > {
+struct normalize < container::ObjectsSet < ElementType > > {
 	static container::ObjectsSet < > eval ( container::ObjectsSet < ElementType > && value ) {
 		return container::ObjectsSet < > ( normalize < ext::set < ElementType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsTree.h b/alib2common/src/container/ObjectsTree.h
index a5d3fb3ffa576094d974b98eefe9b788546de37c..09a2b7d2afbca79f59d5e9a70b2214fb8e451135 100644
--- a/alib2common/src/container/ObjectsTree.h
+++ b/alib2common/src/container/ObjectsTree.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -48,8 +48,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsTree < > normalized_type;
 };
 
 template < class ElementType >
@@ -94,13 +92,6 @@ object::ObjectBase* ObjectsTree < ElementType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::tree < object::Object > > {
-	static ext::tree < object::Object > && eval ( ext::tree < object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class ElementType >
 struct normalize < ext::tree < ElementType > > {
 	static ext::tree < object::Object > eval ( ext::tree < ElementType > && source ) {
@@ -110,12 +101,12 @@ struct normalize < ext::tree < ElementType > > {
 			children.push_back ( normalize < ext::tree < ElementType > >::eval ( std::move ( child ) ) );
 		}
 
-		return ext::tree < object::Object > ( object::Object ( object::AnyObject < ElementType > ( std::move ( source.getData ( ) ) ) ), std::move ( children ) );
+		return ext::tree < object::Object > ( object::ObjectFactory::make ( std::move ( source.getData ( ) ) ), std::move ( children ) );
 	}
 };
 
 template < class ElementType >
-struct normalize < container::ObjectsTree < ElementType >, typename std::enable_if < ! std::is_same < container::ObjectsTree < ElementType >, container::ObjectsTree < > >::value >::type > {
+struct normalize < container::ObjectsTree < ElementType > > {
 	static container::ObjectsTree < > eval ( container::ObjectsTree < ElementType > && value ) {
 		return container::ObjectsTree < > ( normalize < ext::tree < ElementType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsTrie.h b/alib2common/src/container/ObjectsTrie.h
index 0242a19212192ee7d79abeb29bafa502da648c43..6c0c81d57e81ddbdb748fcec0edc23d4309e3ccb 100644
--- a/alib2common/src/container/ObjectsTrie.h
+++ b/alib2common/src/container/ObjectsTrie.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -48,8 +48,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsTrie < > normalized_type;
 };
 
 template < class KeyType, class ValueType >
@@ -94,28 +92,21 @@ object::ObjectBase* ObjectsTrie < KeyType, ValueType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::trie < object::Object, object::Object > > {
-	static ext::trie < object::Object, object::Object > && eval ( ext::trie < object::Object, object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class KeyType, class ValueType >
 struct normalize < ext::trie < KeyType, ValueType > > {
 	static ext::trie < object::Object, object::Object > eval ( ext::trie < KeyType, ValueType > && source ) {
 		ext::map < object::Object, ext::trie < object::Object, object::Object > > children;
 
 		for ( std::pair < KeyType, ext::trie < KeyType, ValueType > > && child : ext::make_moveable_map ( source.getChildren ( ) ) ) {
-			children.insert ( std::make_pair ( object::Object ( object::AnyObject < KeyType > ( std::move ( child.first ) ) ), normalizeRaw ( std::move ( child.second ) ) ) );
+			children.insert ( std::make_pair ( object::ObjectFactory::make ( std::move ( child.first ) ), normalize < ext::trie < KeyType, ValueType > >::eval ( std::move ( child.second ) ) ) );
 		}
 
-		return ext::trie < object::Object, object::Object > ( object::Object ( object::AnyObject < ValueType > ( std::move ( source.getData ( ) ) ) ), std::move ( children ) );
+		return ext::trie < object::Object, object::Object > ( object::ObjectFactory::make ( std::move ( source.getData ( ) ) ), std::move ( children ) );
 	}
 };
 
 template < class KeyType, class ValueType >
-struct normalize < container::ObjectsTrie < KeyType, ValueType >, typename std::enable_if < ! std::is_same < container::ObjectsTrie < KeyType, ValueType >, container::ObjectsTrie < > >::value >::type > {
+struct normalize < container::ObjectsTrie < KeyType, ValueType > > {
 	static container::ObjectsTrie < > eval ( container::ObjectsTrie < KeyType, ValueType > && value ) {
 		return container::ObjectsTrie < > ( normalize < ext::trie < KeyType, ValueType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/src/container/ObjectsVector.h b/alib2common/src/container/ObjectsVector.h
index 2ca9f779d71e7f0c6cb667eeb0355a6448ea14fe..dc9685716566e0d6728e5ea02b0898c033fdf1b7 100644
--- a/alib2common/src/container/ObjectsVector.h
+++ b/alib2common/src/container/ObjectsVector.h
@@ -16,7 +16,7 @@
 #include "ContainerFeatures.h"
 
 #include <object/UniqueObject.h>
-#include <object/AnyObject.h>
+#include <object/ObjectFactory.h>
 
 #include <core/normalize.hpp>
 
@@ -49,8 +49,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef ObjectsVector < > normalized_type;
 };
 
 template < class ElementType >
@@ -99,27 +97,20 @@ object::ObjectBase* ObjectsVector < ElementType >::inc() && {
 
 namespace core {
 
-template < >
-struct normalize < ext::vector < object::Object > > {
-	static ext::vector < object::Object > && eval ( ext::vector < object::Object > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class ElementType >
 struct normalize < ext::vector < ElementType > > {
 	static ext::vector < object::Object > eval ( ext::vector < ElementType > && source ) {
 		ext::vector < object::Object > res;
 
 		for ( ElementType & element : source )
-			res.push_back ( object::Object ( object::AnyObject < ElementType > ( std::move ( element ) ) ) );
+			res.push_back ( object::ObjectFactory::make ( std::move ( element ) ) );
 
 		return res;
 	}
 };
 
 template < class ElementType >
-struct normalize < container::ObjectsVector < ElementType >, typename std::enable_if < ! std::is_same < container::ObjectsVector < ElementType >, container::ObjectsVector < > >::value >::type > {
+struct normalize < container::ObjectsVector < ElementType > > {
 	static container::ObjectsVector < > eval ( container::ObjectsVector < ElementType > && value ) {
 		return container::ObjectsVector < > ( normalize < ext::vector < ElementType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2common/test-src/container/ContainerTest.cpp b/alib2common/test-src/container/ContainerTest.cpp
index d51f6ee45d3b1c10baa1b8f160cd79f8c9000344..f06c5aee22d939e3b63d168de8e74e0213c42c66 100644
--- a/alib2common/test-src/container/ContainerTest.cpp
+++ b/alib2common/test-src/container/ContainerTest.cpp
@@ -3,6 +3,10 @@
 #include "object/Object.h"
 #include "container/ObjectsSet.h"
 #include "container/ObjectsDeque.h"
+#include "container/ObjectsVector.h"
+#include "container/ObjectsMap.h"
+#include "container/ObjectsTree.h"
+#include "container/ObjectsTrie.h"
 
 #include <alib/type_traits>
 
@@ -27,4 +31,20 @@ void ContainerTest::testNormalize ( ) {
 	container::ObjectsDeque < int > Dint;
 	container::ObjectsDeque < object::Object > Dnor = core::normalize < container::ObjectsDeque < int > >::eval ( std::move ( Dint ) );
 	container::ObjectsDeque < object::Object > Dnor2 = core::normalize < container::ObjectsDeque < object::Object > >::eval ( std::move ( Dnor ) );
+
+	container::ObjectsVector < int > Vint;
+	container::ObjectsVector < object::Object > Vnor = core::normalize < container::ObjectsVector < int > >::eval ( std::move ( Vint ) );
+	container::ObjectsVector < object::Object > Vnor2 = core::normalize < container::ObjectsVector < object::Object > >::eval ( std::move ( Vnor ) );
+
+	container::ObjectsMap < int, int > Mintint;
+	container::ObjectsMap < object::Object, object::Object > Mnor = core::normalize < container::ObjectsMap < int, int > >::eval ( std::move ( Mintint ) );
+	container::ObjectsMap < object::Object, object::Object > Mnor2 = core::normalize < container::ObjectsMap < object::Object, object::Object > >::eval ( std::move ( Mnor ) );
+
+	container::ObjectsTree < int > Tint ( 1 );
+	container::ObjectsTree < object::Object > Tnor = core::normalize < container::ObjectsTree < int > >::eval ( std::move ( Tint ) );
+	container::ObjectsTree < object::Object > Tnor2 = core::normalize < container::ObjectsTree < object::Object > >::eval ( std::move ( Tnor ) );
+
+	container::ObjectsTrie < int, int > Rintint ( 1 );
+	container::ObjectsTrie < object::Object, object::Object > Rnor = core::normalize < container::ObjectsTrie < int, int > >::eval ( std::move ( Rintint ) );
+	container::ObjectsTrie < object::Object, object::Object > Rnor2 = core::normalize < container::ObjectsTrie < object::Object, object::Object > >::eval ( std::move ( Rnor ) );
 }
diff --git a/alib2data/src/alphabet/BarSymbol.h b/alib2data/src/alphabet/BarSymbol.h
index 0c8de693ae6e54dd822028a518682af9e43024c6..1c76552091a4bb5f1e0315f72a828d443ee436e5 100644
--- a/alib2data/src/alphabet/BarSymbol.h
+++ b/alib2data/src/alphabet/BarSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef BarSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/BlankSymbol.h b/alib2data/src/alphabet/BlankSymbol.h
index b60dbb847732e38323c5afef1b069af8e67fb022..8872d0ceb0c8bf2eba842826abb8bdb5726f6d0d 100644
--- a/alib2data/src/alphabet/BlankSymbol.h
+++ b/alib2data/src/alphabet/BlankSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef BlankSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/BottomOfTheStackSymbol.h b/alib2data/src/alphabet/BottomOfTheStackSymbol.h
index 18ed29a634814729ce33148dd0aa8b705cc35b1a..17f79e95d5998b7d711303ae4011c04e2f67f3e8 100644
--- a/alib2data/src/alphabet/BottomOfTheStackSymbol.h
+++ b/alib2data/src/alphabet/BottomOfTheStackSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef BottomOfTheStackSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/EndSymbol.h b/alib2data/src/alphabet/EndSymbol.h
index 217abbe51b59dba728713a3a00211d7a1d888e00..88ec81d2965bb5e86928a45ac3d36b71627686ef 100644
--- a/alib2data/src/alphabet/EndSymbol.h
+++ b/alib2data/src/alphabet/EndSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef EndSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/InitialSymbol.h b/alib2data/src/alphabet/InitialSymbol.h
index a31721e96127c1567e7c6678b3986b21480081f5..1e4bf6665e4e2086e34323b5fefc7188a8e94885 100644
--- a/alib2data/src/alphabet/InitialSymbol.h
+++ b/alib2data/src/alphabet/InitialSymbol.h
@@ -48,8 +48,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef InitialSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/LabeledSymbol.h b/alib2data/src/alphabet/LabeledSymbol.h
index f9f8ebf8b6ff115c58a9089d571cdd7c5a5b4be6..e4f9593545a8f035cd8156ad9f8ac59d32a64ebc 100644
--- a/alib2data/src/alphabet/LabeledSymbol.h
+++ b/alib2data/src/alphabet/LabeledSymbol.h
@@ -54,8 +54,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef LabeledSymbol normalized_type;
 };
 
 } /* namespace alphabet */
diff --git a/alib2data/src/alphabet/NonlinearVariableSymbol.h b/alib2data/src/alphabet/NonlinearVariableSymbol.h
index ddaf8179ca737e8a830e0fde9647a16659940722..e454590ab448703f2fa7cf475a48eb01858bca6d 100644
--- a/alib2data/src/alphabet/NonlinearVariableSymbol.h
+++ b/alib2data/src/alphabet/NonlinearVariableSymbol.h
@@ -54,8 +54,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef NonlinearVariableSymbol < > normalized_type;
 };
 
 template < class SymbolType >
@@ -109,7 +107,7 @@ SymbolBase * NonlinearVariableSymbol < SymbolType >::inc ( ) && {
 namespace core {
 
 template < class SymbolType >
-struct normalize < alphabet::NonlinearVariableSymbol < SymbolType >, typename std::enable_if < ! std::is_same < alphabet::NonlinearVariableSymbol < SymbolType >, alphabet::NonlinearVariableSymbol < > >::value >::type > {
+struct normalize < alphabet::NonlinearVariableSymbol < SymbolType > > {
 	static alphabet::NonlinearVariableSymbol < > eval ( alphabet::NonlinearVariableSymbol < SymbolType > && value ) {
 		return alphabet::NonlinearVariableSymbol < > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getSymbol ( ) ) );
 	}
diff --git a/alib2data/src/alphabet/RankedSymbol.h b/alib2data/src/alphabet/RankedSymbol.h
index 3f9ad024ea927ff5a5fb6dc689c637fa6e5d116e..59eddd8af32e9660a395221c0c32cce1627b3015 100644
--- a/alib2data/src/alphabet/RankedSymbol.h
+++ b/alib2data/src/alphabet/RankedSymbol.h
@@ -52,8 +52,6 @@ public:
 	using SymbolBase::operator >=;
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef RankedSymbol < > normalized_type;
 };
 
 template < class SymbolType, class RankType >
@@ -92,21 +90,14 @@ SymbolBase* RankedSymbol < SymbolType, RankType >::inc() && {
 namespace core {
 
 template < class SymbolType, class RankType >
-struct normalize < common::ranked_symbol < SymbolType, RankType >, typename std::enable_if < std::is_same < common::ranked_symbol < SymbolType, RankType >, common::ranked_symbol < > >::value >::type > {
-	static common::ranked_symbol < > && eval ( common::ranked_symbol < SymbolType, RankType > && value ) {
-		return std::move ( value );
-	}
-};
-
-template < class SymbolType, class RankType >
-struct normalize < common::ranked_symbol < SymbolType, RankType >, typename std::enable_if < ! std::is_same < common::ranked_symbol < SymbolType, RankType >, common::ranked_symbol < > >::value >::type > {
+struct normalize < common::ranked_symbol < SymbolType, RankType > > {
 	static common::ranked_symbol < > eval ( common::ranked_symbol < SymbolType, RankType > && value ) {
 		return alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ) );
 	}
 };
 
 template < class SymbolType, class RankType >
-struct normalize < alphabet::RankedSymbol < SymbolType, RankType >, typename std::enable_if < ! std::is_same < alphabet::RankedSymbol < SymbolType, RankType >, alphabet::RankedSymbol < > >::value >::type > {
+struct normalize < alphabet::RankedSymbol < SymbolType, RankType > > {
 	static alphabet::RankedSymbol < > eval ( alphabet::RankedSymbol < SymbolType, RankType > && value ) {
 		return alphabet::RankedSymbol < > ( normalize < common::ranked_symbol < SymbolType, RankType > >::eval ( std::move ( value ) ) );
 	}
diff --git a/alib2data/src/alphabet/StartSymbol.h b/alib2data/src/alphabet/StartSymbol.h
index aea90e3d7537e76e6fc9727542ebfa6413e6d12a..8b8546f3132511f24ede1a1c3cd08d4988d45738 100644
--- a/alib2data/src/alphabet/StartSymbol.h
+++ b/alib2data/src/alphabet/StartSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef StartSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/SubtreeWildcardSymbol.h b/alib2data/src/alphabet/SubtreeWildcardSymbol.h
index 863ee307a66e21e49faec3f7215813e023131a54..ecd47bd2e10775db29d4abbbe2cee03553434341 100644
--- a/alib2data/src/alphabet/SubtreeWildcardSymbol.h
+++ b/alib2data/src/alphabet/SubtreeWildcardSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef SubtreeWildcardSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/alphabet/UniqueSymbol.h b/alib2data/src/alphabet/UniqueSymbol.h
index f11e48bc574536051228686455b38f61467b99c0..50a9a00b2b81707063ddc1a76d56224b1396f52d 100644
--- a/alib2data/src/alphabet/UniqueSymbol.h
+++ b/alib2data/src/alphabet/UniqueSymbol.h
@@ -56,8 +56,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef UniqueSymbol normalized_type;
 };
 
 } /* namespace alphabet */
diff --git a/alib2data/src/alphabet/VariablesBarSymbol.h b/alib2data/src/alphabet/VariablesBarSymbol.h
index 0a7e28065efd7d632665df4e7dd918deaab028ff..8e8cc58c1588f91c2ade3ed73bc6ae1f55c88594 100644
--- a/alib2data/src/alphabet/VariablesBarSymbol.h
+++ b/alib2data/src/alphabet/VariablesBarSymbol.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual SymbolBase * inc ( ) &&;
-
-	typedef VariablesBarSymbol normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/automaton/FSM/CompactNFA.h b/alib2data/src/automaton/FSM/CompactNFA.h
index 5c9e96b7d34b6102f1dddd21254478dba9465dc3..4af5b115c3d0f186f16a4897b5b816a0c9c09f4a 100644
--- a/alib2data/src/automaton/FSM/CompactNFA.h
+++ b/alib2data/src/automaton/FSM/CompactNFA.h
@@ -472,11 +472,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef CompactNFA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -912,7 +907,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class StateType >
-struct normalize < automaton::CompactNFA < SymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::CompactNFA < SymbolType, StateType >, automaton::CompactNFA < > >::value >::type > {
+struct normalize < automaton::CompactNFA < SymbolType, StateType > > {
 	static automaton::CompactNFA < > eval ( automaton::CompactNFA < SymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/FSM/DFA.h b/alib2data/src/automaton/FSM/DFA.h
index f3faccea4050dd6157a066616fa76725e9ec30f5..8d36ad37429646675c4e625f50a2bb62e43ee02f 100644
--- a/alib2data/src/automaton/FSM/DFA.h
+++ b/alib2data/src/automaton/FSM/DFA.h
@@ -438,11 +438,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef DFA < > normalized_type;
 };
 
 template<class SymbolType, class StateType >
@@ -845,7 +840,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class StateType >
-struct normalize < automaton::DFA < SymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::DFA < SymbolType, StateType >, automaton::DFA < > >::value >::type > {
+struct normalize < automaton::DFA < SymbolType, StateType > > {
 	static automaton::DFA < > eval ( automaton::DFA < SymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.h b/alib2data/src/automaton/FSM/EpsilonNFA.h
index b726c90fd436f2f013007e89573daebbbb74f7d3..74a60ce6c3af6ea923c8d876d49192ac606682f2 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.h
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.h
@@ -608,11 +608,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef EpsilonNFA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -1171,7 +1166,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template<class SymbolType, class EpsilonType, class StateType >
-struct normalize < automaton::EpsilonNFA < SymbolType, EpsilonType, StateType >, typename std::enable_if < ! std::is_same < automaton::EpsilonNFA < SymbolType, EpsilonType, StateType >, automaton::EpsilonNFA < > >::value >::type > {
+struct normalize < automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > > {
 	static automaton::EpsilonNFA < > eval ( automaton::EpsilonNFA < SymbolType, EpsilonType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.h b/alib2data/src/automaton/FSM/ExtendedNFA.h
index e690f7a97bcbc4f8de87846c46af183b10dca9e6..3b6d9aec56319a6ff3ee0e6acbc3aade84bbe448 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.h
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.h
@@ -483,11 +483,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef ExtendedNFA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -937,7 +932,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class StateType >
-struct normalize < automaton::ExtendedNFA < SymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::ExtendedNFA < SymbolType, StateType >, automaton::ExtendedNFA < > >::value >::type > {
+struct normalize < automaton::ExtendedNFA < SymbolType, StateType > > {
 	static automaton::ExtendedNFA < > eval ( automaton::ExtendedNFA < SymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
index 33cf090d4b19925bb1489d8b692211aab0142176..b65397f975bf5d71a658429947430dcf73526567 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
@@ -500,11 +500,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef MultiInitialStateNFA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -938,7 +933,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class StateType >
-struct normalize < automaton::MultiInitialStateNFA < SymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::MultiInitialStateNFA < SymbolType, StateType >, automaton::MultiInitialStateNFA < > >::value >::type > {
+struct normalize < automaton::MultiInitialStateNFA < SymbolType, StateType > > {
 	static automaton::MultiInitialStateNFA < > eval ( automaton::MultiInitialStateNFA < SymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/FSM/NFA.h b/alib2data/src/automaton/FSM/NFA.h
index c6f7f3107a6b652b33c53cfc673900d46c36689c..3124a0aac197ab1fdb1d85166ff3d04fe3d6eb39 100644
--- a/alib2data/src/automaton/FSM/NFA.h
+++ b/alib2data/src/automaton/FSM/NFA.h
@@ -470,11 +470,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef NFA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -888,7 +883,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class StateType >
-struct normalize < automaton::NFA < SymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::NFA < SymbolType, StateType >, automaton::NFA < > >::value >::type > {
+struct normalize < automaton::NFA < SymbolType, StateType > > {
 	static automaton::NFA < > eval ( automaton::NFA < SymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index f9f8d002f3ba5e58bafe95d25a527543610e8806..3a7cd9fe80ab671ec1af57a900ad45f529600f25 100644
--- a/alib2data/src/automaton/PDA/DPDA.h
+++ b/alib2data/src/automaton/PDA/DPDA.h
@@ -600,11 +600,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef DPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1163,7 +1158,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::DPDA < > >::value >::type > {
+struct normalize < automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::DPDA < > eval ( automaton::DPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.h b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
index 41e0beb8e4c3362b54328106a0f629aac295d150..1d6075278af6acc70636a95f93969b414902c1a2 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
@@ -582,11 +582,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef InputDrivenDPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -1125,7 +1120,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, automaton::InputDrivenDPDA < > >::value >::type > {
+struct normalize < automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > > {
 	static automaton::InputDrivenDPDA < > eval ( automaton::InputDrivenDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.h b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
index 8d00e94a80313c622325ae4ceda7611036391281..8ffe633afe7c88f6241aac79a27d06fbacf05b1c 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
@@ -607,11 +607,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef InputDrivenNPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -1166,7 +1161,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, automaton::InputDrivenNPDA < > >::value >::type > {
+struct normalize < automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > > {
 	static automaton::InputDrivenNPDA < > eval ( automaton::InputDrivenNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index 9d5526a9307227a98dc8dd2ed14feb8e268b4e0b..d66240510b74c77fd8a74bb9392e3f6395833eae 100644
--- a/alib2data/src/automaton/PDA/NPDA.h
+++ b/alib2data/src/automaton/PDA/NPDA.h
@@ -616,11 +616,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef NPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1138,7 +1133,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::NPDA < > >::value >::type > {
+struct normalize < automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::NPDA < > eval ( automaton::NPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index f426e4500bd6edddaaf1d625084344cdd392f73d..25d9d954fbbfb8aeaa5a3e874f26291527f04b5f 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -693,11 +693,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef NPDTA < > normalized_type;
 };
 
 template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1313,7 +1308,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class OutputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::NPDTA < > >::value >::type > {
+struct normalize < automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::NPDTA < > eval ( automaton::NPDTA < InputSymbolType, OutputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > outputAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getOutputAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
index 4b81eac714e132438e3e22058a2bc4807a1ed9f6..96db4d6cba2bc606694f51b64f53b8fb87eec6e2 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
@@ -819,11 +819,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef RealTimeHeightDeterministicDPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1585,7 +1580,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::RealTimeHeightDeterministicDPDA < > >::value >::type > {
+struct normalize < automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::RealTimeHeightDeterministicDPDA < > eval ( automaton::RealTimeHeightDeterministicDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
index b5bd6acd028d6c67a0b259187e854cfeb00f76b8..8ca9dab84dfed86da69a6ba2d2c2e83c99d6cfe9 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
@@ -939,11 +939,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef RealTimeHeightDeterministicNPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1715,7 +1710,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::RealTimeHeightDeterministicNPDA < > >::value >::type > {
+struct normalize < automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::RealTimeHeightDeterministicNPDA < > eval ( automaton::RealTimeHeightDeterministicNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.h b/alib2data/src/automaton/PDA/SinglePopDPDA.h
index 4846de42de06e1b34f50417411e941d25cbac861..a132f4e616d7b73d8483a9720008f7d2f7a756ee 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.h
@@ -582,11 +582,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef SinglePopDPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1087,7 +1082,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::SinglePopDPDA < > >::value >::type > {
+struct normalize < automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::SinglePopDPDA < > eval ( automaton::SinglePopDPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.h b/alib2data/src/automaton/PDA/SinglePopNPDA.h
index bb783d9863feaecc2821f7153c0e35ed432adc53..41a213f6b2e5d7d50aa86dbbded0be2b79341504 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.h
@@ -617,11 +617,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef SinglePopNPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
@@ -1142,7 +1137,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class EpsilonType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType >, automaton::SinglePopNPDA < > >::value >::type > {
+struct normalize < automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > > {
 	static automaton::SinglePopNPDA < > eval ( automaton::SinglePopNPDA < InputSymbolType, EpsilonType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > pushdownAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getPushdownStoreAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
index 3506764f01992ee659cdec2fbc72e816f917fd79..35cbaf99e27646864bbc194704c2d7583fed481a 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
@@ -759,11 +759,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef VisiblyPushdownDPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -1510,7 +1505,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, automaton::VisiblyPushdownDPDA < > >::value >::type > {
+struct normalize < automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > > {
 	static automaton::VisiblyPushdownDPDA < > eval ( automaton::VisiblyPushdownDPDA < InputSymbolType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > call_alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getCallInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > return_alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getReturnInputAlphabet ( ) );
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
index 5b42fe9fa6ae866d831c9f539dee08937898a03b..b0ba6e5dfcc27aff5facf2d5138ec9daf1ccf824 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
@@ -811,11 +811,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef VisiblyPushdownNPDA < > normalized_type;
 };
 
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
@@ -1581,7 +1576,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class InputSymbolType, class PushdownStoreSymbolType, class StateType >
-struct normalize < automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType >, automaton::VisiblyPushdownNPDA < > >::value >::type > {
+struct normalize < automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > > {
 	static automaton::VisiblyPushdownNPDA < > eval ( automaton::VisiblyPushdownNPDA < InputSymbolType, PushdownStoreSymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > call_alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getCallInputAlphabet ( ) );
 		ext::set < DefaultSymbolType > return_alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getReturnInputAlphabet ( ) );
diff --git a/alib2data/src/automaton/TA/DFTA.h b/alib2data/src/automaton/TA/DFTA.h
index b0fc842a487826cb6dcfc3fd4745fab2dfdb24be..bbeea2d6d2510742ca6aaf104a115ee1ad19c10e 100644
--- a/alib2data/src/automaton/TA/DFTA.h
+++ b/alib2data/src/automaton/TA/DFTA.h
@@ -403,11 +403,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef DFTA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -716,7 +711,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class RankType, class StateType >
-struct normalize < automaton::DFTA < SymbolType, RankType, StateType >, typename std::enable_if < ! std::is_same < automaton::DFTA < SymbolType, RankType, StateType >, automaton::DFTA < > >::value >::type > {
+struct normalize < automaton::DFTA < SymbolType, RankType, StateType > > {
 	static automaton::DFTA < > eval ( automaton::DFTA < SymbolType, RankType, StateType > && value ) {
 		ext::set < common::ranked_symbol < > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/TA/NFTA.h b/alib2data/src/automaton/TA/NFTA.h
index 6f80c897184cee7812a1ff8bdef0612b441b4452..95f210d6cd75bf88d64a2c31e20cd28ec58926d9 100644
--- a/alib2data/src/automaton/TA/NFTA.h
+++ b/alib2data/src/automaton/TA/NFTA.h
@@ -428,11 +428,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef NFTA < > normalized_type;
 };
 
 } /* namespace automaton */
@@ -775,7 +770,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class RankType, class StateType >
-struct normalize < automaton::NFTA < SymbolType, RankType, StateType >, typename std::enable_if < ! std::is_same < automaton::NFTA < SymbolType, RankType, StateType >, automaton::NFTA < > >::value >::type > {
+struct normalize < automaton::NFTA < SymbolType, RankType, StateType > > {
 	static automaton::NFTA < > eval ( automaton::NFTA < SymbolType, RankType, StateType > && value ) {
 		ext::set < common::ranked_symbol < > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getInputAlphabet ( ) );
 		ext::set < DefaultStateType > states = automaton::AutomatonNormalize::normalizeStates ( std::move ( value ).getStates ( ) );
diff --git a/alib2data/src/automaton/TM/OneTapeDTM.h b/alib2data/src/automaton/TM/OneTapeDTM.h
index cfe73173a0f8dfbbe13af92869e51c14736a01de..0d08a931e7eac8ae191fbc5ba68d214e423f9469 100644
--- a/alib2data/src/automaton/TM/OneTapeDTM.h
+++ b/alib2data/src/automaton/TM/OneTapeDTM.h
@@ -506,11 +506,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized automaton.
-	 */
-	typedef OneTapeDTM < > normalized_type;
 };
 
 template<class SymbolType, class StateType >
@@ -969,7 +964,7 @@ public:
  * \returns new instance of the automaton with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template<class SymbolType, class StateType >
-struct normalize < automaton::OneTapeDTM < SymbolType, StateType >, typename std::enable_if < ! std::is_same < automaton::OneTapeDTM < SymbolType, StateType >, automaton::OneTapeDTM < > >::value >::type > {
+struct normalize < automaton::OneTapeDTM < SymbolType, StateType > > {
 	static automaton::OneTapeDTM < > eval ( automaton::OneTapeDTM < SymbolType, StateType > && value ) {
 		ext::set < DefaultSymbolType > tapeAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTapeAlphabet ( ) );
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getInputAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextFree/CFG.h b/alib2data/src/grammar/ContextFree/CFG.h
index 82fa06447b580ee90cbd92c619b39c205646beab..ac1facbaea814ddd5e49c9cd6f21df62b99b5029 100644
--- a/alib2data/src/grammar/ContextFree/CFG.h
+++ b/alib2data/src/grammar/ContextFree/CFG.h
@@ -358,11 +358,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef CFG < > normalized_type;
 };
 
 } /* namespace grammar */
@@ -692,7 +687,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::CFG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::CFG < SymbolType >, grammar::CFG < > >::value >::type > {
+struct normalize < grammar::CFG < SymbolType > > {
 	static grammar::CFG < > eval ( grammar::CFG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index 35f36e746aab7a84bcaefb7aec2109a39447f9d5..1a3615fbf80a67b94e270c4b2e0d1295bb798343 100644
--- a/alib2data/src/grammar/ContextFree/CNF.h
+++ b/alib2data/src/grammar/ContextFree/CNF.h
@@ -415,11 +415,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef CNF < > normalized_type;
 };
 
 template < class SymbolType >
@@ -836,7 +831,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::CNF < SymbolType >, typename std::enable_if < ! std::is_same < grammar::CNF < SymbolType >, grammar::CNF < > >::value >::type > {
+struct normalize < grammar::CNF < SymbolType > > {
 	static grammar::CNF < > eval ( grammar::CNF < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
index 53a5d45e718754d05174d0597c06ea694c43d7e9..c84748d4632991af82abdaec847ebfdfba723d3c 100644
--- a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
+++ b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
@@ -370,11 +370,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef EpsilonFreeCFG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -731,7 +726,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::EpsilonFreeCFG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::EpsilonFreeCFG < SymbolType >, grammar::EpsilonFreeCFG < > >::value >::type > {
+struct normalize < grammar::EpsilonFreeCFG < SymbolType > > {
 	static grammar::EpsilonFreeCFG < > eval ( grammar::EpsilonFreeCFG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextFree/GNF.h b/alib2data/src/grammar/ContextFree/GNF.h
index 7d23c8ef9c6c45f87ddfbf091ce7178f96dc4e73..bde1d647b1e34a10e2713d1bf019ee0c6d679e8a 100644
--- a/alib2data/src/grammar/ContextFree/GNF.h
+++ b/alib2data/src/grammar/ContextFree/GNF.h
@@ -370,11 +370,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef GNF < > normalized_type;
 };
 
 template < class SymbolType >
@@ -740,7 +735,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::GNF < SymbolType >, typename std::enable_if < ! std::is_same < grammar::GNF < SymbolType >, grammar::GNF < > >::value >::type > {
+struct normalize < grammar::GNF < SymbolType > > {
 	static grammar::GNF < > eval ( grammar::GNF < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextFree/LG.h b/alib2data/src/grammar/ContextFree/LG.h
index 23a671e5d90bd1eda025ae3686090b31efa83441..0c13d647117dff120227dd42f05ce655a639814b 100644
--- a/alib2data/src/grammar/ContextFree/LG.h
+++ b/alib2data/src/grammar/ContextFree/LG.h
@@ -397,11 +397,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef LG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -831,7 +826,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::LG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::LG < SymbolType >, grammar::LG < > >::value >::type > {
+struct normalize < grammar::LG < SymbolType > > {
 	static grammar::LG < > eval ( grammar::LG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextSensitive/CSG.h b/alib2data/src/grammar/ContextSensitive/CSG.h
index e64c136b7a1cc4da16dbae984821e53566bc0949..3c62718d7fa14d9a8cc53fe950b001deb783d351 100644
--- a/alib2data/src/grammar/ContextSensitive/CSG.h
+++ b/alib2data/src/grammar/ContextSensitive/CSG.h
@@ -352,11 +352,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef CSG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -717,7 +712,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::CSG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::CSG < SymbolType >, grammar::CSG < > >::value >::type > {
+struct normalize < grammar::CSG < SymbolType > > {
 	static grammar::CSG < > eval ( grammar::CSG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
index 5055d03bdd7eb6d180ef38540759fbb3019e01a2..4dc65777631be991e45b0f98d91e893beed4caef 100644
--- a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
+++ b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
@@ -346,11 +346,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef NonContractingGrammar < > normalized_type;
 };
 
 template < class SymbolType >
@@ -697,7 +692,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::NonContractingGrammar < SymbolType >, typename std::enable_if < ! std::is_same < grammar::NonContractingGrammar < SymbolType >, grammar::NonContractingGrammar < > >::value >::type > {
+struct normalize < grammar::NonContractingGrammar < SymbolType > > {
 	static grammar::NonContractingGrammar < > eval ( grammar::NonContractingGrammar < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index 7a60d0ba8a8c9921803c10051ee36af8fadcab09..753b3c35f6d4dd3526701aa46350efb2d564107a 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -396,11 +396,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef LeftLG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -806,7 +801,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::LeftLG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::LeftLG < SymbolType >, grammar::LeftLG < > >::value >::type > {
+struct normalize < grammar::LeftLG < SymbolType > > {
 	static grammar::LeftLG < > eval ( grammar::LeftLG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index e3fad94bef1817b8ff8fbc2172d1efb21a252785..baf22c45b6eb33689105292621ccf9ebd90d5435 100644
--- a/alib2data/src/grammar/Regular/LeftRG.h
+++ b/alib2data/src/grammar/Regular/LeftRG.h
@@ -419,11 +419,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef LeftRG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -839,7 +834,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::LeftRG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::LeftRG < SymbolType >, grammar::LeftRG < > >::value >::type > {
+struct normalize < grammar::LeftRG < SymbolType > > {
 	static grammar::LeftRG < > eval ( grammar::LeftRG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/Regular/RightLG.h b/alib2data/src/grammar/Regular/RightLG.h
index f81eedb97d5030bd70d5314683221903465f01b0..991fb8202579194e7bc94ecaaa7e18494349a7c7 100644
--- a/alib2data/src/grammar/Regular/RightLG.h
+++ b/alib2data/src/grammar/Regular/RightLG.h
@@ -396,11 +396,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef RightLG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -804,7 +799,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::RightLG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::RightLG < SymbolType >, grammar::RightLG < > >::value >::type > {
+struct normalize < grammar::RightLG < SymbolType > > {
 	static grammar::RightLG < > eval ( grammar::RightLG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/Regular/RightRG.h b/alib2data/src/grammar/Regular/RightRG.h
index c7a74ecde687ec1fb702de68019b10a2ec41a858..0bb59280d0c18b0440197e183ac352b88affc3a9 100644
--- a/alib2data/src/grammar/Regular/RightRG.h
+++ b/alib2data/src/grammar/Regular/RightRG.h
@@ -419,11 +419,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef RightRG < > normalized_type;
 };
 
 template < class SymbolType >
@@ -836,7 +831,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::RightRG < SymbolType >, typename std::enable_if < ! std::is_same < grammar::RightRG < SymbolType >, grammar::RightRG < > >::value >::type > {
+struct normalize < grammar::RightRG < SymbolType > > {
 	static grammar::RightRG < > eval ( grammar::RightRG < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
index eee1525da31860ac46d8b37092cc38afd1cd083b..d39c94c12418d3ff60abcf959ab5b9ca80dba9c1 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
@@ -333,11 +333,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef ContextPreservingUnrestrictedGrammar < > normalized_type;
 };
 
 template < class SymbolType >
@@ -674,7 +669,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::ContextPreservingUnrestrictedGrammar < SymbolType >, typename std::enable_if < ! std::is_same < grammar::ContextPreservingUnrestrictedGrammar < SymbolType >, grammar::ContextPreservingUnrestrictedGrammar < > >::value >::type > {
+struct normalize < grammar::ContextPreservingUnrestrictedGrammar < SymbolType > > {
 	static grammar::ContextPreservingUnrestrictedGrammar < > eval ( grammar::ContextPreservingUnrestrictedGrammar < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
index b9c226e6189cc8731bc054faedd87848914c8e51..f5fde89328fe8fdb47b5ff54e87c05c1dfcc11fa 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
@@ -333,11 +333,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized grammar.
-	 */
-	typedef UnrestrictedGrammar < > normalized_type;
 };
 
 template < class SymbolType >
@@ -653,7 +648,7 @@ public:
  * \returns new instance of the grammar with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < grammar::UnrestrictedGrammar < SymbolType >, typename std::enable_if < ! std::is_same < grammar::UnrestrictedGrammar < SymbolType >, grammar::UnrestrictedGrammar < > >::value >::type > {
+struct normalize < grammar::UnrestrictedGrammar < SymbolType > > {
 	static grammar::UnrestrictedGrammar < > eval ( grammar::UnrestrictedGrammar < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > nonterminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonterminalAlphabet ( ) );
 		ext::set < DefaultSymbolType > terminals = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getTerminalAlphabet ( ) );
diff --git a/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h b/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h
index 041d72cf6f521639c2a62546ff3989196c1dd33c..5355c7379482c6afc897a3a3664990066d646903 100644
--- a/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h
+++ b/alib2data/src/indexes/arbology/CompressedBitParallelTreeIndex.h
@@ -125,8 +125,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef CompressedBitParallelTreeIndex < > normalized_type;
 };
 
 } /* namespace arbology */
@@ -246,7 +244,7 @@ public:
 };
 
 template < class SymbolType, class RankType >
-struct normalize < indexes::arbology::CompressedBitParallelTreeIndex < SymbolType, RankType >, typename std::enable_if < ! std::is_same < indexes::arbology::CompressedBitParallelTreeIndex < SymbolType, RankType >, indexes::arbology::CompressedBitParallelTreeIndex < > >::value >::type > {
+struct normalize < indexes::arbology::CompressedBitParallelTreeIndex < SymbolType, RankType > > {
 	static indexes::arbology::CompressedBitParallelTreeIndex < > eval ( indexes::arbology::CompressedBitParallelTreeIndex < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/indexes/arbology/FullAndLinearIndex.h b/alib2data/src/indexes/arbology/FullAndLinearIndex.h
index c8ac3ff477c1a1dfdb1053395bc5bcd52c4dd1d5..e7d3bac7a010db10ecc287de7e3a0fc219d32edf 100644
--- a/alib2data/src/indexes/arbology/FullAndLinearIndex.h
+++ b/alib2data/src/indexes/arbology/FullAndLinearIndex.h
@@ -112,8 +112,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef FullAndLinearIndex < > normalized_type;
 };
 
 } /* namespace arbology */
@@ -197,7 +195,7 @@ object::ObjectBase * FullAndLinearIndex < SymbolType, RankType, StringIndex >::i
 namespace core {
 
 template < class SymbolType, class RankType, template < typename > class StringIndex >
-struct normalize < indexes::arbology::FullAndLinearIndex < SymbolType, RankType, StringIndex >, typename std::enable_if < ! std::is_same < indexes::arbology::FullAndLinearIndex < SymbolType, RankType, StringIndex >, indexes::arbology::FullAndLinearIndex < > >::value >::type > {
+struct normalize < indexes::arbology::FullAndLinearIndex < SymbolType, RankType, StringIndex > > {
 	static indexes::arbology::FullAndLinearIndex < > eval ( indexes::arbology::FullAndLinearIndex < SymbolType, RankType, StringIndex > && value ) {
 		StringIndex < common::ranked_symbol < > > stringIndex = core::normalize < StringIndex < common::ranked_symbol < SymbolType, RankType > > >::eval ( std::move ( value ).getStringIndex ( ) );
 
diff --git a/alib2data/src/indexes/arbology/NonlinearCompressedBitParallelTreeIndex.h b/alib2data/src/indexes/arbology/NonlinearCompressedBitParallelTreeIndex.h
index a18120904364d21b88601e2431340c55a76de4cc..6e4d798c158557f01d961de6098f221197621ddd 100644
--- a/alib2data/src/indexes/arbology/NonlinearCompressedBitParallelTreeIndex.h
+++ b/alib2data/src/indexes/arbology/NonlinearCompressedBitParallelTreeIndex.h
@@ -128,8 +128,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef NonlinearCompressedBitParallelTreeIndex < > normalized_type;
 };
 
 } /* namespace arbology */
@@ -259,7 +257,7 @@ public:
 };
 
 template < class SymbolType, class RankType >
-struct normalize < indexes::arbology::NonlinearCompressedBitParallelTreeIndex < SymbolType, RankType >, typename std::enable_if < ! std::is_same < indexes::arbology::NonlinearCompressedBitParallelTreeIndex < SymbolType, RankType >, indexes::arbology::NonlinearCompressedBitParallelTreeIndex < > >::value >::type > {
+struct normalize < indexes::arbology::NonlinearCompressedBitParallelTreeIndex < SymbolType, RankType > > {
 	static indexes::arbology::NonlinearCompressedBitParallelTreeIndex < > eval ( indexes::arbology::NonlinearCompressedBitParallelTreeIndex < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/indexes/arbology/NonlinearFullAndLinearIndex.h b/alib2data/src/indexes/arbology/NonlinearFullAndLinearIndex.h
index 206c2de109fe7f9f1fe8d41a2f21139a7512a758..29ec2004358cec4c8e1f55e839a9b9bc1764c8ae 100644
--- a/alib2data/src/indexes/arbology/NonlinearFullAndLinearIndex.h
+++ b/alib2data/src/indexes/arbology/NonlinearFullAndLinearIndex.h
@@ -120,8 +120,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef NonlinearFullAndLinearIndex < > normalized_type;
 };
 
 } /* namespace arbology */
@@ -215,7 +213,7 @@ object::ObjectBase * NonlinearFullAndLinearIndex < SymbolType, RankType, StringI
 namespace core {
 
 template < class SymbolType, class RankType, template < typename > class StringIndex >
-struct normalize < indexes::arbology::NonlinearFullAndLinearIndex < SymbolType, RankType, StringIndex >, typename std::enable_if < ! std::is_same < indexes::arbology::NonlinearFullAndLinearIndex < SymbolType, RankType, StringIndex >, indexes::arbology::NonlinearFullAndLinearIndex < > >::value >::type > {
+struct normalize < indexes::arbology::NonlinearFullAndLinearIndex < SymbolType, RankType, StringIndex > > {
 	static indexes::arbology::NonlinearFullAndLinearIndex < > eval ( indexes::arbology::NonlinearFullAndLinearIndex < SymbolType, RankType, StringIndex > && value ) {
 		StringIndex < common::ranked_symbol < > > stringIndex = core::normalize < StringIndex < common::ranked_symbol < SymbolType, RankType > > >::eval ( std::move ( value ).getStringIndex ( ) );
 
diff --git a/alib2data/src/indexes/stringology/BNDMMatcher.h b/alib2data/src/indexes/stringology/BNDMMatcher.h
index 660bebdf81e723c15b8892a8595ddf2b9ad336bc..ce579acb8d9fb15d5566bec02d6a41eba89de1d8 100644
--- a/alib2data/src/indexes/stringology/BNDMMatcher.h
+++ b/alib2data/src/indexes/stringology/BNDMMatcher.h
@@ -119,8 +119,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef BNDMMatcher < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -220,14 +218,7 @@ public:
 };
 
 template < class SymbolType, size_t BitmaskBitCount >
-struct normalize < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, typename std::enable_if < ! std::is_same < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, indexes::stringology::BNDMMatcher < > >::value && std::is_same < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, indexes::stringology::BNDMMatcher < DefaultSymbolType, BitmaskBitCount > >::value >::type > {
-	static indexes::stringology::BNDMMatcher < DefaultSymbolType, BitmaskBitCount > && eval ( indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount > && value ) {
-		return std::move ( value );
-	}
-};
-
-template < class SymbolType, size_t BitmaskBitCount >
-struct normalize < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, typename std::enable_if < ! std::is_same < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, indexes::stringology::BNDMMatcher < DefaultSymbolType, BitmaskBitCount > >::value && ! std::is_same < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount >, indexes::stringology::BNDMMatcher < DefaultSymbolType, BitmaskBitCount > >::value >::type > {
+struct normalize < indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount > > {
 	static indexes::stringology::BNDMMatcher < DefaultSymbolType, BitmaskBitCount > eval ( indexes::stringology::BNDMMatcher < SymbolType, BitmaskBitCount > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/indexes/stringology/BitParallelIndex.h b/alib2data/src/indexes/stringology/BitParallelIndex.h
index abcc647a9baff4363c3624fffdd907ceafd36afa..013f7738b655baa02c9937d9f8f72b251ac45920 100644
--- a/alib2data/src/indexes/stringology/BitParallelIndex.h
+++ b/alib2data/src/indexes/stringology/BitParallelIndex.h
@@ -114,8 +114,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef BitParallelIndex < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -222,7 +220,7 @@ public:
 };
 
 template < class SymbolType >
-struct normalize < indexes::stringology::BitParallelIndex < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::BitParallelIndex < SymbolType >, indexes::stringology::BitParallelIndex < > >::value >::type > {
+struct normalize < indexes::stringology::BitParallelIndex < SymbolType > > {
 	static indexes::stringology::BitParallelIndex < > eval ( indexes::stringology::BitParallelIndex < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h b/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h
index 8f6096c959ec3a8f3c1906663374b87c0c10a4ea..99e4cf848114cc66b08a34214f1404556f121d91 100644
--- a/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h
+++ b/alib2data/src/indexes/stringology/CompressedBitParallelIndex.h
@@ -114,8 +114,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef CompressedBitParallelIndex < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -222,7 +220,7 @@ public:
 };
 
 template < class SymbolType >
-struct normalize < indexes::stringology::CompressedBitParallelIndex < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::CompressedBitParallelIndex < SymbolType >, indexes::stringology::CompressedBitParallelIndex < > >::value >::type > {
+struct normalize < indexes::stringology::CompressedBitParallelIndex < SymbolType > > {
 	static indexes::stringology::CompressedBitParallelIndex < > eval ( indexes::stringology::CompressedBitParallelIndex < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/indexes/stringology/FactorOracleAutomaton.h b/alib2data/src/indexes/stringology/FactorOracleAutomaton.h
index f8ae660d42b2a0a59a957ec7d06cb3a9c4d83df2..c6ecbd87407d9e964068e41cdd9a9f39e3b9e240 100644
--- a/alib2data/src/indexes/stringology/FactorOracleAutomaton.h
+++ b/alib2data/src/indexes/stringology/FactorOracleAutomaton.h
@@ -102,8 +102,6 @@ public:
 	explicit operator automaton::DFA < SymbolType, unsigned > ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef FactorOracleAutomaton < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -177,7 +175,7 @@ object::ObjectBase* FactorOracleAutomaton < SymbolType >::inc() && {
 namespace core {
 
 template < class SymbolType >
-struct normalize < indexes::stringology::FactorOracleAutomaton < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::FactorOracleAutomaton < SymbolType >, indexes::stringology::FactorOracleAutomaton < > >::value >::type > {
+struct normalize < indexes::stringology::FactorOracleAutomaton < SymbolType > > {
 	static indexes::stringology::FactorOracleAutomaton < > eval ( indexes::stringology::FactorOracleAutomaton < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( std::move ( value ).getAutomaton ( ) ).getInputAlphabet ( ) );
 		ext::set < unsigned > states = std::move ( std::move ( value ).getAutomaton ( ) ).getStates ( );
diff --git a/alib2data/src/indexes/stringology/PositionHeap.h b/alib2data/src/indexes/stringology/PositionHeap.h
index a3720e30c4a8777b3d3a420ad9e2135d7f9c1871..eb9a8a07253d80df482ed69b14bd84387a5a5434 100644
--- a/alib2data/src/indexes/stringology/PositionHeap.h
+++ b/alib2data/src/indexes/stringology/PositionHeap.h
@@ -124,8 +124,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef PositionHeap < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -249,13 +247,6 @@ public:
 	}
 };
 
-template < >
-struct normalize < indexes::stringology::PositionHeap < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > > {
-	static indexes::stringology::PositionHeap < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > && eval ( indexes::stringology::PositionHeap < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > && source ) {
-		return std::move ( source );
-	}
-};
-
 template < class SymbolType, class RankType >
 struct normalize < indexes::stringology::PositionHeap < common::ranked_symbol < SymbolType, RankType > > > {
 	static indexes::stringology::PositionHeap < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > eval ( indexes::stringology::PositionHeap < common::ranked_symbol < SymbolType, RankType > > && source ) {
@@ -268,7 +259,7 @@ struct normalize < indexes::stringology::PositionHeap < common::ranked_symbol <
 };
 
 template < class SymbolType >
-struct normalize < indexes::stringology::PositionHeap < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::PositionHeap < SymbolType >, indexes::stringology::PositionHeap < > >::value >::type > {
+struct normalize < indexes::stringology::PositionHeap < SymbolType > > {
 	static indexes::stringology::PositionHeap < > eval ( indexes::stringology::PositionHeap < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::trie < DefaultSymbolType, unsigned > trie = indexes::IndexesNormalize::normalizeTrie ( std::move ( value ).getRoot ( ) );
diff --git a/alib2data/src/indexes/stringology/SuffixArray.h b/alib2data/src/indexes/stringology/SuffixArray.h
index 567923f0617d0405f6de6dedb62c847d668daea1..e5966662157a16788b82f6282c369ca600ac7fd1 100644
--- a/alib2data/src/indexes/stringology/SuffixArray.h
+++ b/alib2data/src/indexes/stringology/SuffixArray.h
@@ -186,11 +186,6 @@ public:
 	 * @copydoc alib::ObjectBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized index.
-	 */
-	typedef SuffixArray < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -279,7 +274,7 @@ namespace core {
  * \returns new instance of the index with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType >
-struct normalize < indexes::stringology::SuffixArray < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::SuffixArray < SymbolType >, indexes::stringology::SuffixArray < > >::value >::type > {
+struct normalize < indexes::stringology::SuffixArray < SymbolType > > {
 	static indexes::stringology::SuffixArray < > eval ( indexes::stringology::SuffixArray < SymbolType > && value ) {
 		string::LinearString < DefaultSymbolType > string = normalize < string::LinearString < SymbolType > >::eval ( std::move ( value ).getString ( ) );
 
diff --git a/alib2data/src/indexes/stringology/SuffixAutomaton.h b/alib2data/src/indexes/stringology/SuffixAutomaton.h
index 7f28b6d8b76318a14e5777034ff9fb95736a75e6..a5c67c9b767ea846ff597c3943f890933aacc45c 100644
--- a/alib2data/src/indexes/stringology/SuffixAutomaton.h
+++ b/alib2data/src/indexes/stringology/SuffixAutomaton.h
@@ -175,11 +175,6 @@ public:
 	 * @copydoc alib::ObjectBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized index.
-	 */
-	typedef SuffixAutomaton < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -258,7 +253,7 @@ namespace core {
  * \returns new instance of the index with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType >
-struct normalize < indexes::stringology::SuffixAutomaton < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::SuffixAutomaton < SymbolType >, indexes::stringology::SuffixAutomaton < > >::value >::type > {
+struct normalize < indexes::stringology::SuffixAutomaton < SymbolType > > {
 	static indexes::stringology::SuffixAutomaton < > eval ( indexes::stringology::SuffixAutomaton < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( std::move ( value ).getAutomaton ( ) ).getInputAlphabet ( ) );
 		ext::set < unsigned > states = std::move ( std::move ( value ).getAutomaton ( ) ).getStates ( );
diff --git a/alib2data/src/indexes/stringology/SuffixTrie.h b/alib2data/src/indexes/stringology/SuffixTrie.h
index f635c3f5ff4f818ab99d733ce0331298310a4469..dca3531c743902d6338271032b2cef6e59752713 100644
--- a/alib2data/src/indexes/stringology/SuffixTrie.h
+++ b/alib2data/src/indexes/stringology/SuffixTrie.h
@@ -197,11 +197,6 @@ public:
 	 * @copydoc alib::ObjectBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized index.
-	 */
-	typedef SuffixTrie < > normalized_type;
 };
 
 } /* namespace stringology */
@@ -358,7 +353,7 @@ public:
  * \returns new instance of the index with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType >
-struct normalize < indexes::stringology::SuffixTrie < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::SuffixTrie < SymbolType >, indexes::stringology::SuffixTrie < > >::value >::type > {
+struct normalize < indexes::stringology::SuffixTrie < SymbolType > > {
 	static indexes::stringology::SuffixTrie < > eval ( indexes::stringology::SuffixTrie < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlpahet ( ) );
 		ext::trie < DefaultSymbolType, ext::variant < void, unsigned > > trie = indexes::IndexesNormalize::normalizeTrie ( std::move ( value ).getRoot ( ) );
diff --git a/alib2data/src/label/FailStateLabel.h b/alib2data/src/label/FailStateLabel.h
index 56e23f95983b438bc21e08669a290ba420a83c30..2cef0752ba49f11e5611153ad14aeea740a6451d 100644
--- a/alib2data/src/label/FailStateLabel.h
+++ b/alib2data/src/label/FailStateLabel.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef FailStateLabel normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/label/FinalStateLabel.h b/alib2data/src/label/FinalStateLabel.h
index adbb34cc93ce706bc9523ff16dc3c531820a3e8f..73cdc0185282843d758d7dbaaf9c077dd0ff8109 100644
--- a/alib2data/src/label/FinalStateLabel.h
+++ b/alib2data/src/label/FinalStateLabel.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef FinalStateLabel normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/label/HexavigesimalLabel.h b/alib2data/src/label/HexavigesimalLabel.h
index 2f59d87ab9f357e8b5f604ec1136a82dfc2c854a..e581e7fd4fdf1f4126d6efcbe24f1d8cfe801968 100644
--- a/alib2data/src/label/HexavigesimalLabel.h
+++ b/alib2data/src/label/HexavigesimalLabel.h
@@ -52,8 +52,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef HexavigesimalLabel normalized_type;
 };
 
 } /* namespace label */
diff --git a/alib2data/src/label/InitialStateLabel.h b/alib2data/src/label/InitialStateLabel.h
index 54cc254cf7d10d5c02d5c1f4e182516874fd1462..c1978b93c9b568cbd59ccde933c554f4028c7b6b 100644
--- a/alib2data/src/label/InitialStateLabel.h
+++ b/alib2data/src/label/InitialStateLabel.h
@@ -47,8 +47,6 @@ public:
 	static inline typename std::enable_if < ! std::is_integral < Base >::value, Base >::type instance ( );
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef InitialStateLabel normalized_type;
 };
 
 template < typename Base >
diff --git a/alib2data/src/label/ObjectLabel.h b/alib2data/src/label/ObjectLabel.h
index f07fcbd40dc49f2106864eddc2cd03450e0a9e83..aba4eeee152c602d907585f66102087ab32e2725 100644
--- a/alib2data/src/label/ObjectLabel.h
+++ b/alib2data/src/label/ObjectLabel.h
@@ -49,8 +49,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef ObjectLabel normalized_type;
 };
 
 } /* namespace label */
diff --git a/alib2data/src/label/PrimitiveLabel.h b/alib2data/src/label/PrimitiveLabel.h
index 8da581186104ca205700da3b129f3a047de29bbe..e3452a529956adb8d201fecc18d23ef8ee326241 100644
--- a/alib2data/src/label/PrimitiveLabel.h
+++ b/alib2data/src/label/PrimitiveLabel.h
@@ -51,8 +51,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef PrimitiveLabel normalized_type;
 };
 
 } /* namespace label */
diff --git a/alib2data/src/label/UniqueLabel.h b/alib2data/src/label/UniqueLabel.h
index bda4e39196c5fc7885eba302e4d4a82a81072410..94ea914cf38b335b1b6de996d2747739f29234bb 100644
--- a/alib2data/src/label/UniqueLabel.h
+++ b/alib2data/src/label/UniqueLabel.h
@@ -54,8 +54,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual LabelBase * inc ( ) &&;
-
-	typedef UniqueLabel normalized_type;
 };
 
 } /* namespace label */
diff --git a/alib2data/src/regexp/formal/FormalRegExp.h b/alib2data/src/regexp/formal/FormalRegExp.h
index bf7d257a9cd93e0c1c69725d0fc8f8345c997482..29e94935eb115fe3edc3dac328c92ac33295aa3a 100644
--- a/alib2data/src/regexp/formal/FormalRegExp.h
+++ b/alib2data/src/regexp/formal/FormalRegExp.h
@@ -182,11 +182,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized expression.
-	 */
-	typedef FormalRegExp < > normalized_type;
 };
 
 } /* namespace regexp */
@@ -320,7 +315,7 @@ public:
  * \returns new instance of the expression with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType >
-struct normalize < regexp::FormalRegExp < SymbolType >, typename std::enable_if < ! std::is_same < regexp::FormalRegExp < SymbolType >, regexp::FormalRegExp < > >::value >::type > {
+struct normalize < regexp::FormalRegExp < SymbolType > > {
 	static regexp::FormalRegExp < > eval ( regexp::FormalRegExp < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExp.h b/alib2data/src/regexp/unbounded/UnboundedRegExp.h
index 3b3c6354e898280c3372a28821aa8775f83cb0ab..786455f20563fbf9c3ed01ca86c27bf067aa949d 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExp.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExp.h
@@ -184,11 +184,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized expression.
-	 */
-	typedef UnboundedRegExp < > normalized_type;
 };
 
 } /* namespace regexp */
@@ -322,7 +317,7 @@ public:
  * \returns new instance of the expression with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType >
-struct normalize < regexp::UnboundedRegExp < SymbolType >, typename std::enable_if < ! std::is_same < regexp::UnboundedRegExp < SymbolType >, regexp::UnboundedRegExp < > >::value >::type > {
+struct normalize < regexp::UnboundedRegExp < SymbolType > > {
 	static regexp::UnboundedRegExp < > eval ( regexp::UnboundedRegExp < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 
diff --git a/alib2data/src/rte/formal/FormalRTE.h b/alib2data/src/rte/formal/FormalRTE.h
index 93896b967b4f4d91504d9ecef071d6228b984945..b2f22dbe2526e4519a9ca4b9b9d189f72810f69b 100644
--- a/alib2data/src/rte/formal/FormalRTE.h
+++ b/alib2data/src/rte/formal/FormalRTE.h
@@ -286,11 +286,6 @@ public:
 	 * @copydoc alib::GrammarBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized expression.
-	 */
-	typedef FormalRTE < > normalized_type;
 };
 
 template < class SymbolType, class RankType >
@@ -466,7 +461,7 @@ public:
  * \returns new instance of the expression with default template parameters or unmodified instance if the template parameters were already the default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < rte::FormalRTE < SymbolType, RankType >, typename std::enable_if < ! std::is_same < rte::FormalRTE < SymbolType, RankType >, rte::FormalRTE < > >::value >::type > {
+struct normalize < rte::FormalRTE < SymbolType, RankType > > {
 	static rte::FormalRTE < > eval ( rte::FormalRTE < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > constants = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getSubstitutionAlphabet ( ) );
diff --git a/alib2data/src/string/CyclicString.h b/alib2data/src/string/CyclicString.h
index a9da922e630e5df6c1d12ab1dd2a3feb448ef4b4..17b2acbb037b3c9986470e3a847fa4371dfa8f46 100644
--- a/alib2data/src/string/CyclicString.h
+++ b/alib2data/src/string/CyclicString.h
@@ -205,11 +205,6 @@ public:
 	 * @copydoc alib::ObjectBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized string.
-	 */
-	typedef CyclicString < > normalized_type;
 };
 
 } /* namespace string */
@@ -366,7 +361,7 @@ public:
  * \returns new instance of the string with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < string::CyclicString < SymbolType >, typename std::enable_if < ! std::is_same < string::CyclicString < SymbolType >, string::CyclicString < > >::value >::type > {
+struct normalize < string::CyclicString < SymbolType > > {
 	static string::CyclicString < > eval ( string::CyclicString < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::vector < DefaultSymbolType > content = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( value ).getContent ( ) );
diff --git a/alib2data/src/string/Epsilon.h b/alib2data/src/string/Epsilon.h
index 8c5b2b128f39efd2f3228ad1726452b92bb78187..a63d0f7c7bd63e658d09d9ad420d439e23b83058 100644
--- a/alib2data/src/string/Epsilon.h
+++ b/alib2data/src/string/Epsilon.h
@@ -160,11 +160,6 @@ public:
 	 * @copydoc alib::ObjectBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized string.
-	 */
-	typedef Epsilon < > normalized_type;
 };
 
 template < class SymbolType >
@@ -274,7 +269,7 @@ public:
  * \returns new instance of the string with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < string::Epsilon < SymbolType >, typename std::enable_if < ! std::is_same < string::Epsilon < SymbolType >, string::Epsilon < > >::value >::type > {
+struct normalize < string::Epsilon < SymbolType > > {
 	static string::Epsilon < > eval ( string::Epsilon < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 		return string::Epsilon < > ( std::move ( alphabet ) );
diff --git a/alib2data/src/string/LinearString.h b/alib2data/src/string/LinearString.h
index 38ce038ff8c80387f336a5077207c82dc036b6e8..6e38d9c5a3ffe74a163ade78f56dc02cfba5ac5b 100644
--- a/alib2data/src/string/LinearString.h
+++ b/alib2data/src/string/LinearString.h
@@ -209,11 +209,6 @@ public:
 	 * @copydoc alib::ObjectBase::inc()
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
-
-	/**
-	 * Type of normalized string.
-	 */
-	typedef LinearString < > normalized_type;
 };
 
 } /* namespace string */
@@ -382,7 +377,7 @@ public:
  * \returns new instance of the string with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < string::LinearString < SymbolType >, typename std::enable_if < ! std::is_same < string::LinearString < SymbolType >, string::LinearString < > >::value >::type > {
+struct normalize < string::LinearString < SymbolType > > {
 	static string::LinearString < > eval ( string::LinearString < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::vector < DefaultSymbolType > content = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( value ).getContent ( ) );
diff --git a/alib2data/src/tree/ranked/PostfixRankedTree.h b/alib2data/src/tree/ranked/PostfixRankedTree.h
index e399d4d13bf59f2eae89aabfa0dbc9bc75011660..f574d49560769581373ee04658d8801df04200ac 100644
--- a/alib2data/src/tree/ranked/PostfixRankedTree.h
+++ b/alib2data/src/tree/ranked/PostfixRankedTree.h
@@ -230,11 +230,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized tree.
-	 */
-	typedef PostfixRankedTree < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -426,7 +421,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PostfixRankedTree < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PostfixRankedTree < SymbolType, RankType >, tree::PostfixRankedTree < > >::value >::type > {
+struct normalize < tree::PostfixRankedTree < SymbolType, RankType > > {
 	static tree::PostfixRankedTree < > eval ( tree::PostfixRankedTree < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::vector < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( value ).getContent ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
index 01af86773797d4ce536529e04ab8c3ad94ee2381..6768c945d7df698899a94c0a027d6b884121ffc2 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
@@ -398,11 +398,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef PrefixRankedBarNonlinearPattern < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -823,7 +818,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PrefixRankedBarNonlinearPattern < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PrefixRankedBarNonlinearPattern < SymbolType, RankType >, tree::PrefixRankedBarNonlinearPattern < > >::value >::type > {
+struct normalize < tree::PrefixRankedBarNonlinearPattern < SymbolType, RankType > > {
 	static tree::PrefixRankedBarNonlinearPattern < > eval ( tree::PrefixRankedBarNonlinearPattern < SymbolType, RankType > && value ) {
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > variablesBars = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getVariablesBar ( ) );
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
index 48897725384decf76dcf8462338fc3e2a9b986b6..038f9add7958fe98a3db76f82165cb17054a4af2 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -327,11 +327,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef PrefixRankedBarPattern < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -666,7 +661,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PrefixRankedBarPattern < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PrefixRankedBarPattern < SymbolType, RankType >, tree::PrefixRankedBarPattern < > >::value >::type > {
+struct normalize < tree::PrefixRankedBarPattern < SymbolType, RankType > > {
 	static tree::PrefixRankedBarPattern < > eval ( tree::PrefixRankedBarPattern < SymbolType, RankType > && value ) {
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > variablesBars = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getVariablesBar ( ) );
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.h b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
index 7891e1154960afc8d0cfe0b93d0951160d3971a2..6ac150c1e561f4db2571ee32734f3ef82f1879b2 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -273,11 +273,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized tree.
-	 */
-	typedef PrefixRankedBarTree < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -528,7 +523,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PrefixRankedBarTree < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PrefixRankedBarTree < SymbolType, RankType >, tree::PrefixRankedBarTree < > >::value >::type > {
+struct normalize < tree::PrefixRankedBarTree < SymbolType, RankType > > {
 	static tree::PrefixRankedBarTree < > eval ( tree::PrefixRankedBarTree < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getBars ( ) );
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
index 023dcb6873a7399e4c48750d1f8d361450bb0be9..733509e17f38da930ba2ef66fd68c33b52c056eb 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -312,11 +312,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef PrefixRankedNonlinearPattern < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -623,7 +618,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PrefixRankedNonlinearPattern < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PrefixRankedNonlinearPattern < SymbolType, RankType >, tree::PrefixRankedNonlinearPattern < > >::value >::type > {
+struct normalize < tree::PrefixRankedNonlinearPattern < SymbolType, RankType > > {
 	static tree::PrefixRankedNonlinearPattern < > eval ( tree::PrefixRankedNonlinearPattern < SymbolType, RankType > && value ) {
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getNonlinearVariables ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index 73676d30578ac7bebf78cfb1baac1fb8063e7dda..5837d5b12ca1d044e4b3728ec64e78890686b758 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -261,11 +261,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef PrefixRankedPattern < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -498,7 +493,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PrefixRankedPattern < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PrefixRankedPattern < SymbolType, RankType >, tree::PrefixRankedPattern < > >::value >::type > {
+struct normalize < tree::PrefixRankedPattern < SymbolType, RankType > > {
 	static tree::PrefixRankedPattern < > eval ( tree::PrefixRankedPattern < SymbolType, RankType > && value ) {
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index 568e402f0ca922650c49b8d4d62587f9fc631915..c55f72c1ecce9ae999520bdd78bd64885c85c8d0 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -236,11 +236,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized tree.
-	 */
-	typedef PrefixRankedTree < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -435,7 +430,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::PrefixRankedTree < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::PrefixRankedTree < SymbolType, RankType >, tree::PrefixRankedTree < > >::value >::type > {
+struct normalize < tree::PrefixRankedTree < SymbolType, RankType > > {
 	static tree::PrefixRankedTree < > eval ( tree::PrefixRankedTree < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::vector < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( value ).getContent ( ) );
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index 3917aab71c0b261b888124e13846913fa160c018..5e876de0855679cf4a38da758f83bf77539c7338 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -286,11 +286,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef RankedNonlinearPattern < > normalized_type;
-
 	/**
 	 * Nice printer of the tree natural representation
 	 *
@@ -567,7 +562,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::RankedNonlinearPattern < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::RankedNonlinearPattern < SymbolType, RankType >, tree::RankedNonlinearPattern < > >::value >::type > {
+struct normalize < tree::RankedNonlinearPattern < SymbolType, RankType > > {
 	static tree::RankedNonlinearPattern < > eval ( tree::RankedNonlinearPattern < SymbolType, RankType > && value ) {
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getNonlinearVariables ( ) );
diff --git a/alib2data/src/tree/ranked/RankedPattern.h b/alib2data/src/tree/ranked/RankedPattern.h
index c6ccde7ebef9426f48578e1b8d4f3eae717a1228..e07942433fded099938cc9a0e71ba166da8921cf 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -256,11 +256,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef RankedPattern < > normalized_type;
-
 	/**
 	 * Nice printer of the tree natural representation
 	 *
@@ -478,7 +473,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::RankedPattern < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::RankedPattern < SymbolType, RankType >, tree::RankedPattern < > >::value >::type > {
+struct normalize < tree::RankedPattern < SymbolType, RankType > > {
 	static tree::RankedPattern < > eval ( tree::RankedPattern < SymbolType, RankType > && value ) {
 		common::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
diff --git a/alib2data/src/tree/ranked/RankedTree.h b/alib2data/src/tree/ranked/RankedTree.h
index 9a86c2be34a9c19e6bdb3e4c486aa3b08365bdb1..e88a222db95120fbd27c477e56f69f6dcf3a0de2 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -242,11 +242,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized tree.
-	 */
-	typedef RankedTree < > normalized_type;
-
 	/**
 	 * Hierarchical printer of the tree.
 	 *
@@ -432,7 +427,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType, class RankType >
-struct normalize < tree::RankedTree < SymbolType, RankType >, typename std::enable_if < ! std::is_same < tree::RankedTree < SymbolType, RankType >, tree::RankedTree < > >::value >::type > {
+struct normalize < tree::RankedTree < SymbolType, RankType > > {
 	static tree::RankedTree < > eval ( tree::RankedTree < SymbolType, RankType > && value ) {
 		ext::set < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::tree < common::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = tree::TreeNormalize::normalizeRankedTree ( std::move ( value ).getContent ( ) );
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.h b/alib2data/src/tree/unranked/PrefixBarTree.h
index 0c1a55f98632ad1aa0932aa4be38a40561bc9ab7..dcc4a7042bffffa41ad3962c81fbac2b6ebe1573 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.h
+++ b/alib2data/src/tree/unranked/PrefixBarTree.h
@@ -261,11 +261,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized tree.
-	 */
-	typedef PrefixBarTree < > normalized_type;
-
 	/**
 	 * \brief Creates a new instance of the string from a linear representation of a tree
 	 *
@@ -493,7 +488,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < tree::PrefixBarTree < SymbolType >, typename std::enable_if < ! std::is_same < tree::PrefixBarTree < SymbolType >, tree::PrefixBarTree < > >::value >::type > {
+struct normalize < tree::PrefixBarTree < SymbolType > > {
 	static tree::PrefixBarTree < > eval ( tree::PrefixBarTree < SymbolType > && value ) {
 		DefaultSymbolType bar = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getBar ( ) );
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index f6f2a92aeff826642c1a8b065b2d94f6f7742f2a..610807f8ed4e860282a4bae2725d69f31d1dd502 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -275,11 +275,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef UnrankedNonlinearPattern < > normalized_type;
-
 	/**
 	 * Nice printer of the tree natural representation
 	 *
@@ -537,7 +532,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < tree::UnrankedNonlinearPattern < SymbolType >, typename std::enable_if < ! std::is_same < tree::UnrankedNonlinearPattern < SymbolType >, tree::UnrankedNonlinearPattern < > >::value >::type > {
+struct normalize < tree::UnrankedNonlinearPattern < SymbolType > > {
 	static tree::UnrankedNonlinearPattern < > eval ( tree::UnrankedNonlinearPattern < SymbolType > && value ) {
 		DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
 		ext::set < DefaultSymbolType > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getNonlinearVariables ( ) );
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index 5303511294ec4f189fc87f606b8dacacb07bb459..f1e85f9ec67f16f5d8f74945809579d543e931a7 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -246,11 +246,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef UnrankedPattern < > normalized_type;
-
 	/**
 	 * Nice printer of the tree natural representation
 	 *
@@ -454,7 +449,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < tree::UnrankedPattern < SymbolType >, typename std::enable_if < ! std::is_same < tree::UnrankedPattern < SymbolType >, tree::UnrankedPattern < > >::value >::type > {
+struct normalize < tree::UnrankedPattern < SymbolType > > {
 	static tree::UnrankedPattern < > eval ( tree::UnrankedPattern < SymbolType > && value ) {
 		DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( value ).getSubtreeWildcard ( ) );
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index d3742c914502b5329eb81e89921115c8ebc219cc..566dd64f2e050eba9bccaacc4b7aaedeff0773c8 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -224,11 +224,6 @@ public:
 	 */
 	virtual object::ObjectBase * inc ( ) && override;
 
-	/**
-	 * Type of normalized pattern.
-	 */
-	typedef UnrankedTree < > normalized_type;
-
 	/**
 	 * Nice printer of the tree natural representation
 	 *
@@ -398,7 +393,7 @@ public:
  * \returns new instance of the tree with default template parameters or unmodified instance if the template parameters were already default ones
  */
 template < class SymbolType >
-struct normalize < tree::UnrankedTree < SymbolType >, typename std::enable_if < ! std::is_same < tree::UnrankedTree < SymbolType >, tree::UnrankedTree < > >::value >::type > {
+struct normalize < tree::UnrankedTree < SymbolType > > {
 	static tree::UnrankedTree < > eval ( tree::UnrankedTree < SymbolType > && value ) {
 		ext::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( value ).getAlphabet ( ) );
 		ext::tree < DefaultSymbolType > content = tree::TreeNormalize::normalizeTree ( std::move ( value ).getContent ( ) );
diff --git a/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h b/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h
index 2bbc688bc8faa26edf67bacaef9e843483c3023e..8a0928bac2b19005f1066e43f7a037df5a936c3f 100644
--- a/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h
+++ b/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h
@@ -90,8 +90,6 @@ public:
 	}
 
 	object::ObjectBase * inc ( ) && override;
-
-	typedef AdjacencyListDirectedGraph normalized_type;
 };
 
 } // namespace graph
diff --git a/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h b/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h
index 4a344aebb02a5da21e5e21b63ce68f9d1496c85a..14f62480b9505073d9ca5767757dc9a6bbc4a262 100644
--- a/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h
+++ b/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h
@@ -93,8 +93,6 @@ public:
 	}
 
 	object::ObjectBase * inc ( ) && override;
-
-	typedef AdjacencyMatrixDirectedGraph normalized_type;
 };
 
 } // namespace graph
diff --git a/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h b/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h
index 70cc934bf2ee9efe8d4c6c0795bb3e1c5f30533d..bc81187a94c0243fdb53e781ec76c356a04a2c4f 100644
--- a/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h
+++ b/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h
@@ -87,8 +87,6 @@ public:
 	}
 
 	object::ObjectBase * inc ( ) && override;
-
-	typedef AdjacencyListUndirectedGraph normalized_type;
 };
 
 } // namespace graph
diff --git a/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h b/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h
index a8b56cf1ac34eb359e486d4eb590f6d256400f11..528d4d727944afca7e797364c04d13e1aa55bb22 100644
--- a/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h
+++ b/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h
@@ -90,8 +90,6 @@ public:
 	}
 
 	object::ObjectBase * inc ( ) && override;
-
-	typedef AdjacencyMatrixUndirectedGraph normalized_type;
 };
 
 } // namespace graph
diff --git a/alib2data_experimental/src/indexes/stringology/CompactSuffixAutomatonTerminatingSymbol.h b/alib2data_experimental/src/indexes/stringology/CompactSuffixAutomatonTerminatingSymbol.h
index 7a2ec0d3df4212fd95005ce1977e4c53ab41485d..c6ca7cfce6193f083b050152444c71a8be41fb32 100644
--- a/alib2data_experimental/src/indexes/stringology/CompactSuffixAutomatonTerminatingSymbol.h
+++ b/alib2data_experimental/src/indexes/stringology/CompactSuffixAutomatonTerminatingSymbol.h
@@ -156,8 +156,6 @@ public:
 
 	virtual object::ObjectBase * inc ( ) &&;
 
-	typedef CompactSuffixAutomatonTerminatingSymbol < > normalized_type;
-
 };
 
 template < class SymbolType >
@@ -223,7 +221,7 @@ object::ObjectBase* CompactSuffixAutomatonTerminatingSymbol < SymbolType >::inc(
 namespace core {
 
 template < class SymbolType >
-struct normalize < indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < SymbolType >, typename std::enable_if < ! std::is_same < indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < SymbolType >, indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < > >::value >::type > {
+struct normalize < indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < SymbolType > > {
 	static indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < > eval ( indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < SymbolType > && value ) {
 		indexes::stringology::CompactSuffixAutomatonTerminatingSymbol < DefaultStateType > res;
 		res.setString ( alphabet::SymbolNormalize::normalizeSymbols ( std::move ( value ).getString ( ) ) );
diff --git a/alib2data_experimental/src/indexes/stringology/SuffixTrieTerminatingSymbol.h b/alib2data_experimental/src/indexes/stringology/SuffixTrieTerminatingSymbol.h
index e645650589ab8c8a3c2302c902ce57580331c288..43c087946fb9a8a9d6f91af8b769d0c70f8d5fb1 100644
--- a/alib2data_experimental/src/indexes/stringology/SuffixTrieTerminatingSymbol.h
+++ b/alib2data_experimental/src/indexes/stringology/SuffixTrieTerminatingSymbol.h
@@ -98,8 +98,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef SuffixTrieTerminatingSymbol normalized_type;
 };
 
 } /* namespace tree */
diff --git a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
index 25f652a9eba4ace505f41485c8187c279d7297ec..5947d522e6f654befb85f5665598fe67aebc0bc1 100644
--- a/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
+++ b/alib2data_experimental/src/string/LinearStringTerminatingSymbol.h
@@ -85,8 +85,6 @@ public:
 	virtual explicit operator std::string ( ) const;
 
 	virtual object::ObjectBase * inc ( ) &&;
-
-	typedef LinearStringTerminatingSymbol normalized_type;
 };
 
 } /* namespace string */