prefix move/forward to fix ADL conflicts

Author: TheNumbat

README.md

@@ -271,7 +271,6 @@ For faster parallel builds, you can instead generate [ninja](https://ninja-build
 
 ## To-Dos
 
-- Fix ADL conflict with std::
 - Modules
 - Async
     - [ ] scheduler priorities

rpp/alloc0.h

@@ -35,7 +35,7 @@ struct Scalar_Adaptor {
         requires Allocator<A> && Constructable<T, Args...>
     [[nodiscard]] static T* make(Args&&... args) noexcept {
         T* mem = reinterpret_cast<T*>(A::alloc(sizeof(T)));
-        new(mem) T{forward<Args>(args)...};
+        new(mem) T{rpp::forward<Args>(args)...};
         return mem;
     }
 
@@ -139,7 +139,7 @@ struct Free_List {
     template<typename... Args>
         requires Constructable<T, Args...>
     [[nodiscard]] T* make(Args&&... args) noexcept {
-        return new(alloc()) T{forward<Args>(args)...};
+        return new(alloc()) T{rpp::forward<Args>(args)...};
     }
 
     void destroy(T* value) noexcept {

rpp/alloc1.h

@@ -36,7 +36,7 @@ struct Pool {
             Thread::Lock lock(mutex);
             block = list.make();
         }
-        new(block->data) T{forward<Args>(args)...};
+        new(block->data) T{rpp::forward<Args>(args)...};
         return reinterpret_cast<T*>(block);
     }
 
@@ -79,7 +79,7 @@ struct Mpool {
     template<typename T, typename... Args>
         requires Constructable<T, Args...>
     [[nodiscard]] constexpr static T* make(Args&&... args) noexcept {
-        return detail::Pool<sizeof(T)>::template make<T, Args...>(forward<Args>(args)...);
+        return detail::Pool<sizeof(T)>::template make<T, Args...>(rpp::forward<Args>(args)...);
     }
 
     template<typename T>

rpp/array.h

@@ -18,7 +18,7 @@ struct Array {
 
     template<typename... S>
         requires Length<N, S...> && All_Are<T, S...>
-    constexpr explicit Array(S&&... init) noexcept : data_{forward<S>(init)...} {
+    constexpr explicit Array(S&&... init) noexcept : data_{rpp::forward<S>(init)...} {
     }
 
     template<typename... S>

rpp/box.h

@@ -14,13 +14,13 @@ struct Box {
     explicit Box(T&& value) noexcept
         requires Move_Constructable<T>
     {
-        data_ = A::template make<T>(move(value));
+        data_ = A::template make<T>(rpp::move(value));
     }
 
     template<typename... Args>
         requires Constructable<T, Args...>
     explicit Box(Args&&... args) noexcept {
-        data_ = A::template make<T>(forward<Args>(args)...);
+        data_ = A::template make<T>(rpp::forward<Args>(args)...);
     }
 
     template<Base_Of<T> D>
@@ -57,7 +57,7 @@ struct Box {
     [[nodiscard]] static Box make(Args&&... args) noexcept {
         Box ret;
         auto data = A::template make<Storage<T>>();
-        new(data->data()) T{forward<Args>(args)...};
+        new(data->data()) T{rpp::forward<Args>(args)...};
         ret.data_ = reinterpret_cast<T*>(data);
         return ret;
     }
@@ -78,7 +78,7 @@ struct Box {
     template<typename... Args>
     void emplace(Args&&... args) noexcept {
         this->~Box();
-        data_ = A::template make<T>(forward<Args>(args)...);
+        data_ = A::template make<T>(rpp::forward<Args>(args)...);
     }
 
     [[nodiscard]] T* operator->() noexcept {

rpp/files.h

@@ -18,7 +18,7 @@ using File_Time = u64;
 
 struct Write_Watcher {
 
-    explicit Write_Watcher(String_View path) noexcept : path_(move(path)) {
+    explicit Write_Watcher(String_View path) noexcept : path_(rpp::move(path)) {
         Opt<File_Time> time = last_write_time(path_);
         if(time.ok()) last_write_time_ = *time;
     }

rpp/format1.h

@@ -28,7 +28,7 @@ template<Enum E>
             return {};
         }
         String_View rest = input.sub(end - start, input.length());
-        return Opt<Pair<i64, String_View>>{Pair{ret, move(rest)}};
+        return Opt<Pair<i64, String_View>>{Pair{ret, rpp::move(rest)}};
     }
 }
 
@@ -42,7 +42,7 @@ template<Enum E>
             return {};
         }
         String_View rest = input.sub(end - start, input.length());
-        return Opt<Pair<f32, String_View>>{Pair{ret, move(rest)}};
+        return Opt<Pair<f32, String_View>>{Pair{ret, rpp::move(rest)}};
     }
 }
 
@@ -67,10 +67,10 @@ template<Enum E>
 [[nodiscard]] inline Opt<Pair<E, String_View>> parse_enum(String_View s) noexcept {
     Opt<Pair<E, String_View>> ret = {};
     if(auto n = parse_string(s); n.ok()) {
-        auto [name, rest] = move(*n);
+        auto [name, rest] = rpp::move(*n);
         iterate_enum<E>([&](const Literal& check, const E& check_value) {
             if(name == String_View{check}) {
-                ret = Opt<Pair<E, String_View>>{Pair<E, String_View>{check_value, move(rest)}};
+                ret = Opt<Pair<E, String_View>>{Pair<E, String_View>{check_value, rpp::move(rest)}};
             }
         });
     }

rpp/function.h

@@ -22,7 +22,7 @@ struct Function<Words, R(Args...)> {
     template<typename F>
         requires Same<Invoke_Result<F, Args...>, R>
     Function(F&& f) noexcept {
-        construct(forward<F>(f));
+        construct(rpp::forward<F>(f));
     }
     ~Function() noexcept {
         destruct();
@@ -46,7 +46,7 @@ struct Function<Words, R(Args...)> {
 
     [[nodiscard]] R operator()(Args... args) noexcept {
         assert(vtable);
-        return invoke(forward<Args>(args)...);
+        return invoke(rpp::forward<Args>(args)...);
     }
 
 private:
@@ -61,23 +61,23 @@ struct Function<Words, R(Args...)> {
         static VoidFn f_vtable[] = {reinterpret_cast<VoidFn>(&f_destruct<F>),
                                     reinterpret_cast<VoidFn>(&f_move<F>),
                                     reinterpret_cast<VoidFn>(&f_invoke<F>)};
-        new(storage) F{forward<F>(f)};
+        new(storage) F{rpp::forward<F>(f)};
         vtable = static_cast<VoidFn*>(f_vtable);
     }
     void destruct() noexcept {
         if(vtable) {
-            void (*destruct)(void*) = reinterpret_cast<void (*)(void*)>(vtable[0]);
-            destruct(storage);
+            void (*do_destruct)(void*) = reinterpret_cast<void (*)(void*)>(vtable[0]);
+            do_destruct(storage);
         }
         vtable = null;
     }
     void move(void* dst) noexcept {
-        void (*move)(void*, void*) = reinterpret_cast<void (*)(void*, void*)>(vtable[1]);
-        move(dst, storage);
+        void (*do_move)(void*, void*) = reinterpret_cast<void (*)(void*, void*)>(vtable[1]);
+        do_move(dst, storage);
     }
     [[nodiscard]] R invoke(Args... args) noexcept {
-        R (*invoke)(void*, Args...) = reinterpret_cast<R (*)(void*, Args...)>(vtable[2]);
-        return invoke(storage, forward<Args>(args)...);
+        R (*do_invoke)(void*, Args...) = reinterpret_cast<R (*)(void*, Args...)>(vtable[2]);
+        return do_invoke(storage, rpp::forward<Args>(args)...);
     }
 
     template<typename F>
@@ -96,7 +96,7 @@ struct Function<Words, R(Args...)> {
     }
     template<typename F>
     [[nodiscard]] static R f_invoke(F* src, Args... args) noexcept {
-        return src->operator()(forward<Args>(args)...);
+        return src->operator()(rpp::forward<Args>(args)...);
     }
 
     alignas(MAX_ALIGN) u8 storage[Words * 8] = {};

rpp/hash.h

@@ -81,17 +81,17 @@ concept Hashable = requires(K k) {
 
 template<Hashable T>
 [[nodiscard]] constexpr u64 hash(T&& value) noexcept {
-    return Hash::Hash<Decay<T>>::hash(forward<T>(value));
+    return Hash::Hash<Decay<T>>::hash(rpp::forward<T>(value));
 }
 
 template<Hashable T>
 [[nodiscard]] constexpr u64 hash_nonzero(T&& value) noexcept {
-    return Hash::Hash<Decay<T>>::hash(forward<T>(value)) | 1;
+    return Hash::Hash<Decay<T>>::hash(rpp::forward<T>(value)) | 1;
 }
 
 template<Hashable... Ts>
 [[nodiscard]] constexpr u64 hash(Ts&&... values) noexcept {
-    return Hash::squirrel5((hash(forward<Ts>(values)) + ...));
+    return Hash::squirrel5((hash(rpp::forward<Ts>(values)) + ...));
 }
 
 template<size_t N>

rpp/heap.h

@@ -20,7 +20,7 @@ struct Heap {
         requires All_Are<T, S...> && Move_Constructable<T>
     explicit Heap(S&&... init) noexcept {
         reserve(sizeof...(S));
-        (push(forward<S>(init)), ...);
+        (push(rpp::forward<S>(init)), ...);
     }
 
     explicit Heap(const Heap& src) noexcept = delete;
@@ -91,7 +91,7 @@ struct Heap {
         } else {
             static_assert(Move_Constructable<T>);
             for(u64 i = 0; i < length_; i++) {
-                new(&new_data[i]) T{move(data_[i])};
+                new(&new_data[i]) T{rpp::move(data_[i])};
             }
         }
         A::free(data_);
@@ -130,7 +130,7 @@ struct Heap {
         requires Move_Constructable<T>
     {
         if(full()) grow();
-        new(&data_[length_++]) T{move(value)};
+        new(&data_[length_++]) T{rpp::move(value)};
         reheap_up(length_ - 1);
     }
 
@@ -139,7 +139,7 @@ struct Heap {
         requires Constructable<T, Args...>
     {
         if(full()) grow();
-        new(&data_[length_++]) T{forward<Args>(args)...};
+        new(&data_[length_++]) T{rpp::forward<Args>(args)...};
         reheap_up(length_ - 1);
     }
 
@@ -158,7 +158,7 @@ struct Heap {
                 Libc::memcpy(data_, data_ + length_, sizeof(T));
             } else {
                 static_assert(Move_Constructable<T>);
-                new(data_) T{move(data_[length_])};
+                new(data_) T{rpp::move(data_[length_])};
             }
             reheap_down(0);
         }
@@ -188,9 +188,9 @@ struct Heap {
     void swap(u64 a, u64 b) noexcept
         requires Move_Constructable<T>
     {
-        T temp{move(data_[a])};
-        new(&data_[a]) T{move(data_[b])};
-        new(&data_[b]) T{move(temp)};
+        T temp{rpp::move(data_[a])};
+        new(&data_[a]) T{rpp::move(data_[b])};
+        new(&data_[b]) T{rpp::move(temp)};
     }
 
     void reheap_up(u64 idx) noexcept