Index: trunk/nv/core/random.hh
===================================================================
--- trunk/nv/core/random.hh	(revision 384)
+++ trunk/nv/core/random.hh	(revision 385)
@@ -10,5 +10,5 @@
 #include <nv/core/common.hh>
 #include <nv/stl/math.hh>
-#include <nv/stl/traits/primary.hh>
+#include <nv/stl/type_traits/primary.hh>
 
 namespace nv
Index: trunk/nv/core/types.hh
===================================================================
--- trunk/nv/core/types.hh	(revision 384)
+++ trunk/nv/core/types.hh	(revision 385)
@@ -10,5 +10,5 @@
 #include <nv/stl/memory.hh>
 #include <nv/stl/cstring_store.hh>
-#include <nv/stl/traits/properties.hh>
+#include <nv/stl/type_traits/properties.hh>
 #include <unordered_map>
 #include <vector>
Index: trunk/nv/lua/lua_state.hh
===================================================================
--- trunk/nv/lua/lua_state.hh	(revision 384)
+++ trunk/nv/lua/lua_state.hh	(revision 385)
@@ -15,5 +15,5 @@
 #include <nv/stl/flags.hh>
 #include <nv/stl/handle.hh>
-#include <nv/stl/traits/function.hh>
+#include <nv/stl/type_traits/function.hh>
 
 #include <nv/lua/lua_handle.hh>
Index: trunk/nv/lua/lua_values.hh
===================================================================
--- trunk/nv/lua/lua_values.hh	(revision 384)
+++ trunk/nv/lua/lua_values.hh	(revision 385)
@@ -9,5 +9,5 @@
 
 #include <nv/core/common.hh>
-#include <nv/stl/traits/properties.hh>
+#include <nv/stl/type_traits/properties.hh>
 #include <nv/stl/string.hh>
 
Index: trunk/nv/stl/flags.hh
===================================================================
--- trunk/nv/stl/flags.hh	(revision 384)
+++ trunk/nv/stl/flags.hh	(revision 385)
@@ -15,5 +15,5 @@
 
 #include <nv/core/common.hh>
-#include <nv/stl/traits/transforms.hh>
+#include <nv/stl/type_traits/transforms.hh>
 #include <nv/stl/algorithm.hh>
 
Index: trunk/nv/stl/memory.hh
===================================================================
--- trunk/nv/stl/memory.hh	(revision 384)
+++ trunk/nv/stl/memory.hh	(revision 385)
@@ -17,6 +17,6 @@
 
 #include <nv/core/common.hh>
-#include <nv/stl/traits/properties.hh>
-#include <nv/stl/traits/alignment.hh>
+#include <nv/stl/type_traits/properties.hh>
+#include <nv/stl/type_traits/alignment.hh>
 #include <nv/stl/utility.hh>
 #include <nv/stl/iterator.hh>
Index: trunk/nv/stl/range.hh
===================================================================
--- trunk/nv/stl/range.hh	(revision 384)
+++ trunk/nv/stl/range.hh	(revision 385)
@@ -16,5 +16,5 @@
 #include <nv/stl/math.hh>
 #include <nv/stl/iterator.hh>
-#include <nv/stl/traits/transforms.hh>
+#include <nv/stl/type_traits/transforms.hh>
 
 namespace nv
Index: trunk/nv/stl/string.hh
===================================================================
--- trunk/nv/stl/string.hh	(revision 384)
+++ trunk/nv/stl/string.hh	(revision 385)
@@ -24,5 +24,5 @@
 #include <sstream>
 #include <nv/core/common.hh>
-#include <nv/stl/traits/primary.hh>
+#include <nv/stl/type_traits/primary.hh>
 #include <nv/stl/memory.hh>
 #include <nv/stl/exception.hh>
Index: trunk/nv/stl/type_traits.hh
===================================================================
--- trunk/nv/stl/type_traits.hh	(revision 384)
+++ trunk/nv/stl/type_traits.hh	(revision 385)
@@ -24,10 +24,10 @@
 
 #include <nv/core/common.hh>
-#include <nv/stl/traits/common.hh>
-#include <nv/stl/traits/primary.hh>
-#include <nv/stl/traits/properties.hh>
-#include <nv/stl/traits/alignment.hh>
-#include <nv/stl/traits/transforms.hh>
-#include <nv/stl/traits/function.hh>
+#include <nv/stl/type_traits/common.hh>
+#include <nv/stl/type_traits/primary.hh>
+#include <nv/stl/type_traits/properties.hh>
+#include <nv/stl/type_traits/alignment.hh>
+#include <nv/stl/type_traits/transforms.hh>
+#include <nv/stl/type_traits/function.hh>
 
 #endif // NV_STL_TYPE_TRAITS_HH
Index: trunk/nv/stl/type_traits/alignment.hh
===================================================================
--- trunk/nv/stl/type_traits/alignment.hh	(revision 385)
+++ trunk/nv/stl/type_traits/alignment.hh	(revision 385)
@@ -0,0 +1,137 @@
+// Copyright (C) 2015 ChaosForge Ltd
+// http://chaosforge.org/
+//
+// This file is part of NV Libraries.
+// For conditions of distribution and use, see copyright notice in nv.hh
+/**
+* @file alignment.hh
+* @author Kornel Kisielewicz epyon@chaosforge.org
+* @brief type traits - alignment
+*/
+
+#ifndef NV_STL_TRAITS_ALIGNMENT_HH
+#define NV_STL_TRAITS_ALIGNMENT_HH
+
+#include <nv/core/common.hh>
+#include <nv/stl/type_traits/common.hh>
+
+namespace nv
+{
+
+	namespace detail
+	{
+		class aligned_dummy;
+		typedef void( *aligned_fptr )( );
+		typedef int( aligned_dummy::*aligned_memptr );
+		typedef int ( aligned_dummy::*aligned_memfptr )( );
+	}
+
+#if NV_COMPILER == NV_MSVC 
+#pragma warning( push )
+#pragma warning( disable : 4121 ) 
+#endif		
+	union max_align_t
+	{
+		double                  dummy0;
+		long double             dummy1;
+		void*                   dummy2;
+		long long               dummy3;
+		detail::aligned_fptr    dummy4;
+		detail::aligned_memptr  dummy5;
+		detail::aligned_memfptr dummy6;
+	};
+#if NV_COMPILER == NV_MSVC 
+#pragma warning( pop )
+#endif		
+
+#if NV_COMPILER == NV_CLANG
+	template< typename T, size_t Size, size_t Align >
+	struct aligned_array
+	{
+		typedef T alignas( Align ) type[Size];
+	};
+#elif NV_COMPILER == NV_GNUC
+	template< typename T, size_t Size, size_t Align >
+	struct aligned_array
+	{
+		typedef T __attribute__( ( aligned( Align ) ) ) type[Size];
+	};
+#else
+	// TODO: remove this shit after moving to MSVC 2015
+	template< typename T, size_t Size, size_t Align >
+	struct aligned_array;
+
+	// According to LLVM ( https://llvm.org/svn/llvm-project/llvm/trunk/include/llvm/Support/AlignOf.h )
+	// MSVC has problems with align below 16...
+#define NV_ALIGNED_ARRAY(N) \
+	template< typename T, size_t Size > \
+	struct aligned_array< T, Size, N >  \
+			{ \
+		typedef __declspec( align(N) ) T type[Size]; \
+			}; 
+
+	NV_ALIGNED_ARRAY( 1 )
+		NV_ALIGNED_ARRAY( 2 )
+		NV_ALIGNED_ARRAY( 4 )
+		NV_ALIGNED_ARRAY( 8 )
+		NV_ALIGNED_ARRAY( 16 )
+		NV_ALIGNED_ARRAY( 32 )
+		NV_ALIGNED_ARRAY( 64 )
+		NV_ALIGNED_ARRAY( 128 )
+
+#undef NV_ALIGNED_ARRAY
+#endif
+	
+	template< typename T, size_t Size, size_t Align >
+	using aligned_array_t = typename aligned_array< T, Size, Align >::type;
+
+	template< size_t Size, size_t Align = alignof( max_align_t ) >
+	struct aligned_storage
+	{
+		struct type
+		{
+			typename aligned_array< unsigned char, Size, Align >::type data;
+		};
+	};
+
+	template< size_t Size, size_t Align = alignof( max_align_t ) >
+	using aligned_storage_t = typename aligned_storage<Size, Align>::type;
+
+	namespace detail
+	{
+		template < size_t... Sizes >
+		struct size_max;
+
+		template <>
+		struct size_max < >
+		{
+			static constexpr size_t value = 0;
+		};
+
+		template < size_t Size >
+		struct size_max < Size >
+		{
+			static constexpr size_t value = Size;
+		};
+
+		template < size_t S1, size_t S2, size_t... Sizes >
+		struct size_max< S1, S2, Sizes... > : size_max < ( S1 < S2 ? S2 : S1 ), Sizes... > {};
+	}
+
+	template< size_t Size, typename... Types >
+	struct aligned_union
+	{
+		static constexpr size_t max_length = detail::size_max < Size, sizeof( Types )... >::value;
+		static constexpr size_t alignment_value = detail::size_max < alignment_of< Types >::value... >::value;
+		struct type
+		{
+			typename aligned_array< unsigned char, max_length, alignment_value >::type data;
+		};
+	};
+
+	template < size_t Size, typename... Types >
+	using aligned_union_t = typename aligned_union<Size, Types...>::type;
+
+}
+
+#endif // NV_STL_TRAITS_ALIGNMENT_HH
Index: trunk/nv/stl/type_traits/common.hh
===================================================================
--- trunk/nv/stl/type_traits/common.hh	(revision 385)
+++ trunk/nv/stl/type_traits/common.hh	(revision 385)
@@ -0,0 +1,190 @@
+// Copyright (C) 2015 ChaosForge Ltd
+// http://chaosforge.org/
+//
+// This file is part of NV Libraries.
+// For conditions of distribution and use, see copyright notice in nv.hh
+/**
+* @file common.hh
+* @author Kornel Kisielewicz epyon@chaosforge.org
+* @brief type traits - common traits used everywhere
+*/
+
+#ifndef NV_STL_TRAITS_COMMON_HH
+#define NV_STL_TRAITS_COMMON_HH
+
+#include <nv/core/common.hh>
+
+namespace nv
+{
+
+	template< typename T, T VALUE>
+	struct integral_constant
+	{
+		static constexpr T value = VALUE;
+		typedef T value_type;
+		typedef integral_constant<T, VALUE> type;
+		constexpr operator value_type() const noexcept { return value; }
+		constexpr value_type operator()() const noexcept { return value; }
+	};
+
+	// TODO: Propagate
+	template< bool B >
+	using bool_constant = integral_constant < bool, B > ;
+
+	typedef bool_constant<true> true_type;
+	typedef bool_constant<false> false_type;
+
+	template< bool Test, typename T = void>
+	struct enable_if {};
+
+	template< typename T >
+	struct enable_if < true, T >
+	{
+		typedef T type;
+	};
+
+	template< bool Test, typename T = void>
+	using enable_if_t = typename enable_if< Test, T >::type;
+
+	template< bool Test, typename T1, typename T2 >
+	struct conditional
+	{
+		typedef T2 type;
+	};
+
+	template< typename T1, typename T2>
+	struct conditional < true, T1, T2 >
+	{
+		typedef T1 type;
+	};
+
+	template< bool Test, typename T1, typename T2 >
+	using conditional_t = typename conditional< Test, T1, T2 >::type;
+
+	template < typename T1, typename T2 >
+	struct is_same : false_type {};
+
+	template < typename T >
+	struct is_same < T, T > : true_type{};
+
+	// TODO: these seem to simple compared to MSVC/GCC - so we'll leave them in
+	// detail - research why it is so.
+	template < typename T >	struct is_const : false_type {};
+	template < typename T > struct is_const < T const > : true_type{};
+	template < typename T > struct is_volatile : false_type {};
+	template < typename T > struct is_volatile < T volatile > : true_type{};
+	// TODO END
+
+	// add const volatile and reference mutators
+
+	template< typename T > struct add_const          { typedef const T type; };
+	template< typename T > struct add_volatile       { typedef volatile T type; };
+	template< typename T > struct add_cv             { typedef const volatile T type; };
+	
+	template< typename T > struct add_reference             { typedef T& type; };
+	template<> struct add_reference < void >                { typedef void type; };
+	template<> struct add_reference < const void >          { typedef void type; };
+	template<> struct add_reference < volatile void >       { typedef void type; };
+	template<> struct add_reference < const volatile void > { typedef void type; };
+
+	template< typename T > struct add_rvalue_reference             { typedef T&& type; };
+	template<> struct add_rvalue_reference < void >                { typedef void type; };
+	template<> struct add_rvalue_reference < const void >          { typedef void type; };
+	template<> struct add_rvalue_reference < volatile void >       { typedef void type; };
+	template<> struct add_rvalue_reference < const volatile void > { typedef void type; };
+
+	template< typename T > using add_lvalue_reference = add_reference<T>;
+
+	template< typename T > using add_const_t            = typename add_const<T>::type;
+	template< typename T > using add_volatile_t         = typename add_volatile<T>::type;
+	template< typename T > using add_cv_t               = typename add_cv<T>::type;
+	template< typename T > using add_reference_t        = typename add_reference<T>::type;
+	template< typename T > using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+	template< typename T > using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+	// remove const volatile and reference mutators
+
+	template< typename T > struct remove_reference { typedef T type; };
+	template< typename T > struct remove_reference < T& >                     { typedef T type; };
+	template< typename T > struct remove_reference < T&& >                    { typedef T type; };
+
+	template< typename T > struct remove_const                                { typedef T type; };
+	template< typename T > struct remove_const < const T >                    { typedef T type; };
+	template< typename T > struct remove_const < const T[] >                  { typedef T type[]; };
+	template< typename T, unsigned int N > struct remove_const < const T[N] > { typedef T type[N]; };
+
+	template< typename T > struct remove_volatile                             { typedef T type; };
+	template< typename T > struct remove_volatile < volatile T >              { typedef T type; };
+	template< typename T > struct remove_volatile < volatile T[] >            { typedef T type[]; };
+	template< typename T, unsigned int N > struct remove_volatile < volatile T[N] > { typedef T type[N]; };
+
+	template< typename T >
+	struct remove_cv
+	{
+		typedef typename remove_const< typename remove_volatile<T>::type >::type type;
+	};
+
+	template< typename T >
+	struct remove_cvr
+	{
+		typedef typename remove_cv< typename remove_reference<T>::type >::type type;
+	};
+
+	template< typename T > using remove_reference_t = typename remove_reference<T>::type;
+	template< typename T > using remove_const_t     = typename remove_const<T>::type;
+	template< typename T > using remove_volatile_t  = typename remove_volatile<T>::type;
+	template< typename T > using remove_cvr_t       = typename remove_cvr<T>::type;
+	template< typename T > using remove_cv_t        = typename remove_cv<T>::type;
+
+	// pointer/array mutators
+
+	template< typename T > struct add_pointer { typedef typename remove_reference<T>::type *type; };
+	
+	template< typename T > struct remove_pointer { typedef T type; };
+	template< typename T > struct remove_pointer < T* > { typedef T type; };
+	template< typename T > struct remove_pointer < T* const > { typedef T type; };
+	template< typename T > struct remove_pointer < T* volatile > { typedef T type; };
+	template< typename T > struct remove_pointer < T* const volatile > { typedef T type; };
+
+	template< typename T > struct remove_extent { typedef T type; };
+	template< typename T > struct remove_extent < T[] > { typedef T type; };
+	template< typename T, unsigned int N > struct remove_extent < T[N] > { typedef T type; };
+
+	template< typename T > struct remove_all_extents { typedef T type; };
+	template< typename T > struct remove_all_extents < T[] > { typedef typename remove_all_extents<T>::type type; };
+	template< typename T, unsigned int N > struct remove_all_extents < T[N] > { typedef typename remove_all_extents<T>::type type; };
+
+	template< typename T > using add_pointer_t        = typename add_pointer<T>::type;
+	template< typename T > using remove_pointer_t     = typename remove_pointer<T>::type;
+	template< typename T > using remove_extent_t      = typename remove_extent<T>::type;
+	template< typename T > using remove_all_extents_t = typename remove_all_extents<T>::type;
+
+	template < typename T >	struct is_lvalue_reference : false_type {};
+	template < typename T >	struct is_lvalue_reference < T& > : true_type{};
+	template < typename T >	struct is_rvalue_reference : false_type {};
+	template < typename T >	struct is_rvalue_reference < T&& > : true_type{};
+
+	template < typename T >
+	typename add_rvalue_reference<T>::type declval();
+
+	template< typename T >
+	constexpr typename remove_reference<T>::type&& move( T&& arg ) noexcept
+	{
+		return ( ( typename remove_reference<T>::type&& )arg );
+	}
+
+	template < typename T >
+	constexpr T&& forward( typename remove_reference<T>::type& t )
+	{
+		return static_cast<T&&>( t );
+	}
+
+	template < typename T >
+	constexpr T&& forward( typename remove_reference<T>::type&& t ) noexcept
+	{
+		static_assert( !is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue." );
+		return static_cast<T&&>( t );
+	}
+}
+
+#endif // NV_STL_TRAITS_COMMON_HH
Index: trunk/nv/stl/type_traits/function.hh
===================================================================
--- trunk/nv/stl/type_traits/function.hh	(revision 385)
+++ trunk/nv/stl/type_traits/function.hh	(revision 385)
@@ -0,0 +1,93 @@
+// Copyright (C) 2015 ChaosForge Ltd
+// http://chaosforge.org/
+//
+// This file is part of NV Libraries.
+// For conditions of distribution and use, see copyright notice in nv.hh
+/**
+* @file function.hh
+* @author Kornel Kisielewicz epyon@chaosforge.org
+* @brief type traits - function traits
+*/
+// TODO: remove_cv? call traits? support "......"?
+
+#ifndef NV_STL_TRAITS_FUNCTION_HH
+#define NV_STL_TRAITS_FUNCTION_HH
+
+#include <nv/core/common.hh>
+#include <nv/stl/type_traits/common.hh>
+
+namespace nv
+{
+
+	namespace detail
+	{
+
+		template < typename F >
+		struct function_traits_impl
+		{
+
+		};
+
+		template < typename R >
+		struct function_traits_impl < R( *)( void ) >
+		{
+			typedef R( *type )( );
+			typedef R        return_type;
+			typedef void     class_type;
+			static constexpr int arg_count = 0;
+		};
+
+		template < typename R, typename... Args >
+		struct function_traits_impl < R( *)( Args... ) >
+		{
+			typedef R( *type )( Args... );
+			typedef R        return_type;
+			typedef void     class_type;
+			static constexpr int arg_count = sizeof...( Args );
+		};
+
+		template < class C, typename R >
+		struct function_traits_impl < R( C::* )( ) >
+		{
+			typedef R( *type )( );
+			typedef R       return_type;
+			typedef C       class_type;
+			static constexpr int arg_count = 0;
+		};
+
+		template < class C, typename R, typename... Args >
+		struct function_traits_impl < R( C::* )( Args... ) >
+		{
+			typedef R( C::*type )( Args... );
+			typedef R        return_type;
+			typedef C        class_type;
+			static constexpr int arg_count = sizeof...( Args );
+		};
+
+	}
+
+	template < typename F >
+	struct function_traits : detail::function_traits_impl < F >
+	{
+
+	};
+
+	template < typename T >
+	struct return_type
+	{
+		typedef typename function_traits< T >::return_type type;
+	};
+	template < typename T >
+	using return_type_t = typename return_type<T>::type;
+
+	template < typename T >
+	struct memfn_class_type
+	{
+		typedef typename function_traits< T >::class_type type;
+	};
+	template < typename T >
+	using memfn_class_type_t = typename memfn_class_type<T>::type;
+
+}
+
+#endif // NV_STL_TRAITS_FUNCTION_HH
Index: trunk/nv/stl/type_traits/primary.hh
===================================================================
--- trunk/nv/stl/type_traits/primary.hh	(revision 385)
+++ trunk/nv/stl/type_traits/primary.hh	(revision 385)
@@ -0,0 +1,119 @@
+// Copyright (C) 2015 ChaosForge Ltd
+// http://chaosforge.org/
+//
+// This file is part of NV Libraries.
+// For conditions of distribution and use, see copyright notice in nv.hh
+/**
+* @file primary.hh
+* @author Kornel Kisielewicz epyon@chaosforge.org
+* @brief type traits - primary traits
+*/
+
+#ifndef NV_STL_TRAITS_PRIMARY_HH
+#define NV_STL_TRAITS_PRIMARY_HH
+
+#include <nv/core/common.hh>
+#include <nv/stl/type_traits/common.hh>
+
+namespace nv
+{
+
+	namespace detail
+	{
+		template< typename T > struct is_integral_impl           : false_type {};
+		template<> struct is_integral_impl< bool >               : true_type{};
+		template<> struct is_integral_impl< char >               : true_type{};
+		template<> struct is_integral_impl< signed char >        : true_type{};
+		template<> struct is_integral_impl< unsigned char >      : true_type{};
+		template<> struct is_integral_impl< wchar_t >            : true_type{};
+		template<> struct is_integral_impl< signed short >       : true_type{};
+		template<> struct is_integral_impl< unsigned short >     : true_type{};
+		template<> struct is_integral_impl< signed int >         : true_type{};
+		template<> struct is_integral_impl< unsigned int >       : true_type{};
+		template<> struct is_integral_impl< signed long >        : true_type{};
+		template<> struct is_integral_impl< unsigned long >      : true_type{};
+		template<> struct is_integral_impl< signed long long >   : true_type{};
+		template<> struct is_integral_impl< unsigned long long > : true_type{};
+
+		template< typename T > struct is_floating_point_impl     : false_type {};
+		template<> struct is_floating_point_impl< float >        : true_type{};
+		template<> struct is_floating_point_impl< double >       : true_type{};
+		template<> struct is_floating_point_impl< long double >  : true_type{};
+
+		template < typename T > struct is_pointer_impl           : false_type {};
+		template < typename T > struct is_pointer_impl< T* >     : true_type{};
+	}
+
+	template< typename T > struct is_void           : is_same < void,      remove_cv_t<T> > {};
+	template< typename T > struct is_nullptr        : is_same < nullptr_t, remove_cv_t<T> > {};
+	template< typename T > struct is_integral       : detail::is_integral_impl < remove_cv_t<T> > {};
+	template< typename T > struct is_floating_point : detail::is_floating_point_impl < remove_cv_t<T> > {};
+
+	template < typename T >           struct is_array          : false_type {};
+	template < typename T >           struct is_array < T[] >  : true_type{};
+	template < typename T, size_t N > struct is_array < T[N] > : true_type{};
+
+	template < typename T >           struct is_enum  : bool_constant < __is_enum( T ) > {};
+	template < typename T >           struct is_union : bool_constant < __is_union( T ) > {};
+	template < typename T >           struct is_class : bool_constant < __is_class( T ) > {};
+
+	// is_function_pointer / is_member_function pointer - extension
+	// TODO: sanity check - this is very different - http://en.cppreference.com/w/cpp/types/is_function
+	// TODO: "......" function match version?
+	// TODO: call conventions really needed?
+
+	template < typename F > struct is_function_pointer : false_type {};
+#if NV_COMPILER == NV_MSVC
+	template < typename R, typename... Args > struct is_function_pointer< R( __cdecl * )( Args... ) > : true_type{};
+	template < typename R, typename... Args > struct is_function_pointer< R( __stdcall * )( Args... ) > : true_type{};
+	template < typename R, typename... Args > struct is_function_pointer< R( __fastcall * )( Args... ) > : true_type{};
+	template < typename R, typename... Args > struct is_function_pointer< R( __vectorcall * )( Args... ) > : true_type{};
+#else
+	template < typename R, typename... Args > struct is_function_pointer< R( *)( Args... ) > : true_type{};
+#endif
+
+	template < typename C > struct is_member_function_pointer : false_type {};
+#if NV_COMPILER == NV_MSVC
+#define NV_IS_MEMFNPTR( call_conv ) \
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( call_conv C::* )( Args... ) > : true_type{}; \
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( call_conv C::* )( Args... ) const > : true_type{}; \
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( call_conv C::* )( Args... ) volatile > : true_type{}; \
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( call_conv C::* )( Args... ) const volatile > : true_type{};
+
+NV_IS_MEMFNPTR( __thiscall )
+NV_IS_MEMFNPTR( __cdecl )
+NV_IS_MEMFNPTR( __stdcall )
+NV_IS_MEMFNPTR( __fastcall )
+NV_IS_MEMFNPTR( __vectorcall )
+
+#undef NV_IS_MEMFNPTR
+#else
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( C::* )( Args... ) > : true_type{};
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( C::* )( Args... ) const > : true_type{};
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( C::* )( Args... ) volatile > : true_type{};
+	template < typename R, typename C, typename... Args > struct is_member_function_pointer< R( C::* )( Args... ) const volatile > : true_type{};
+#endif
+
+	template < typename F >
+	struct is_member_pointer : bool_constant < is_member_function_pointer<F>::value > {};
+	template < typename C, typename R >
+	struct is_member_pointer<R C::*> : true_type{};
+
+	// TODO: check if member functions can actually match under any compiler
+	template < typename T >
+	struct is_pointer : bool_constant < 
+		( detail::is_pointer_impl<remove_cv_t<T>>::value )
+		&& !( is_member_pointer<T>::value ) > {};
+
+	template < typename T >
+	struct is_member_object_pointer : bool_constant <
+		is_member_pointer<T>::value 
+		&& !is_member_function_pointer<T>::value > {};
+
+	template< typename T > struct is_function : bool_constant < is_function_pointer< remove_cv_t<T> *>::value > {};
+	template< typename T > struct is_function < T& >  : false_type{};
+	template< typename T > struct is_function < T&& > : false_type{};
+
+}
+
+#endif // NV_STL_TRAITS_PRIMARY_HH
Index: trunk/nv/stl/type_traits/properties.hh
===================================================================
--- trunk/nv/stl/type_traits/properties.hh	(revision 385)
+++ trunk/nv/stl/type_traits/properties.hh	(revision 385)
@@ -0,0 +1,302 @@
+// Copyright (C) 2015 ChaosForge Ltd
+// http://chaosforge.org/
+//
+// This file is part of NV Libraries.
+// For conditions of distribution and use, see copyright notice in nv.hh
+/**
+* @file properties.hh
+* @author Kornel Kisielewicz epyon@chaosforge.org
+* @brief type traits - type properties
+*/
+
+#ifndef NV_STL_TRAITS_PROPERTIES_HH
+#define NV_STL_TRAITS_PROPERTIES_HH
+
+#include <nv/core/common.hh>
+#include <nv/stl/type_traits/common.hh>
+#include <nv/stl/type_traits/primary.hh>
+
+namespace nv
+{
+	template < typename T >
+	struct is_fundamental : bool_constant <
+		is_void<T>::value || 
+		is_nullptr<T>::value ||
+		is_integral<T>::value ||
+		is_floating_point<T>::value
+	> {};
+
+	template < typename T >
+	struct is_arithmetic : bool_constant < 
+		is_integral<T>::value || 
+		is_floating_point<T>::value 
+	> {};
+
+	template < typename T >
+	struct is_scalar : bool_constant <
+		is_arithmetic<T>::value ||
+		is_enum<T>::value ||
+		is_pointer<T>::value ||
+		is_member_pointer<T>::value ||
+		is_nullptr<T>::value
+	> {};
+
+	template < typename T >
+	struct is_object : bool_constant <
+		is_scalar<T>::value ||
+		is_array<T>::value ||
+		is_union<T>::value ||
+		is_class<T>::value
+	> {};
+
+	template < typename T >
+	struct is_compound : bool_constant < !is_fundamental< T >::value > {};
+
+	template < typename T >
+	struct is_reference : bool_constant < 
+		is_lvalue_reference<T>::value || 
+		is_rvalue_reference<T>::value 
+	> {};
+
+
+	// TODO : confirm conformance
+#if NV_COMPILER == NV_MSVC
+	template < typename T >	struct is_trivially_copyable : bool_constant < ( __has_trivial_copy( T ) || __is_pod( T ) ) && !is_volatile<T>::value > {};
+#else
+	template < typename T >	struct is_trivially_copyable : bool_constant < ( __has_trivial_copy( T ) || __is_pod( T ) ) && ( !is_volatile<T>::value && !is_reference<T>::value ) > {};
+#endif
+
+	template < typename T > struct is_trivial         : bool_constant < __is_trivial( T ) > {};
+	template < typename T >	struct is_standard_layout : bool_constant < __is_standard_layout( T ) > {};
+	template < typename T > struct is_pod             : bool_constant < __is_pod( T ) > {};
+	template < typename T > struct is_literal_type    : bool_constant < __is_literal_type( T ) > {};
+	template < typename T > struct is_empty           : bool_constant < __is_empty( T ) > {};
+	template < typename T > struct is_polymorphic     : bool_constant < __is_polymorphic( T ) > {};
+	template < typename T > struct is_abstract        : bool_constant < __is_abstract( T ) > {};
+
+	template < typename T > struct is_signed : false_type {};
+	template <> struct is_signed<char>       : bool_constant< ( char( 0 ) > char( -1 ) ) > {};
+	template <> struct is_signed<signed char>            : true_type{};
+	template <> struct is_signed<const signed char>      : true_type{};
+	template <> struct is_signed<signed short>           : true_type{};
+	template <> struct is_signed<const signed short>     : true_type{};
+	template <> struct is_signed<signed int>             : true_type{};
+	template <> struct is_signed<const signed int>       : true_type{};
+	template <> struct is_signed<signed long>            : true_type{};
+	template <> struct is_signed<const signed long>      : true_type{};
+	template <> struct is_signed<signed long long>       : true_type{};
+	template <> struct is_signed<const signed long long> : true_type{};
+
+	template < typename T > struct is_unsigned : false_type {};
+	template <> struct is_unsigned<char>       : bool_constant < ( char( 0 ) < char( -1 ) ) > {};
+	template <> struct is_unsigned<unsigned char>            : true_type{};
+	template <> struct is_unsigned<const unsigned char>      : true_type{};
+	template <> struct is_unsigned<unsigned short>           : true_type{};
+	template <> struct is_unsigned<const unsigned short>     : true_type{};
+	template <> struct is_unsigned<unsigned int>             : true_type{};
+	template <> struct is_unsigned<const unsigned int>       : true_type{};
+	template <> struct is_unsigned<unsigned long>            : true_type{};
+	template <> struct is_unsigned<const unsigned long>      : true_type{};
+	template <> struct is_unsigned<unsigned long long>       : true_type{};
+	template <> struct is_unsigned<const unsigned long long> : true_type{};
+
+#if NV_COMPILER == NV_MSVC
+// 	TODO : implement when needed - this works only in MSVC
+// 	template < typename T, typename... Args > 
+// 	struct is_constructible : bool_constant < __is_constructible( T, Args ) > {};
+// 	template < typename T, typename... Args > 
+// 	struct is_trivially_constructible : bool_constant < __is_trivially_constructible( T, Args ) > {};
+// 	template < typename T, typename... Args > 
+// 	struct is_nothrow_constructible : bool_constant < __is_nothrow_constructible( T, Args ) > {};
+#else
+// 	template < typename T, typename... Args >
+// 	struct is_constructible;
+// 	template < typename T, typename... Args >
+// 	struct is_trivially_constructible;
+// 	template < typename T, typename... Args >
+// 	struct is_nothrow_constructible;
+#endif
+
+// TODO : implement if needed
+// 	template < typename T > 
+// 	struct is_default_constructible;
+// 	template < typename T > 
+// 	struct is_trivially_default_constructible;
+// 	template < typename T > 
+// 	struct is_nothrow_default_constructible;
+
+// 	namespace detail
+// 	{
+// 		template < typename T, bool = is_referenceable< T >::value >
+// 		struct is_copy_constructible_impl;
+// 		template < typename T >
+// 		struct is_copy_constructible_impl < T, false > : false_type{};
+// 		template < typename T > 
+// 		struct is_copy_constructible_impl < T, true > : is_constructible < T, const T& > { };
+// 		template < typename T, bool = is_referenceable< T >::value >
+// 		struct is_move_constructible_impl;
+// 		template < typename T >
+// 		struct is_move_constructible_impl < T, false > : false_type{};
+// 		template < typename T > 
+// 		struct is_move_constructible_impl < T, true > : is_constructible < T, T&& > { };
+// 	}
+
+// TODO : implement if needed
+// 	template < typename T > 
+// 	struct is_copy_constructible;
+// 	template < typename T > 
+// 	struct is_trivially_copy_constructible;
+// 	template < typename T > 
+// 	struct is_nothrow_copy_constructible;
+
+// TODO : implement if needed
+// 	template < typename T > 
+// 	struct is_move_constructible;
+// 	template < typename T > 
+// 	struct is_trivially_move_constructible;
+// 	template < typename T > 
+// 	struct is_nothrow_move_constructible;
+
+	namespace detail
+	{
+		template < typename T >
+		struct is_referenceable : bool_constant <
+			is_object<T>::value ||
+			is_reference<T>::value
+		> {};
+		template < typename R, typename... Args >
+		struct is_referenceable < R( Args... ) > : true_type {};
+#if NV_COMPILER != NV_MSVC
+		template < typename R, typename... Args >
+		struct is_referenceable < R( Args...... ) > : true_type {};
+#endif
+
+		template < typename To, typename From >
+		struct is_assignable_impl
+		{
+			struct lazy_int { lazy_int( int ) {} };
+
+			template < typename Dest, typename Source >
+			static auto test( int ) -> decltype( ( declval<Dest>() = declval<Source>() ), true_type() );
+
+			template < typename Dest, typename Source >
+			static auto test( lazy_int ) -> false_type;
+
+			typedef decltype( test< To, From > ( 0 ) ) type;
+		};
+
+		template <
+			typename From, typename To, 
+			bool Invalid = ( is_void<From>::value || is_function<To>::value || is_array <To>::value )
+		>
+		struct is_convertible_impl
+		{ 
+			typedef typename is_void<To>::type type;
+		};
+
+		template < typename From, typename To >
+		struct is_convertible_impl< From, To, false >
+		{
+			struct lazy_int { lazy_int( int ) {} };
+
+			template < typename Source >
+			static void test_target( Source );
+
+			template < typename Source, typename Dest >
+			static auto test( int ) -> decltype( test_target( declval<Source>() ), true_type() );
+
+			template < typename Source, typename Dest >
+			static auto test( lazy_int )->false_type;
+
+			typedef decltype( test< From, To >( 0 ) ) type;
+		};
+	}
+
+	template < typename To, typename From >
+	struct is_assignable : detail::is_assignable_impl< To, From >::type { };
+
+	namespace detail
+	{
+		template < typename T, bool = is_referenceable< T >::value >
+		struct is_copy_assignable_impl;
+		template < typename T >
+		struct is_copy_assignable_impl < T, false > : false_type{};
+		template < typename T >
+		struct is_copy_assignable_impl < T, true > : is_assignable < T, const T& > {};
+
+		template < typename T, bool = is_referenceable< T >::value >
+		struct is_move_assignable_impl;
+		template < typename T >
+		struct is_move_assignable_impl < T, false > : false_type{};
+		template < typename T >
+		struct is_move_assignable_impl < T, true > : is_assignable < T&, T&& >{};
+	}
+
+	template < typename T >
+	struct is_copy_assignable : detail::is_copy_assignable_impl < T > {};
+
+	template < typename T >
+	struct is_move_assignable : detail::is_move_assignable_impl < T > {};
+
+// TODO : implement if needed
+// 	template < typename T > 
+// 	struct is_trivially_assignable;
+// 	template < typename T > 
+// 	struct is_nothrow_assignable;
+// 	template < typename T > 
+// 	struct is_trivially_copy_assignable;
+// 	template < typename T > 
+// 	struct is_nothrow_copy_assignable;
+// 	template < typename T > 
+// 	struct is_trivially_move_assignable;
+// 	template < typename T > 
+// 	struct is_nothrow_move_assignable;
+// 	template < typename T > 
+// 	struct is_trivially_destructible;
+// 	template < typename T > 
+// 	struct is_nothrow_destructible;
+
+	template < typename T >	struct has_virtual_destructor  : bool_constant < __has_virtual_destructor( T ) > {};
+
+	template< typename T >
+	struct alignment_of	: integral_constant < size_t, alignof( typename remove_reference< T >::type ) > {};
+
+	template < typename T >
+	struct rank : integral_constant < size_t, 0 > {};
+	template < typename T >
+	struct rank<T[]> : integral_constant < size_t, rank<T>::value + 1 > {};
+	template < typename T, size_t N >
+	struct rank<T[N]> : integral_constant < size_t, rank<T>::value + 1 > {};
+
+	template < typename T, unsigned N = 0>
+	struct extent : integral_constant < size_t, 0 > {};
+	template < typename T>
+	struct extent<T[], 0> : integral_constant < size_t, 0 > {};
+	template < typename T, unsigned N >
+	struct extent<T[], N> : integral_constant < size_t, extent<T, N - 1>::value > {};
+	template < typename T, size_t N >
+	struct extent<T[N], 0> : integral_constant < size_t, N > {};
+	template < typename T, size_t I, unsigned N >
+	struct extent< T[I], N > : integral_constant < size_t, extent<T, N - 1>::value > {};
+
+	template < typename Base, typename Derived > 
+	struct is_base_of : bool_constant < __is_base_of( Base, Derived ) > {};
+
+#if NV_COMPILER == NV_MSVC 
+	template < typename From, typename To > 
+	struct is_convertible : bool_constant < __is_convertible_to( From, To ) > {};
+#else
+	template < typename From, typename To > 
+	struct is_convertible : detail::is_convertible_impl< From, To >::type {};
+#endif
+
+
+// TODO: non-standard, remove?
+	template < typename T >	struct has_trivial_constructor : bool_constant < __has_trivial_constructor( T ) || __is_pod( T ) > {};
+	template < typename T >	struct has_trivial_copy        : bool_constant < ( __has_trivial_copy( T ) || __is_pod( T ) ) && ( !is_volatile<T>::value ) > {};
+	template < typename T >	struct has_trivial_assign      : bool_constant < ( __has_trivial_assign( T ) || __is_pod( T ) ) && ( !is_volatile<T>::value && !is_const<T>::value ) > {};
+	template < typename T >	struct has_trivial_destructor  : bool_constant < __has_trivial_destructor( T ) || __is_pod( T ) > {};
+
+}
+
+#endif // NV_STL_TRAITS_PROPERTIES_HH
Index: trunk/nv/stl/type_traits/transforms.hh
===================================================================
--- trunk/nv/stl/type_traits/transforms.hh	(revision 385)
+++ trunk/nv/stl/type_traits/transforms.hh	(revision 385)
@@ -0,0 +1,304 @@
+// Copyright (C) 2015 ChaosForge Ltd
+// http://chaosforge.org/
+//
+// This file is part of NV Libraries.
+// For conditions of distribution and use, see copyright notice in nv.hh
+/**
+* @file transforms.hh
+* @author Kornel Kisielewicz epyon@chaosforge.org
+* @brief type traits - transforms
+*/
+
+#ifndef NV_STL_TRAITS_TRANSFORMS_HH
+#define NV_STL_TRAITS_TRANSFORMS_HH
+
+#include <nv/core/common.hh>
+#include <nv/stl/type_traits/common.hh>
+#include <nv/stl/type_traits/primary.hh>
+
+namespace nv
+{
+
+	namespace detail
+	{
+
+		template< typename T, bool CONST, bool VOLATILE>
+		struct cv_selector;
+
+		template< typename T >
+		struct cv_selector < T, false, false > { typedef T type; };
+
+		template< typename T >
+		struct cv_selector < T, true, false > { typedef const T type; };
+
+		template< typename T >
+		struct cv_selector < T, false, true > { typedef volatile T type; };
+
+		template< typename T >
+		struct cv_selector < T, true, true > { typedef const volatile T type; };
+
+		template< typename SOURCE, typename TARGET,
+			bool CONST = is_const<SOURCE>::value,
+			bool VOLATILE = is_volatile<SOURCE>::value >
+		struct match_cv
+		{
+			typedef typename cv_selector< TARGET, CONST, VOLATILE >::type type;
+		};
+
+		template < typename T >
+		struct signed_type
+		{
+			typedef T type;
+		};
+
+		template<> struct signed_type < char > { typedef signed char type; };
+		template<> struct signed_type < unsigned char > { typedef signed char type; };
+		template<> struct signed_type < unsigned short > { typedef signed short type; };
+		template<> struct signed_type < unsigned int > { typedef signed int type; };
+		template<> struct signed_type < unsigned long > { typedef signed long type; };
+		template<> struct signed_type < unsigned long long > { typedef signed long long type; };
+
+		template < typename T >
+		struct unsigned_type
+		{
+			typedef T type;
+		};
+
+		template<> struct unsigned_type < char > { typedef unsigned char type; };
+		template<> struct unsigned_type < signed char > { typedef unsigned char type; };
+		template<> struct unsigned_type < signed short > { typedef unsigned short type; };
+		template<> struct unsigned_type < signed int > { typedef unsigned int type; };
+		template<> struct unsigned_type < signed long > { typedef unsigned long type; };
+		template<> struct unsigned_type < signed long long > { typedef unsigned long long type; };
+
+		template < typename T, bool IS_ENUM = is_enum< T >::value >
+		struct make_signed_impl;
+
+		template < typename T >
+		struct make_signed_impl < T, false >
+		{
+		private:
+			typedef signed_type< remove_cv_t<T> > signed_type_result;
+		public:
+			typedef match_cv< T, typename signed_type_result::type > type;
+		};
+
+		template < typename T >
+		struct make_signed_impl < T, true >
+		{
+		private:
+			static constexpr bool size1test = sizeof( T ) <= sizeof( signed char );
+			static constexpr bool size2test = sizeof( T ) <= sizeof( signed short );
+			static constexpr bool size4test = sizeof( T ) <= sizeof( signed int );
+			typedef conditional_t<size4test, signed int, signed long> test4type;
+			typedef conditional_t<size2test, signed short, test4type> test2type;
+		public:
+			typedef conditional_t<size1test, signed char, test2type> type;
+		};
+
+		template < typename T, bool IS_ENUM = is_enum< T >::value >
+		struct make_unsigned_impl;
+
+		template < typename T >
+		struct make_unsigned_impl < T, false >
+		{
+		private:
+			typedef unsigned_type<remove_cv_t<T>> unsigned_type_result;
+		public:
+			typedef match_cv< T, typename unsigned_type_result::type > type;
+		};
+
+		template < typename T >
+		struct make_unsigned_impl < T, true >
+		{
+		private:
+			static constexpr bool size1test = sizeof( T ) <= sizeof( unsigned char );
+			static constexpr bool size2test = sizeof( T ) <= sizeof( unsigned short );
+			static constexpr bool size4test = sizeof( T ) <= sizeof( unsigned int );
+			typedef conditional_t<size4test, unsigned int, unsigned long> test4type;
+			typedef conditional_t<size2test, unsigned short, test4type> test2type;
+		public:
+			typedef conditional_t<size1test, unsigned char, test2type> type;
+		};
+
+	}
+
+	template < typename T >
+	struct make_signed
+	{
+		typedef typename detail::make_signed_impl<T>::type type;
+	};
+
+	template <> struct make_signed < bool > ;
+
+	template < typename T >
+	using make_signed_t = typename make_signed<T>::type;
+
+	template < typename T >
+	struct make_unsigned
+	{
+		typedef typename detail::make_unsigned_impl<T>::type type;
+	};
+
+	template <> struct make_unsigned < bool > ;
+
+	template < typename T >
+	using make_unsigned_t = typename make_unsigned<T>::type;
+
+
+#if NV_COMPILER == NV_MSVC || NV_COMPILER == NV_CLANG
+	template < typename T >
+	struct underlying_type
+	{
+		typedef __underlying_type( T ) type;
+	};
+#else
+	template< typename T >
+	struct underlying_type
+	{
+		typedef typename conditional <
+			T( -1 ) < T( 0 ),
+			typename make_signed< T >::type,
+			typename make_unsigned< T >::type
+			> ::type type;
+	};
+#endif
+	template < typename T >
+	using underlying_type_t = typename underlying_type<T>::type;
+
+	namespace detail
+	{
+
+		template< typename T, bool IsEnum >
+		struct make_underlying_type_impl
+		{
+			typedef T type;
+		};
+
+		template< typename T >
+		struct make_underlying_type_impl< T, true >
+		{
+			typedef typename underlying_type<T>::type type;
+		};
+
+	}
+
+	template < typename T >
+	struct make_underlying_type
+	{
+		typedef typename detail::make_underlying_type_impl< T, is_enum<T>::value >::type type;
+	};
+
+	template < typename T >
+	using make_underlying_type_t = typename make_underlying_type<T>::type;
+
+	template< typename T >
+	struct decay
+	{
+		typedef remove_reference_t<T> U;
+		typedef conditional_t <
+			is_array<U>::value,
+			remove_extent_t<U>*,
+			conditional_t <
+				is_function<U>::value,
+				add_pointer_t<U>,
+				remove_cv_t<U>
+			>
+		> type;
+	};
+
+	template< typename T > 
+	using decay_t = typename decay<T>::type;
+
+	template <class ...T> struct common_type;
+
+	template < typename T >
+	struct common_type < T >
+	{
+		typedef typename decay<T>::type type;
+	};
+
+	template < typename T1, typename T2 >
+	struct common_type < T1, T2 >
+	{
+		typedef typename decay<
+			decltype( true ? declval<T1>() : declval<T2>()
+			)>::type type;
+	};
+
+	template < typename T1, typename T2, typename... Types >
+	struct common_type < T1, T2, Types... >
+	{
+		typedef typename common_type<
+			typename common_type<T1, T2>::type,
+			Types...>::type type;
+	};
+
+	template < typename... Types >
+	using common_type_t = typename common_type<Types...>::type;
+
+	namespace detail
+	{
+
+		template < typename F, typename... Args >
+		inline auto result_call( F&& f, Args&&... args )
+			-> decltype( forward<F>( f )( forward<Args>( args )... ) )
+		{
+			return forward<F>( f )( forward<Args>( args )... );
+		}
+
+		template < typename Base, typename T, typename Derived >
+		inline auto result_call( T Base::*pmd, Derived&& ref )
+			-> decltype( forward<Derived>( ref ).*pmd )
+		{
+			return forward<Derived>( ref ).*pmd;
+		}
+
+		template < typename PMD, typename Pointer >
+		inline auto result_call( PMD&& pmd, Pointer&& ptr )
+			-> decltype( ( *forward<Pointer>( ptr ) ).*forward<PMD>( pmd ) )
+		{
+			return ( *forward<Pointer>( ptr ) ).*forward<PMD>( pmd );
+		}
+
+		template < typename Base, typename T, typename Derived, typename... Args >
+		inline auto result_call( T Base::*pmf, Derived&& ref, Args&&... args )
+			-> decltype( ( forward<Derived>( ref ).*pmf )( forward<Args>( args )... ) )
+		{
+			return ( forward<Derived>( ref ).*pmf )( forward<Args>( args )... );
+		}
+
+		template < typename PMF, typename Pointer, typename... Args >
+		inline auto result_call( PMF&& pmf, Pointer&& ptr, Args&&... args )
+			-> decltype( ( ( *forward<Pointer>( ptr ) ).*forward<PMF>( pmf ) )( forward<Args>( args )... ) )
+		{
+			return ( ( *forward<Pointer>( ptr ) ).*forward<PMF>( pmf ) )( forward<Args>( args )... );
+		}
+
+		// TODO: fix this once compiler takes it
+		// 		template < typename, typename = void >
+		// 		struct result_of_impl {};
+		// 
+		// 		template < typename F, typename...Args >
+		// 		struct result_of_impl < F( Args... ),
+		// 			decltype( void( result_call( declval_i<F>(), declval_i<Args>()... ) ) ) >
+		// 		{
+		// 			using type = decltype( result_call( declval_i<F>(), declval_i<Args>()... ) );
+		// 		};
+
+		template < typename > struct result_of_impl;
+		template < typename F, typename... Args >
+		struct result_of_impl < F( Args... ) >
+		{
+			using type = decltype( result_call( declval<F>(), declval<Args>()... ) );
+		};
+	}
+
+	template < typename T >
+	struct result_of : detail::result_of_impl < T > {};
+
+	template < typename T >
+	using result_of_t = typename result_of<T>::type;
+}
+
+#endif // NV_STL_TRAITS_TRANSFORMS_HH
Index: trunk/nv/stl/utility.hh
===================================================================
--- trunk/nv/stl/utility.hh	(revision 384)
+++ trunk/nv/stl/utility.hh	(revision 385)
@@ -15,5 +15,5 @@
 
 #include <nv/core/common.hh>
-#include <nv/stl/traits/common.hh>
+#include <nv/stl/type_traits/common.hh>
 
 namespace nv
Index: trunk/src/lua/lua_glm.cc
===================================================================
--- trunk/src/lua/lua_glm.cc	(revision 384)
+++ trunk/src/lua/lua_glm.cc	(revision 385)
@@ -9,5 +9,5 @@
 #include "nv/lua/lua_raw.hh"
 #include "nv/core/random.hh"
-#include "nv/stl/traits/common.hh"
+#include "nv/stl/type_traits/common.hh"
 
 static size_t nlua_swizzel_lookup[256];