Lots of C++11 / C++14 template magic added to:

* <functional> - reference_wrapper, invoke
* <memory> - addressof
* <utility> - forward, move
* <tuple> - make_tuple
* <type_traits> - too many to list

Author: VioletGiraffe

bits/pair.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "rel_ops.hpp"
+
+namespace std {
+
+template <class T1, class T2> struct _UCXXEXPORT pair {
+	typedef T1 first_type;
+	typedef T2 second_type;
+
+	T1 first;
+	T2 second;
+	pair() : first(), second() {  }
+	pair(const T1& x, const T2& y) : first(x), second(y) {  }
+	template<class U, class V> pair(const pair<U, V> &p) : first(p.first), second(p.second) { }
+};
+
+template <class T1, class T2> bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y){
+	using namespace rel_ops;
+	return (x.first == y.first && x.second==y.second);
+}
+template <class T1, class T2> bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y){
+	return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
+}
+template <class T1, class T2> bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y){
+	return !(x == y);
+}
+template <class T1, class T2> bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y){
+	return y < x;
+}
+template <class T1, class T2> bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y){
+	return !(x < y);
+}
+template <class T1, class T2> bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y){
+	return !(y < x);
+}
+template <class T1, class T2> pair<T1,T2> make_pair(const T1& x, const T2& y){
+	return pair<T1,T2>(x, y);
+}
+
+}

bits/rel_ops.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+namespace std {
+
+namespace rel_ops {
+	template<class T> inline bool operator!=(const T& x, const T& y){
+		return !(x == y);
+	}
+
+	template<class T> inline bool operator> (const T& x, const T& y){
+		return ( y < x);
+	}
+
+	template<class T> inline bool operator<=(const T& x, const T& y){
+		return !( y < x );
+	}
+
+	template<class T> inline bool operator>=(const T& x, const T& y){
+		return !(x < y);
+	}
+}
+
+}

bits/type_traits_impl.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+namespace std {
+
+/// void_t
+template< class... >
+using void_t = void;
+
+
+/// Integral constant
+template <class T, T v>
+struct integral_constant
+{
+	static constexpr T value = v;
+	typedef T value_type;
+	typedef integral_constant type; // using injected-class-name
+	constexpr operator value_type() const noexcept { return value; }
+	constexpr value_type operator()() const noexcept { return value; } //since c++14
+};
+
+template <bool B>
+using bool_constant = integral_constant<bool, B>;
+
+/// typedef for true_type
+typedef bool_constant<true> true_type;
+
+/// typedef for false_type
+typedef bool_constant<false> false_type;
+
+/// is_lvalue_reference
+template <typename>
+struct is_lvalue_reference : public false_type
+{
+};
+
+template <typename _Tp>
+struct is_lvalue_reference<_Tp &> : public true_type
+{
+};
+
+/// is_rvalue_reference
+template <typename>
+struct is_rvalue_reference : public false_type
+{
+};
+
+template <typename _Tp>
+struct is_rvalue_reference<_Tp &&> : public true_type
+{
+};
+
+}

functional

@@ -20,6 +20,8 @@
 #define __STD_HEADER_FUNCTIONAL 1
 
 #include <basic_definitions>
+#include <memory>
+#include <type_traits>
 
 #pragma GCC visibility push(default)
 
@@ -431,6 +433,77 @@ compose2(const Op1 & fn1, const Op2 & fn2, const Op3 & fn3){
 	return binary_compose<Op1, Op2, Op3>(fn1, fn2, fn3);
 }
 
+/// Invoke
+
+namespace detail {
+template <class T>
+struct is_reference_wrapper : std::false_type {};
+template <class U>
+struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
+ 
+template <class T, class Type, class T1, class... Args>
+decltype(auto) INVOKE(Type T::* f, T1&& t1, Args&&... args)
+{
+    if (std::is_member_function_pointer<decltype(f)>::value) {
+        if (std::is_base_of<T, std::decay_t<T1>>::value)
+            return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...);
+        else if (is_reference_wrapper<std::decay_t<T1>>::value)
+            return (t1.get().*f)(std::forward<Args>(args)...);
+        else
+            return ((*std::forward<T1>(t1)).*f)(std::forward<Args>(args)...);
+    } else {
+        static_assert(std::is_member_function_pointer<decltype(f)>::value, "std::is_member_function_pointer<decltype(f)>::value");
+        static_assert(sizeof...(args) == 0, "(sizeof...(args) == 0");
+        if (std::is_base_of<T, std::decay_t<T1>>::value)
+            return std::forward<T1>(t1).*f;
+        else if (is_reference_wrapper<std::decay_t<T1>>::value)
+            return t1.get().*f;
+        else
+            return (*std::forward<T1>(t1)).*f;
+    }
+}
+ 
+template <class F, class... Args>
+decltype(auto) INVOKE(F&& f, Args&&... args)
+{
+      return std::forward<F>(f)(std::forward<Args>(args)...);
+}
+} // namespace detail
+ 
+template< class F, class... Args>
+std::invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
+{
+    return detail::INVOKE(std::forward<F>(f), std::forward<Args>(args)...);
+}
+
+template <class T>
+class reference_wrapper {
+public:
+  // types
+  typedef T type;
+ 
+  // construct/copy/destroy
+  reference_wrapper(T& ref) noexcept : _ptr(std::addressof(ref)) {}
+  reference_wrapper(T&&) = delete;
+  reference_wrapper(const reference_wrapper&) noexcept = default;
+ 
+  // assignment
+  reference_wrapper& operator=(const reference_wrapper& x) noexcept = default;
+ 
+  // access
+  operator T& () const noexcept { return *_ptr; }
+  T& get() const noexcept { return *_ptr; }
+ 
+  template< class... ArgTypes >
+  std::invoke_result_t<T&, ArgTypes...>
+    operator() ( ArgTypes&&... args ) const {
+    return invoke(get(), std::forward<ArgTypes>(args)...);
+  }
+ 
+private:
+  T* _ptr;
+};
+
 #pragma GCC visibility pop
 
 #endif

memory

@@ -21,16 +21,25 @@
 #include <cstddef>
 #include <cstdlib>
 #include <iterator_base>
-#include <utility>
 #include <cstdio>
 
+#include <bits/pair.hpp> // std::pair
+
 #ifndef HEADER_STD_MEMORY
 #define HEADER_STD_MEMORY 1
 
 #pragma GCC visibility push(default)
 
 namespace std{
 
+template< class T >
+T* addressof(T& arg) noexcept
+{
+    return reinterpret_cast<T*>(
+               &const_cast<char&>(
+                  reinterpret_cast<const volatile char&>(arg)));
+}
+
 template <class T> class allocator;
 	// Specialize for void:
 

tuple

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <functional>
+#include <type_traits>
+#include <utility>
+
 namespace std
 {
 
@@ -42,10 +46,57 @@ namespace detail {
   };
 }
 
-template <int index, typename First, typename... Rest>
+template <size_t index, typename First, typename... Rest>
 auto get(const tuple<First, Rest...> &t) -> decltype(detail::tuple_getter<index, First, Rest...>::value(&t))
 {
   return detail::tuple_getter<index, First, Rest...>::value(&t);
 }
 
+template< class T >
+class tuple_size; /*undefined*/
+
+template< class... Types >
+class tuple_size< std::tuple<Types...> >
+ : public std::integral_constant<std::size_t, sizeof...(Types)> { };
+
+template< class T >
+class tuple_size<const T>
+ : public std::integral_constant<std::size_t, tuple_size<T>::value> { };
+
+template< class T >
+class tuple_size< volatile T >
+ : public std::integral_constant<std::size_t, tuple_size<T>::value> { };
+
+template< class T >
+class tuple_size< const volatile T >
+ : public std::integral_constant<std::size_t, tuple_size<T>::value> { };
+
+#if __cplusplus >= 201703L // c++17
+template< class T >
+inline constexpr size_t tuple_size_v = tuple_size<T>::value;
+#endif
+
+namespace detail {
+	template <class T>
+	struct unwrap_refwrapper
+	{
+		using type = T;
+	};
+	
+	template <class T>
+	struct unwrap_refwrapper<reference_wrapper<T>>
+	{
+		using type = T&;
+	};
+	
+	template <class T>
+	using special_decay_t = typename unwrap_refwrapper<typename std::decay<T>::type>::type;
+}
+ 
+template <typename... Types>
+auto make_tuple(Types&&... args)
+{
+	return std::tuple<detail::special_decay_t<Types>...>(std::forward<Types>(args)...);
+}
+
 }