diff --git a/alib2std/src/extensions/memory.hpp b/alib2std/src/extensions/memory.hpp
index 1ee1dff21bdd62da278eacfc4a460a5edaadc44e..cd49a08947e5f29775ed1fef317f239b1a449e45 100644
--- a/alib2std/src/extensions/memory.hpp
+++ b/alib2std/src/extensions/memory.hpp
@@ -252,15 +252,15 @@ private:
 
 };
 
-template<class T>
+template < class T >
 class smart_ptr {
 	T * m_Data;
-public:
 
+public:
 	smart_ptr ( ) : m_Data ( NULL ) {
 	}
 
-	smart_ptr ( T * data ) : m_Data ( data ){
+	smart_ptr ( T * data ) : m_Data ( data ) {
 	}
 
 	smart_ptr ( const smart_ptr < T > & other ) : m_Data ( std::clone ( other.m_Data ) ) {
@@ -293,7 +293,7 @@ public:
 		return m_Data;
 	}
 
-	T const * operator ->( ) const {
+	T * operator ->( ) const {
 		return m_Data;
 	}
 
@@ -301,7 +301,7 @@ public:
 		return * m_Data;
 	}
 
-	T const & operator *( ) const {
+	T & operator *( ) const {
 		return * m_Data;
 	}
 
@@ -309,7 +309,7 @@ public:
 		return m_Data;
 	}
 
-	T const * get ( ) const {
+	T * get ( ) const {
 		return m_Data;
 	}
 
@@ -409,9 +409,9 @@ std::unique_ptr < T > make_unique ( Args && ... args ) {
 	return std::unique_ptr < T > ( new T ( std::forward < Args > ( args ) ... ) );
 }
 
-template < typename T >
-std::unique_ptr < typename std::decay < T >::type > copy_unique ( const std::unique_ptr < T > & ptr ) {
-	return ptr ? std::make_unique < typename std::decay < T >::type > ( * ptr ) : nullptr;
+template < typename T, typename ... Args >
+std::smart_ptr < T > make_smart ( Args && ... args ) {
+	return std::smart_ptr < T > ( new T ( std::forward < Args > ( args ) ... ) );
 }
 
 } /* namespace std */
diff --git a/alib2std/src/extensions/tuple.hpp b/alib2std/src/extensions/tuple.hpp
index e54377aa1118f0fd308e23bbee71d33f15cbfeca..d7a71445dd3faad7f78f8dc85f945c9d500ed81a 100644
--- a/alib2std/src/extensions/tuple.hpp
+++ b/alib2std/src/extensions/tuple.hpp
@@ -36,35 +36,39 @@ std::ostream& operator<<(std::ostream& out, const std::tuple<Ts...>& tuple) {
 	return out;
 }
 
-template<int I, typename Tuple>
+template < int I, typename Tuple >
 struct compareTupleHelper;
 
-template<int I, typename Tuple>
+template < int I, typename Tuple >
 struct compareTupleHelper {
-	static int compHelp(const Tuple& t1, const Tuple& t2) {
-		compare<typename std::decay < typename tuple_element<I, Tuple>::type >::type > comp;
-		int res = comp(std::get<I>(t1), std::get<I>(t2));
-		if(res != 0) return res;
-		return compareTupleHelper<I - 1, Tuple>::compHelp(t1, t2);
+	static int compHelp ( const Tuple & t1, const Tuple & t2 ) {
+		int res = compareTupleHelper < I - 1, Tuple >::compHelp ( t1, t2 );
+
+		if ( res != 0 ) return res;
+
+		compare < typename std::decay < typename tuple_element < I, Tuple >::type >::type > comp;
+		return comp ( std::get < I > ( t1 ), std::get < I > ( t2 ) );
 	}
+
 };
 
-template<class Tuple>
-struct compareTupleHelper<0, Tuple> {
-	static int compHelp(const Tuple& t1, const Tuple& t2) {
-		compare<typename std::decay < typename tuple_element<0, Tuple>::type >::type > comp;
-		return comp(std::get<0>(t1), std::get<0>(t2));
+template < class Tuple >
+struct compareTupleHelper < 0, Tuple > {
+	static int compHelp ( const Tuple & t1, const Tuple & t2 ) {
+		compare < typename std::decay < typename tuple_element < 0, Tuple >::type >::type > comp;
+		return comp ( std::get < 0 > ( t1 ), std::get < 0 > ( t2 ) );
 	}
+
 };
 
-template<typename ... Ts>
-struct compare<tuple<Ts...>> {
-	int operator()(const tuple<Ts...>& first, const tuple<Ts...>& second) const {
-		return compareTupleHelper<tuple_size<std::tuple<Ts...>>::value - 1, std::tuple<Ts...>>::compHelp(first, second);
+template < typename ... Ts >
+struct compare < tuple < Ts ... > > {
+	int operator ()( const tuple < Ts ... > & first, const tuple < Ts ... > & second ) const {
+		return compareTupleHelper < tuple_size < std::tuple < Ts ... > >::value - 1, std::tuple < Ts ... > >::compHelp ( first, second );
 	}
+
 };
 
 } /* namespace std */
 
 #endif /* __TUPLE_HPP_ */
-