From a351246847eee3afd611ded31fbade7491ee830a Mon Sep 17 00:00:00 2001
From: Blurring Shadow <976999484@qq.com>
Date: Wed, 24 May 2023 17:31:33 +0800
Subject: [PATCH 1/6] fix(*all*): correct headers

---
 include/stdsharp/array/array.h             | 10 +++++++---
 include/stdsharp/concepts/concepts.h       | 13 ++++++-------
 include/stdsharp/memory/memory.h           |  6 ++----
 include/stdsharp/type_traits/type_traits.h |  3 ++-
 include/stdsharp/utility/adl_proof.h       |  2 --
 include/stdsharp/utility/invocable.h       |  2 +-
 include/stdsharp/utility/utility.h         |  3 ---
 include/stdsharp/utility/value_wrapper.h   |  2 ++
 8 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/include/stdsharp/array/array.h b/include/stdsharp/array/array.h
index ec6b47d6..b10943e7 100644
--- a/include/stdsharp/array/array.h
+++ b/include/stdsharp/array/array.h
@@ -4,19 +4,23 @@
 #include <algorithm>
 #include <ranges>
 
+#include "../macros.h"
+
 namespace stdsharp
 {
     template<::std::size_t N>
     struct range_to_array_fn
     {
         template<typename Rng, typename Proj = ::std::identity>
-        constexpr auto operator()(Rng&& rng, Proj&& proj = {}) const
+        constexpr auto operator()(Rng&& rng, Proj proj = {}) const
         {
-            ::std::array<::std::projected<::std::ranges::iterator_t<Rng>, Proj>, N> arr{};
+            using value_type = ::std::projected<::std::ranges::iterator_t<Rng>, Proj>::value_type;
+
+            ::std::array<value_type, N> arr{};
 
             ::std::ranges::copy(
                 cpp_forward(rng) | //
-                    ::std::views::transform(cpp_forward(proj)) | //
+                    ::std::views::transform(proj) | //
                     ::std::views::take(N),
                 arr.begin()
             );
diff --git a/include/stdsharp/concepts/concepts.h b/include/stdsharp/concepts/concepts.h
index a01441e2..cee7e3fd 100644
--- a/include/stdsharp/concepts/concepts.h
+++ b/include/stdsharp/concepts/concepts.h
@@ -3,9 +3,9 @@
 //
 #pragma once
 
+#include <compare>
 #include <concepts>
 #include <type_traits>
-#include <utility>
 
 #include "../macros.h"
 
@@ -288,14 +288,13 @@ namespace stdsharp
     template<typename T>
     concept nothrow_move_assignable = ::std::is_nothrow_move_assignable_v<T>;
 
-    template<typename T>
-    concept nothrow_swappable =
-        requires(T& t1, T& t2) { requires noexcept(::std::ranges::swap(t1, t2)); };
-
     template<typename T, typename U>
     concept nothrow_swappable_with =
         requires(T& t, U& u) { requires noexcept(::std::ranges::swap(t, u)); };
 
+    template<typename T>
+    concept nothrow_swappable = nothrow_swappable_with<T, T>;
+
     template<typename T>
     concept nothrow_movable = ::std::movable<T> && //
         nothrow_move_constructible<T> &&
@@ -320,11 +319,11 @@ namespace stdsharp
     concept nothrow_convertible_to = ::std::is_nothrow_convertible_v<T, U>;
 
     template<typename From, typename To>
-    concept explicitly_convertible = requires { static_cast<To>(std::declval<From>()); };
+    concept explicitly_convertible = requires(From&& v) { static_cast<To>(cpp_forward(v)); };
 
     template<typename From, typename To>
     concept nothrow_explicitly_convertible =
-        requires { requires noexcept(static_cast<To>(std::declval<From>())); };
+        requires(From&& v) { requires noexcept(static_cast<To>(cpp_forward(v))); };
 
     template<typename To, typename From>
     concept explicitly_convertible_from = explicitly_convertible<From, To>;
diff --git a/include/stdsharp/memory/memory.h b/include/stdsharp/memory/memory.h
index 9ecf39e2..20c40457 100644
--- a/include/stdsharp/memory/memory.h
+++ b/include/stdsharp/memory/memory.h
@@ -1,6 +1,4 @@
 #pragma once
 
-#include "pointer_traits.h"
-#include "single_static_buffer.h"
-#include "static_allocator.h"
-#include "raii_memory.h"
\ No newline at end of file
+#include "small_object_optimization.h"
+#include "allocator_reference.h"
\ No newline at end of file
diff --git a/include/stdsharp/type_traits/type_traits.h b/include/stdsharp/type_traits/type_traits.h
index d19f855c..8ac1389d 100644
--- a/include/stdsharp/type_traits/type_traits.h
+++ b/include/stdsharp/type_traits/type_traits.h
@@ -1,4 +1,5 @@
 #pragma once
 
 #include "member.h"
-#include "object.h"
\ No newline at end of file
+#include "object.h"
+#include "type_sequence.h"
\ No newline at end of file
diff --git a/include/stdsharp/utility/adl_proof.h b/include/stdsharp/utility/adl_proof.h
index 80c0fa71..95d8d943 100644
--- a/include/stdsharp/utility/adl_proof.h
+++ b/include/stdsharp/utility/adl_proof.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <concepts>
-
 namespace stdsharp
 {
     namespace details
diff --git a/include/stdsharp/utility/invocable.h b/include/stdsharp/utility/invocable.h
index af483b2b..c6a275a2 100644
--- a/include/stdsharp/utility/invocable.h
+++ b/include/stdsharp/utility/invocable.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../utility/value_wrapper.h"
+#include "value_wrapper.h"
 
 namespace stdsharp
 {
diff --git a/include/stdsharp/utility/utility.h b/include/stdsharp/utility/utility.h
index 694d9c9f..80d55d5f 100644
--- a/include/stdsharp/utility/utility.h
+++ b/include/stdsharp/utility/utility.h
@@ -1,14 +1,11 @@
 
 #pragma once
 
-#include <utility>
-
 #include "auto_cast.h"
 #include "cast_to.h"
 #include "constructor.h"
 #include "invocable.h"
 #include "../type_traits/core_traits.h"
-#include "value_wrapper.h"
 
 namespace stdsharp
 {
diff --git a/include/stdsharp/utility/value_wrapper.h b/include/stdsharp/utility/value_wrapper.h
index 0225ad75..bbfa3bde 100644
--- a/include/stdsharp/utility/value_wrapper.h
+++ b/include/stdsharp/utility/value_wrapper.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "../concepts/concepts.h"
 #include "../compilation_config_in.h"
 

From 6a422b6b45f2c795a12a2ee1c1ec656b7b69e977 Mon Sep 17 00:00:00 2001
From: Blurring Shadow <976999484@qq.com>
Date: Wed, 24 May 2023 22:05:20 +0800
Subject: [PATCH 2/6] build(cmake): update project version

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ddaf7a44..97b55ff7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,7 @@ include(cmake/Utils.cmake)
 #
 project(
   stdsharp
-  VERSION 0.6.0
+  VERSION 0.6.1
   LANGUAGES CXX)
 
 config_lib(${PROJECT_NAME} INTERFACE STD 23)

From e95b590dc92b7ca45e9561f85c030c4c12269cb3 Mon Sep 17 00:00:00 2001
From: Blurring Shadow <976999484@qq.com>
Date: Fri, 26 May 2023 11:37:59 +0800
Subject: [PATCH 3/6] refactor(*all*): use std namespace alias

---
 include/stdsharp/algorithm/algorithm.h        |  52 +--
 include/stdsharp/array/array.h                |  16 +-
 include/stdsharp/cassert/cassert.h            |  10 +-
 include/stdsharp/cmath/cmath.h                |   2 +-
 include/stdsharp/compare/compare.h            |   4 +-
 include/stdsharp/concepts/concepts.h          | 234 ++++++------
 include/stdsharp/concurrent_object.h          |  48 ++-
 include/stdsharp/containers/actions.h         |  51 ++-
 include/stdsharp/containers/concepts.h        | 350 +++++++++---------
 include/stdsharp/cstdint/cstdint.h            |  26 +-
 include/stdsharp/default_operator.h           |   8 +-
 include/stdsharp/enumeration.h                |   6 +-
 include/stdsharp/exception/exception.h        |  28 +-
 include/stdsharp/filesystem/filesystem.h      | 204 +++++-----
 include/stdsharp/format/format.h              |  74 ++--
 include/stdsharp/fstream/fstream.h            |  46 +--
 include/stdsharp/functional/compose.h         |  23 +-
 include/stdsharp/functional/invocables.h      |  46 +--
 include/stdsharp/functional/invoke.h          |  22 +-
 include/stdsharp/functional/operations.h      |  68 ++--
 include/stdsharp/functional/pipeable.h        |  20 +-
 .../functional/symmetric_operations.h         |  22 +-
 include/stdsharp/iterator/iterator.h          |  18 +-
 include/stdsharp/macros.h                     |   2 +-
 include/stdsharp/memory/allocator_aware.h     |  52 ++-
 include/stdsharp/memory/allocator_reference.h |  10 +-
 include/stdsharp/memory/allocator_traits.h    | 134 ++++---
 include/stdsharp/memory/composed_allocator.h  |  33 +-
 include/stdsharp/memory/object_allocation.h   |  40 +-
 include/stdsharp/memory/pointer_traits.h      |  32 +-
 .../memory/small_object_optimization.h        |  24 +-
 include/stdsharp/memory/static_allocator.h    |  22 +-
 .../stdsharp/memory/static_memory_resource.h  |  49 ++-
 include/stdsharp/mutex/mutex.h                |  24 +-
 include/stdsharp/namespace_alias.h            |  10 +
 include/stdsharp/pattern_match.h              |  26 +-
 include/stdsharp/random/random.h              |   2 +-
 include/stdsharp/ranges/ranges.h              |  14 +-
 include/stdsharp/reflection/reflection.h      |  18 +-
 include/stdsharp/scope.h                      |  14 +-
 include/stdsharp/type_traits/indexed_traits.h |  81 ++--
 include/stdsharp/type_traits/member.h         |   4 +-
 include/stdsharp/type_traits/object.h         |  14 +-
 include/stdsharp/type_traits/special_member.h |  36 +-
 include/stdsharp/type_traits/type_sequence.h  |  30 +-
 include/stdsharp/type_traits/value_sequence.h | 156 ++++----
 include/stdsharp/utility/constructor.h        |  12 +-
 .../stdsharp/utility/implement_dispatcher.h   |   8 +-
 include/stdsharp/utility/invocable.h          |  38 +-
 include/stdsharp/utility/utility.h            |   7 +-
 include/stdsharp/utility/value_wrapper.h      |  19 +-
 51 files changed, 1137 insertions(+), 1152 deletions(-)
 create mode 100644 include/stdsharp/namespace_alias.h

diff --git a/include/stdsharp/algorithm/algorithm.h b/include/stdsharp/algorithm/algorithm.h
index d0155e37..accf705b 100644
--- a/include/stdsharp/algorithm/algorithm.h
+++ b/include/stdsharp/algorithm/algorithm.h
@@ -10,22 +10,22 @@
 
 namespace stdsharp
 {
-    inline constexpr auto set_if = []<typename T, typename U, ::std::predicate<U, T> Comp>
-        requires ::std::assignable_from<T&, U> // clang-format off
+    inline constexpr auto set_if = []<typename T, typename U, std::predicate<U, T> Comp>
+        requires std::assignable_from<T&, U> // clang-format off
         (T& left, U&& right, Comp comp = {})
         noexcept(nothrow_predicate<Comp, U, T> && nothrow_assignable_from<T&, U>)
         -> T& // clang-format on
     {
-        if(::std::invoke(cpp_move(comp), right, left)) left = cpp_forward(right);
+        if(std::invoke(cpp_move(comp), right, left)) left = cpp_forward(right);
         return left;
     };
 
     using set_if_fn = decltype(set_if);
 
     inline constexpr auto set_if_greater = []<typename T, typename U>
-        requires ::std::invocable<set_if_fn, T&, U, ::std::ranges::greater> // clang-format off
+        requires std::invocable<set_if_fn, T&, U, std::ranges::greater> // clang-format off
         (T & left, U && right)
-        noexcept(nothrow_invocable<set_if_fn, T&, U, ::std::ranges::greater>) -> T& // clang-format on
+        noexcept(nothrow_invocable<set_if_fn, T&, U, std::ranges::greater>) -> T& // clang-format on
     {
         return set_if(left, cpp_forward(right), greater_v);
     };
@@ -33,9 +33,9 @@ namespace stdsharp
     using set_if_greater_fn = decltype(set_if_greater);
 
     inline constexpr auto set_if_less = []<typename T, typename U>
-        requires ::std::invocable<set_if_fn, T&, U, ::std::ranges::less> // clang-format off
+        requires std::invocable<set_if_fn, T&, U, std::ranges::less> // clang-format off
         (T& left, U&& right)
-        noexcept(nothrow_invocable<set_if_fn, T&, U, ::std::ranges::less>) -> T& // clang-format on
+        noexcept(nothrow_invocable<set_if_fn, T&, U, std::ranges::less>) -> T& // clang-format on
     {
         return set_if(left, cpp_forward(right), less_v);
     };
@@ -46,9 +46,9 @@ namespace stdsharp
     {
         template<
             typename T,
-            typename Proj = ::std::identity,
-            ::std::indirect_strict_weak_order<::std::projected<const T*, Proj>> Compare =
-                ::std::ranges::less // clang-format off
+            typename Proj = std::identity,
+            std::indirect_strict_weak_order<std::projected<const T*, Proj>> Compare =
+                std::ranges::less // clang-format off
         > // clang-format on
         [[nodiscard]] constexpr auto operator()( // NOLINTBEGIN(*-easily-swappable-parameters)
             const T& t,
@@ -61,33 +61,33 @@ namespace stdsharp
                 !is_debug ||
                 nothrow_predicate<
                     Compare,
-                    ::std::projected<const T*, Proj>,
-                    ::std::projected<const T*, Proj> // clang-format off
+                    std::projected<const T*, Proj>,
+                    std::projected<const T*, Proj> // clang-format off
                 > // clang-format on
             )
         {
-            const auto& proj_max = ::std::invoke(proj, max);
-            const auto& proj_min = ::std::invoke(proj, min);
-            const auto& proj_t = ::std::invoke(proj, t);
+            const auto& proj_max = std::invoke(proj, max);
+            const auto& proj_min = std::invoke(proj, min);
+            const auto& proj_t = std::invoke(proj, t);
 
-            precondition<::std::invalid_argument>(
-                [&] { return !::std::invoke(cmp, proj_max, proj_min); },
+            precondition<std::invalid_argument>(
+                [&] { return !std::invoke(cmp, proj_max, proj_min); },
                 "max value should not less than min value"
             );
 
-            return !::std::invoke(cmp, proj_t, proj_min) && !::std::invoke(cmp, proj_max, proj_t);
+            return !std::invoke(cmp, proj_t, proj_min) && !std::invoke(cmp, proj_max, proj_t);
         }
     } is_between{};
 
     constexpr struct strict_compare_fn
     {
-        template<::std::ranges::input_range TRng, ::std::ranges::input_range URng>
-            requires ::std::three_way_comparable_with<
+        template<std::ranges::input_range TRng, std::ranges::input_range URng>
+            requires std::three_way_comparable_with<
                 range_const_reference_t<TRng>,
                 range_const_reference_t<URng>>
         constexpr auto operator()(const TRng& left, const URng& right) const
         {
-            using ordering = ::std::partial_ordering;
+            using ordering = std::partial_ordering;
 
             auto pre = ordering::equivalent;
             const auto cmp_impl = [](ordering& pre, const ordering next)
@@ -106,10 +106,10 @@ namespace stdsharp
             };
 
             {
-                auto l_it = ::std::ranges::cbegin(left);
-                auto r_it = ::std::ranges::cbegin(right);
-                const auto l_end = ::std::ranges::cend(left);
-                const auto r_end = ::std::ranges::cend(right);
+                auto l_it = std::ranges::cbegin(left);
+                auto r_it = std::ranges::cbegin(right);
+                const auto l_end = std::ranges::cend(left);
+                const auto r_end = std::ranges::cend(right);
                 for(; !is_ud(pre); ++l_it, ++r_it)
                 {
                     if(l_it == l_end)
@@ -124,7 +124,7 @@ namespace stdsharp
                         break;
                     }
 
-                    cmp_impl(pre, ::std::compare_three_way{}(*l_it, *r_it));
+                    cmp_impl(pre, std::compare_three_way{}(*l_it, *r_it));
                 }
             }
 
diff --git a/include/stdsharp/array/array.h b/include/stdsharp/array/array.h
index b10943e7..95a39270 100644
--- a/include/stdsharp/array/array.h
+++ b/include/stdsharp/array/array.h
@@ -8,20 +8,20 @@
 
 namespace stdsharp
 {
-    template<::std::size_t N>
+    template<std::size_t N>
     struct range_to_array_fn
     {
-        template<typename Rng, typename Proj = ::std::identity>
+        template<typename Rng, typename Proj = std::identity>
         constexpr auto operator()(Rng&& rng, Proj proj = {}) const
         {
-            using value_type = ::std::projected<::std::ranges::iterator_t<Rng>, Proj>::value_type;
+            using value_type = std::projected<std::ranges::iterator_t<Rng>, Proj>::value_type;
 
-            ::std::array<value_type, N> arr{};
+            std::array<value_type, N> arr{};
 
-            ::std::ranges::copy(
+            std::ranges::copy(
                 cpp_forward(rng) | //
-                    ::std::views::transform(proj) | //
-                    ::std::views::take(N),
+                    std::views::transform(proj) | //
+                    std::views::take(N),
                 arr.begin()
             );
 
@@ -29,6 +29,6 @@ namespace stdsharp
         }
     };
 
-    template<::std::size_t N>
+    template<std::size_t N>
     inline constexpr range_to_array_fn<N> range_to_array{};
 }
\ No newline at end of file
diff --git a/include/stdsharp/cassert/cassert.h b/include/stdsharp/cassert/cassert.h
index 1e14bb8b..6a878e09 100644
--- a/include/stdsharp/cassert/cassert.h
+++ b/include/stdsharp/cassert/cassert.h
@@ -16,18 +16,18 @@ namespace stdsharp
         ;
 
     template<typename Exception, typename Predicate, typename... Args>
-        requires ::std::constructible_from<Exception, Args...> &&
-        ::std::predicate<const Predicate&> && is_debug
+        requires std::constructible_from<Exception, Args...> && std::predicate<const Predicate&> &&
+        is_debug
     constexpr void precondition(const Predicate& predicate, Args&&... args)
     {
-        ::std::invoke(predicate) ? void() : throw Exception{static_cast<Args&&>(args)...}; // NOLINT
+        std::invoke(predicate) ? void() : throw Exception{static_cast<Args&&>(args)...}; // NOLINT
     }
 
     template<typename, typename Predicate>
-        requires ::std::predicate<const Predicate&>
+        requires std::predicate<const Predicate&>
     constexpr void precondition([[maybe_unused]] const Predicate& predicate, auto&&...) noexcept
     {
-        STDSHARP_ASSUME(::std::invoke(predicate));
+        STDSHARP_ASSUME(std::invoke(predicate));
     }
 }
 
diff --git a/include/stdsharp/cmath/cmath.h b/include/stdsharp/cmath/cmath.h
index 7eed8d0a..79207ed3 100644
--- a/include/stdsharp/cmath/cmath.h
+++ b/include/stdsharp/cmath/cmath.h
@@ -5,7 +5,7 @@
 
 namespace stdsharp
 {
-    constexpr auto ceil_reminder(const ::std::integral auto x, decltype(x) y) noexcept
+    constexpr auto ceil_reminder(const std::integral auto x, decltype(x) y) noexcept
     {
         return (x + y - 1) / y;
     }
diff --git a/include/stdsharp/compare/compare.h b/include/stdsharp/compare/compare.h
index 98b24983..6253f7de 100644
--- a/include/stdsharp/compare/compare.h
+++ b/include/stdsharp/compare/compare.h
@@ -4,8 +4,8 @@
 
 namespace stdsharp
 {
-    constexpr bool is_ud(const ::std::partial_ordering c) noexcept
+    constexpr bool is_ud(const std::partial_ordering c) noexcept
     {
-        return c == ::std::partial_ordering::unordered;
+        return c == std::partial_ordering::unordered;
     }
 }
\ No newline at end of file
diff --git a/include/stdsharp/concepts/concepts.h b/include/stdsharp/concepts/concepts.h
index cee7e3fd..e4b397b2 100644
--- a/include/stdsharp/concepts/concepts.h
+++ b/include/stdsharp/concepts/concepts.h
@@ -8,168 +8,168 @@
 #include <type_traits>
 
 #include "../macros.h"
+#include "../namespace_alias.h"
 
 namespace stdsharp
 {
     template<typename T, typename... U>
-    concept same_as_any = (::std::same_as<T, U> || ...);
+    concept same_as_any = (std::same_as<T, U> || ...);
 
     template<typename T, typename... U>
-    concept all_same = (::std::same_as<T, U> && ...);
+    concept all_same = (std::same_as<T, U> && ...);
 
     template<typename T>
-    concept enum_ = ::std::is_enum_v<T>;
+    concept enum_ = std::is_enum_v<T>;
 
     template<typename T>
-    concept reference = ::std::is_reference_v<T>;
+    concept reference = std::is_reference_v<T>;
 
     template<typename T>
-    concept lvalue_ref = ::std::is_lvalue_reference_v<T>;
+    concept lvalue_ref = std::is_lvalue_reference_v<T>;
 
     template<typename T>
-    concept rvalue_ref = ::std::is_rvalue_reference_v<T>;
+    concept rvalue_ref = std::is_rvalue_reference_v<T>;
 
     template<typename T>
-    concept const_ = ::std::is_const_v<T>;
+    concept const_ = std::is_const_v<T>;
 
     template<typename T>
-    concept const_lvalue_ref =
-        ::std::is_lvalue_reference_v<T> && const_<::std::remove_reference_t<T>>;
+    concept const_lvalue_ref = std::is_lvalue_reference_v<T> && const_<std::remove_reference_t<T>>;
 
     template<typename T>
-    concept volatile_ = ::std::is_volatile_v<T>;
+    concept volatile_ = std::is_volatile_v<T>;
 
     template<typename T>
     concept const_volatile = const_<T> && volatile_<T>;
 
     template<typename T>
-    concept abstract = ::std::is_abstract_v<T>;
+    concept abstract = std::is_abstract_v<T>;
 
     template<typename T>
-    concept aggregate = ::std::is_aggregate_v<T>;
+    concept aggregate = std::is_aggregate_v<T>;
 
     template<typename T>
     concept character = same_as_any<T, char, char8_t, char16_t, char32_t, wchar_t>;
 
     template<typename T>
-    concept arithmetic = ::std::is_arithmetic_v<T>;
+    concept arithmetic = std::is_arithmetic_v<T>;
 
     template<typename T>
-    concept signed_ = ::std::is_signed_v<T>;
+    concept signed_ = std::is_signed_v<T>;
 
     template<typename T>
-    concept empty_type = ::std::is_empty_v<T>;
+    concept empty_type = std::is_empty_v<T>;
 
     template<typename T>
-    concept unsigned_ = ::std::is_unsigned_v<T>;
+    concept unsigned_ = std::is_unsigned_v<T>;
 
     template<typename T>
-    concept floating_point = ::std::is_floating_point_v<T>;
+    concept floating_point = std::is_floating_point_v<T>;
 
     template<typename T, typename U = T>
     concept arithmetic_like =
-        ::std::three_way_comparable<T> && requires(T t1, U t2) { // clang-format off
-        { t1 + t2 } -> ::std::same_as<T>;
-        { t1 - t2 } -> ::std::same_as<T>;
-        { t1 * t2 } -> ::std::same_as<T>;
-        { t1 / t2 } -> ::std::same_as<T>;
-        { t1 % t2 } -> ::std::same_as<T>;
-        { t1 & t2 } -> ::std::same_as<T>;
-        { t1 | t2 } -> ::std::same_as<T>;
-        { t1 ^ t2 } -> ::std::same_as<T>;
-        { t1 << t2 } -> ::std::same_as<T>;
-        { t1 >> t2 } -> ::std::same_as<T>;
-        { t1 += t2 } -> ::std::same_as<T&>;
-        { t1 -= t2 } -> ::std::same_as<T&>;
-        { t1 *= t2 } -> ::std::same_as<T&>;
-        { t1 /= t2 } -> ::std::same_as<T&>;
-        { t1 %= t2 } -> ::std::same_as<T&>;
-        { t1 &= t2 } -> ::std::same_as<T&>;
-        { t1 |= t2 } -> ::std::same_as<T&>;
-        { t1 ^= t2 } -> ::std::same_as<T&>;
-        { t1 <<= t2 } -> ::std::same_as<T&>;
-        { t1 >>= t2 } -> ::std::same_as<T&>;
+        std::three_way_comparable<T> && requires(T t1, U t2) { // clang-format off
+        { t1 + t2 } -> std::same_as<T>;
+        { t1 - t2 } -> std::same_as<T>;
+        { t1 * t2 } -> std::same_as<T>;
+        { t1 / t2 } -> std::same_as<T>;
+        { t1 % t2 } -> std::same_as<T>;
+        { t1 & t2 } -> std::same_as<T>;
+        { t1 | t2 } -> std::same_as<T>;
+        { t1 ^ t2 } -> std::same_as<T>;
+        { t1 << t2 } -> std::same_as<T>;
+        { t1 >> t2 } -> std::same_as<T>;
+        { t1 += t2 } -> std::same_as<T&>;
+        { t1 -= t2 } -> std::same_as<T&>;
+        { t1 *= t2 } -> std::same_as<T&>;
+        { t1 /= t2 } -> std::same_as<T&>;
+        { t1 %= t2 } -> std::same_as<T&>;
+        { t1 &= t2 } -> std::same_as<T&>;
+        { t1 |= t2 } -> std::same_as<T&>;
+        { t1 ^= t2 } -> std::same_as<T&>;
+        { t1 <<= t2 } -> std::same_as<T&>;
+        { t1 >>= t2 } -> std::same_as<T&>;
     };
 
     template<typename T>
-    concept fundamental_array = ::std::is_array_v<T>;
+    concept fundamental_array = std::is_array_v<T>;
 
     template<typename T, typename U>
-    concept base_of = ::std::is_base_of_v<T, U>;
+    concept base_of = std::is_base_of_v<T, U>;
 
     template<typename T>
-    concept class_ = ::std::is_class_v<T>;
+    concept class_ = std::is_class_v<T>;
 
     template<typename T>
-    concept function = ::std::is_function_v<T>;
+    concept function = std::is_function_v<T>;
 
     template<typename T>
-    concept pointer = ::std::is_pointer_v<T>;
+    concept pointer = std::is_pointer_v<T>;
 
     template<typename T>
-    concept fundamental = ::std::is_fundamental_v<T>;
+    concept fundamental = std::is_fundamental_v<T>;
 
     template<typename T>
-    concept scalar = ::std::is_scalar_v<T>;
+    concept scalar = std::is_scalar_v<T>;
 
     template<typename T>
-    concept object = ::std::is_object_v<T>;
+    concept object = std::is_object_v<T>;
 
     template<typename T>
-    concept compound = ::std::is_compound_v<T>;
+    concept compound = std::is_compound_v<T>;
 
     template<typename T>
-    concept member_object_pointer = ::std::is_member_object_pointer_v<T>;
+    concept member_object_pointer = std::is_member_object_pointer_v<T>;
 
     template<typename T>
-    concept member_function_pointer = ::std::is_member_function_pointer_v<T>;
+    concept member_function_pointer = std::is_member_function_pointer_v<T>;
 
     template<typename T>
-    concept member_pointer = ::std::is_member_pointer_v<T>;
+    concept member_pointer = std::is_member_pointer_v<T>;
 
     template<typename T>
-    concept polymorphic = ::std::is_polymorphic_v<T>;
+    concept polymorphic = std::is_polymorphic_v<T>;
 
     template<typename T>
-    concept final = ::std::is_final_v<T>;
+    concept final = std::is_final_v<T>;
 
     template<typename T>
     concept inheritable = class_<T> && !final<T>;
 
     template<typename T>
-    concept trivial = ::std::is_trivial_v<T>;
+    concept trivial = std::is_trivial_v<T>;
 
     template<typename T, typename U>
-    concept assignable = ::std::is_assignable_v<T, U>;
+    concept assignable = std::is_assignable_v<T, U>;
 
     template<typename T, typename U>
-    concept assignable_to = ::std::assignable_from<U, T>;
+    concept assignable_to = std::assignable_from<U, T>;
 
     template<typename T>
-    concept move_assignable = ::std::assignable_from<::std::add_lvalue_reference_t<T>, T>;
+    concept move_assignable = std::assignable_from<std::add_lvalue_reference_t<T>, T>;
 
     template<typename T>
     concept copy_assignable = move_assignable<T> && //
-        ::std::assignable_from<::std::add_lvalue_reference_t<T>, ::std::add_const_t<T>> && //
-        ::std::assignable_from<//
-            ::std::add_lvalue_reference_t<T>,
-            ::std::add_lvalue_reference_t<T>
+        std::assignable_from<std::add_lvalue_reference_t<T>, std::add_const_t<T>> && //
+        std::assignable_from<//
+            std::add_lvalue_reference_t<T>,
+            std::add_lvalue_reference_t<T>
         > &&
-        ::std::assignable_from< //
-            ::std::add_lvalue_reference_t<T>,
-            ::std::add_lvalue_reference_t<::std::add_const_t<T>>
+        std::assignable_from< //
+            std::add_lvalue_reference_t<T>,
+            std::add_lvalue_reference_t<std::add_const_t<T>>
         >;
 
     template<typename B> // clang-format off
-    concept boolean_testable = ::std::convertible_to<B, bool> && requires(B&& b)
+    concept boolean_testable = std::convertible_to<B, bool> && requires(B&& b)
     {
-        { !cpp_forward(b) } -> ::std::convertible_to<bool>;
+        { !cpp_forward(b) } -> std::convertible_to<bool>;
     }; // clang-format on
 
     template<typename T, typename U>
     concept weakly_equality_comparable_with = requires(
-        const ::std::remove_reference_t<T>& t,
-        const ::std::remove_reference_t<U>& u
+        const std::remove_reference_t<T>& t,
+        const std::remove_reference_t<U>& u
     ) // clang-format off
     {
         { t == u } -> boolean_testable;
@@ -180,8 +180,8 @@ namespace stdsharp
 
     template<typename T, typename U>
     concept nothrow_weakly_equality_comparable_with = weakly_equality_comparable_with<T, U> &&
-        requires(const ::std::remove_reference_t<T>& t,
-                 const ::std::remove_reference_t<U>& u) //
+        requires(const std::remove_reference_t<T>& t,
+                 const std::remove_reference_t<U>& u) //
     {
         noexcept(t == u);
         noexcept(t != u);
@@ -197,8 +197,8 @@ namespace stdsharp
 
     template<typename T, typename U>
     concept partial_ordered_with = requires(
-        const ::std::remove_reference_t<T>& t,
-        const ::std::remove_reference_t<U>& u
+        const std::remove_reference_t<T>& t,
+        const std::remove_reference_t<U>& u
     ) // clang-format off
     {
         { t <  u } -> boolean_testable;
@@ -212,111 +212,109 @@ namespace stdsharp
     };
 
     template<typename T, typename... Args>
-    concept list_initializable_from = requires { T{::std::declval<Args>()...}; };
+    concept list_initializable_from = requires { T{std::declval<Args>()...}; };
 
     template<typename T, typename... Args>
     concept nothrow_list_initializable_from =
-        requires { requires noexcept(T{::std::declval<Args>()...}); };
+        requires { requires noexcept(T{std::declval<Args>()...}); };
 
     template<typename T, typename... Args>
-    concept implicitly_constructible_from = ::std::constructible_from<T, Args...> &&
-        requires { ::std::declval<void(const T&)>()({::std::declval<Args>()...}); };
+    concept implicitly_constructible_from = std::constructible_from<T, Args...> &&
+        requires { std::declval<void(const T&)>()({std::declval<Args>()...}); };
 
     template<typename T>
     concept implicitly_move_constructible =
-        ::std::move_constructible<T> && implicitly_constructible_from<T, T>;
+        std::move_constructible<T> && implicitly_constructible_from<T, T>;
 
     template<typename T>
-    concept implicitly_copy_constructible = ::std::copy_constructible<T> && //
+    concept implicitly_copy_constructible = std::copy_constructible<T> && //
         implicitly_move_constructible<T> && //
         implicitly_constructible_from<T, T&> && //
         implicitly_constructible_from<T, const T> && //
         implicitly_constructible_from<T, const T&>;
 
     template<typename T>
-    concept trivial_copyable = ::std::is_trivially_copyable_v<T>;
+    concept trivial_copyable = std::is_trivially_copyable_v<T>;
 
     template<typename T>
-    concept trivial_constructible = ::std::is_trivially_constructible_v<T>;
+    concept trivial_constructible = std::is_trivially_constructible_v<T>;
 
     template<typename T>
-    concept trivial_copy_constructible = ::std::is_trivially_copy_constructible_v<T>;
+    concept trivial_copy_constructible = std::is_trivially_copy_constructible_v<T>;
 
     template<typename T>
-    concept trivial_copy_assignable = ::std::is_trivially_copy_assignable_v<T>;
+    concept trivial_copy_assignable = std::is_trivially_copy_assignable_v<T>;
 
     template<typename T>
-    concept trivial_move_constructible = ::std::is_trivially_move_constructible_v<T>;
+    concept trivial_move_constructible = std::is_trivially_move_constructible_v<T>;
 
     template<typename T>
-    concept trivial_move_assignable = ::std::is_trivially_move_assignable_v<T>;
+    concept trivial_move_assignable = std::is_trivially_move_assignable_v<T>;
 
     template<typename T, typename U>
-    concept not_same_as = !::std::same_as<T, U>;
+    concept not_same_as = !std::same_as<T, U>;
 
     template<typename T, typename U>
-    concept decay_same_as = ::std::same_as<::std::decay_t<T>, U>;
+    concept decay_same_as = std::same_as<std::decay_t<T>, U>;
 
     template<typename T>
-    concept decay_constructible = ::std::constructible_from<::std::decay_t<T>, T>;
+    concept decay_constructible = std::constructible_from<std::decay_t<T>, T>;
 
     template<typename T, typename... Args>
-    concept nothrow_constructible_from = ::std::is_nothrow_constructible_v<T, Args...>;
+    concept nothrow_constructible_from = std::is_nothrow_constructible_v<T, Args...>;
 
     template<typename T>
-    concept nothrow_decay_constructible = nothrow_constructible_from<::std::decay_t<T>, T>;
+    concept nothrow_decay_constructible = nothrow_constructible_from<std::decay_t<T>, T>;
 
     template<typename T>
     concept nothrow_default_initializable =
-        ::std::default_initializable<T> && ::std::is_nothrow_default_constructible_v<T>;
+        std::default_initializable<T> && std::is_nothrow_default_constructible_v<T>;
 
     template<typename T>
-    concept nothrow_move_constructible = ::std::is_nothrow_move_constructible_v<T>;
+    concept nothrow_move_constructible = std::is_nothrow_move_constructible_v<T>;
 
     template<typename T>
-    concept nothrow_copy_constructible = ::std::is_nothrow_copy_constructible_v<T>;
+    concept nothrow_copy_constructible = std::is_nothrow_copy_constructible_v<T>;
 
     template<typename T, typename U>
-    concept nothrow_assignable = ::std::is_nothrow_assignable_v<T, U>;
+    concept nothrow_assignable = std::is_nothrow_assignable_v<T, U>;
 
     template<typename T, typename U>
-    concept nothrow_assignable_from = ::std::is_nothrow_assignable_v<T, U>;
+    concept nothrow_assignable_from = std::is_nothrow_assignable_v<T, U>;
 
     template<typename T>
-    concept nothrow_copy_assignable = ::std::is_nothrow_copy_assignable_v<T>;
+    concept nothrow_copy_assignable = std::is_nothrow_copy_assignable_v<T>;
 
     template<typename T>
-    concept nothrow_move_assignable = ::std::is_nothrow_move_assignable_v<T>;
+    concept nothrow_move_assignable = std::is_nothrow_move_assignable_v<T>;
 
     template<typename T, typename U>
     concept nothrow_swappable_with =
-        requires(T& t, U& u) { requires noexcept(::std::ranges::swap(t, u)); };
+        requires(T& t, U& u) { requires noexcept(std::ranges::swap(t, u)); };
 
     template<typename T>
     concept nothrow_swappable = nothrow_swappable_with<T, T>;
 
     template<typename T>
-    concept nothrow_movable = ::std::movable<T> && //
+    concept nothrow_movable = std::movable<T> && //
         nothrow_move_constructible<T> &&
-        nothrow_assignable_from<::std::add_lvalue_reference_t<T>, T> && //
+        nothrow_assignable_from<std::add_lvalue_reference_t<T>, T> && //
         nothrow_swappable<T>;
 
     template<typename T>
-    concept nothrow_copyable =
-        nothrow_movable<T> && //
+    concept nothrow_copyable = nothrow_movable<T> && //
         nothrow_copy_constructible<T> && //
         nothrow_assignable_from< //
-            ::std::add_lvalue_reference_t<T>,
-            ::std::add_lvalue_reference_t<T> // clang-format off
+                                   std::add_lvalue_reference_t<T>,
+                                   std::add_lvalue_reference_t<T> // clang-format off
         > && // clang-format on
-        nothrow_assignable_from<::std::add_lvalue_reference_t<T>, ::std::add_const_t<T>> &&
-        nothrow_assignable_from<
-            ::std::add_lvalue_reference_t<T>,
-            ::std::add_lvalue_reference_t<::std::add_const_t<T>> // clang-format off
+        nothrow_assignable_from<std::add_lvalue_reference_t<T>, std::add_const_t<T>> &&
+        nothrow_assignable_from<std::add_lvalue_reference_t<T>,
+                                std::add_lvalue_reference_t<std::add_const_t<T>> // clang-format off
         >; // clang-format on
 
     template<typename T, typename U>
-    concept nothrow_convertible_to = ::std::is_nothrow_convertible_v<T, U>;
+    concept nothrow_convertible_to = std::is_nothrow_convertible_v<T, U>;
 
     template<typename From, typename To>
     concept explicitly_convertible = requires(From&& v) { static_cast<To>(cpp_forward(v)); };
@@ -332,13 +330,13 @@ namespace stdsharp
     concept nothrow_explicitly_convertible_from = nothrow_explicitly_convertible<From, To>;
 
     template<typename T, typename U>
-    concept convertible_from = ::std::convertible_to<U, T>;
+    concept convertible_from = std::convertible_to<U, T>;
 
     template<typename T, typename U>
-    concept nothrow_convertible_from = ::std::is_nothrow_convertible_v<U, T>;
+    concept nothrow_convertible_from = std::is_nothrow_convertible_v<U, T>;
 
     template<typename T, typename U>
-    concept inter_convertible = ::std::convertible_to<T, U> && convertible_from<T, U>;
+    concept inter_convertible = std::convertible_to<T, U> && convertible_from<T, U>;
 
     template<typename T, typename U>
     concept nothrow_inter_convertible =
@@ -353,13 +351,13 @@ namespace stdsharp
         nothrow_explicitly_convertible<T, U> && nothrow_explicitly_convertible_from<T, U>;
 
     template<typename Func, typename... Args>
-    concept nothrow_invocable = ::std::is_nothrow_invocable_v<Func, Args...>;
+    concept nothrow_invocable = std::is_nothrow_invocable_v<Func, Args...>;
 
     template<typename Func, typename ReturnT, typename... Args>
-    concept invocable_r = ::std::is_invocable_r_v<ReturnT, Func, Args...>;
+    concept invocable_r = std::is_invocable_r_v<ReturnT, Func, Args...>;
 
     template<typename Func, typename ReturnT, typename... Args>
-    concept nothrow_invocable_r = ::std::is_nothrow_invocable_r_v<ReturnT, Func, Args...>;
+    concept nothrow_invocable_r = std::is_nothrow_invocable_r_v<ReturnT, Func, Args...>;
 
     template<typename Func, typename... Args>
     concept nothrow_predicate = nothrow_invocable_r<Func, bool, Args...>;
@@ -374,14 +372,14 @@ namespace stdsharp
     concept const_ref_aligned = const_aligned<T, U> && ref_aligned<T, U>;
 
     template<typename T>
-    concept nullable_pointer = ::std::default_initializable<T> && //
-        ::std::copy_constructible<T> && //
+    concept nullable_pointer = std::default_initializable<T> && //
+        std::copy_constructible<T> && //
         copy_assignable<T> && //
-        ::std::equality_comparable<T> && //
-        weakly_equality_comparable_with<T, ::std::nullptr_t>;
+        std::equality_comparable<T> && //
+        weakly_equality_comparable_with<T, std::nullptr_t>;
 
     template<typename T>
-    concept referenceable = requires { typename ::std::add_lvalue_reference<T>; };
+    concept referenceable = requires { typename std::add_lvalue_reference<T>; };
 
     template<typename T> // clang-format off
     concept dereferenceable = requires(T& t) { { *t } -> referenceable; }; // clang-format on
diff --git a/include/stdsharp/concurrent_object.h b/include/stdsharp/concurrent_object.h
index 74ed10d0..736ae3cb 100644
--- a/include/stdsharp/concurrent_object.h
+++ b/include/stdsharp/concurrent_object.h
@@ -10,12 +10,12 @@
 
 namespace stdsharp
 {
-    template<typename T, shared_lockable Lockable = ::std::shared_mutex>
+    template<typename T, shared_lockable Lockable = std::shared_mutex>
         requires basic_lockable<Lockable>
     class concurrent_object
     {
     public:
-        using value_type = ::std::optional<T>;
+        using value_type = std::optional<T>;
 
     private:
         template<typename OtherLockable>
@@ -38,7 +38,7 @@ namespace stdsharp
 
         template<typename Other>
         static constexpr bool other_assignable =
-            requires(value_type obj) { assign_value(obj, ::std::declval<Other>()); };
+            requires(value_type obj) { assign_value(obj, std::declval<Other>()); };
 
         static constexpr bool copy_assignable = other_assignable<const concurrent_object&>;
         static constexpr bool move_assignable = other_assignable<concurrent_object>;
@@ -63,8 +63,8 @@ namespace stdsharp
             template<typename This, typename Func>
             constexpr void operator()(This&& instance, Func&& func) const
             {
-                const ::std::shared_lock lock{instance.lockable()};
-                ::std::invoke(cpp_forward(func), cpp_forward(instance).object_);
+                const std::shared_lock lock{instance.lockable()};
+                std::invoke(cpp_forward(func), cpp_forward(instance).object_);
             }
         };
 
@@ -73,14 +73,14 @@ namespace stdsharp
             template<typename Func>
             constexpr void operator()(concurrent_object&& instance, Func&& func) const
             {
-                ::std::invoke(cpp_forward(func), cpp_move(instance).object_);
+                std::invoke(cpp_forward(func), cpp_move(instance).object_);
             }
 
             template<typename Func>
             constexpr void operator()(concurrent_object& instance, Func&& func) const
             {
-                const ::std::unique_lock lock{instance.lockable()};
-                ::std::invoke(cpp_forward(func), instance.object_);
+                const std::unique_lock lock{instance.lockable()};
+                std::invoke(cpp_forward(func), instance.object_);
             }
         };
 
@@ -90,18 +90,18 @@ namespace stdsharp
         concurrent_object() = default;
 
         template<typename... Args>
-            requires ::std::constructible_from<T, Args...> && ::std::default_initializable<Lockable>
+            requires std::constructible_from<T, Args...> && std::default_initializable<Lockable>
         explicit constexpr concurrent_object(Args&&... t_arg): object_(cpp_forward(t_arg)...)
         {
         }
 
         template<typename... TArgs, typename... LockArgs>
-            requires ::std::constructible_from<T, TArgs...> &&
-                         ::std::constructible_from<Lockable, LockArgs...>
+            requires std::constructible_from<T, TArgs...> &&
+                         std::constructible_from<Lockable, LockArgs...>
         explicit constexpr concurrent_object(
-            const ::std::piecewise_construct_t tag,
-            ::std::tuple<TArgs...> t_arg,
-            ::std::tuple<LockArgs...> lock_arg
+            const std::piecewise_construct_t tag,
+            std::tuple<TArgs...> t_arg,
+            std::tuple<LockArgs...> lock_arg
         ):
             object_(cpp_forward(t_arg)), lockable_(tag, cpp_move(lock_arg))
         {
@@ -151,38 +151,36 @@ namespace stdsharp
 
         template<typename OtherLockable>
         constexpr void swap(concurrent_object<T, OtherLockable>& other) //
-            requires ::std::swappable_with<
+            requires std::swappable_with<
                 value_type,
-                typename ::std::remove_reference_t<decltype(other)>::value_type // clang-format off
+                typename std::remove_reference_t<decltype(other)>::value_type // clang-format off
             > // clang-format on
         {
             write(
                 [&other](value_type& obj) //
-                {
-                    other.write([&obj](auto& other_obj) { ::std::ranges::swap(obj, other_obj); });
-                } //
+                { other.write([&obj](auto& other_obj) { std::ranges::swap(obj, other_obj); }); } //
             );
         }
 
-        template<::std::invocable<const value_type&> Func>
+        template<std::invocable<const value_type&> Func>
         constexpr void read(Func&& func) const&
         {
             read_fn{}(*this, cpp_forward(func));
         }
 
-        template<::std::invocable<const value_type> Func>
+        template<std::invocable<const value_type> Func>
         constexpr void read(Func&& func) const&&
         {
             read_fn{}(static_cast<const concurrent_object&&>(*this), cpp_forward(func));
         }
 
-        template<::std::invocable<value_type&> Func>
+        template<std::invocable<value_type&> Func>
         constexpr void write(Func&& func) &
         {
             write_fn{}(*this, cpp_forward(func));
         }
 
-        template<::std::invocable<value_type> Func>
+        template<std::invocable<value_type> Func>
         constexpr void write(Func&& func) &&
         {
             write_fn{}(cpp_move(*this), cpp_forward(func));
@@ -191,14 +189,14 @@ namespace stdsharp
         constexpr const auto& lockable() const noexcept { return lockable_; }
 
     private:
-        ::std::optional<T> object_{};
+        std::optional<T> object_{};
         mutable Lockable lockable_{};
 
         constexpr auto& lockable() noexcept { return lockable_; }
     };
 
     template<typename T>
-    concurrent_object(T&&) -> concurrent_object<::std::decay_t<T>>;
+    concurrent_object(T&&) -> concurrent_object<std::decay_t<T>>;
 
     namespace reflection
     {
diff --git a/include/stdsharp/containers/actions.h b/include/stdsharp/containers/actions.h
index aef0473d..7acf52f4 100644
--- a/include/stdsharp/containers/actions.h
+++ b/include/stdsharp/containers/actions.h
@@ -44,8 +44,8 @@ namespace stdsharp::actions
                 template<container_erasable Container>
                 constexpr auto operator()(
                     Container& container,
-                    const ::std::equality_comparable_with< // clang-format off
-                         typename ::std::decay_t<Container>::value_type
+                    const std::equality_comparable_with< // clang-format off
+                         typename std::decay_t<Container>::value_type
                     > auto& value // clang-format on
                 ) const
                     requires requires // clang-format off
@@ -61,8 +61,8 @@ namespace stdsharp::actions
                     requires associative_like_container<Container>
                 constexpr auto operator()(
                     Container& container,
-                    const ::std::equality_comparable_with<
-                        typename ::std::decay_t<Container>::key_type // clang-format off
+                    const std::equality_comparable_with<
+                        typename std::decay_t<Container>::key_type // clang-format off
                     > auto& key // clang-format on
                 ) const
                 {
@@ -71,7 +71,7 @@ namespace stdsharp::actions
 
                 template<
                     container_erasable Container,
-                    ::std::convertible_to<
+                    std::convertible_to<
                         actions::details::container_citer<Container> // clang-format off
                     >... ConstIter
                 > // clang-format on
@@ -109,7 +109,7 @@ namespace stdsharp::actions
         struct emplace_##where##_default_fn                                                     \
         {                                                                                       \
             template<typename Container, typename... Args>                                      \
-                requires ::std::invocable<                                                      \
+                requires std::invocable<                                                        \
                     emplace_fn,                                                                 \
                     Container&,                                                                 \
                     details::container_citer<Container>,                                        \
@@ -123,11 +123,11 @@ namespace stdsharp::actions
         struct emplace_##where##_mem_fn                                                         \
         {                                                                                       \
             template<typename... Args, container_emplace_constructible<Args...> Container>      \
-            constexpr typename ::std::decay_t<Container>::reference                             \
+            constexpr typename std::decay_t<Container>::reference                               \
                 operator()(Container& container, Args&&... args) const                          \
                 requires requires {                                                             \
                     requires stdsharp::container<Container>;                                    \
-                    container.emplace_##where(::std::declval<Args>()...);                       \
+                    container.emplace_##where(std::declval<Args>()...);                         \
                 }                                                                               \
             {                                                                                   \
                 return container.emplace_##where(cpp_forward(args)...);                         \
@@ -160,9 +160,9 @@ namespace stdsharp::actions
                 constexpr auto operator()(Container& container, Predicate&& predicate_fn) const
                     requires requires //
                 {
-                    requires ::std::same_as<
-                        decltype(erase_if(container, ::std::declval<Predicate>())),
-                        ::std::ranges::range_size_t<Container> // clang-format off
+                    requires std::same_as<
+                        decltype(erase_if(container, std::declval<Predicate>())),
+                        std::ranges::range_size_t<Container> // clang-format off
                     >; // clang-format on
                 }
                 {
@@ -178,9 +178,8 @@ namespace stdsharp::actions
                 > // clang-format on
                     requires requires //
                 {
-                    requires ::std::
-                        invocable<decltype(::std::ranges::remove_if), Container, Predicate>;
-                    requires ::std::invocable<
+                    requires std::invocable<decltype(std::ranges::remove_if), Container, Predicate>;
+                    requires std::invocable<
                         cpo::erase_fn,
                         Container&,
                         actions::details::container_citer<Container>,
@@ -189,7 +188,7 @@ namespace stdsharp::actions
                 }
                 constexpr auto operator()(Container& container, Predicate&& predicate_fn) const
                 {
-                    const auto& it = ::std::ranges::remove_if(container, cpp_forward(predicate_fn));
+                    const auto& it = std::ranges::remove_if(container, cpp_forward(predicate_fn));
                     const auto removed_size = it.size();
                     cpo::erase(container, it.begin(), it.end());
                     return removed_size;
@@ -206,7 +205,7 @@ namespace stdsharp::actions
     inline constexpr struct resize_fn
     {
         template<typename Container>
-        using size_type = ::std::ranges::range_size_t<Container>;
+        using size_type = std::ranges::range_size_t<Container>;
 
         template<sequence_container Container>
         constexpr void operator()(Container& container, const size_type<Container> size) const
@@ -222,7 +221,7 @@ namespace stdsharp::actions
         struct pop_##where##_default_fn                                                         \
         {                                                                                       \
             template<typename Container>                                                        \
-                requires ::std::                                                                \
+                requires std::                                                                  \
                     invocable<cpo::erase_fn, Container&, details::container_citer<Container>>   \
                 constexpr void operator()(Container& container) const                           \
             {                                                                                   \
@@ -236,7 +235,7 @@ namespace stdsharp::actions
             constexpr void operator()(Container& container) const                               \
                 requires requires {                                                             \
                     requires sequence_container<Container>;                                     \
-                    requires ::std::same_as<decltype(container.pop_##where()), void>;           \
+                    requires std::same_as<decltype(container.pop_##where()), void>;             \
                 }                                                                               \
             {                                                                                   \
                 return container.pop_##where();                                                 \
@@ -261,7 +260,7 @@ namespace stdsharp::actions
         {
         private:
             template<
-                ::std::size_t Count,
+                std::size_t Count,
                 auto HasMember = requires(Container container) { container.reserve(Count); }>
             static constexpr auto reserved(Container& container) noexcept(!HasMember)
             {
@@ -270,7 +269,7 @@ namespace stdsharp::actions
 
         public:
             template<typename... Args>
-                requires(::std::invocable<actions::emplace_back_fn, Container&, Args> && ...)
+                requires(std::invocable<actions::emplace_back_fn, Container&, Args> && ...)
             constexpr auto operator()(Args&&... args) const noexcept( //
                 (nothrow_invocable<actions::emplace_back_fn, Container&, Args>&&...) && //
                 noexcept(reserved<Container, sizeof...(Args)>())
@@ -283,7 +282,7 @@ namespace stdsharp::actions
             }
 
             template<typename... Args>
-                requires(::std::invocable<actions::emplace_fn, Container&, Args> && ...)
+                requires(std::invocable<actions::emplace_fn, Container&, Args> && ...)
             constexpr auto operator()(Args&&... args) const noexcept( //
                 (nothrow_invocable<actions::emplace_fn, Container&, Args>&&...) && //
                 noexcept(reserved<Container, sizeof...(Args)>())
@@ -308,21 +307,21 @@ namespace stdsharp::actions
         template<typename Container>
         struct make_container_from_tuple_fn
         {
-            template<typename Tuple, typename ValueType = ::std::ranges::range_value_t<Container>>
+            template<typename Tuple, typename ValueType = std::ranges::range_value_t<Container>>
                 requires requires //
             {
-                ::std::apply(regular_make_container_fn<Container>{}, ::std::declval<Tuple>()); //
+                std::apply(regular_make_container_fn<Container>{}, std::declval<Tuple>()); //
             }
             constexpr auto operator()(
-                const ::std::piecewise_construct_t,
+                const std::piecewise_construct_t,
                 Tuple&& tuple
             ) const noexcept( //
                 noexcept( //
-                    ::std::apply(regular_make_container_fn<Container>{}, ::std::declval<Tuple>())
+                    std::apply(regular_make_container_fn<Container>{}, std::declval<Tuple>())
                 )
             )
             {
-                return ::std::apply(regular_make_container_fn<Container>{}, cpp_forward(tuple));
+                return std::apply(regular_make_container_fn<Container>{}, cpp_forward(tuple));
             }
         };
     }
diff --git a/include/stdsharp/containers/concepts.h b/include/stdsharp/containers/concepts.h
index e7121d73..b8ddfb56 100644
--- a/include/stdsharp/containers/concepts.h
+++ b/include/stdsharp/containers/concepts.h
@@ -17,21 +17,21 @@
 namespace stdsharp
 {
     template<typename T, auto Size>
-    struct allocator_of<::std::array<T, Size>>
+    struct allocator_of<std::array<T, Size>>
     {
-        using type = ::std::allocator<T>;
+        using type = std::allocator<T>;
     };
 
     template<typename ValueType, typename Allocator>
     concept erasable = requires(Allocator allocator_instance, ValueType* ptr) //
     {
         requires allocator_req<Allocator>;
-        requires ::std::same_as<
+        requires std::same_as<
             Allocator,
             typename allocator_traits<Allocator>:: //
             template rebind_alloc<ValueType> // clang-format off
         >; // clang-format on
-        requires ::std::destructible<ValueType>;
+        requires std::destructible<ValueType>;
         allocator_traits<Allocator>::destroy(allocator_instance, ptr);
     };
 
@@ -46,8 +46,8 @@ namespace stdsharp
     concept container_erasable = requires //
     {
         requires erasable<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>> // clang-format off
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>> // clang-format off
         >; // clang-format on
     };
 
@@ -55,8 +55,8 @@ namespace stdsharp
     concept container_nothrow_erasable = requires //
     {
         requires nothrow_erasable<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>> // clang-format off
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>> // clang-format off
         >; // clang-format on
     };
 
@@ -64,12 +64,12 @@ namespace stdsharp
     concept move_insertable =
         requires(Allocator allocator_instance, ValueType* ptr, ValueType&& rv) //
     {
-        requires ::std::same_as<
+        requires std::same_as<
             Allocator,
             typename allocator_traits<Allocator>:: //
             template rebind_alloc<ValueType> // clang-format off
         >; // clang-format on
-        requires ::std::move_constructible<ValueType>;
+        requires std::move_constructible<ValueType>;
         allocator_traits<Allocator>::construct(allocator_instance, ptr, cpp_move(rv));
     };
 
@@ -88,8 +88,8 @@ namespace stdsharp
     concept container_move_insertable = requires //
     {
         requires move_insertable<
-            typename ::std::decay_t<Container>::value_type, // clang-format off
-                allocator_of_t<::std::decay_t<Container>>
+            typename std::decay_t<Container>::value_type, // clang-format off
+                allocator_of_t<std::decay_t<Container>>
         >; // clang-format on
     };
 
@@ -97,15 +97,15 @@ namespace stdsharp
     concept container_nothrow_move_insertable = requires //
     {
         requires nothrow_move_insertable<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>> // clang-format off
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>> // clang-format off
         >; // clang-format on
     };
 
     template<typename ValueType, typename Allocator>
     concept copy_insertable = requires(Allocator allocator_instance, ValueType* ptr, ValueType v) //
     {
-        requires move_insertable<ValueType, Allocator> && ::std::copy_constructible<ValueType>;
+        requires move_insertable<ValueType, Allocator> && std::copy_constructible<ValueType>;
         allocator_traits<Allocator>::construct(allocator_instance, ptr, v);
     };
 
@@ -122,8 +122,8 @@ namespace stdsharp
     concept container_copy_insertable = requires //
     {
         requires copy_insertable<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>> // clang-format off
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>> // clang-format off
         >; // clang-format on
     };
 
@@ -131,8 +131,8 @@ namespace stdsharp
     concept container_nothrow_copy_insertable = requires //
     {
         requires nothrow_copy_insertable<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>> // clang-format off
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>> // clang-format off
         >; // clang-format on
     };
 
@@ -140,12 +140,12 @@ namespace stdsharp
     concept emplace_constructible =
         requires(Allocator allocator_instance, ValueType* ptr, Args&&... args) //
     {
-        requires ::std::same_as<
+        requires std::same_as<
             Allocator,
             typename allocator_traits<Allocator>:: //
             template rebind_alloc<ValueType> // clang-format off
         >; // clang-format on
-        requires ::std::constructible_from<ValueType, Args...>;
+        requires std::constructible_from<ValueType, Args...>;
         allocator_traits<Allocator>::construct(allocator_instance, ptr, cpp_forward(args)...);
     };
 
@@ -163,8 +163,8 @@ namespace stdsharp
     concept container_emplace_constructible = requires //
     {
         requires emplace_constructible<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>>,
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>>,
             Args... // clang-format off
         >; // clang-format on
     };
@@ -173,8 +173,8 @@ namespace stdsharp
     concept container_nothrow_emplace_constructible = requires //
     {
         requires nothrow_emplace_constructible<
-            typename ::std::decay_t<Container>::value_type,
-            allocator_of_t<::std::decay_t<Container>>,
+            typename std::decay_t<Container>::value_type,
+            allocator_of_t<std::decay_t<Container>>,
             Args... // clang-format off
         >; // clang-format on
     };
@@ -183,21 +183,21 @@ namespace stdsharp
     {
         template<typename T, typename U>
         concept iterator_identical = requires(
-            ::std::iterator_traits<T> t_traits,
-            ::std::iterator_traits<U> u_traits
+            std::iterator_traits<T> t_traits,
+            std::iterator_traits<U> u_traits
         ) //
         {
-            requires ::std::same_as<
+            requires std::same_as<
                 typename decltype(t_traits)::value_type,
                 typename decltype(u_traits)::value_type // clang-format off
             >; // clang-format on
-            requires ::std::same_as<
+            requires std::same_as<
                 typename decltype(t_traits)::difference_type,
                 typename decltype(u_traits)::difference_type // clang-format off
             >; // clang-format on
-            requires ::std::
+            requires std::
                 same_as<typename decltype(t_traits)::pointer, typename decltype(u_traits)::pointer>;
-            requires ::std::same_as<
+            requires std::same_as<
                 typename decltype(t_traits)::reference,
                 typename decltype(u_traits)::reference // clang-format off
             >; // clang-format on
@@ -227,14 +227,14 @@ namespace stdsharp
                 requires // clang-format off
                 {
                     { instance.insert(const_iter, cpp_move(value)) } ->
-                        ::std::same_as<decltype(iter)>; // clang-format on
+                        std::same_as<decltype(iter)>; // clang-format on
 
                     requires logical_imply(
                         container_copy_insertable<decltype(instance)>,
                         requires // clang-format off
                         {
                             { instance.insert(const_iter, const_value) } ->
-                                ::std::same_as<decltype(iter)>; // clang-format on
+                                std::same_as<decltype(iter)>; // clang-format on
                         }
                     );
                 }
@@ -244,17 +244,17 @@ namespace stdsharp
 
     template<typename Iterator, typename Node>
     using insert_return_type =
-        details::insert_return_type_of<::std::set<int>::insert_return_type>::type<Iterator, Node>;
+        details::insert_return_type_of<std::set<int>::insert_return_type>::type<Iterator, Node>;
 
     template<typename Container, typename... Members>
     concept container = requires //
     {
-        typename ::std::decay_t<Container>;
+        typename std::decay_t<Container>;
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             const decltype(instance) const_instance,
             decltype(instance)::value_type value,
-            ::std::ranges::range_reference_t<decltype(instance)> rng_ref,
+            std::ranges::range_reference_t<decltype(instance)> rng_ref,
             decltype(instance)::reference ref,
             decltype(instance)::const_reference const_ref,
             decltype(instance)::iterator iter,
@@ -263,17 +263,17 @@ namespace stdsharp
             decltype(instance)::size_type size // clang-format off
         ) // clang-format on
         {
-            requires ::std::ranges::forward_range<decltype(instance)>;
+            requires std::ranges::forward_range<decltype(instance)>;
 
-            requires ::std::destructible<decltype(instance)>;
+            requires std::destructible<decltype(instance)>;
 
             requires logical_imply(
                          (nothrow_default_initializable<Members> && ...),
                          nothrow_default_initializable<decltype(instance)> //
                      ) ||
                 logical_imply(
-                         (::std::default_initializable<Members> && ...),
-                         ::std::default_initializable<decltype(instance)> //
+                         (std::default_initializable<Members> && ...),
+                         std::default_initializable<decltype(instance)> //
                 );
 
             requires logical_imply(
@@ -282,9 +282,9 @@ namespace stdsharp
                          nothrow_copy_constructible<decltype(instance)> //
                      ) ||
                 logical_imply(
-                         (::std::copy_constructible<Members> && ...) &&
+                         (std::copy_constructible<Members> && ...) &&
                              container_copy_insertable<decltype(instance)>,
-                         ::std::copy_constructible<decltype(instance)> //
+                         std::copy_constructible<decltype(instance)> //
                 );
             requires logical_imply(
                          (nothrow_copy_assignable<Members> && ...) &&
@@ -299,8 +299,8 @@ namespace stdsharp
                 );
 
             requires logical_imply(
-                         (::std::move_constructible<Members> && ...),
-                         ::std::move_constructible<decltype(instance)> //
+                         (std::move_constructible<Members> && ...),
+                         std::move_constructible<decltype(instance)> //
                      ) ||
                 logical_imply(
                          (nothrow_move_constructible<Members> && ...),
@@ -308,15 +308,15 @@ namespace stdsharp
                 );
 
             requires logical_imply(
-                ::std::equality_comparable<decltype(value)>,
-                ::std::equality_comparable<decltype(instance)> //
+                std::equality_comparable<decltype(value)>,
+                std::equality_comparable<decltype(instance)> //
             );
 
             requires requires(
                 allocator_of_t<decltype(instance)> alloc,
                 allocator_traits<decltype(alloc)> traits,
-                ::std::bool_constant<decltype(traits):: //
-                                     propagate_on_container_move_assignment::value> propagate
+                std::bool_constant<decltype(traits):: //
+                                   propagate_on_container_move_assignment::value> propagate
             ) //
             {
                 requires container_erasable<decltype(instance)>;
@@ -335,47 +335,46 @@ namespace stdsharp
                     );
             };
 
-            requires ::std::
-                same_as<decltype(value), ::std::ranges::range_value_t<decltype(instance)>>;
-            requires ::std::same_as<decltype(ref), ::std::add_lvalue_reference_t<decltype(value)>>;
-            requires ::std::same_as<decltype(const_ref), add_const_lvalue_ref_t<decltype(value)>>;
-            requires ::std::same_as<decltype(iter), ::std::ranges::iterator_t<decltype(instance)>>;
-            requires ::std::same_as<decltype(iter), ::std::ranges::sentinel_t<decltype(instance)>>;
+            requires std::same_as<decltype(value), std::ranges::range_value_t<decltype(instance)>>;
+            requires std::same_as<decltype(ref), std::add_lvalue_reference_t<decltype(value)>>;
+            requires std::same_as<decltype(const_ref), add_const_lvalue_ref_t<decltype(value)>>;
+            requires std::same_as<decltype(iter), std::ranges::iterator_t<decltype(instance)>>;
+            requires std::same_as<decltype(iter), std::ranges::sentinel_t<decltype(instance)>>;
 
             {
                 const_instance.cbegin()
-            } -> ::std::same_as<decltype(const_iter)>;
+            } -> std::same_as<decltype(const_iter)>;
 
             {
                 const_instance.cend()
-            } -> ::std::same_as<decltype(const_iter)>;
+            } -> std::same_as<decltype(const_iter)>;
 
-            requires ::std::same_as<decltype(ref), decltype(rng_ref)> ||
-                ::std::same_as<decltype(const_ref), decltype(rng_ref)>;
-            requires ::std::same_as<
+            requires std::same_as<decltype(ref), decltype(rng_ref)> ||
+                std::same_as<decltype(const_ref), decltype(rng_ref)>;
+            requires std::same_as<
                 decltype(const_ref),
                 range_const_reference_t<decltype(instance)> // clang-format off
             >; // clang-format on
-            requires ::std::signed_integral<decltype(diff)>;
-            requires ::std::
-                same_as<decltype(diff), ::std::ranges::range_difference_t<decltype(instance)>>;
-            requires ::std::unsigned_integral<decltype(size)>;
+            requires std::signed_integral<decltype(diff)>;
+            requires std::
+                same_as<decltype(diff), std::ranges::range_difference_t<decltype(instance)>>;
+            requires std::unsigned_integral<decltype(size)>;
             requires requires //
             {
-                []<typename T, typename U>(::std::forward_list<T, U>*) {}(&instance); //
+                []<typename T, typename U>(std::forward_list<T, U>*) {}(&instance); //
             } ||
                 requires //
             {
-                requires ::std::
-                    same_as<decltype(size), ::std::ranges::range_size_t<decltype(instance)>>;
+                requires std::
+                    same_as<decltype(size), std::ranges::range_size_t<decltype(instance)>>;
             };
             requires(
-                ::std::numeric_limits<decltype(size)>::max() >
-                ::std::numeric_limits<decltype(diff)>::max()
+                std::numeric_limits<decltype(size)>::max() >
+                std::numeric_limits<decltype(diff)>::max()
             ); // clang-format off
 
-            { instance.max_size() } -> ::std::same_as<decltype(size)>;
-            { instance.empty() } -> ::std::convertible_to<bool>; // clang-format on
+            { instance.max_size() } -> std::same_as<decltype(size)>;
+            { instance.empty() } -> std::convertible_to<bool>; // clang-format on
         };
     };
 
@@ -383,20 +382,20 @@ namespace stdsharp
     concept reversible_container = container<Container, Members...> &&
         requires //
     {
-        typename ::std::decay_t<Container>;
+        typename std::decay_t<Container>;
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             const decltype(instance)& const_instance,
             decltype(instance)::reverse_iterator iter,
             decltype(instance)::const_reverse_iterator const_iter
         ) // clang-format off
         {
-            { instance.rbegin() } -> ::std::same_as<decltype(iter)>;
-            { instance.rend() } -> ::std::same_as<decltype(iter)>;
-            { const_instance.rbegin() } -> ::std::same_as<decltype(const_iter)>;
-            { const_instance.rend() } -> ::std::same_as<decltype(const_iter)>;
-            { instance.crbegin() } -> ::std::same_as<decltype(const_iter)>;
-            { instance.crend() } -> ::std::same_as<decltype(const_iter)>; // clang-format on
+            { instance.rbegin() } -> std::same_as<decltype(iter)>;
+            { instance.rend() } -> std::same_as<decltype(iter)>;
+            { const_instance.rbegin() } -> std::same_as<decltype(const_iter)>;
+            { const_instance.rend() } -> std::same_as<decltype(const_iter)>;
+            { instance.crbegin() } -> std::same_as<decltype(const_iter)>;
+            { instance.crend() } -> std::same_as<decltype(const_iter)>; // clang-format on
         };
     };
 
@@ -404,18 +403,18 @@ namespace stdsharp
     concept allocator_aware_container = requires //
     {
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             decltype(instance)::value_type value,
             decltype(instance)::allocator_type alloc
         ) //
         {
             requires allocator_req<decltype(alloc)>;
             requires container<Container, decltype(alloc), Members...>;
-            requires ::std::constructible_from<decltype(instance), decltype(alloc)>;
+            requires std::constructible_from<decltype(instance), decltype(alloc)>;
 
             requires logical_imply(
                 container_copy_insertable<decltype(instance)>,
-                ::std::constructible_from<
+                std::constructible_from<
                     decltype(instance),
                     const decltype(instance)&,
                     decltype(alloc) // clang-format off
@@ -423,16 +422,16 @@ namespace stdsharp
             );
             requires logical_imply(
                 container_move_insertable<decltype(instance)>,
-                ::std::constructible_from<
+                std::constructible_from<
                     decltype(instance),
                     decltype(instance),
                     decltype(alloc) // clang-format off
                 > // clang-format on
             );
-            requires ::std::same_as<decltype(value), typename decltype(alloc)::value_type>;
+            requires std::same_as<decltype(value), typename decltype(alloc)::value_type>;
 
             // clang-format off
-            { instance.get_allocator() } -> ::std::same_as<decltype(alloc)>; // clang-format on
+            { instance.get_allocator() } -> std::same_as<decltype(alloc)>; // clang-format on
         };
     };
 
@@ -441,7 +440,7 @@ namespace stdsharp
         requires //
     {
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             const decltype(instance)& const_instance,
             decltype(instance)::value_type value,
             const decltype(value)& const_value,
@@ -452,7 +451,7 @@ namespace stdsharp
         {
             requires logical_imply(
                 container_copy_insertable<decltype(instance)>,
-                ::std::constructible_from<
+                std::constructible_from<
                     decltype(instance),
                     decltype(size),
                     decltype(value) // clang-format off
@@ -461,28 +460,28 @@ namespace stdsharp
 
             requires logical_imply(
                 container_emplace_constructible<decltype(instance), decltype(value)>,
-                requires(::std::initializer_list<decltype(value)> v_list) //
+                requires(std::initializer_list<decltype(value)> v_list) //
                 {
-                    requires ::std::constructible_from<
+                    requires std::constructible_from<
                         decltype(instance),
                         decltype(const_iter),
                         decltype(const_iter) // clang-format off
                     >;
-                    requires ::std::constructible_from<decltype(instance), decltype(v_list)>;
-                    { instance.insert(const_iter, v_list) } -> ::std::same_as<decltype(iter)>;
-                    { instance.assign(v_list) } -> ::std::same_as<void>;
+                    requires std::constructible_from<decltype(instance), decltype(v_list)>;
+                    { instance.insert(const_iter, v_list) } -> std::same_as<decltype(iter)>;
+                    { instance.assign(v_list) } -> std::same_as<void>;
 
                     { instance.emplace(const_iter, const_value) } ->
-                        ::std::same_as<decltype(iter)>;
+                        std::same_as<decltype(iter)>;
 
                     { instance.insert(const_iter, const_iter, const_iter) } ->
-                        ::std::same_as<decltype(iter)>;
-                    { instance.assign(const_iter, const_iter) } -> ::std::same_as<void>;
+                        std::same_as<decltype(iter)>;
+                    { instance.assign(const_iter, const_iter) } -> std::same_as<void>;
 
-                    { instance.erase(const_iter) } -> ::std::same_as<decltype(iter)>;
-                    { instance.erase(const_iter, const_iter) } -> ::std::same_as<decltype(iter)>;
+                    { instance.erase(const_iter) } -> std::same_as<decltype(iter)>;
+                    { instance.erase(const_iter, const_iter) } -> std::same_as<decltype(iter)>;
 
-                    { instance.clear() } -> ::std::same_as<void>; // clang-format on
+                    { instance.clear() } -> std::same_as<void>; // clang-format on
                 }
             );
 
@@ -493,39 +492,39 @@ namespace stdsharp
                     copy_assignable<decltype(value)>, // clang-format off
                 requires(decltype(size) n)
                 {
-                    requires ::std::assignable_from<
+                    requires std::assignable_from<
                         decltype(instance)&,
-                        ::std::initializer_list<decltype(value)>
+                        std::initializer_list<decltype(value)>
                     >;
 
-                    { instance.insert(const_iter, n, const_value) } -> ::std::same_as<decltype(iter)>;
+                    { instance.insert(const_iter, n, const_value) } -> std::same_as<decltype(iter)>;
 
-                    { instance.assign(n, const_value) } -> ::std::same_as<void>;
+                    { instance.assign(n, const_value) } -> std::same_as<void>;
                 }
             );
 
-            { instance.front() } -> ::std::same_as<typename decltype(instance)::reference>;
+            { instance.front() } -> std::same_as<typename decltype(instance)::reference>;
             { const_instance.front() } ->
-                ::std::same_as<typename decltype(instance)::const_reference>; // clang-format on
+                std::same_as<typename decltype(instance)::const_reference>; // clang-format on
         };
     };
 
     template<typename Container>
     concept contiguous_container =
-        container<Container> && ::std::ranges::contiguous_range<::std::decay_t<Container>>;
+        container<Container> && std::ranges::contiguous_range<std::decay_t<Container>>;
 
     namespace details
     {
         template<typename Container>
         concept unique_associative = requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             decltype(instance)::node_type node,
             decltype(instance)::insert_return_type insert_return_v
         ) // clang-format off
         {
             { instance.insert(cpp_move(node)) } ->
-                ::std::same_as<decltype(insert_return_v)>;
-            requires ::std::same_as<
+                std::same_as<decltype(insert_return_v)>;
+            requires std::same_as<
                 decltype(insert_return_v),
                 insert_return_type<decltype(instance.begin()), decltype(node)>
             >;
@@ -533,24 +532,24 @@ namespace stdsharp
 
         template<typename Container>
         concept multikey_associative = requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             decltype(instance)::node_type node
         ) // clang-format off
         {
             { instance.insert(cpp_move(node)) } ->
-                ::std::same_as<typename decltype(instance)::iterator>; // clang-format on
+                std::same_as<typename decltype(instance)::iterator>; // clang-format on
         };
 
         template<typename Container, typename... Args>
         struct container_optional_constructible
         {
             template<typename...>
-            static constexpr bool value = ::std::constructible_from<Container, Args...>;
+            static constexpr bool value = std::constructible_from<Container, Args...>;
 
             template<typename... Optional>
                 requires(sizeof...(Optional) > 0)
             static constexpr bool value<Optional...> =
-                ::std::constructible_from<Container, Args..., Optional...> &&
+                std::constructible_from<Container, Args..., Optional...> &&
                 []<typename... T>(const basic_type_sequence<T...>) consteval //
             {
                 return value<T...>;
@@ -564,7 +563,7 @@ namespace stdsharp
         requires //
     {
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             const decltype(instance)& const_instance,
             decltype(instance)::key_type key,
             decltype(instance)::const_reference const_ref,
@@ -573,7 +572,7 @@ namespace stdsharp
             decltype(instance)::iterator iter,
             decltype(instance)::const_iterator const_iter,
             decltype(instance)::size_type size,
-            ::std::initializer_list<decltype(value)> v_list
+            std::initializer_list<decltype(value)> v_list
         ) //
         {
             requires details::container_insertable<decltype(instance)>;
@@ -583,39 +582,39 @@ namespace stdsharp
                 requires // clang-format off
                 {
                     { instance.emplace_hint(const_iter, const_ref) } ->
-                        ::std::same_as<decltype(iter)>;
+                        std::same_as<decltype(iter)>;
                     { instance.insert(const_iter, const_iter) } ->
-                        ::std::same_as<void>;
-                    { instance.insert(v_list) } -> ::std::same_as<void>;
+                        std::same_as<void>;
+                    { instance.insert(v_list) } -> std::same_as<void>;
                 }
             );
 
-            { instance.extract(const_iter) } -> ::std::same_as<decltype(node)>;
-            { instance.extract(key) } -> ::std::same_as<decltype(node)>;
+            { instance.extract(const_iter) } -> std::same_as<decltype(node)>;
+            { instance.extract(key) } -> std::same_as<decltype(node)>;
 
-            { instance.erase(key) } -> ::std::same_as<decltype(size)>;
+            { instance.erase(key) } -> std::same_as<decltype(size)>;
 
-            { instance.find(key) } -> ::std::same_as<decltype(iter)>;
-            { const_instance.find(key) } -> ::std::same_as<decltype(const_iter)>;
+            { instance.find(key) } -> std::same_as<decltype(iter)>;
+            { const_instance.find(key) } -> std::same_as<decltype(const_iter)>;
 
-            { const_instance.count(key) } -> ::std::same_as<decltype(size)>;
+            { const_instance.count(key) } -> std::same_as<decltype(size)>;
 
-            { const_instance.contains(key) } -> ::std::same_as<bool>;
+            { const_instance.contains(key) } -> std::same_as<bool>;
 
             { instance.equal_range(key) } ->
-                ::std::same_as<::std::pair<decltype(iter), decltype(iter)>>;
+                std::same_as<std::pair<decltype(iter), decltype(iter)>>;
             { const_instance.equal_range(key) } ->
-                ::std::same_as<::std::pair<decltype(const_iter), decltype(const_iter)>>;
+                std::same_as<std::pair<decltype(const_iter), decltype(const_iter)>>;
 
-            { instance.insert(const_iter, cpp_move(node)) } -> ::std::same_as<decltype(iter)>;
+            { instance.insert(const_iter, cpp_move(node)) } -> std::same_as<decltype(iter)>;
 
-            { instance.erase(const_iter) } -> ::std::same_as<decltype(iter)>;
-            { instance.erase(const_iter, const_iter) } -> ::std::same_as<decltype(iter)>;
-            { instance.erase(iter) } -> ::std::same_as<decltype(iter)>;
+            { instance.erase(const_iter) } -> std::same_as<decltype(iter)>;
+            { instance.erase(const_iter, const_iter) } -> std::same_as<decltype(iter)>;
+            { instance.erase(iter) } -> std::same_as<decltype(iter)>;
 
-            { instance.merge(instance) } -> ::std::same_as<void>;
+            { instance.merge(instance) } -> std::same_as<void>;
 
-            { instance.clear() } -> ::std::same_as<void>; // clang-format on
+            { instance.clear() } -> std::same_as<void>; // clang-format on
         };
     };
 
@@ -623,7 +622,7 @@ namespace stdsharp
     concept associative_container = requires //
     {
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             const decltype(instance)& const_instance,
             decltype(instance)::value_type value,
             decltype(instance)::key_type key,
@@ -633,17 +632,17 @@ namespace stdsharp
             decltype(instance)::iterator iter,
             decltype(instance)::const_iterator const_iter,
             decltype(instance)::size_type size,
-            ::std::initializer_list<decltype(value)> v_list
+            std::initializer_list<decltype(value)> v_list
         ) //
         {
             requires associative_like_container<decltype(instance), decltype(key_cmp), Members...>;
 
-            requires ::std::copyable<decltype(key_cmp)>;
-            requires ::std::predicate<decltype(key_cmp), decltype(key), decltype(key)>;
-            requires ::std::constructible_from<decltype(instance), const decltype(key_cmp)>;
+            requires std::copyable<decltype(key_cmp)>;
+            requires std::predicate<decltype(key_cmp), decltype(key), decltype(key)>;
+            requires std::constructible_from<decltype(instance), const decltype(key_cmp)>;
 
-            requires ::std::copyable<decltype(value_cmp)>;
-            requires ::std::predicate<decltype(value_cmp), decltype(value), decltype(value)>;
+            requires std::copyable<decltype(value_cmp)>;
+            requires std::predicate<decltype(value_cmp), decltype(value), decltype(value)>;
 
             requires logical_imply(
                 container_emplace_constructible<decltype(instance), decltype(value)>,
@@ -661,18 +660,18 @@ namespace stdsharp
 #if (defined __cpp_lib_containers_ranges) && !(defined _MSVC_LANG)
             requires details::container_optional_constructible<
                 decltype(instance),
-                ::std::from_range_t,
+                std::from_range_t,
                 decltype(instance) // clang-format off
             >::template value<decltype(key_cmp), decltype(alloc)>;
 #endif
 
-            { instance.key_comp() } -> ::std::same_as<decltype(key_cmp)>;
-            { instance.value_comp() } -> ::std::same_as<decltype(value_cmp)>;
+            { instance.key_comp() } -> std::same_as<decltype(key_cmp)>;
+            { instance.value_comp() } -> std::same_as<decltype(value_cmp)>;
 
-            { instance.lower_bound(key) } -> ::std::same_as<decltype(iter)>;
-            { const_instance.lower_bound(key) } -> ::std::same_as<decltype(const_iter)>;
-            { instance.upper_bound(key) } -> ::std::same_as<decltype(iter)>;
-            { const_instance.upper_bound(key) } -> ::std::same_as<decltype(const_iter)>; // clang-format on
+            { instance.lower_bound(key) } -> std::same_as<decltype(iter)>;
+            { const_instance.lower_bound(key) } -> std::same_as<decltype(const_iter)>;
+            { instance.upper_bound(key) } -> std::same_as<decltype(iter)>;
+            { const_instance.upper_bound(key) } -> std::same_as<decltype(const_iter)>; // clang-format on
         };
     };
 
@@ -688,7 +687,7 @@ namespace stdsharp
     concept unordered_associative_container = requires //
     {
         requires requires(
-            ::std::decay_t<Container> instance,
+            std::decay_t<Container> instance,
             const decltype(instance)& const_instance,
             decltype(instance)::value_type value,
             decltype(instance)::key_type key,
@@ -703,16 +702,16 @@ namespace stdsharp
             decltype(instance)::const_local_iterator const_local_iter,
             decltype(instance)::difference_type diff,
             decltype(instance)::size_type size,
-            ::std::initializer_list<decltype(value)> v_list
+            std::initializer_list<decltype(value)> v_list
         ) //
         {
             requires associative_like_container<decltype(instance), decltype(hasher), Members...>;
 
-            requires ::std::copyable<decltype(key_equal)>;
-            requires ::std::predicate<decltype(key_equal), decltype(key), decltype(key)>;
+            requires std::copyable<decltype(key_equal)>;
+            requires std::predicate<decltype(key_equal), decltype(key), decltype(key)>;
 
-            requires ::std::copyable<decltype(hasher)>;
-            requires invocable_r<decltype(hasher), ::std::size_t, decltype(key)>;
+            requires std::copyable<decltype(hasher)>;
+            requires invocable_r<decltype(hasher), std::size_t, decltype(key)>;
 
             requires details::iterator_identical<decltype(iter), decltype(local_iter)>;
             requires details::iterator_identical<decltype(const_iter), decltype(const_local_iter)>;
@@ -747,7 +746,7 @@ namespace stdsharp
 #if(defined __cpp_lib_containers_ranges) && !(defined _MSVC_LANG)
                     requires details::container_optional_constructible<
                         decltype(instance),
-                        ::std::from_range_t,
+                        std::from_range_t,
                         decltype(instance) // clang-format off
                     >::template value<
                         decltype(size),
@@ -761,37 +760,37 @@ namespace stdsharp
 
             requires logical_imply(
                 container_copy_insertable<decltype(instance)> && copy_assignable<decltype(value)> &&
-                    ::std::default_initializable<decltype(hasher)> &&
-                    ::std::default_initializable<decltype(key_equal)> &&
-                    ::std::default_initializable<decltype(alloc)>,
-                ::std::constructible_from<decltype(instance), decltype(v_list)> //
+                    std::default_initializable<decltype(hasher)> &&
+                    std::default_initializable<decltype(key_equal)> &&
+                    std::default_initializable<decltype(alloc)>,
+                std::constructible_from<decltype(instance), decltype(v_list)> //
             ); // clang-format off
 
-            { instance.key_eq() } -> ::std::same_as<decltype(key_equal)>;
-            { instance.hash_function() } -> ::std::same_as<decltype(hasher)>;
+            { instance.key_eq() } -> std::same_as<decltype(key_equal)>;
+            { instance.hash_function() } -> std::same_as<decltype(hasher)>;
 
-            { const_instance.bucket(key) } -> ::std::same_as<decltype(size)>;
-            { const_instance.bucket_count() } -> ::std::same_as<decltype(size)>;
-            { const_instance.max_bucket_count() } -> ::std::same_as<decltype(size)>;
+            { const_instance.bucket(key) } -> std::same_as<decltype(size)>;
+            { const_instance.bucket_count() } -> std::same_as<decltype(size)>;
+            { const_instance.max_bucket_count() } -> std::same_as<decltype(size)>;
 
-            { instance.max_load_factor(0.0f) } -> ::std::same_as<void>;
+            { instance.max_load_factor(0.0f) } -> std::same_as<void>;
 
-            { const_instance.load_factor()  } -> ::std::same_as<float>;
-            { const_instance.max_load_factor() } -> ::std::same_as<float>;
+            { const_instance.load_factor()  } -> std::same_as<float>;
+            { const_instance.max_load_factor() } -> std::same_as<float>;
 
-            { const_instance.bucket_size(size) } -> ::std::same_as<decltype(size)>;
+            { const_instance.bucket_size(size) } -> std::same_as<decltype(size)>;
 
-            { instance.rehash(size) } -> ::std::same_as<void>;
+            { instance.rehash(size) } -> std::same_as<void>;
 
-            { instance.reserve(size) } -> ::std::same_as<void>;
+            { instance.reserve(size) } -> std::same_as<void>;
 
-            { instance.begin(size) } -> ::std::same_as<decltype(local_iter)>;
-            { instance.end(size) } -> ::std::same_as<decltype(local_iter)>;
+            { instance.begin(size) } -> std::same_as<decltype(local_iter)>;
+            { instance.end(size) } -> std::same_as<decltype(local_iter)>;
 
-            { const_instance.begin(size) } -> ::std::same_as<decltype(const_local_iter)>;
-            { const_instance.end(size) } -> ::std::same_as<decltype(const_local_iter)>;
-            { const_instance.cbegin(size) } -> ::std::same_as<decltype(const_local_iter)>;
-            { const_instance.cend(size) } -> ::std::same_as<decltype(const_local_iter)>; // clang-format on
+            { const_instance.begin(size) } -> std::same_as<decltype(const_local_iter)>;
+            { const_instance.end(size) } -> std::same_as<decltype(const_local_iter)>;
+            { const_instance.cbegin(size) } -> std::same_as<decltype(const_local_iter)>;
+            { const_instance.cend(size) } -> std::same_as<decltype(const_local_iter)>; // clang-format on
         };
     };
 
@@ -806,6 +805,5 @@ namespace stdsharp
         details::multikey_associative<Container>;
 
     template<typename Predicate, typename Container>
-    concept container_predicatable =
-        ::std::predicate<Predicate, range_const_reference_t<Container>>;
+    concept container_predicatable = std::predicate<Predicate, range_const_reference_t<Container>>;
 }
\ No newline at end of file
diff --git a/include/stdsharp/cstdint/cstdint.h b/include/stdsharp/cstdint/cstdint.h
index e588cb80..9b6523aa 100644
--- a/include/stdsharp/cstdint/cstdint.h
+++ b/include/stdsharp/cstdint/cstdint.h
@@ -8,24 +8,24 @@
 
 namespace stdsharp
 {
-    inline constexpr ::std::size_t char_bit = CHAR_BIT;
+    inline constexpr std::size_t char_bit = CHAR_BIT;
 
-    using byte = ::std::underlying_type_t<::std::byte>;
-    using i8 = ::std::int8_t; ///< 8-bit signed integer type.
-    using u8 = ::std::uint8_t; ///< 8-bit unsigned integer type.
-    using i16 = ::std::int16_t; ///< 16-bit signed integer type.
-    using u16 = ::std::uint16_t; ///< 16-bit unsigned integer type.
-    using i32 = ::std::int32_t; ///< 32-bit signed integer type.
-    using u32 = ::std::uint32_t; ///< 32-bit unsigned integer type.
-    using i64 = ::std::int64_t; ///< 64-bit signed integer type.
-    using u64 = ::std::uint64_t; ///< 64-bit unsigned integer type.
+    using byte = std::underlying_type_t<std::byte>;
+    using i8 = std::int8_t; ///< 8-bit signed integer type.
+    using u8 = std::uint8_t; ///< 8-bit unsigned integer type.
+    using i16 = std::int16_t; ///< 16-bit signed integer type.
+    using u16 = std::uint16_t; ///< 16-bit unsigned integer type.
+    using i32 = std::int32_t; ///< 32-bit signed integer type.
+    using u32 = std::uint32_t; ///< 32-bit unsigned integer type.
+    using i64 = std::int64_t; ///< 64-bit signed integer type.
+    using u64 = std::uint64_t; ///< 64-bit unsigned integer type.
     using ssize_t =
-        ::std::make_signed_t<::std::size_t>; ///< Signed integer type corresponding to `size_t`.
+        std::make_signed_t<std::size_t>; ///< Signed integer type corresponding to `size_t`.
 
     inline constexpr struct
     {
         template<typename T>
-        [[nodiscard]] constexpr ::std::make_unsigned_t<T> operator()(const T t) noexcept
+        [[nodiscard]] constexpr std::make_unsigned_t<T> operator()(const T t) noexcept
         {
             return auto_cast(t);
         }
@@ -34,7 +34,7 @@ namespace stdsharp
     inline constexpr struct
     {
         template<typename T>
-        [[nodiscard]] constexpr ::std::make_signed_t<T> operator()(const T t) noexcept
+        [[nodiscard]] constexpr std::make_signed_t<T> operator()(const T t) noexcept
         {
             return auto_cast(t);
         }
diff --git a/include/stdsharp/default_operator.h b/include/stdsharp/default_operator.h
index 01bac69d..b0d5d247 100644
--- a/include/stdsharp/default_operator.h
+++ b/include/stdsharp/default_operator.h
@@ -10,7 +10,7 @@ namespace stdsharp
     {
         [[nodiscard]] friend constexpr T operator+(const T& t) //
             noexcept(nothrow_copy_constructible<T>)
-            requires ::std::copy_constructible<T>
+            requires std::copy_constructible<T>
         {
             return t;
         }
@@ -37,7 +37,7 @@ namespace stdsharp
 
         [[nodiscard]] friend constexpr auto operator++(T& t, int) //
             noexcept(nothrow_copy_constructible<T>&& noexcept(++t))
-            requires ::std::copy_constructible<T> && requires { ++t; }
+            requires std::copy_constructible<T> && requires { ++t; }
         {
             const auto copy = t;
             ++t;
@@ -46,7 +46,7 @@ namespace stdsharp
 
         [[nodiscard]] friend constexpr auto operator--(T& t, int) //
             noexcept(nothrow_copy_constructible<T>&& noexcept(--t))
-            requires ::std::copy_constructible<T> && requires { --t; }
+            requires std::copy_constructible<T> && requires { --t; }
         {
             const auto copy = t;
             --t;
@@ -89,7 +89,7 @@ namespace stdsharp
     [[nodiscard]] friend constexpr T operator op(U&& u, V&& t) noexcept(  \
         noexcept(cast_fwd<T>(cpp_forward(t)) op cpp_forward(u))           \
     )                                                                     \
-        requires(!::std::convertible_to<U, T>) && Commutable &&           \
+        requires(!std::convertible_to<U, T>) && Commutable &&             \
         requires { cast_fwd<T>(cpp_forward(t)) op cpp_forward(u); }       \
     {                                                                     \
         return cast_fwd<T>(cpp_forward(t)) op cpp_forward(u);             \
diff --git a/include/stdsharp/enumeration.h b/include/stdsharp/enumeration.h
index 08e9570a..c07e3e46 100644
--- a/include/stdsharp/enumeration.h
+++ b/include/stdsharp/enumeration.h
@@ -9,7 +9,7 @@ namespace stdsharp
     struct enumeration
     {
         using enum_type = T;
-        using underlying_type = ::std::underlying_type_t<T>;
+        using underlying_type = std::underlying_type_t<T>;
 
         T value{};
 
@@ -29,7 +29,7 @@ namespace stdsharp
     };
 
     template<typename T>
-    enumeration(T) -> enumeration<::std::remove_cv_t<T>>;
+    enumeration(T) -> enumeration<std::remove_cv_t<T>>;
 
     template<enum_ T>
     struct flag : enumeration<T>
@@ -90,5 +90,5 @@ namespace stdsharp
     };
 
     template<typename T>
-    flag(T) -> flag<::std::remove_cv_t<T>>;
+    flag(T) -> flag<std::remove_cv_t<T>>;
 }
\ No newline at end of file
diff --git a/include/stdsharp/exception/exception.h b/include/stdsharp/exception/exception.h
index 8c6ce1ac..677eb10c 100644
--- a/include/stdsharp/exception/exception.h
+++ b/include/stdsharp/exception/exception.h
@@ -6,13 +6,13 @@
 
 namespace stdsharp
 {
-    template<::std::size_t I>
-    class aggregate_exceptions : public ::std::exception
+    template<std::size_t I>
+    class aggregate_exceptions : public std::exception
     {
-        ::std::array<::std::exception_ptr, I> exceptions_;
+        std::array<std::exception_ptr, I> exceptions_;
 
     public:
-        aggregate_exceptions(const ::std::array<::std::exception_ptr, I>& exceptions) noexcept:
+        aggregate_exceptions(const std::array<std::exception_ptr, I>& exceptions) noexcept:
             exceptions_(exceptions)
         {
         }
@@ -22,44 +22,44 @@ namespace stdsharp
         [[nodiscard]] const auto& exceptions() const noexcept { return exceptions_; }
     };
 
-    template<::std::size_t I>
-    aggregate_exceptions(const ::std::array<::std::exception_ptr, I>&) -> aggregate_exceptions<I>;
+    template<std::size_t I>
+    aggregate_exceptions(const std::array<std::exception_ptr, I>&) -> aggregate_exceptions<I>;
 
     namespace details
     {
-        template<::std::invocable T, ::std::size_t I>
+        template<std::invocable T, std::size_t I>
         constexpr void aggregate_try(auto& exceptions, T&& t)
         {
             try
             {
-                ::std::invoke(cpp_forward(t));
+                std::invoke(cpp_forward(t));
             }
             catch(...)
             {
-                exceptions[I] = ::std::current_exception();
+                exceptions[I] = std::current_exception();
                 throw aggregate_exceptions{exceptions};
             }
         }
 
-        template<::std::size_t I, ::std::invocable T, ::std::invocable... U>
+        template<std::size_t I, std::invocable T, std::invocable... U>
         constexpr void aggregate_try(auto& exceptions, T&& t, U&&... u)
         {
             try
             {
-                ::std::invoke(cpp_forward(t));
+                std::invoke(cpp_forward(t));
             }
             catch(...)
             {
-                exceptions[I] = ::std::current_exception();
+                exceptions[I] = std::current_exception();
                 aggregate_try<I + 1, U...>(exceptions, cpp_forward(u)...);
             }
         }
     }
 
-    template<::std::invocable... T>
+    template<std::invocable... T>
     constexpr void aggregate_try(T&&... t)
     {
-        ::std::array<::std::exception_ptr, sizeof...(T)> exceptions;
+        std::array<std::exception_ptr, sizeof...(T)> exceptions;
         details::aggregate_try<0, T...>(exceptions, cpp_forward(t)...);
     }
 }
\ No newline at end of file
diff --git a/include/stdsharp/filesystem/filesystem.h b/include/stdsharp/filesystem/filesystem.h
index aa6724dc..f08cd58f 100644
--- a/include/stdsharp/filesystem/filesystem.h
+++ b/include/stdsharp/filesystem/filesystem.h
@@ -30,17 +30,17 @@ namespace stdsharp::filesystem
         };
     }
 
-    template<typename Rep, ::std::uintmax_t Num, ::std::uintmax_t Denom>
-    class space_size<Rep, ::std::ratio<Num, Denom>> :
+    template<typename Rep, std::uintmax_t Num, std::uintmax_t Denom>
+    class space_size<Rep, std::ratio<Num, Denom>> :
         default_arithmetic_operation<
-            space_size<Rep, ::std::ratio<Num, Denom>>,
+            space_size<Rep, std::ratio<Num, Denom>>,
             details::space_size_delegate // clang-format off
         > // clang-format on
     {
     public:
         using rep = Rep;
 
-        using period = ::meta::_t<::std::ratio<Num, Denom>>;
+        using period = ::meta::_t<std::ratio<Num, Denom>>;
 
         static constexpr auto num = period::num;
 
@@ -55,7 +55,7 @@ namespace stdsharp::filesystem
         rep value_{};
 
         template<auto N, auto D>
-        static constexpr auto cast_from(const auto factor, const ::std::ratio<N, D>) noexcept
+        static constexpr auto cast_from(const auto factor, const std::ratio<N, D>) noexcept
         {
             return static_cast<rep>(factor * denom * N / (num * D)); // NOLINT(*-integer-division)
         }
@@ -63,7 +63,7 @@ namespace stdsharp::filesystem
     public:
         static constexpr space_size zero() noexcept { return {}; }
 
-        static constexpr space_size max() noexcept { return ::std::numeric_limits<rep>::max(); }
+        static constexpr space_size max() noexcept { return std::numeric_limits<rep>::max(); }
 
         space_size() = default;
 
@@ -79,7 +79,7 @@ namespace stdsharp::filesystem
         [[nodiscard]] constexpr auto operator<=>(const space_size<OtherRep, Period> other) //
             const noexcept
         {
-            if constexpr(::std::ratio_greater_equal_v<period, Period>)
+            if constexpr(std::ratio_greater_equal_v<period, Period>)
                 return value_ <=> cast_from(other.value_, Period{});
             else return other <=> *this;
         }
@@ -88,7 +88,7 @@ namespace stdsharp::filesystem
         [[nodiscard]] constexpr auto operator==(const space_size<OtherRep, Period> other) //
             const noexcept
         {
-            return (*this <=> other) == ::std::strong_ordering::equal;
+            return (*this <=> other) == std::strong_ordering::equal;
         }
 
         template<typename OtherRep, typename Period>
@@ -103,27 +103,27 @@ namespace stdsharp::filesystem
 
     namespace details
     {
-        inline constexpr ::std::uintmax_t size_numeration_base = 1024;
+        inline constexpr std::uintmax_t size_numeration_base = 1024;
     }
 
-    using bits = space_size<::std::uintmax_t, ::std::ratio<1, char_bit>>;
+    using bits = space_size<std::uintmax_t, std::ratio<1, char_bit>>;
 
-    using bytes = space_size<::std::uintmax_t, ::std::ratio<1>>;
+    using bytes = space_size<std::uintmax_t, std::ratio<1>>;
 
-    using kilobytes = space_size<::std::uintmax_t, ::std::kilo>;
+    using kilobytes = space_size<std::uintmax_t, std::kilo>;
 
-    using megabytes = space_size<::std::uintmax_t, ::std::mega>;
+    using megabytes = space_size<std::uintmax_t, std::mega>;
 
-    using gigabytes = space_size<::std::uintmax_t, ::std::giga>;
+    using gigabytes = space_size<std::uintmax_t, std::giga>;
 
-    using terabytes = space_size<::std::uintmax_t, ::std::tera>;
+    using terabytes = space_size<std::uintmax_t, std::tera>;
 
-    using petabytes = space_size<::std::uintmax_t, ::std::peta>;
+    using petabytes = space_size<std::uintmax_t, std::peta>;
 
-    using exabytes = space_size<::std::uintmax_t, ::std::exa>;
+    using exabytes = space_size<std::uintmax_t, std::exa>;
 
 #if(INTMAX_MAX / 1'000'000'000) >= 1'000'000'000'000
-    using zettabytes = space_size<::std::uintmax_t, ::std::zetta>;
+    using zettabytes = space_size<std::uintmax_t, std::zetta>;
 
     inline namespace literals
     {
@@ -134,7 +134,7 @@ namespace stdsharp::filesystem
 
         [[nodiscard]] constexpr auto operator""_ZB(long double v) noexcept
         {
-            return space_size<long double, ::std::zetta>{v};
+            return space_size<long double, std::zetta>{v};
         }
     }
 
@@ -148,7 +148,7 @@ namespace stdsharp::filesystem
     };
 
     #if(INTMAX_MAX / 1'000'000'000) >= 1'000'000'000'000'000
-    using yottabytes = space_size<::std::uintmax_t, ::std::yotta>;
+    using yottabytes = space_size<std::uintmax_t, std::yotta>;
 
     inline namespace literals
     {
@@ -159,7 +159,7 @@ namespace stdsharp::filesystem
 
         [[nodiscard]] constexpr auto operator""_YB(long double v) noexcept
         {
-            return space_size<long double, ::std::yotta>{v};
+            return space_size<long double, std::yotta>{v};
         }
     }
 
@@ -174,28 +174,28 @@ namespace stdsharp::filesystem
     #endif
 #endif
 
-    using kibibytes = space_size<::std::uintmax_t, ::std::ratio<details::size_numeration_base>>;
+    using kibibytes = space_size<std::uintmax_t, std::ratio<details::size_numeration_base>>;
 
     using mebibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * kibibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * kibibytes::period::num>>;
     using gibibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * mebibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * mebibytes::period::num>>;
     using tebibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * gibibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * gibibytes::period::num>>;
     using pebibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * tebibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * tebibytes::period::num>>;
     using exbibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * pebibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * pebibytes::period::num>>;
 
 #if(INTMAX_MAX / 1024) >= 1'152'921'504'606'846'976
     using zebibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * exbibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * exbibytes::period::num>>;
 
     inline namespace literals
     {
@@ -221,8 +221,8 @@ namespace stdsharp::filesystem
 
     #if(INTMAX_MAX / 1024 / 1024) >= 1'152'921'504'606'846'976
     using yobibytes = space_size<
-        ::std::uintmax_t,
-        ::std::ratio<details::size_numeration_base * zebibytes::period::num>>;
+        std::uintmax_t,
+        std::ratio<details::size_numeration_base * zebibytes::period::num>>;
 
     inline namespace literals
     {
@@ -274,22 +274,22 @@ namespace stdsharp::filesystem
     {
         constexpr auto sv = []
         {
-            ::std::string_view sv;
+            std::string_view sv;
             constexpr_pattern_match::from_type<Period>(
-                [&](const ::std::type_identity<bits::period>) { sv = "b"; },
-                [&](const ::std::type_identity<bytes::period>) { sv = "B"; },
-                [&](const ::std::type_identity<kilobytes::period>) { sv = "KB"; },
-                [&](const ::std::type_identity<megabytes::period>) { sv = "MB"; },
-                [&](const ::std::type_identity<gigabytes::period>) { sv = "GB"; },
-                [&](const ::std::type_identity<terabytes::period>) { sv = "TB"; },
-                [&](const ::std::type_identity<petabytes::period>) { sv = "PB"; },
-                [&](const ::std::type_identity<exabytes::period>) { sv = "EB"; },
-                [&](const ::std::type_identity<kibibytes::period>) { sv = "KiB"; },
-                [&](const ::std::type_identity<mebibytes::period>) { sv = "MiB"; },
-                [&](const ::std::type_identity<gibibytes::period>) { sv = "GiB"; },
-                [&](const ::std::type_identity<tebibytes::period>) { sv = "TiB"; },
-                [&](const ::std::type_identity<pebibytes::period>) { sv = "PiB"; },
-                [&](const ::std::type_identity<exbibytes::period>) { sv = "EiB"; }
+                [&](const std::type_identity<bits::period>) { sv = "b"; },
+                [&](const std::type_identity<bytes::period>) { sv = "B"; },
+                [&](const std::type_identity<kilobytes::period>) { sv = "KB"; },
+                [&](const std::type_identity<megabytes::period>) { sv = "MB"; },
+                [&](const std::type_identity<gigabytes::period>) { sv = "GB"; },
+                [&](const std::type_identity<terabytes::period>) { sv = "TB"; },
+                [&](const std::type_identity<petabytes::period>) { sv = "PB"; },
+                [&](const std::type_identity<exabytes::period>) { sv = "EB"; },
+                [&](const std::type_identity<kibibytes::period>) { sv = "KiB"; },
+                [&](const std::type_identity<mebibytes::period>) { sv = "MiB"; },
+                [&](const std::type_identity<gibibytes::period>) { sv = "GiB"; },
+                [&](const std::type_identity<tebibytes::period>) { sv = "TiB"; },
+                [&](const std::type_identity<pebibytes::period>) { sv = "PiB"; },
+                [&](const std::type_identity<exbibytes::period>) { sv = "EiB"; }
             );
 
             return sv;
@@ -451,47 +451,47 @@ namespace std
 {
     template<typename Rep, typename Period, typename CharT>
         requires requires(
-            ::stdsharp::filesystem::space_size<Rep, Period> s,
-            ::std::basic_stringstream<CharT> ss
+            stdsharp::filesystem::space_size<Rep, Period> s,
+            std::basic_stringstream<CharT> ss
         ) { ss << s; }
-    struct formatter<::stdsharp::filesystem::space_size<Rep, Period>, CharT>
+    struct formatter<stdsharp::filesystem::space_size<Rep, Period>, CharT>
     {
     private:
-        using space_size = ::stdsharp::filesystem::space_size<Rep, Period>;
+        using space_size = stdsharp::filesystem::space_size<Rep, Period>;
 
-        ::stdsharp::fill_spec<CharT> fill_{};
-        ::stdsharp::align_t align_{};
-        ::stdsharp::nested_spec<::std::size_t> width_{};
+        stdsharp::fill_spec<CharT> fill_{};
+        stdsharp::align_t align_{};
+        stdsharp::nested_spec<std::size_t> width_{};
 
-        ::stdsharp::precision_spec precision_{};
+        stdsharp::precision_spec precision_{};
 
-        ::stdsharp::locale_spec locale_{};
+        stdsharp::locale_spec locale_{};
 
-        ::std::basic_string_view<CharT> from_unit_;
+        std::basic_string_view<CharT> from_unit_;
 
         template<typename T>
-        using identity = ::std::type_identity<T>;
+        using identity = std::type_identity<T>;
 
     public:
         constexpr auto parse(basic_format_parse_context<CharT>& ctx)
         {
             {
                 basic_format_parse_context<CharT> copied_ctx{
-                    ::std::basic_string_view{ctx.begin(), ctx.end()} //
+                    std::basic_string_view{ctx.begin(), ctx.end()} //
                 };
 
-                const auto size = ::std::ranges::size(copied_ctx);
+                const auto size = std::ranges::size(copied_ctx);
 
-                const auto fill = ::stdsharp::parse_fill_spec(copied_ctx);
+                const auto fill = stdsharp::parse_fill_spec(copied_ctx);
 
                 if(fill.fill)
                 {
-                    const auto align = ::stdsharp::parse_align_spec(copied_ctx);
+                    const auto align = stdsharp::parse_align_spec(copied_ctx);
 
-                    if(align != ::stdsharp::align_t::none)
+                    if(align != stdsharp::align_t::none)
                     {
                         const auto width =
-                            ::stdsharp::parse_nested_integer_spec<::std::size_t>(copied_ctx);
+                            stdsharp::parse_nested_integer_spec<std::size_t>(copied_ctx);
 
                         if(!width.valueless_by_exception())
                         {
@@ -499,14 +499,14 @@ namespace std
                             align_ = align;
                             width_ = width;
 
-                            ctx.advance_to(ctx.begin() + (size - ::std::ranges::size(copied_ctx)));
+                            ctx.advance_to(ctx.begin() + (size - std::ranges::size(copied_ctx)));
                         }
                     }
                 }
             }
 
-            precision_ = ::stdsharp::parse_precision_spec(ctx);
-            locale_ = ::stdsharp::parse_locale_spec(ctx);
+            precision_ = stdsharp::parse_precision_spec(ctx);
+            locale_ = stdsharp::parse_locale_spec(ctx);
 
             {
                 const auto [from_unit] = ::ctre::starts_with<R"((?:[KMGTPE]i?)?B|b)">(ctx);
@@ -518,7 +518,7 @@ namespace std
                 }
             }
 
-            ::stdsharp::parse_end_assert(ctx);
+            stdsharp::parse_end_assert(ctx);
 
             return ctx.begin();
         }
@@ -527,15 +527,15 @@ namespace std
         auto format(const space_size s, basic_format_context<OutputIt, CharT>& fc) const
         {
             const auto& fill = fill_.fill;
-            const auto width = ::stdsharp::get_arg(fc, width_);
+            const auto width = stdsharp::get_arg(fc, width_);
             const auto& formatted = [this, s = s, &fc]() mutable
             {
                 const auto& precision = precision_.precision;
                 const auto from_unit = [from_unit_ = from_unit_]
                 {
-                    ::std::array<char, 4> from_unit{};
+                    std::array<char, 4> from_unit{};
 
-                    ::std::ranges::transform(
+                    std::ranges::transform(
                         from_unit_,
                         from_unit.begin(),
                         [](const CharT c) { return static_cast<char>(c); }
@@ -543,20 +543,20 @@ namespace std
                     return from_unit;
                 }();
 
-                ::std::string_view current_unit{
+                std::string_view current_unit{
                     from_unit.begin(),
-                    ::std::ranges::find(from_unit, char{}) //
+                    std::ranges::find(from_unit, char{}) //
                 };
-                ::std::basic_ostringstream<CharT> ss;
+                std::basic_ostringstream<CharT> ss;
 
                 const auto do_format = [&current_unit, &ss, &s]
                 {
                     const auto format_case = [&]<typename SpaceSize>( // clang-format off
                         const identity<SpaceSize>,
-                        const ::std::string_view next_unit
+                        const std::string_view next_unit
                     ) noexcept // clang-format on
                     {
-                        return [&, next_unit](const ::std::string_view)
+                        return [&, next_unit](const std::string_view)
                         {
                             const SpaceSize cast_size = s;
 
@@ -567,19 +567,19 @@ namespace std
                         };
                     };
 
-                    ::stdsharp::pattern_match(
+                    stdsharp::pattern_match(
                         current_unit,
-                        ::std::pair{
-                            [](const ::std::string_view unit) noexcept { return unit.empty(); },
-                            [](const ::std::string_view)
+                        std::pair{
+                            [](const std::string_view unit) noexcept { return unit.empty(); },
+                            [](const std::string_view)
                             {
                                 throw format_error{"Precision exceeded"}; //
                             } //
                         },
-#define STDSHARP_MAKE_PAIR(str, type, next_str)                              \
-    ::std::pair{                                                             \
-        [](const ::std::string_view unit) noexcept { return unit == #str; }, \
-        format_case(identity<::stdsharp::filesystem::type>{}, #next_str)}
+#define STDSHARP_MAKE_PAIR(str, type, next_str)                            \
+    std::pair{                                                             \
+        [](const std::string_view unit) noexcept { return unit == #str; }, \
+        format_case(identity<stdsharp::filesystem::type>{}, #next_str)}
 
                         STDSHARP_MAKE_PAIR(b, bits, ),
                         STDSHARP_MAKE_PAIR(B, bytes, b),
@@ -600,9 +600,9 @@ namespace std
                     );
                 };
 
-                ss.imbue(locale_.use_locale ? fc.locale() : ::std::locale::classic());
+                ss.imbue(locale_.use_locale ? fc.locale() : std::locale::classic());
 
-                if(const auto precision_v = ::stdsharp::get_arg(fc, precision); precision_v)
+                if(const auto precision_v = stdsharp::get_arg(fc, precision); precision_v)
                     for(auto i = *precision_v; i != 0; --i) do_format();
                 else
                     while(s.size() > 0)
@@ -622,7 +622,7 @@ namespace std
             if(
                 [=, &formatted, &fc, align = align_]
                 {
-                    if(fill && width && align != ::stdsharp::align_t::none)
+                    if(fill && width && align != stdsharp::align_t::none)
                     {
                         const auto width_v = *width;
 
@@ -633,22 +633,22 @@ namespace std
 
                             switch(align)
                             {
-                            case ::stdsharp::align_t::left:
-                                ::std::ranges::copy(formatted, fc.out());
-                                ::std::ranges::fill_n(fc.out(), fill_size, fill_c);
+                            case stdsharp::align_t::left:
+                                std::ranges::copy(formatted, fc.out());
+                                std::ranges::fill_n(fc.out(), fill_size, fill_c);
                                 break;
 
-                            case ::stdsharp::align_t::right:
-                                ::std::ranges::fill_n(fc.out(), fill_size, fill_c);
-                                ::std::ranges::copy(formatted, fc.out());
+                            case stdsharp::align_t::right:
+                                std::ranges::fill_n(fc.out(), fill_size, fill_c);
+                                std::ranges::copy(formatted, fc.out());
                                 break;
 
-                            case ::stdsharp::align_t::center:
+                            case stdsharp::align_t::center:
                             {
                                 const auto half_fill_s = fill_size / 2;
-                                ::std::ranges::fill_n(fc.out(), half_fill_s, fill_c);
-                                ::std::ranges::copy(formatted, fc.out());
-                                ::std::ranges::fill_n(fc.out(), fill_size - half_fill_s, fill_c);
+                                std::ranges::fill_n(fc.out(), half_fill_s, fill_c);
+                                std::ranges::copy(formatted, fc.out());
+                                std::ranges::fill_n(fc.out(), fill_size - half_fill_s, fill_c);
                             }
                             break;
 
@@ -662,7 +662,7 @@ namespace std
                     return true;
                 }()
             )
-                ::std::ranges::copy(formatted, fc.out());
+                std::ranges::copy(formatted, fc.out());
             return fc.out();
         }
     };
diff --git a/include/stdsharp/format/format.h b/include/stdsharp/format/format.h
index 41252d5b..ddc2b5bd 100644
--- a/include/stdsharp/format/format.h
+++ b/include/stdsharp/format/format.h
@@ -17,18 +17,18 @@ namespace stdsharp
     namespace details
     {
         template<typename CharT>
-        using parse_context = ::std::basic_format_parse_context<CharT>;
+        using parse_context = std::basic_format_parse_context<CharT>;
 
         template<typename OutputIt, typename CharT>
-        using context = ::std::basic_format_context<OutputIt, CharT>;
+        using context = std::basic_format_context<OutputIt, CharT>;
 
         template<typename CharT>
-        using iter = typename ::std::basic_format_parse_context<CharT>::iterator;
+        using iter = typename std::basic_format_parse_context<CharT>::iterator;
 
-        template<::std::integral T>
+        template<std::integral T>
         constexpr auto parse_integer(const auto& rng) noexcept
         {
-            return ::std::accumulate(
+            return std::accumulate(
                 rng.begin(),
                 rng.end(),
                 T{0},
@@ -43,7 +43,7 @@ namespace stdsharp
 
     struct nested_arg_index
     {
-        ::std::size_t value;
+        std::size_t value;
 
         template<typename Visitor, typename OutputIt, typename CharT>
         [[nodiscard]] constexpr decltype(auto) get_from_context(
@@ -51,7 +51,7 @@ namespace stdsharp
             Visitor&& vis //
         ) const
         {
-            return ::std::visit_format_arg(cpp_forward(vis), fc.arg(value));
+            return std::visit_format_arg(cpp_forward(vis), fc.arg(value));
         }
 
         template<typename T, typename OutputIt, typename CharT>
@@ -62,17 +62,17 @@ namespace stdsharp
         {
             return get_from_context(
                 fc,
-                []<typename U>(U&& u) noexcept -> ::std::optional<T>
+                []<typename U>(U&& u) noexcept -> std::optional<T>
                 {
-                    if constexpr(::std::convertible_to<U, T>) return static_cast<T>(cpp_forward(u));
-                    else return ::std::nullopt;
+                    if constexpr(std::convertible_to<U, T>) return static_cast<T>(cpp_forward(u));
+                    else return std::nullopt;
                 }
             );
         }
     };
 
     template<typename T>
-    using nested_spec = ::std::variant<::std::monostate, T, nested_arg_index>;
+    using nested_spec = std::variant<std::monostate, T, nested_arg_index>;
 
     namespace details
     {
@@ -84,21 +84,21 @@ namespace stdsharp
     [[nodiscard]] constexpr auto get_arg(const details::context<OutputIt, CharT>& fc, SpecT&& spec)
         requires requires { details::nested_spec_like(spec); }
     {
-        using result_t = ::std::conditional_t<
-            ::std::same_as<ResultT, void>,
+        using result_t = std::conditional_t<
+            std::same_as<ResultT, void>,
             decltype(details::nested_spec_like(spec)),
             ResultT>;
 
-        if(spec.valueless_by_exception() || ::std::holds_alternative<::std::monostate>(spec))
-            return ::std::optional<result_t>{::std::nullopt};
-        return ::std::visit(
-            [&fc]<typename U>(U&& u) -> ::std::optional<result_t>
+        if(spec.valueless_by_exception() || std::holds_alternative<std::monostate>(spec))
+            return std::optional<result_t>{std::nullopt};
+        return std::visit(
+            [&fc]<typename U>(U&& u) -> std::optional<result_t>
             {
-                if constexpr(::std::same_as<::std::remove_cvref_t<U>, result_t>)
-                    return ::std::optional<result_t>{cpp_forward(u)};
-                else if constexpr(::std::same_as<::std::remove_cvref_t<U>, nested_arg_index>)
+                if constexpr(std::same_as<std::remove_cvref_t<U>, result_t>)
+                    return std::optional<result_t>{cpp_forward(u)};
+                else if constexpr(std::same_as<std::remove_cvref_t<U>, nested_arg_index>)
                     return cpp_forward(u).template get_from_context<result_t>(fc);
-                else return ::std::nullopt;
+                else return std::nullopt;
             },
             spec
         );
@@ -108,20 +108,20 @@ namespace stdsharp
     void parse_assert(const details::parse_context<CharT>& ctx)
     {
         const auto begin = ctx.begin();
-        throw ::std::format_error{
-            ::std::format(
+        throw std::format_error{
+            std::format(
                 "invalid format:\n \"{}\"\n{}",
-                ::std::basic_string_view{begin, ctx.end()},
-                ::std::format(
+                std::basic_string_view{begin, ctx.end()},
+                std::format(
                     "{}^ Unexpected character here",
-                    // TODO: c++23 ::std::ranges::views::repeat
+                    // TODO: c++23 std::ranges::views::repeat
                     ::ranges::views::repeat_n(' ', begin - ctx.begin())
                 )
             ) //
         };
     }
 
-    template<typename CharT, ::std::predicate<CharT> Predicate>
+    template<typename CharT, std::predicate<CharT> Predicate>
     constexpr void parse_validate(const details::parse_context<CharT>& ctx, Predicate predicate)
     {
         const auto begin = ctx.begin();
@@ -141,10 +141,10 @@ namespace stdsharp
 
         if(begin == ctx.end() || *begin == '}') return;
 
-        throw ::std::format_error{
-            ::std::format(
+        throw std::format_error{
+            std::format(
                 "invalid format: \"{}\"\nEnd of string expected",
-                ::std::basic_string_view{begin, ctx.end()}
+                std::basic_string_view{begin, ctx.end()}
             ) //
         };
     }
@@ -152,7 +152,7 @@ namespace stdsharp
     template<typename CharT>
     struct fill_spec
     {
-        ::std::optional<CharT> fill;
+        std::optional<CharT> fill;
     };
 
     template<typename CharT>
@@ -165,7 +165,7 @@ namespace stdsharp
             ctx.advance_to(fill.end());
             return {*fill.begin()};
         }
-        return {::std::nullopt};
+        return {std::nullopt};
     }
 
     enum class align_t
@@ -176,7 +176,7 @@ namespace stdsharp
         center
     };
 
-    template<::std::convertible_to<char> CharT>
+    template<std::convertible_to<char> CharT>
     [[nodiscard]] constexpr auto parse_align_spec(details::parse_context<CharT>& ctx)
     {
         const auto [align] = ::ctre::starts_with<"[<^>]">(ctx);
@@ -195,7 +195,7 @@ namespace stdsharp
         return align_t::none;
     }
 
-    template<::std::integral IntType, ::std::convertible_to<char> CharT>
+    template<std::integral IntType, std::convertible_to<char> CharT>
     [[nodiscard]] constexpr nested_spec<IntType>
         parse_nested_integer_spec(details::parse_context<CharT>& ctx)
     {
@@ -206,13 +206,13 @@ namespace stdsharp
         {
             ctx.advance_to(end);
             return nested_arg_index{
-                ::std::ranges::empty(ref) ? ctx.next_arg_id() :
-                                            details::parse_integer<::std::size_t>(ref)};
+                std::ranges::empty(ref) ? ctx.next_arg_id() :
+                                          details::parse_integer<std::size_t>(ref)};
         }
         if(value)
         {
             ctx.advance_to(end);
-            return details::parse_integer<::std::size_t>(value);
+            return details::parse_integer<std::size_t>(value);
         }
 
         return {};
diff --git a/include/stdsharp/fstream/fstream.h b/include/stdsharp/fstream/fstream.h
index ca9659bb..2d0b2107 100644
--- a/include/stdsharp/fstream/fstream.h
+++ b/include/stdsharp/fstream/fstream.h
@@ -13,8 +13,8 @@ namespace stdsharp
         struct get_from_stream_fn
         {
             template<typename... Args>
-                requires ::std::constructible_from<T, Args...>
-            [[nodiscard]] constexpr auto operator()(::std::istream& is, Args&&... args) const
+                requires std::constructible_from<T, Args...>
+            [[nodiscard]] constexpr auto operator()(std::istream& is, Args&&... args) const
             {
                 T t{cpp_forward(args)...};
                 is >> t;
@@ -29,24 +29,24 @@ namespace stdsharp
     namespace details
     {
         template<typename T>
-            requires ::std::invocable<
+            requires std::invocable<
                 get_from_stream_fn<T>,
-                ::std::ifstream // clang-format off
+                std::ifstream // clang-format off
             > // clang-format on
         struct read_all_to_container_fn
         {
-            template<typename Container = ::std::vector<T>>
-                requires ::std::invocable<read_all_to_container_fn, Container&>
+            template<typename Container = std::vector<T>>
+                requires std::invocable<read_all_to_container_fn, Container&>
             [[nodiscard]] auto&
-                operator()(Container& container, const ::std::filesystem::path& path) const
+                operator()(Container& container, const std::filesystem::path& path) const
             {
-                ::std::ifstream fs{path};
+                std::ifstream fs{path};
                 return (*this)(container, fs);
             }
 
-            template<typename Container = ::std::vector<T>>
-                requires ::std::invocable<actions::emplace_back_fn, Container&, T>
-            [[nodiscard]] constexpr auto& operator()(Container& container, ::std::istream& is) const
+            template<typename Container = std::vector<T>>
+                requires std::invocable<actions::emplace_back_fn, Container&, T>
+            [[nodiscard]] constexpr auto& operator()(Container& container, std::istream& is) const
             {
                 while(is) actions::emplace_back(container, get_from_stream<T>(is));
 
@@ -60,44 +60,44 @@ namespace stdsharp
 
     namespace details
     {
-        template<typename T, ::std::default_initializable Container>
-            requires ::std::invocable<read_all_to_container_fn<T>, Container&, ::std::istream&>
+        template<typename T, std::default_initializable Container>
+            requires std::invocable<read_all_to_container_fn<T>, Container&, std::istream&>
         struct read_all_fn
         {
-            [[nodiscard]] constexpr auto operator()(::std::istream& is) const
+            [[nodiscard]] constexpr auto operator()(std::istream& is) const
             {
                 Container container{};
                 return read_all_to_container<T>(container, is);
             }
 
-            [[nodiscard]] auto operator()(const ::std::filesystem::path& path) const
+            [[nodiscard]] auto operator()(const std::filesystem::path& path) const
             {
-                ::std::ifstream fs{path};
+                std::ifstream fs{path};
                 return (*this)(fs);
             }
         };
 
         struct read_all_text_fn
         {
-            [[nodiscard]] auto operator()(::std::istream& is) const
+            [[nodiscard]] auto operator()(std::istream& is) const
             {
-                using traits_t = ::std::istream::traits_type;
+                using traits_t = std::istream::traits_type;
 
-                ::std::string str;
-                ::std::getline(is, str, traits_t::to_char_type(traits_t::eof()));
+                std::string str;
+                std::getline(is, str, traits_t::to_char_type(traits_t::eof()));
 
                 return str;
             }
 
-            [[nodiscard]] auto operator()(const ::std::filesystem::path& path) const
+            [[nodiscard]] auto operator()(const std::filesystem::path& path) const
             {
-                ::std::ifstream fs{path};
+                std::ifstream fs{path};
                 return (*this)(fs);
             }
         };
     }
 
-    template<typename T, typename Container = ::std::vector<T>>
+    template<typename T, typename Container = std::vector<T>>
     inline constexpr details::read_all_fn<T, Container> read_all{};
 
     inline constexpr details::read_all_text_fn read_all_text{};
diff --git a/include/stdsharp/functional/compose.h b/include/stdsharp/functional/compose.h
index 988d56f4..2a9561a1 100644
--- a/include/stdsharp/functional/compose.h
+++ b/include/stdsharp/functional/compose.h
@@ -15,10 +15,10 @@ namespace stdsharp
                 return cpp_forward(arg);
             }
 
-            template<typename... Arg, ::std::invocable<Arg...> First, typename... Fn>
-                requires ::std::invocable<
+            template<typename... Arg, std::invocable<Arg...> First, typename... Fn>
+                requires std::invocable<
                     compose_impl,
-                    ::std::invoke_result_t<First, Arg...>,
+                    std::invoke_result_t<First, Arg...>,
                     empty_t,
                     Fn... // clang-format off
                 > // clang-format on
@@ -30,14 +30,14 @@ namespace stdsharp
             ) const noexcept( //
                 nothrow_invocable<
                     compose_impl,
-                    ::std::invoke_result_t<First, Arg...>,
+                    std::invoke_result_t<First, Arg...>,
                     empty_t,
                     Fn... // clang-format off
                 > // clang-format on
             )
             {
                 return (*this)( //
-                    ::std::invoke(cpp_forward(first), cpp_forward(arg)...),
+                    std::invoke(cpp_forward(first), cpp_forward(arg)...),
                     empty,
                     cpp_forward(fn)...
                 );
@@ -49,14 +49,14 @@ namespace stdsharp
     struct composed : private value_wrapper<T>...
     {
         template<typename... U>
-            requires(::std::constructible_from<value_wrapper<T>, U> && ...)
+            requires(std::constructible_from<value_wrapper<T>, U> && ...)
         constexpr composed(U&&... u): value_wrapper<T>(cpp_forward(u))...
         {
         }
 
 #define BS_OPERATOR(const_, ref)                                                              \
     template<typename... Args>                                                                \
-        requires ::std::invocable<details::compose_impl, Args..., empty_t, T...>              \
+        requires std::invocable<details::compose_impl, Args..., empty_t, T...>                \
     constexpr decltype(auto) operator()(Args&&... args)                                       \
         const_ ref noexcept(nothrow_invocable<details::compose_impl, Args..., empty_t, T...>) \
     {                                                                                         \
@@ -75,21 +75,20 @@ namespace stdsharp
     };
 
     template<typename... T>
-    composed(T&&...) -> composed<::std::decay_t<T>...>;
+    composed(T&&...) -> composed<std::decay_t<T>...>;
 
     inline constexpr struct make_composed_fn
     {
         template<typename... T>
-            requires requires { composed{::std::declval<T>()...}; }
-        constexpr auto operator()(T&&... t) const
-            noexcept(noexcept(composed{::std::declval<T>()...}))
+            requires requires { composed{std::declval<T>()...}; }
+        constexpr auto operator()(T&&... t) const noexcept(noexcept(composed{std::declval<T>()...}))
         {
             return composed{cpp_forward(t)...};
         }
     } make_composed{};
 
     template<typename... Fn>
-    concept composable = ::std::invocable<make_composed_fn, Fn...>;
+    concept composable = std::invocable<make_composed_fn, Fn...>;
 
     template<typename... Fn>
     concept nothrow_composable = nothrow_invocable<make_composed_fn, Fn...>;
diff --git a/include/stdsharp/functional/invocables.h b/include/stdsharp/functional/invocables.h
index c9fdd37c..e685e2f8 100644
--- a/include/stdsharp/functional/invocables.h
+++ b/include/stdsharp/functional/invocables.h
@@ -11,19 +11,19 @@ namespace stdsharp
 {
     namespace details
     {
-        template<typename T, ::std::size_t I>
+        template<typename T, std::size_t I>
         struct indexed_invocable : stdsharp::indexed_value<T, I>
         {
             using base = stdsharp::indexed_value<T, I>;
 
             using base::base;
 
-#define STDSHARP_OPERATOR(const_, ref)                                                  \
-    template<typename... Args, ::std::invocable<Args...> Fn = const_ T ref>             \
-    constexpr decltype(auto) operator()(Args&&... args)                                 \
-        const_ ref noexcept(nothrow_invocable<Fn, Args...>)                             \
-    {                                                                                   \
-        return ::std::invoke(static_cast<const_ T ref>(this->v), cpp_forward(args)...); \
+#define STDSHARP_OPERATOR(const_, ref)                                                \
+    template<typename... Args, std::invocable<Args...> Fn = const_ T ref>             \
+    constexpr decltype(auto) operator()(Args&&... args)                               \
+        const_ ref noexcept(nothrow_invocable<Fn, Args...>)                           \
+    {                                                                                 \
+        return std::invoke(static_cast<const_ T ref>(this->v), cpp_forward(args)...); \
     }
 
             STDSHARP_OPERATOR(, &)
@@ -37,20 +37,20 @@ namespace stdsharp
         template<typename... Func>
         struct invocables
         {
-            template<typename = ::std::index_sequence_for<Func...>>
+            template<typename = std::index_sequence_for<Func...>>
             struct impl;
 
             using type = impl<>;
 
-            template<::std::size_t... I>
-            struct impl<::std::index_sequence<I...>> :
+            template<std::size_t... I>
+            struct impl<std::index_sequence<I...>> :
                 indexed_invocable<Func, I>...,
                 indexed_types<Func...>
             {
                 impl() = default;
 
                 template<typename... Args>
-                    requires(::std::constructible_from<Func, Args> && ...)
+                    requires(std::constructible_from<Func, Args> && ...)
                 constexpr impl(Args&&... args) //
                     noexcept((nothrow_constructible_from<Func, Args> && ...)):
                     indexed_invocable<Func, I>(cpp_forward(args))...
@@ -67,11 +67,11 @@ namespace stdsharp
 
     inline constexpr make_invocables_fn make_invocables{};
 
-    template<::std::size_t Index>
+    template<std::size_t Index>
     struct invoke_at_fn
     {
         template<typename T, typename... Args>
-            requires ::std::invocable<get_element_t<Index, T>, Args...>
+            requires std::invocable<get_element_t<Index, T>, Args...>
         constexpr decltype(auto) operator()(T&& t, Args&&... args) const
             noexcept(nothrow_invocable<get_element_t<Index, T>, Args...>)
         {
@@ -86,28 +86,28 @@ namespace stdsharp
     struct invoke_first_fn
     {
     private:
-        template<typename T, typename... Args, ::std::size_t I = 0>
+        template<typename T, typename... Args, std::size_t I = 0>
             requires requires //
         {
             requires(Predicator<get_element_t<I, T>, Args...>::value); //
         }
-        static constexpr ::std::size_t find_first_impl(const index_constant<I>) noexcept
+        static constexpr std::size_t find_first_impl(const index_constant<I>) noexcept
         {
             return I;
         }
 
-        template<typename T, typename... Args, ::std::size_t I = 0>
-        static constexpr ::std::size_t find_first_impl(const index_constant<I>) noexcept
+        template<typename T, typename... Args, std::size_t I = 0>
+        static constexpr std::size_t find_first_impl(const index_constant<I>) noexcept
         {
             return find_first<T, Args...>(index_constant<I + 1>{});
         }
 
-        template<typename T, typename... Args, ::std::size_t I = 0>
-        static constexpr ::std::size_t find_first(const index_constant<I> = {}) noexcept
+        template<typename T, typename... Args, std::size_t I = 0>
+        static constexpr std::size_t find_first(const index_constant<I> = {}) noexcept
         {
             if constexpr(requires { typename get_element_t<I, T>; })
                 return find_first_impl<T, Args...>(index_constant<I>{});
-            else return static_cast<::std::size_t>(-1);
+            else return static_cast<std::size_t>(-1);
         }
 
         template<typename T, typename... Args>
@@ -133,7 +133,7 @@ namespace stdsharp
     namespace details
     {
         template<typename Func, typename... Args>
-            requires ::std::invocable<Func, Args...>
+            requires std::invocable<Func, Args...>
         struct sequenced_invocables_predicate
         {
             static constexpr auto value = true;
@@ -155,7 +155,7 @@ namespace stdsharp
     template<                                                                   \
         typename... Args,                                                       \
         typename Base = const_ base ref,                                        \
-        ::std::invocable<Base, Args...> Fn = sequenced_invoke_fn>               \
+        std::invocable<Base, Args...> Fn = sequenced_invoke_fn>                 \
     constexpr decltype(auto) operator()(Args&&... args)                         \
         const_ ref noexcept(nothrow_invocable<Fn, Base, Args...>)               \
     {                                                                           \
@@ -171,7 +171,7 @@ namespace stdsharp
     };
 
     template<typename... T>
-    basic_sequenced_invocables(T&&...) -> basic_sequenced_invocables<::std::decay_t<T>...>;
+    basic_sequenced_invocables(T&&...) -> basic_sequenced_invocables<std::decay_t<T>...>;
 
     template<typename... Invocable>
     using sequenced_invocables = adl_proof_t<basic_sequenced_invocables, Invocable...>;
diff --git a/include/stdsharp/functional/invoke.h b/include/stdsharp/functional/invoke.h
index 3711d8f0..e0a51494 100644
--- a/include/stdsharp/functional/invoke.h
+++ b/include/stdsharp/functional/invoke.h
@@ -16,12 +16,12 @@ namespace stdsharp
     inline constexpr auto optional_invoke = make_sequenced_invocables(invoke, empty_invoke);
 
     template<typename... Args>
-    concept nothrow_optional_invocable = noexcept(optional_invoke(::std::declval<Args>()...));
+    concept nothrow_optional_invocable = noexcept(optional_invoke(std::declval<Args>()...));
 
     template<bool Condition>
     struct conditional_invoke_fn
     {
-        template<::std::invocable Func>
+        template<std::invocable Func>
             requires(Condition)
         constexpr decltype(auto) operator()(Func&& func, const auto& = empty_invoke) const
             noexcept(nothrow_invocable<Func>)
@@ -29,7 +29,7 @@ namespace stdsharp
             return func();
         }
 
-        template<::std::invocable Func = empty_invoke_fn>
+        template<std::invocable Func = empty_invoke_fn>
         constexpr decltype(auto) operator()(const auto&, Func&& func = empty_invoke) const
             noexcept(nothrow_invocable<Func>)
         {
@@ -41,7 +41,7 @@ namespace stdsharp
     inline constexpr conditional_invoke_fn<Condition> conditional_invoke{};
 
     template<bool Condition, typename T, typename U>
-    concept conditional_invocable = ::std::invocable<conditional_invoke_fn<Condition>, T, U>;
+    concept conditional_invocable = std::invocable<conditional_invoke_fn<Condition>, T, U>;
 
     template<bool Condition, typename T, typename U>
     concept nothrow_conditional_invocable =
@@ -56,9 +56,9 @@ namespace stdsharp
         {
             return
 #if __cpp_lib_invoke_r >= 202106L
-                ::std::invoke_r<ReturnT>(cpp_forward(args)...)
+                std::invoke_r<ReturnT>(cpp_forward(args)...)
 #else
-                static_cast<ReturnT>(::std::invoke(cpp_forward(func), cpp_forward(args)...))
+                static_cast<ReturnT>(std::invoke(cpp_forward(func), cpp_forward(args)...))
 #endif
                     ;
         };
@@ -72,21 +72,21 @@ namespace stdsharp
         template<typename Fn, typename Projector, typename... Args>
             requires requires //
         {
-            requires(::std::invocable<Projector, Args> && ...);
-            requires ::std::invocable<Fn, ::std::invoke_result_t<Projector, Args>...>;
+            requires(std::invocable<Projector, Args> && ...);
+            requires std::invocable<Fn, std::invoke_result_t<Projector, Args>...>;
         }
         constexpr decltype(auto) operator()(Fn&& fn, Projector projector, Args&&... args) const
             noexcept(
                 (nothrow_invocable<Projector, Args> && ...) && //
-                nothrow_invocable<Fn, ::std::invoke_result_t<Projector, Args>...> //
+                nothrow_invocable<Fn, std::invoke_result_t<Projector, Args>...> //
             )
         {
-            return ::std::invoke(cpp_forward(fn), ::std::invoke(projector, cpp_forward(args))...);
+            return std::invoke(cpp_forward(fn), std::invoke(projector, cpp_forward(args))...);
         }
     } projected_invoke{};
 
     template<typename... Args>
-    concept projected_invocable = ::std::invocable<projected_invoke_fn, Args...>;
+    concept projected_invocable = std::invocable<projected_invoke_fn, Args...>;
 
     template<typename... Args>
     concept projected_nothrow_invocable = nothrow_invocable<projected_invoke_fn, Args...>;
diff --git a/include/stdsharp/functional/operations.h b/include/stdsharp/functional/operations.h
index 897f5a30..c16b299b 100644
--- a/include/stdsharp/functional/operations.h
+++ b/include/stdsharp/functional/operations.h
@@ -12,16 +12,16 @@ namespace stdsharp
     inline constexpr struct copy_fn
     {
         template<typename T>
-            requires ::std::constructible_from<::std::decay_t<T>, T>
-        [[nodiscard]] constexpr ::std::decay_t<T> operator()(T&& t) const
-            noexcept(nothrow_constructible_from<::std::decay_t<T>>)
+            requires std::constructible_from<std::decay_t<T>, T>
+        [[nodiscard]] constexpr std::decay_t<T> operator()(T&& t) const
+            noexcept(nothrow_constructible_from<std::decay_t<T>>)
         {
             return t;
         }
     } copy{};
 
     template<typename Func>
-    using not_fn_t = decltype(::std::not_fn(::std::declval<Func>()));
+    using not_fn_t = decltype(std::not_fn(std::declval<Func>()));
 
     namespace details
     {
@@ -38,8 +38,8 @@ namespace stdsharp
 
         struct assign_by_construct
         {
-            template<typename T, typename... U, typename ActualT = ::std::remove_reference_t<T>>
-                requires ::std::constructible_from<ActualT, U...>
+            template<typename T, typename... U, typename ActualT = std::remove_reference_t<T>>
+                requires std::constructible_from<ActualT, U...>
             constexpr decltype(auto) operator()(T& left, U&&... right) const
                 noexcept(noexcept(left = ActualT{cpp_forward(right)...}))
             {
@@ -53,27 +53,27 @@ namespace stdsharp
     {
     } assign_v{};
 
-    inline constexpr ::std::ranges::equal_to equal_to_v{};
-    inline constexpr ::std::ranges::not_equal_to not_equal_to_v{};
-    inline constexpr ::std::ranges::less less_v{};
-    inline constexpr ::std::ranges::greater greater_v{};
-    inline constexpr ::std::ranges::less_equal less_equal_v{};
-    inline constexpr ::std::ranges::greater_equal greater_equal_v{};
-    inline constexpr ::std::compare_three_way compare_three_way_v{};
-    inline constexpr ::std::plus<> plus_v{};
-    inline constexpr ::std::minus<> minus_v{};
-    inline constexpr ::std::divides<> divides_v{};
-    inline constexpr ::std::multiplies<> multiplies_v{};
-    inline constexpr ::std::modulus<> modulus_v{};
-    inline constexpr ::std::negate<> negate_v{};
-    inline constexpr ::std::logical_and<> logical_and_v{};
-    inline constexpr ::std::logical_not<> logical_not_v{};
-    inline constexpr ::std::logical_or<> logical_or_v{};
-
-    inline constexpr ::std::bit_and<> bit_and_v{};
-    inline constexpr ::std::bit_not<> bit_not_v{};
-    inline constexpr ::std::bit_or<> bit_or_v{};
-    inline constexpr ::std::bit_xor<> bit_xor_v{};
+    inline constexpr std::ranges::equal_to equal_to_v{};
+    inline constexpr std::ranges::not_equal_to not_equal_to_v{};
+    inline constexpr std::ranges::less less_v{};
+    inline constexpr std::ranges::greater greater_v{};
+    inline constexpr std::ranges::less_equal less_equal_v{};
+    inline constexpr std::ranges::greater_equal greater_equal_v{};
+    inline constexpr std::compare_three_way compare_three_way_v{};
+    inline constexpr std::plus<> plus_v{};
+    inline constexpr std::minus<> minus_v{};
+    inline constexpr std::divides<> divides_v{};
+    inline constexpr std::multiplies<> multiplies_v{};
+    inline constexpr std::modulus<> modulus_v{};
+    inline constexpr std::negate<> negate_v{};
+    inline constexpr std::logical_and<> logical_and_v{};
+    inline constexpr std::logical_not<> logical_not_v{};
+    inline constexpr std::logical_or<> logical_or_v{};
+
+    inline constexpr std::bit_and<> bit_and_v{};
+    inline constexpr std::bit_not<> bit_not_v{};
+    inline constexpr std::bit_or<> bit_or_v{};
+    inline constexpr std::bit_xor<> bit_xor_v{};
 
     inline constexpr struct bit_xnor
     {
@@ -172,7 +172,7 @@ namespace stdsharp
 
 #undef BS_UTIL_ASSIGN_OPERATE
 
-    inline constexpr ::std::identity identity_v{};
+    inline constexpr std::identity identity_v{};
 
 #define BS_UTIL_INCREMENT_DECREMENT_OPERATE(operator_prefix, op, al_op)                            \
     inline constexpr struct pre_##operator_prefix##crease                                          \
@@ -204,8 +204,8 @@ namespace stdsharp
     {
         struct advance_by_op
         {
-            template<typename T, unsigned_ Distance = ::std::iter_difference_t<T>>
-                requires ::std::invocable<pre_increase, T>
+            template<typename T, unsigned_ Distance = std::iter_difference_t<T>>
+                requires std::invocable<pre_increase, T>
             constexpr decltype(auto) operator()(T& v, Distance distance) const
                 noexcept(nothrow_invocable<pre_increase, T>)
             {
@@ -214,14 +214,14 @@ namespace stdsharp
                 return v;
             }
 
-            template<typename T, signed_ Distance = ::std::iter_difference_t<T>>
+            template<typename T, signed_ Distance = std::iter_difference_t<T>>
                 requires(
-                    ::std::invocable<advance_by_op, T, ::std::make_unsigned_t<Distance>> &&
-                    ::std::invocable<pre_decrease, T> //
+                    std::invocable<advance_by_op, T, std::make_unsigned_t<Distance>> &&
+                    std::invocable<pre_decrease, T> //
                 )
             constexpr decltype(auto) operator()(T& v, Distance distance) const noexcept( //
                 noexcept( //
-                    nothrow_invocable<advance_by_op, T, ::std::make_unsigned_t<Distance>> &&
+                    nothrow_invocable<advance_by_op, T, std::make_unsigned_t<Distance>> &&
                     nothrow_invocable<pre_decrease, T>
                 )
             )
diff --git a/include/stdsharp/functional/pipeable.h b/include/stdsharp/functional/pipeable.h
index 819c638a..b0f3da09 100644
--- a/include/stdsharp/functional/pipeable.h
+++ b/include/stdsharp/functional/pipeable.h
@@ -25,18 +25,18 @@ namespace stdsharp
         template<typename Fn>
             requires requires //
         {
-            requires ::std::invocable<make_invocables_fn, Fn>;
-            requires ::std::invocable<
+            requires std::invocable<make_invocables_fn, Fn>;
+            requires std::invocable<
                 make_inherited_fn,
                 pipeable_base<Mode>,
-                ::std::invoke_result_t<make_invocables_fn, Fn> // clang-format off
+                std::invoke_result_t<make_invocables_fn, Fn> // clang-format off
             >; // clang-format on
         }
         constexpr auto operator()(Fn&& fun) const noexcept( //
             nothrow_invocable<
                 make_inherited_fn,
                 pipeable_base<Mode>,
-                ::std::invoke_result_t<make_invocables_fn, Fn> // clang-format off
+                std::invoke_result_t<make_invocables_fn, Fn> // clang-format off
             > // clang-format on
         )
         {
@@ -48,8 +48,8 @@ namespace stdsharp
     inline constexpr make_pipeable_fn<Mode> make_pipeable{};
 
     template<typename T, pipe_mode Mode = pipe_mode::left>
-    concept pipeable = ::std::derived_from<::std::decay_t<T>, pipeable_base<Mode>> || //
-        (Mode == pipe_mode::left && ::ranges::is_pipeable_v<::std::decay_t<T>>);
+    concept pipeable = std::derived_from<std::decay_t<T>, pipeable_base<Mode>> || //
+        (Mode == pipe_mode::left && ::ranges::is_pipeable_v<std::decay_t<T>>);
 
     template<typename Pipe>
         requires pipeable<Pipe> || pipeable<Pipe, pipe_mode::right>
@@ -60,19 +60,19 @@ namespace stdsharp
         class pipeable_operator
         {
             template<typename Arg, pipeable<pipe_mode::left> Pipe>
-                requires ::std::invocable<Pipe, Arg>
+                requires std::invocable<Pipe, Arg>
             friend constexpr decltype(auto) operator|(Arg&& arg, Pipe&& pipe) //
                 noexcept(nothrow_invocable<Pipe, Arg>)
             {
-                return ::std::invoke(pipe, cpp_forward(arg));
+                return std::invoke(pipe, cpp_forward(arg));
             }
 
             template<pipeable<pipe_mode::right> Pipe, typename Arg>
-                requires ::std::invocable<Pipe, Arg>
+                requires std::invocable<Pipe, Arg>
             friend constexpr decltype(auto) operator|(Pipe&& pipe, Arg&& arg) //
                 noexcept(nothrow_invocable<Pipe, Arg>)
             {
-                return ::std::invoke(pipe, cpp_forward(arg));
+                return std::invoke(pipe, cpp_forward(arg));
             }
         };
     }
diff --git a/include/stdsharp/functional/symmetric_operations.h b/include/stdsharp/functional/symmetric_operations.h
index 079566a2..1416887e 100644
--- a/include/stdsharp/functional/symmetric_operations.h
+++ b/include/stdsharp/functional/symmetric_operations.h
@@ -11,32 +11,32 @@ namespace stdsharp::cpo::inline cpo_impl
         struct arithmetic_operation;
 
         template<>
-        struct arithmetic_operation<plus_assign> : ::std::type_identity<minus_assign>
+        struct arithmetic_operation<plus_assign> : std::type_identity<minus_assign>
         {
         };
 
         template<>
-        struct arithmetic_operation<minus_assign> : ::std::type_identity<plus_assign>
+        struct arithmetic_operation<minus_assign> : std::type_identity<plus_assign>
         {
         };
 
         template<>
-        struct arithmetic_operation<multiplies_assign> : ::std::type_identity<divides_assign>
+        struct arithmetic_operation<multiplies_assign> : std::type_identity<divides_assign>
         {
         };
 
         template<>
-        struct arithmetic_operation<divides_assign> : ::std::type_identity<multiplies_assign>
+        struct arithmetic_operation<divides_assign> : std::type_identity<multiplies_assign>
         {
         };
 
         template<>
-        struct arithmetic_operation<negate_assign> : ::std::type_identity<negate_assign>
+        struct arithmetic_operation<negate_assign> : std::type_identity<negate_assign>
         {
         };
 
         template<>
-        struct arithmetic_operation<logical_not_assign> : ::std::type_identity<logical_not_assign>
+        struct arithmetic_operation<logical_not_assign> : std::type_identity<logical_not_assign>
         {
         };
 
@@ -44,13 +44,13 @@ namespace stdsharp::cpo::inline cpo_impl
         {
             template<
                 typename... Args,
-                ::std::invocable<Args...> Operation,
+                std::invocable<Args...> Operation,
                 typename SymOp = ::meta::_t<arithmetic_operation<Operation>> // clang-format off
             > // clang-format on
             [[nodiscard]] constexpr auto operator()(const Operation, Args&&... args) const
-                noexcept(noexcept(bind(SymOp{}, cpp_forward(args)...)))
+                noexcept(noexcept(bind_as_lvalue(SymOp{}, cpp_forward(args)...)))
             {
-                return bind(SymOp{}, cpp_forward(args)...);
+                return bind_as_lvalue(SymOp{}, cpp_forward(args)...);
             }
         };
 
@@ -60,9 +60,9 @@ namespace stdsharp::cpo::inline cpo_impl
         struct adl_symmetric_operation_fn
         {
             template<typename... Args>
-                requires requires { symmetric_operation(::std::declval<Args>()...); }
+                requires requires { symmetric_operation(std::declval<Args>()...); }
             [[nodiscard]] constexpr decltype(auto) operator()(Args&&... args) const
-                noexcept(symmetric_operation(::std::declval<Args>()...))
+                noexcept(symmetric_operation(std::declval<Args>()...))
             {
                 return symmetric_operation(cpp_forward(args)...);
             }
diff --git a/include/stdsharp/iterator/iterator.h b/include/stdsharp/iterator/iterator.h
index b090d950..a68a88da 100644
--- a/include/stdsharp/iterator/iterator.h
+++ b/include/stdsharp/iterator/iterator.h
@@ -9,29 +9,29 @@
 
 namespace stdsharp
 {
-    template<::std::indirectly_readable T>
+    template<std::indirectly_readable T>
     using iter_const_reference_t =
 #if __cpp_lib_ranges_as_const >= 202207L
-        ::std::iter_const_reference_t<T>
+        std::iter_const_reference_t<T>
 #else
-        ::std::common_reference_t<const ::std::iter_value_t<T>&&, ::std::iter_reference_t<T>>
+        std::common_reference_t<const std::iter_value_t<T>&&, std::iter_reference_t<T>>
 #endif
         ;
 
     template<typename I>
-    concept weakly_decrementable = ::std::movable<I> &&
+    concept weakly_decrementable = std::movable<I> &&
         requires(I i) //
     {
-        typename ::std::iter_difference_t<I>;
-        requires ::std::signed_integral<::std::iter_difference_t<I>>; // clang-format off
-        { --i } -> ::std::same_as<I&>; // clang-format on
+        typename std::iter_difference_t<I>;
+        requires std::signed_integral<std::iter_difference_t<I>>; // clang-format off
+        { --i } -> std::same_as<I&>; // clang-format on
         i--;
     };
 
     template<typename I>
-    concept decrementable = ::std::regular<I> && weakly_decrementable<I> &&
+    concept decrementable = std::regular<I> && weakly_decrementable<I> &&
         requires(I i) // clang-format off
     {
-        { i-- } -> ::std::same_as<I>; // clang-format on
+        { i-- } -> std::same_as<I>; // clang-format on
     };
 }
\ No newline at end of file
diff --git a/include/stdsharp/macros.h b/include/stdsharp/macros.h
index b57e2137..4d4504ae 100644
--- a/include/stdsharp/macros.h
+++ b/include/stdsharp/macros.h
@@ -11,5 +11,5 @@ namespace stdsharp::details
 
 #define cpp_forward(...) static_cast<decltype(__VA_ARGS__)>(__VA_ARGS__)
 #define cpp_move(...) \
-    static_cast<decltype(::stdsharp::details::remove_ref(__VA_ARGS__))&&>(__VA_ARGS__)
+    static_cast<decltype(stdsharp::details::remove_ref(__VA_ARGS__))&&>(__VA_ARGS__)
 #define cpp_is_constexpr(...) requires { noexcept((__VA_ARGS__, true)); }
\ No newline at end of file
diff --git a/include/stdsharp/memory/allocator_aware.h b/include/stdsharp/memory/allocator_aware.h
index 61eb995e..975cb2c9 100644
--- a/include/stdsharp/memory/allocator_aware.h
+++ b/include/stdsharp/memory/allocator_aware.h
@@ -127,7 +127,7 @@ namespace stdsharp
         [[nodiscard]] static constexpr allocation_for<ValueType>
             move_construct(allocator_type&, allocation_for<ValueType>& other) noexcept
         {
-            return ::std::exchange(other, {});
+            return std::exchange(other, {});
         }
 
         template<typename ValueType>
@@ -235,7 +235,7 @@ namespace stdsharp
 
             dst_allocation.deallocate(dst_alloc);
             if constexpr(propagate_on_move_v) dst_alloc = cpp_move(src_alloc);
-            dst_allocation = ::std::exchange(src_allocation, {});
+            dst_allocation = std::exchange(src_allocation, {});
         }
 
         static constexpr void swap(
@@ -245,7 +245,7 @@ namespace stdsharp
             allocation& src_allocation
         ) noexcept(!is_debug)
         {
-            precondition<::std::invalid_argument>( //
+            precondition<std::invalid_argument>( //
                 [&dst_alloc, &src_alloc]
                 {
                     if constexpr(!always_equal_v)
@@ -254,8 +254,8 @@ namespace stdsharp
                     return true;
                 }
             );
-            ::std::swap(dst_allocation, src_allocation);
-            if constexpr(propagate_on_swap_v) ::std::ranges::swap(dst_alloc, src_alloc);
+            std::swap(dst_allocation, src_allocation);
+            if constexpr(propagate_on_swap_v) std::ranges::swap(dst_alloc, src_alloc);
         }
     };
 
@@ -327,7 +327,7 @@ namespace stdsharp
             operator<(const allocation_obj_req& left, const allocation_obj_req& right) noexcept
         {
             bool has_less = false;
-            const auto cmp = ::std::ranges::equal(
+            const auto cmp = std::ranges::equal(
                 left.to_array(),
                 right.to_array(),
                 [&has_less](const expr_req left, const expr_req right)
@@ -349,7 +349,7 @@ namespace stdsharp
             operator>(const allocation_obj_req& left, const allocation_obj_req& right) noexcept
         {
             bool has_greater = false;
-            const auto cmp = ::std::ranges::equal(
+            const auto cmp = std::ranges::equal(
                 left.to_array(),
                 right.to_array(),
                 [&has_greater](const expr_req left, const expr_req right)
@@ -370,27 +370,23 @@ namespace stdsharp
         [[nodiscard]] friend constexpr bool
             operator<=(const allocation_obj_req& left, const allocation_obj_req& right) noexcept
         {
-            return ::std::ranges::equal(
-                left.to_array(),
-                right.to_array(),
-                ::std::ranges::less_equal{}
-            );
+            return std::ranges::equal(left.to_array(), right.to_array(), std::ranges::less_equal{});
         }
 
         [[nodiscard]] friend constexpr bool
             operator>=(const allocation_obj_req& left, const allocation_obj_req& right) noexcept
         {
-            return ::std::ranges::equal(
+            return std::ranges::equal(
                 left.to_array(),
                 right.to_array(),
-                ::std::ranges::greater_equal{}
+                std::ranges::greater_equal{}
             );
         }
 
         [[nodiscard]] friend constexpr bool
             operator==(const allocation_obj_req& left, const allocation_obj_req& right) noexcept
         {
-            return ::std::ranges::equal(left.to_array(), right.to_array());
+            return std::ranges::equal(left.to_array(), right.to_array());
         }
     };
 
@@ -401,19 +397,19 @@ namespace stdsharp
     public:
         using value_type = ValueType;
 
-        static constexpr auto copy_constructible_req = ::std::min(
+        static constexpr auto copy_constructible_req = std::min(
             traits::template construct_req<value_type, const value_type&>,
             expr_req::well_formed
         );
 
-        static constexpr auto copy_assignable_req = ::std::min(
+        static constexpr auto copy_assignable_req = std::min(
             traits::template construct_req<value_type, const value_type&>,
             get_expr_req(copy_assignable<value_type>, !propagate_on_copy_v || always_equal_v)
         );
 
         static constexpr auto move_assignable_req = propagate_on_move_v || always_equal_v ?
             expr_req::no_exception :
-            ::std::min(
+            std::min(
                 traits::template construct_req<value_type, value_type>,
                 get_expr_req(move_assignable<value_type>, nothrow_move_assignable<value_type>)
             );
@@ -435,9 +431,9 @@ namespace stdsharp
             noexcept(!is_debug):
             allocation_(allocation), has_value_(has_value)
         {
-            precondition<::std::invalid_argument>( //
-                ::std::bind_front(
-                    ::std::ranges::greater_equal{},
+            precondition<std::invalid_argument>( //
+                std::bind_front(
+                    std::ranges::greater_equal{},
                     allocation_.size(),
                     has_value_ ? sizeof(value_type) : 0
                 ),
@@ -519,10 +515,10 @@ namespace stdsharp
     template<typename T>
         requires requires(const T t, T::allocator_type alloc) //
     {
-        requires ::std::derived_from<T, allocator_aware_traits<decltype(alloc)>>;
+        requires std::derived_from<T, allocator_aware_traits<decltype(alloc)>>;
         // clang-format off
         { t.get_allocator() } noexcept ->
-            ::std::convertible_to<decltype(alloc)>; // clang-format on
+            std::convertible_to<decltype(alloc)>; // clang-format on
     }
     struct allocator_aware_ctor : T
     {
@@ -538,13 +534,13 @@ namespace stdsharp
 
         template<typename... Args>
         static constexpr auto alloc_arg_ctor =
-            constructible_from_test<T, ::std::allocator_arg_t, allocator_type, Args...>;
+            constructible_from_test<T, std::allocator_arg_t, allocator_type, Args...>;
 
     public:
         template<typename... Args>
-            requires ::std::constructible_from<T, Args..., allocator_type>
+            requires std::constructible_from<T, Args..., allocator_type>
         constexpr allocator_aware_ctor(
-            const ::std::allocator_arg_t,
+            const std::allocator_arg_t,
             const allocator_type& alloc,
             Args&&... args
         ) noexcept(nothrow_constructible_from<T, Args..., allocator_type>):
@@ -554,7 +550,7 @@ namespace stdsharp
 
         constexpr allocator_aware_ctor(const this_t& other) //
             noexcept(nothrow_constructible_from<T, const T&, allocator_type>)
-            requires ::std::constructible_from<T, const T&, allocator_type>
+            requires std::constructible_from<T, const T&, allocator_type>
             :
             T( //
                 static_cast<const T&>(other),
@@ -565,7 +561,7 @@ namespace stdsharp
 
         constexpr allocator_aware_ctor(this_t&& other) //
             noexcept(nothrow_constructible_from<T, T, allocator_type>)
-            requires ::std::constructible_from<T, T, allocator_type>
+            requires std::constructible_from<T, T, allocator_type>
             : T(static_cast<T&&>(other), other.get_allocator())
         {
         }
diff --git a/include/stdsharp/memory/allocator_reference.h b/include/stdsharp/memory/allocator_reference.h
index 90627590..196effcb 100644
--- a/include/stdsharp/memory/allocator_reference.h
+++ b/include/stdsharp/memory/allocator_reference.h
@@ -5,12 +5,12 @@
 namespace stdsharp
 {
     template<allocator_req Alloc>
-    class allocator_reference : ::std::reference_wrapper<Alloc>
+    class allocator_reference : std::reference_wrapper<Alloc>
     {
         using traits = allocator_traits<Alloc>;
 
     public:
-        using ::std::reference_wrapper<Alloc>::reference_wrapper;
+        using std::reference_wrapper<Alloc>::reference_wrapper;
 
         using value_type = traits::value_type;
         using pointer = traits::pointer;
@@ -46,13 +46,13 @@ namespace stdsharp
 
         [[nodiscard]] constexpr auto allocate_at_least(const size_type n) const
         {
-            return ::std::allocate_at_least(this->get(), n);
+            return std::allocate_at_least(this->get(), n);
         }
 
         template<typename U, typename... Args>
         constexpr void construct(U* const p, Args&&... args) const //
-            noexcept(noexcept(traits::construct(this->get(), p, ::std::declval<Args>()...)))
-            requires requires { traits::construct(this->get(), p, ::std::declval<Args>()...); }
+            noexcept(noexcept(traits::construct(this->get(), p, std::declval<Args>()...)))
+            requires requires { traits::construct(this->get(), p, std::declval<Args>()...); }
         {
             traits::construct(this->get(), p, cpp_forward(args)...);
         }
diff --git a/include/stdsharp/memory/allocator_traits.h b/include/stdsharp/memory/allocator_traits.h
index c4ee41ed..3126fdb1 100644
--- a/include/stdsharp/memory/allocator_traits.h
+++ b/include/stdsharp/memory/allocator_traits.h
@@ -9,7 +9,7 @@
 
 namespace stdsharp
 {
-    using max_alignment = ::std::alignment_of<::std::max_align_t>;
+    using max_alignment = std::alignment_of<std::max_align_t>;
 
     inline constexpr auto max_alignment_v = max_alignment::value;
 
@@ -24,7 +24,7 @@ namespace stdsharp
         concept allocator_pointer =
             nullable_pointer<T> && nothrow_default_initializable<T> && nothrow_movable<T> &&
             nothrow_swappable<T> && nothrow_copyable<T> && nothrow_weakly_equality_comparable<T> &&
-            nothrow_weakly_equality_comparable_with<T, ::std::nullptr_t>;
+            nothrow_weakly_equality_comparable_with<T, std::nullptr_t>;
     }
 
     template<typename Alloc>
@@ -35,7 +35,7 @@ namespace stdsharp
 
         requires requires(
             Alloc alloc,
-            ::std::allocator_traits<Alloc> t_traits,
+            std::allocator_traits<Alloc> t_traits,
             decltype(t_traits)::pointer p,
             decltype(t_traits)::const_pointer const_p,
             decltype(t_traits)::void_pointer void_p,
@@ -57,16 +57,16 @@ namespace stdsharp
                 details::allocator_pointer<decltype(void_p)> &&
                 details::allocator_pointer<decltype(const_void_p)>;
 
-            requires ::std::random_access_iterator<decltype(p)> &&
-                ::std::contiguous_iterator<decltype(p)>;
+            requires std::random_access_iterator<decltype(p)> &&
+                std::contiguous_iterator<decltype(p)>;
 
             requires nothrow_convertible_to<decltype(p), decltype(const_p)> &&
-                ::std::random_access_iterator<decltype(const_p)> &&
-                ::std::contiguous_iterator<decltype(const_p)>;
+                std::random_access_iterator<decltype(const_p)> &&
+                std::contiguous_iterator<decltype(const_p)>;
 
             requires nothrow_convertible_to<decltype(p), decltype(void_p)> &&
                 nothrow_explicitly_convertible<decltype(void_p), decltype(p)> &&
-                ::std::same_as<decltype(void_p), typename decltype(u_traits)::void_pointer>;
+                std::same_as<decltype(void_p), typename decltype(u_traits)::void_pointer>;
 
             requires nothrow_convertible_to<decltype(p), decltype(const_void_p)> &&
                 nothrow_convertible_to<decltype(const_p), decltype(const_void_p)> &&
@@ -74,22 +74,22 @@ namespace stdsharp
                 nothrow_convertible_to<
                          decltype(void_p),
                          decltype(const_void_p)> &&
-                ::std::same_as< // clang-format off
+                std::same_as< // clang-format off
                     decltype(const_void_p),
                     typename decltype(u_traits)::const_void_pointer
                 >; // clang-format on
 
-            requires ::std::unsigned_integral<decltype(size)>;
+            requires std::unsigned_integral<decltype(size)>;
 
-            requires ::std::signed_integral<typename decltype(t_traits)::difference_type>;
+            requires std::signed_integral<typename decltype(t_traits)::difference_type>;
 
-            requires ::std::
+            requires std::
                 same_as<typename decltype(u_traits)::template rebind_alloc<decltype(v)>, Alloc>;
             // clang-format off
 
-            { *p } -> ::std::same_as<::std::add_lvalue_reference_t<decltype(v)>>;
-            { *const_p } -> ::std::same_as<add_const_lvalue_ref_t<decltype(v)>>;
-            { *const_p } -> ::std::same_as<add_const_lvalue_ref_t<decltype(v)>>; // clang-format on
+            { *p } -> std::same_as<std::add_lvalue_reference_t<decltype(v)>>;
+            { *const_p } -> std::same_as<add_const_lvalue_ref_t<decltype(v)>>;
+            { *const_p } -> std::same_as<add_const_lvalue_ref_t<decltype(v)>>; // clang-format on
 
             requires requires(
                 decltype(u_traits)::pointer other_p,
@@ -101,8 +101,8 @@ namespace stdsharp
                 nothrow_constructible_from<Alloc, const decltype(u_alloc)&>;
                 nothrow_constructible_from<Alloc, decltype(u_alloc)>;
 
-                { other_p->v } -> ::std::same_as<decltype(((*other_p).v))>;
-                { other_const_p->v } -> ::std::same_as<decltype(((*other_const_p).v))>;
+                { other_p->v } -> std::same_as<decltype(((*other_p).v))>;
+                { other_const_p->v } -> std::same_as<decltype(((*other_const_p).v))>;
 
                 t_traits.construct(alloc, other_p);
                 t_traits.destroy(alloc, other_p);
@@ -110,32 +110,31 @@ namespace stdsharp
                 requires noexcept(alloc == another_alloc) && noexcept(alloc != another_alloc);
             }; // clang-format on
 
-            ::std::pointer_traits<decltype(p)>::pointer_to(v); // clang-format off
+            std::pointer_traits<decltype(p)>::pointer_to(v); // clang-format off
 
-            { t_traits.allocate(alloc, size) } -> ::std::same_as<decltype(p)>;
-            { t_traits.allocate(alloc, size, const_void_p) } -> ::std::same_as<decltype(p)>;
+            { t_traits.allocate(alloc, size) } -> std::same_as<decltype(p)>;
+            { t_traits.allocate(alloc, size, const_void_p) } -> std::same_as<decltype(p)>;
             noexcept(alloc.deallocate(p, size));
-            { t_traits.max_size(alloc) } -> ::std::same_as<decltype(size)>;
+            { t_traits.max_size(alloc) } -> std::same_as<decltype(size)>;
             // clang-format on
 
-            requires ::std::derived_from<decltype(always_equal), ::std::true_type> ||
-                ::std::derived_from<decltype(always_equal), ::std::false_type>;
+            requires std::derived_from<decltype(always_equal), std::true_type> ||
+                std::derived_from<decltype(always_equal), std::false_type>;
 
             // clang-format off
-            { t_traits.select_on_container_copy_construction(alloc) } -> ::std::same_as<Alloc>;
+            { t_traits.select_on_container_copy_construction(alloc) } -> std::same_as<Alloc>;
             // clang-format on
 
-            requires ::std::derived_from<decltype(copy_assign), ::std::true_type> &&
+            requires std::derived_from<decltype(copy_assign), std::true_type> &&
                     nothrow_copy_assignable<Alloc> ||
-                    ::std::derived_from<decltype(copy_assign), ::std::false_type>;
+                    std::derived_from<decltype(copy_assign), std::false_type>;
 
-            requires ::std::derived_from<decltype(move_assign), ::std::true_type> &&
+            requires std::derived_from<decltype(move_assign), std::true_type> &&
                     nothrow_move_assignable<Alloc> ||
-                    ::std::derived_from<decltype(move_assign), ::std::false_type>;
+                    std::derived_from<decltype(move_assign), std::false_type>;
 
-            requires ::std::derived_from<decltype(swap), ::std::true_type> &&
-                    nothrow_swappable<Alloc> ||
-                    ::std::derived_from<decltype(swap), ::std::false_type>;
+            requires std::derived_from<decltype(swap), std::true_type> &&
+                    nothrow_swappable<Alloc> || std::derived_from<decltype(swap), std::false_type>;
         };
     };
 
@@ -145,7 +144,7 @@ namespace stdsharp
         struct make_obj_using_allocator_fn
         {
             template<typename Alloc, typename... Args>
-                requires ::std::constructible_from<T, Args..., const Alloc&>
+                requires std::constructible_from<T, Args..., const Alloc&>
             constexpr T operator()(const Alloc& alloc, Args&&... args) const
                 noexcept(nothrow_constructible_from<T, Args..., const Alloc&>)
             {
@@ -153,15 +152,11 @@ namespace stdsharp
             }
 
             template<typename Alloc, typename... Args>
-                requires ::std::constructible_from<T, ::std::allocator_arg_t, const Alloc&, Args...>
+                requires std::constructible_from<T, std::allocator_arg_t, const Alloc&, Args...>
             constexpr T operator()(const Alloc& alloc, Args&&... args) const
-                noexcept(nothrow_constructible_from<
-                         T,
-                         ::std::allocator_arg_t,
-                         const Alloc&,
-                         Args...>)
+                noexcept(nothrow_constructible_from<T, std::allocator_arg_t, const Alloc&, Args...>)
             {
-                return T{::std::allocator_arg, alloc, cpp_forward(args)...};
+                return T{std::allocator_arg, alloc, cpp_forward(args)...};
             }
         };
     }
@@ -174,27 +169,27 @@ namespace stdsharp
     inline constexpr make_obj_uses_allocator_fn<T> make_obj_uses_allocator{};
 
     template<allocator_req Alloc>
-    struct allocator_traits : private ::std::allocator_traits<Alloc>
+    struct allocator_traits : private std::allocator_traits<Alloc>
     {
     private: // NOLINTBEGIN(*-owning-memory)
         struct default_constructor
         {
             template<typename T, typename... Args>
             constexpr decltype(auto) operator()(const Alloc&, T* const ptr, Args&&... args) const
-                noexcept(noexcept(::std::ranges::construct_at(ptr, ::std::declval<Args>()...)))
-                requires requires { ::std::ranges::construct_at(ptr, ::std::declval<Args>()...); }
+                noexcept(noexcept(std::ranges::construct_at(ptr, std::declval<Args>()...)))
+                requires requires { std::ranges::construct_at(ptr, std::declval<Args>()...); }
             {
-                return ::std::ranges::construct_at(ptr, cpp_forward(args)...);
+                return std::ranges::construct_at(ptr, cpp_forward(args)...);
             }
 
             template<typename T, typename... Args>
             constexpr decltype(auto) operator()(
                 const Alloc&,
                 void* const ptr,
-                const ::std::in_place_type_t<T>,
+                const std::in_place_type_t<T>,
                 Args&&... args
-            ) const noexcept(noexcept(::std::ranges::construct_at(ptr, ::std::declval<Args>()...)))
-                requires requires { ::std::ranges::construct_at(ptr, ::std::declval<Args>()...); }
+            ) const noexcept(noexcept(std::ranges::construct_at(ptr, std::declval<Args>()...)))
+                requires requires { std::ranges::construct_at(ptr, std::declval<Args>()...); }
             {
                 return ::new(ptr) T{cpp_forward(args)...};
             }
@@ -203,43 +198,43 @@ namespace stdsharp
         struct using_alloc_ctor
         {
             template<typename T, typename... Args>
-                requires ::std::constructible_from<T, Args..., const Alloc&>
+                requires std::constructible_from<T, Args..., const Alloc&>
             constexpr void operator()(const Alloc& alloc, T* const ptr, Args&&... args) //
                 const noexcept(stdsharp::nothrow_constructible_from<T, Args..., const Alloc&>)
             {
-                ::std::ranges::construct_at(ptr, cpp_forward(args)..., alloc);
+                std::ranges::construct_at(ptr, cpp_forward(args)..., alloc);
             }
 
-            template<typename T, typename... Args, typename Tag = ::std::allocator_arg_t>
-                requires ::std::constructible_from<T, Tag, const Alloc&, Args...>
+            template<typename T, typename... Args, typename Tag = std::allocator_arg_t>
+                requires std::constructible_from<T, Tag, const Alloc&, Args...>
             constexpr void operator()(const Alloc& alloc, T* const ptr, Args&&... args) //
                 const noexcept(stdsharp::nothrow_constructible_from<T, Tag, const Alloc&, Args...>)
             {
-                ::std::ranges::construct_at(ptr, ::std::allocator_arg, alloc, cpp_forward(args)...);
+                std::ranges::construct_at(ptr, std::allocator_arg, alloc, cpp_forward(args)...);
             }
 
             template<typename T, typename... Args>
-                requires ::std::constructible_from<T, Args..., const Alloc&>
+                requires std::constructible_from<T, Args..., const Alloc&>
             constexpr void operator()(
                 const Alloc& alloc,
                 void* const ptr,
-                const ::std::in_place_type_t<T>,
+                const std::in_place_type_t<T>,
                 Args&&... args
             ) const noexcept(stdsharp::nothrow_constructible_from<T, Args..., const Alloc&>)
             {
                 ::new(ptr) T{cpp_forward(args)..., alloc};
             }
 
-            template<typename T, typename... Args, typename Tag = ::std::allocator_arg_t>
-                requires ::std::constructible_from<T, Tag, const Alloc&, Args...>
+            template<typename T, typename... Args, typename Tag = std::allocator_arg_t>
+                requires std::constructible_from<T, Tag, const Alloc&, Args...>
             constexpr void operator()(
                 const Alloc& alloc,
                 void* const ptr,
-                const ::std::in_place_type_t<T>,
+                const std::in_place_type_t<T>,
                 Args&&... args
             ) const noexcept(stdsharp::nothrow_constructible_from<T, Tag, const Alloc&, Args...>)
             {
-                ::new(ptr) T{::std::allocator_arg, alloc, cpp_forward(args)...};
+                ::new(ptr) T{std::allocator_arg, alloc, cpp_forward(args)...};
             }
         };
 
@@ -247,8 +242,8 @@ namespace stdsharp
         {
             template<typename T, typename... Args>
             constexpr void operator()(Alloc& a, T* const ptr, Args&&... args) const
-                noexcept(noexcept(a.construct(ptr, ::std::declval<Args>()...)))
-                requires requires { a.construct(ptr, ::std::declval<Args>()...); }
+                noexcept(noexcept(a.construct(ptr, std::declval<Args>()...)))
+                requires requires { a.construct(ptr, std::declval<Args>()...); }
             {
                 a.construct(ptr, cpp_forward(args)...);
             }
@@ -262,7 +257,7 @@ namespace stdsharp
 
         template<typename T, typename... Args>
         static constexpr auto construct_req =
-            get_expr_req(::std::invocable<constructor, Alloc&, T*, Args...>, nothrow_invocable<constructor, Alloc&, T*, Args...>);
+            get_expr_req(std::invocable<constructor, Alloc&, T*, Args...>, nothrow_invocable<constructor, Alloc&, T*, Args...>);
 
     private:
         struct custom_destructor
@@ -280,7 +275,7 @@ namespace stdsharp
             template<typename U>
             constexpr void operator()(const Alloc&, U* const ptr) const noexcept
             {
-                ::std::ranges::destroy_at(ptr);
+                std::ranges::destroy_at(ptr);
             }
         };
 
@@ -290,18 +285,17 @@ namespace stdsharp
         static constexpr destructor destroy{};
 
     private:
-        using base = ::std::allocator_traits<Alloc>;
+        using base = std::allocator_traits<Alloc>;
 
         template<typename T, typename... Args>
-        static constexpr auto constructible_from =
-            ::std::invocable<constructor, Alloc&, T*, Args...>;
+        static constexpr auto constructible_from = std::invocable<constructor, Alloc&, T*, Args...>;
 
         template<typename T, typename... Args>
         static constexpr auto nothrow_constructible_from =
             nothrow_invocable<constructor, Alloc&, T*, Args...>;
 
         template<typename T>
-        static constexpr auto destructible = ::std::invocable<destructor, Alloc&, T*>;
+        static constexpr auto destructible = std::invocable<destructor, Alloc&, T*>;
 
         template<typename T>
         static constexpr auto nothrow_destructible = nothrow_invocable<destructor, Alloc&, T*>;
@@ -378,7 +372,7 @@ namespace stdsharp
         ) noexcept
             requires requires // clang-format off
         {
-            { alloc.try_allocate(count) } -> ::std::same_as<pointer>; // clang-format on
+            { alloc.try_allocate(count) } -> std::same_as<pointer>; // clang-format on
             requires noexcept(alloc.try_allocate(count));
         }
         {
@@ -386,7 +380,7 @@ namespace stdsharp
                 requires
                 {
                     { alloc.try_allocate(count, hint) } ->
-                        ::std::same_as<pointer>; // clang-format on
+                        std::same_as<pointer>; // clang-format on
                     requires noexcept(alloc.try_allocate(count, hint));
                 } //
             )
@@ -397,7 +391,7 @@ namespace stdsharp
 
         static constexpr auto allocate_at_least(allocator_type& alloc, const size_type count)
         {
-            return ::std::allocate_at_least(alloc, count);
+            return std::allocate_at_least(alloc, count);
         }
 
         template<typename T>
@@ -419,7 +413,7 @@ namespace stdsharp
             destructible<T> ?
                 nothrow_destructible<T> ? expr_req::no_exception : expr_req::well_formed :
                 expr_req::ill_formed,
-            ::std::swappable<T> ?
+            std::swappable<T> ?
                 nothrow_swappable<T> ? expr_req::no_exception : expr_req::well_formed :
                 expr_req::ill_formed //
         };
@@ -439,7 +433,7 @@ namespace stdsharp
 
     template<typename T>
         requires requires { typename T::allocator_type; }
-    struct allocator_of<T> : ::std::type_identity<typename T::allocator_type>
+    struct allocator_of<T> : std::type_identity<typename T::allocator_type>
     {
     };
 
diff --git a/include/stdsharp/memory/composed_allocator.h b/include/stdsharp/memory/composed_allocator.h
index b3edf8b2..65adf095 100644
--- a/include/stdsharp/memory/composed_allocator.h
+++ b/include/stdsharp/memory/composed_allocator.h
@@ -14,13 +14,13 @@ namespace stdsharp
             const typename allocator_traits<T>::const_void_pointer ptr
         ) // clang-format off
         {
-            { alloc.contains(ptr) } -> ::std::convertible_to<bool>; // clang-format on
+            { alloc.contains(ptr) } -> std::convertible_to<bool>; // clang-format on
             requires noexcept(alloc.contains(ptr));
         };
     }
 
     template<details::allocator_contains FirstAlloc, allocator_req SecondAlloc>
-        requires ::std::same_as<typename FirstAlloc::value_type, typename SecondAlloc::value_type>
+        requires std::same_as<typename FirstAlloc::value_type, typename SecondAlloc::value_type>
     class composed_allocator
     {
     public:
@@ -28,7 +28,7 @@ namespace stdsharp
         using second_allocator_type = SecondAlloc;
 
     private:
-        ::std::pair<first_allocator_type, second_allocator_type> alloc_pair_;
+        std::pair<first_allocator_type, second_allocator_type> alloc_pair_;
 
         using first_traits = allocator_traits<first_allocator_type>;
         using second_traits = allocator_traits<second_allocator_type>;
@@ -48,17 +48,17 @@ namespace stdsharp
     public:
         using value_type = FirstAlloc::value_type;
 
-        using propagate_on_container_copy_assignment = ::std::disjunction<
+        using propagate_on_container_copy_assignment = std::disjunction<
             typename first_traits::propagate_on_container_copy_assignment,
             typename second_traits::propagate_on_container_copy_assignment>;
-        using propagate_on_container_move_assignment = ::std::disjunction<
+        using propagate_on_container_move_assignment = std::disjunction<
             typename first_traits::propagate_on_container_move_assignment,
             typename second_traits::propagate_on_container_move_assignment>;
-        using propagate_on_container_swap = ::std::disjunction<
+        using propagate_on_container_swap = std::disjunction<
             typename first_traits::propagate_on_container_swap,
             typename second_traits::propagate_on_container_swap>;
 
-        using is_always_equal = ::std::conjunction<
+        using is_always_equal = std::conjunction<
             typename first_traits::is_always_equal,
             typename second_traits::is_always_equal>;
 
@@ -72,14 +72,14 @@ namespace stdsharp
 
         composed_allocator() = default;
 
-        template<typename... Args, ::std::constructible_from<Args...> Pair = decltype(alloc_pair_)>
+        template<typename... Args, std::constructible_from<Args...> Pair = decltype(alloc_pair_)>
         constexpr explicit composed_allocator(Args&&... args) //
             noexcept(nothrow_constructible_from<Pair, Args...>):
             alloc_pair_(cpp_forward(args)...)
         {
         }
 
-        constexpr auto allocate(const ::std::size_t n, const void* const hint = nullptr)
+        constexpr auto allocate(const std::size_t n, const void* const hint = nullptr)
         {
             const auto ptr = first_traits::try_allocate(
                 alloc_pair_.first,
@@ -95,8 +95,7 @@ namespace stdsharp
                 ptr;
         }
 
-        constexpr auto
-            try_allocate(const ::std::size_t n, const void* const hint = nullptr) noexcept
+        constexpr auto try_allocate(const std::size_t n, const void* const hint = nullptr) noexcept
         {
             const auto ptr = first_traits::try_allocate(
                 alloc_pair_.first,
@@ -112,7 +111,7 @@ namespace stdsharp
                 ptr;
         }
 
-        constexpr void deallocate(value_type* const ptr, const ::std::size_t n)
+        constexpr void deallocate(value_type* const ptr, const std::size_t n)
         {
             auto& [first, second] = alloc_pair_;
             if(first.contains(first_ptr_traits::to_pointer(ptr))) first.deallocate(ptr, n);
@@ -121,7 +120,7 @@ namespace stdsharp
 
         [[nodiscard]] constexpr auto max_size() const noexcept
         {
-            return ::std::min(
+            return std::min(
                 first_traits::max_size(alloc_pair_.first),
                 second_traits::max_size(alloc_pair_.second)
             );
@@ -135,12 +134,12 @@ namespace stdsharp
             };
         }
 
-        [[nodiscard]] constexpr auto allocate_at_least(const ::std::size_t n)
+        [[nodiscard]] constexpr auto allocate_at_least(const std::size_t n)
         {
             struct
             {
                 value_type* ptr;
-                ::std::size_t count;
+                std::size_t count;
             } result;
 
             aggregate_try(
@@ -167,7 +166,7 @@ namespace stdsharp
         template<
             typename T,
             typename... Args,
-            auto Req = ::std::
+            auto Req = std::
                 min(first_traits::template construct_req<T, Args...>,
                     second_traits::template construct_req<T, Args...>)>
             requires(Req >= expr_req::well_formed)
@@ -192,5 +191,5 @@ namespace stdsharp
     };
 
     template<typename T, typename U>
-    composed_allocator(T&&, U&&) -> composed_allocator<::std::decay_t<T>, ::std::decay_t<U>>;
+    composed_allocator(T&&, U&&) -> composed_allocator<std::decay_t<T>, std::decay_t<U>>;
 }
\ No newline at end of file
diff --git a/include/stdsharp/memory/object_allocation.h b/include/stdsharp/memory/object_allocation.h
index 49a8aff7..03ac6291 100644
--- a/include/stdsharp/memory/object_allocation.h
+++ b/include/stdsharp/memory/object_allocation.h
@@ -39,8 +39,8 @@ namespace stdsharp
 
             constexpr allocation_dispatchers(
                 const dispatchers& b,
-                const ::std::string_view current_type,
-                const ::std::size_t type_size
+                const std::string_view current_type,
+                const std::size_t type_size
             ) noexcept:
                 dispatchers_(b), current_type_(current_type), type_size_(type_size)
             {
@@ -53,9 +53,9 @@ namespace stdsharp
 
             template<
                 typename T,
-                typename AllocationFor = traits::template allocation_for<::std::decay_t<T>>>
+                typename AllocationFor = traits::template allocation_for<std::decay_t<T>>>
                 requires(Req <= AllocationFor::obj_req)
-            constexpr allocation_dispatchers(const ::std::type_identity<T>) noexcept:
+            constexpr allocation_dispatchers(const std::type_identity<T>) noexcept:
                 allocation_dispatchers(
                     dispatchers(
                         [](alloc& alloc, allocation& other) noexcept
@@ -200,8 +200,8 @@ namespace stdsharp
 
         private:
             dispatchers dispatchers_{};
-            ::std::string_view current_type_ = type_id<void>;
-            ::std::size_t type_size_{};
+            std::string_view current_type_ = type_id<void>;
+            std::size_t type_size_{};
         };
 
         template<allocation_obj_req Req, typename Alloc>
@@ -237,16 +237,15 @@ namespace stdsharp
             template<
                 typename... Args,
                 typename T,
-                typename ValueType = ::std::decay_t<T>,
-                typename Identity = ::std::type_identity<ValueType> // clang-format off
+                typename ValueType = std::decay_t<T>,
+                typename Identity = std::type_identity<ValueType> // clang-format off
             > // clang-format on
-                requires ::std::constructible_from<compressed_t, Identity, const allocator_type&> &&
-                             ::std::
-                                 invocable<make_allocation_by_obj_fn<T>, allocator_type&, Args...>
+                requires std::constructible_from<compressed_t, Identity, const allocator_type&> &&
+                             std::invocable<make_allocation_by_obj_fn<T>, allocator_type&, Args...>
             constexpr allocation_rsc(
-                const ::std::allocator_arg_t,
+                const std::allocator_arg_t,
                 const allocator_type& alloc,
-                const ::std::in_place_type_t<T>,
+                const std::in_place_type_t<T>,
                 Args&&... args
             ):
                 compressed_(Identity{}, alloc),
@@ -357,7 +356,7 @@ namespace stdsharp
                     other.get_allocation()
                 );
 
-                ::std::swap(get_dispatchers(), other_dispatchers);
+                std::swap(get_dispatchers(), other_dispatchers);
             }
 
             [[nodiscard]] constexpr auto& get_allocator() const noexcept
@@ -426,9 +425,8 @@ namespace stdsharp
         public:
             template<typename T, typename... Args>
             static constexpr auto emplace_constructible =
-                (Base::template construct_req<::std::decay_t<T>, Args...> >= expr_req::well_formed
-                ) &&
-                ::std::constructible_from<dispatchers_t, ::std::type_identity<::std::decay_t<T>>>;
+                (Base::template construct_req<std::decay_t<T>, Args...> >= expr_req::well_formed) &&
+                std::constructible_from<dispatchers_t, std::type_identity<std::decay_t<T>>>;
 
             using typename Base::allocator_type;
             using Base::Base;
@@ -436,7 +434,7 @@ namespace stdsharp
 
             static constexpr auto req = Req;
 
-            template<::std::same_as<void> T = void>
+            template<std::same_as<void> T = void>
             constexpr void emplace() noexcept
             {
                 this->destroy();
@@ -446,19 +444,19 @@ namespace stdsharp
                 requires emplace_constructible<T, Args...>
             constexpr decltype(auto) emplace(Args&&... args)
             {
-                using value_t = ::std::decay_t<T>;
+                using value_t = std::decay_t<T>;
 
                 this->destroy();
                 get_allocation().allocate(get_allocator(), sizeof(value_t));
 
                 this_t::construct(get_allocator(), ptr<value_t>(), cpp_forward(args)...);
-                get_dispatchers() = dispatchers_t{::std::type_identity<value_t>{}};
+                get_dispatchers() = dispatchers_t{std::type_identity<value_t>{}};
 
                 return get<value_t>();
             }
 
             template<typename T, typename... Args, typename U>
-            constexpr decltype(auto) emplace(const ::std::initializer_list<U> il, Args&&... args)
+            constexpr decltype(auto) emplace(const std::initializer_list<U> il, Args&&... args)
                 requires emplace_constructible<T, decltype(il), Args...>
             {
                 return emplace<T, decltype(il), Args...>(il, cpp_forward(args)...);
diff --git a/include/stdsharp/memory/pointer_traits.h b/include/stdsharp/memory/pointer_traits.h
index 62bc9632..ba6b07ff 100644
--- a/include/stdsharp/memory/pointer_traits.h
+++ b/include/stdsharp/memory/pointer_traits.h
@@ -10,10 +10,10 @@
 namespace stdsharp
 {
     template<typename Ptr>
-    struct pointer_traits : private ::std::pointer_traits<Ptr>
+    struct pointer_traits : private std::pointer_traits<Ptr>
     {
     private:
-        using base = ::std::pointer_traits<Ptr>;
+        using base = std::pointer_traits<Ptr>;
 
     public:
         using typename base::pointer;
@@ -25,18 +25,18 @@ namespace stdsharp
         template<typename U>
         using rebind = base::template rebind<U>;
 
-        using reference = ::std::add_lvalue_reference_t<element_type>;
+        using reference = std::add_lvalue_reference_t<element_type>;
 
         using raw_pointer = element_type*;
 
     private:
         struct base_pointer_to
         {
-            template<::std::same_as<reference> T>
+            template<std::same_as<reference> T>
                 requires requires(T t) //
             {
                 requires(
-                    requires { Ptr::pointer_to(t); } || requires { ::std::addressof(t); }
+                    requires { Ptr::pointer_to(t); } || requires { std::addressof(t); }
                 );
             }
             constexpr pointer operator()(T t) const noexcept
@@ -50,7 +50,7 @@ namespace stdsharp
             constexpr pointer operator()(auto& r) const noexcept
                 requires nothrow_explicitly_convertible<raw_pointer, pointer>
             {
-                return auto_cast(::std::addressof(r));
+                return auto_cast(std::addressof(r));
             }
         };
 
@@ -61,9 +61,9 @@ namespace stdsharp
         struct base_to_address
         {
             constexpr auto operator()(const pointer& p) const noexcept
-                requires requires { ::std::to_address(p); }
+                requires requires { std::to_address(p); }
             {
-                return ::std::to_address(p);
+                return std::to_address(p);
             }
         };
 
@@ -87,7 +87,7 @@ namespace stdsharp
 
         struct dereference_to_pointer
         {
-            template<::std::same_as<raw_pointer> T = raw_pointer>
+            template<std::same_as<raw_pointer> T = raw_pointer>
                 requires requires(const T p) { pointer_to(*p); }
             constexpr pointer operator()(const T p) const noexcept
             {
@@ -114,20 +114,20 @@ namespace stdsharp
     public:
         static constexpr void pointer_to() = delete;
 
-        static constexpr auto pointer_to(::std::same_as<element_type> auto& r) noexcept
-            requires ::std::invocable<pointer_to_fn, reference>
+        static constexpr auto pointer_to(std::same_as<element_type> auto& r) noexcept
+            requires std::invocable<pointer_to_fn, reference>
         {
             return pointer_to_impl(r);
         }
 
         static constexpr auto to_address(const pointer& p) noexcept
-            requires ::std::invocable<to_address_fn, const pointer&>
+            requires std::invocable<to_address_fn, const pointer&>
         {
             return to_address_impl(p);
         }
 
         static constexpr auto to_pointer(const raw_pointer p) noexcept // NOLINT(*-misplaced-const)
-            requires ::std::invocable<to_pointer_fn, const raw_pointer>
+            requires std::invocable<to_pointer_fn, const raw_pointer>
         {
             return to_pointer_impl(p);
         }
@@ -141,7 +141,7 @@ namespace stdsharp
         {
             using traits = pointer_traits<T>;
             using ret =
-                ::std::conditional_t<const_<typename traits::element_type>, const void*, void*>;
+                std::conditional_t<const_<typename traits::element_type>, const void*, void*>;
 
             return static_cast<ret>(traits::to_address(ptr));
         }
@@ -155,7 +155,7 @@ namespace stdsharp
             requires requires { pointer_traits<Pointer>{}; }
         struct traits
         {
-            using ptr = ::std::
+            using ptr = std::
                 conditional_t<const_<typename pointer_traits<Pointer>::element_type>, const T*, T*>;
         };
 
@@ -164,7 +164,7 @@ namespace stdsharp
             requires requires //
         {
             traits<Pointer>{};
-            requires ::std::invocable<to_void_pointer_fn, const Pointer&>;
+            requires std::invocable<to_void_pointer_fn, const Pointer&>;
             requires !explicitly_convertible<Pointer, typename traits<Pointer>::ptr>;
         }
         STDSHARP_INTRINSIC [[nodiscard]] constexpr auto operator()(const Pointer& p) const noexcept
diff --git a/include/stdsharp/memory/small_object_optimization.h b/include/stdsharp/memory/small_object_optimization.h
index 74bbbc78..555f1c33 100644
--- a/include/stdsharp/memory/small_object_optimization.h
+++ b/include/stdsharp/memory/small_object_optimization.h
@@ -8,10 +8,10 @@ namespace stdsharp
     {
         template<typename Alloc>
         concept soo_alloc =
-            allocator_req<Alloc> && ::std::same_as<typename Alloc::value_type, all_aligned>;
+            allocator_req<Alloc> && std::same_as<typename Alloc::value_type, all_aligned>;
 
         template<
-            ::std::size_t Size,
+            std::size_t Size,
             typename Allocator,
             typename Base = composed_allocator<
                 static_allocator_for<all_aligned, Size>,
@@ -32,20 +32,20 @@ namespace stdsharp
             };
 
             template<typename... Args>
-                requires ::std::constructible_from<Allocator, Args...>
+                requires std::constructible_from<Allocator, Args...>
             constexpr soo_allocator(
                 static_memory_resource<Size>& resource,
                 Args&&... args
             ) noexcept(nothrow_constructible_from<Allocator, Args...>):
                 Base(
                     static_allocator_for<all_aligned, Size>{resource},
-                    Allocator{::std::forward<Args>(args)...}
+                    Allocator{std::forward<Args>(args)...}
                 )
             {
             }
 
             constexpr soo_allocator() noexcept(nothrow_constructible_from<Allocator>)
-                requires ::std::constructible_from<Allocator>
+                requires std::constructible_from<Allocator>
                 : soo_allocator(get_static_memory_resource<Size>())
             {
             }
@@ -53,23 +53,23 @@ namespace stdsharp
     }
 
     template<
-        ::std::size_t Size = 1,
-        details::soo_alloc Allocator = ::std::allocator<all_aligned> // clang-format off
+        std::size_t Size = 1,
+        details::soo_alloc Allocator = std::allocator<all_aligned> // clang-format off
     > // clang-format on
     using soo_allocator = details::soo_allocator<Size, Allocator>;
 
     template<
         typename T,
-        ::std::size_t Size = 1,
-        details::soo_alloc Allocator = ::std::allocator<all_aligned>>
+        std::size_t Size = 1,
+        details::soo_alloc Allocator = std::allocator<all_aligned>>
     using soo_allocation_for = obj_allocation_for<T, soo_allocator<Size, Allocator>>;
 
-    template<::std::size_t Size = 1, details::soo_alloc Allocator = ::std::allocator<all_aligned>>
+    template<std::size_t Size = 1, details::soo_alloc Allocator = std::allocator<all_aligned>>
     using trivial_soo_allocation = trivial_obj_allocation<soo_allocator<Size, Allocator>>;
 
-    template<::std::size_t Size = 1, details::soo_alloc Allocator = ::std::allocator<all_aligned>>
+    template<std::size_t Size = 1, details::soo_alloc Allocator = std::allocator<all_aligned>>
     using normal_soo_allocation = normal_obj_allocation<soo_allocator<Size, Allocator>>;
 
-    template<::std::size_t Size = 1, details::soo_alloc Allocator = ::std::allocator<all_aligned>>
+    template<std::size_t Size = 1, details::soo_alloc Allocator = std::allocator<all_aligned>>
     using unique_soo_allocation = unique_obj_allocation<soo_allocator<Size, Allocator>>;
 }
\ No newline at end of file
diff --git a/include/stdsharp/memory/static_allocator.h b/include/stdsharp/memory/static_allocator.h
index 24b55504..29cb9fda 100644
--- a/include/stdsharp/memory/static_allocator.h
+++ b/include/stdsharp/memory/static_allocator.h
@@ -6,14 +6,14 @@
 
 namespace stdsharp
 {
-    template<typename T, ::std::size_t ResourceSize>
+    template<typename T, std::size_t ResourceSize>
     class static_allocator
     {
     public:
         using value_type = T;
-        using propagate_on_container_move_assignment = ::std::true_type;
-        using propagate_on_container_copy_assignment = ::std::true_type;
-        using propagate_on_container_swap = ::std::true_type;
+        using propagate_on_container_move_assignment = std::true_type;
+        using propagate_on_container_copy_assignment = std::true_type;
+        using propagate_on_container_swap = std::true_type;
 
         static constexpr auto size = ResourceSize;
 
@@ -33,17 +33,17 @@ namespace stdsharp
         {
         }
 
-        [[nodiscard]] constexpr T* allocate(const ::std::size_t required_size)
+        [[nodiscard]] constexpr T* allocate(const std::size_t required_size)
         {
             return pointer_cast<T>(resource().allocate(to_generic_size(required_size)));
         }
 
-        [[nodiscard]] constexpr T* try_allocate(const ::std::size_t required_size)
+        [[nodiscard]] constexpr T* try_allocate(const std::size_t required_size)
         {
             return pointer_cast<T>(resource().try_allocate(to_generic_size(required_size)));
         }
 
-        constexpr void deallocate(T* const ptr, const ::std::size_t required_size) noexcept
+        constexpr void deallocate(T* const ptr, const std::size_t required_size) noexcept
         {
             if(ptr == nullptr) return;
             resource().deallocate(pointer_cast<all_aligned>(ptr), to_generic_size(required_size));
@@ -62,18 +62,18 @@ namespace stdsharp
         }
 
     private:
-        ::std::reference_wrapper<resource_type> src_;
+        std::reference_wrapper<resource_type> src_;
 
-        static constexpr auto to_generic_size(const ::std::size_t size_v)
+        static constexpr auto to_generic_size(const std::size_t size_v)
         {
             return ceil_reminder(size_v * sizeof(T), sizeof(all_aligned));
         }
     };
 
-    template<::std::size_t Size>
+    template<std::size_t Size>
     static_allocator(static_memory_resource<Size>&) -> static_allocator<all_aligned, Size>;
 
-    template<typename T, ::std::size_t Size>
+    template<typename T, std::size_t Size>
     using static_allocator_for =
         static_allocator<T, ceil_reminder(Size * sizeof(T), sizeof(all_aligned))>;
 }
\ No newline at end of file
diff --git a/include/stdsharp/memory/static_memory_resource.h b/include/stdsharp/memory/static_memory_resource.h
index 77ddc456..bf21060e 100644
--- a/include/stdsharp/memory/static_memory_resource.h
+++ b/include/stdsharp/memory/static_memory_resource.h
@@ -15,10 +15,10 @@ namespace stdsharp
     union all_aligned
     {
     private:
-        ::std::max_align_t v;
+        std::max_align_t v;
     };
 
-    template<::std::size_t Size>
+    template<std::size_t Size>
     class static_memory_resource
     {
     public:
@@ -26,9 +26,9 @@ namespace stdsharp
 
         using value_t = all_aligned;
 
-        using states_t = ::std::array<bool, size>;
+        using states_t = std::array<bool, size>;
 
-        using storage_t = ::std::array<all_aligned, size>;
+        using storage_t = std::array<all_aligned, size>;
 
         static_memory_resource() = default;
 
@@ -46,37 +46,36 @@ namespace stdsharp
 
         ~static_memory_resource() = default;
 
-        [[nodiscard]] constexpr all_aligned* allocate(const ::std::size_t required_size)
+        [[nodiscard]] constexpr all_aligned* allocate(const std::size_t required_size)
         {
             const auto ptr = try_allocate(required_size);
 
-            return (ptr == nullptr && required_size != 0) ? throw ::std::bad_alloc{} : ptr;
+            return (ptr == nullptr && required_size != 0) ? throw std::bad_alloc{} : ptr;
         }
 
-        [[nodiscard]] constexpr all_aligned* try_allocate(const ::std::size_t required_size)
+        [[nodiscard]] constexpr all_aligned* try_allocate(const std::size_t required_size)
         {
             if(required_size == 0) return nullptr;
 
-            const auto found = ::std::ranges::search_n(state_, auto_cast(required_size), false);
+            const auto found = std::ranges::search_n(state_, auto_cast(required_size), false);
 
             if(found.empty()) return nullptr;
 
-            ::std::ranges::fill(found, true);
-            return ::std::ranges::next(
+            std::ranges::fill(found, true);
+            return std::ranges::next(
                 storage_.data(),
-                ::std::ranges::distance(state_.cbegin(), found.begin())
+                std::ranges::distance(state_.cbegin(), found.begin())
             );
         }
 
-        constexpr void
-            deallocate(all_aligned* const ptr, const ::std::size_t required_size) noexcept
+        constexpr void deallocate(all_aligned* const ptr, const std::size_t required_size) noexcept
         {
             if(ptr == nullptr) return;
-            precondition<::std::out_of_range>(
+            precondition<std::out_of_range>(
                 [ptr, this] { return contains(ptr); },
                 "pointer does not belong to this resource"
             );
-            ::std::ranges::fill_n(map_state(ptr), auto_cast(required_size), false);
+            std::ranges::fill_n(map_state(ptr), auto_cast(required_size), false);
         }
 
         constexpr void release() noexcept { state_ = {}; }
@@ -87,17 +86,17 @@ namespace stdsharp
 
         [[nodiscard]] constexpr auto used() const noexcept
         {
-            return ::std::ranges::count(state_, true);
+            return std::ranges::count(state_, true);
         }
 
         [[nodiscard]] constexpr auto remaining() const noexcept { return size - used(); }
 
         [[nodiscard]] constexpr auto contains(const void* const ptr) noexcept
         {
-            return ::std::is_constant_evaluated() ? //
+            return std::is_constant_evaluated() ? //
                 constexpr_map_state_impl(ptr) < size :
-                (ptr >= ::std::to_address(storage_.cbegin())) &&
-                    (ptr < ::std::to_address(storage_.cend()));
+                (ptr >= std::to_address(storage_.cbegin())) &&
+                    (ptr < std::to_address(storage_.cend()));
         }
 
         [[nodiscard]] constexpr bool operator==(const static_memory_resource& other) const noexcept
@@ -110,19 +109,19 @@ namespace stdsharp
         {
             const auto diff = [&, this]
             {
-                return ::std::is_constant_evaluated() ? //
+                return std::is_constant_evaluated() ? //
                     constexpr_map_state_impl(ptr) :
                     ptr - storage_.data();
             }();
 
-            return state_.begin() + ::std::ranges::min(diff, static_cast<decltype(diff)>(size));
+            return state_.begin() + std::ranges::min(diff, static_cast<decltype(diff)>(size));
         }
 
         [[nodiscard]] constexpr auto constexpr_map_state_impl(const void* const ptr) noexcept
         {
             const auto data = storage_.data();
-            const auto ptr_view = ::std::views::iota(data, ::std::ranges::next(data, size));
-            return ::std::ranges::find(ptr_view, ptr) - ptr_view.begin();
+            const auto ptr_view = std::views::iota(data, std::ranges::next(data, size));
+            return std::ranges::find(ptr_view, ptr) - ptr_view.begin();
         }
 
         storage_t storage_{};
@@ -130,11 +129,11 @@ namespace stdsharp
         states_t state_{};
     };
 
-    template<typename T, ::std::size_t Size>
+    template<typename T, std::size_t Size>
     using static_memory_resource_for =
         static_memory_resource<ceil_reminder(Size * sizeof(T), sizeof(all_aligned))>;
 
-    template<::std::size_t Size>
+    template<std::size_t Size>
     constexpr auto& get_static_memory_resource() noexcept
     {
 #ifdef _MSC_VER
diff --git a/include/stdsharp/mutex/mutex.h b/include/stdsharp/mutex/mutex.h
index c3e62165..44a62be6 100644
--- a/include/stdsharp/mutex/mutex.h
+++ b/include/stdsharp/mutex/mutex.h
@@ -3,7 +3,7 @@
 #include <mutex>
 #include <concepts>
 
-using namespace ::std::literals;
+using namespace std::literals;
 
 namespace stdsharp
 {
@@ -18,15 +18,15 @@ namespace stdsharp
     concept lockable = basic_lockable<T> &&
         requires(T t) //
     { // clang-format off
-        { t.try_lock() } -> ::std::same_as<bool>; // clang-format on
+        { t.try_lock() } -> std::same_as<bool>; // clang-format on
     };
 
     template<typename T>
     concept timed_lockable = lockable<T> &&
         requires(T t) //
     { // clang-format off
-        { t.try_lock_for(1s) } -> ::std::same_as<bool>;
-        { t.try_lock_until(std::chrono::system_clock::now()) } -> ::std::same_as<bool>; // clang-format on
+        { t.try_lock_for(1s) } -> std::same_as<bool>;
+        { t.try_lock_until(std::chrono::system_clock::now()) } -> std::same_as<bool>; // clang-format on
     };
 
     template<typename T>
@@ -34,23 +34,23 @@ namespace stdsharp
     {
         t.lock_shared();
         t.unlock_shared(); // clang-format off
-        { t.try_lock_shared() } -> ::std::same_as<bool>; // clang-format on
+        { t.try_lock_shared() } -> std::same_as<bool>; // clang-format on
     };
 
     template<typename T>
     concept shared_timed_lockable = shared_lockable<T> &&
         requires(T t) //
     { // clang-format off
-        { t.try_lock_shared_for(1s) } -> ::std::same_as<bool>;
-        { t.try_lock_shared_until(std::chrono::system_clock::now()) } -> ::std::same_as<bool>; // clang-format on
+        { t.try_lock_shared_for(1s) } -> std::same_as<bool>;
+        { t.try_lock_shared_until(std::chrono::system_clock::now()) } -> std::same_as<bool>; // clang-format on
     };
 
     template<typename T>
-    concept mutex = lockable<T> && !::std::movable<T> && ::std::default_initializable<T> &&
+    concept mutex = lockable<T> && !std::movable<T> && std::default_initializable<T> &&
         requires(T t) //
     { // clang-format off
-        { t.lock() } -> ::std::same_as<void>;
-        { t.unlock() } -> ::std::same_as<void>; // clang-format on
+        { t.lock() } -> std::same_as<void>;
+        { t.unlock() } -> std::same_as<void>; // clang-format on
     };
 
     template<typename T>
@@ -61,8 +61,8 @@ namespace stdsharp
         requires(T t) //
     {
         t.try_unlock_shared(); // clang-format off
-        { t.lock_shared() } -> ::std::same_as<void>;
-        { t.unlock_shared() } -> ::std::same_as<void>; // clang-format on
+        { t.lock_shared() } -> std::same_as<void>;
+        { t.unlock_shared() } -> std::same_as<void>; // clang-format on
     };
 
     template<typename T>
diff --git a/include/stdsharp/namespace_alias.h b/include/stdsharp/namespace_alias.h
new file mode 100644
index 00000000..c0ae2889
--- /dev/null
+++ b/include/stdsharp/namespace_alias.h
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace std
+{
+}
+
+namespace stdsharp
+{
+    namespace std = std;
+}
\ No newline at end of file
diff --git a/include/stdsharp/pattern_match.h b/include/stdsharp/pattern_match.h
index 119ab365..3d70ea14 100644
--- a/include/stdsharp/pattern_match.h
+++ b/include/stdsharp/pattern_match.h
@@ -8,25 +8,25 @@ namespace stdsharp
     {
         template<
             typename Condition,
-            ::std::predicate<const Condition&>... Predicate,
-            ::std::invocable<const Condition&>... Func // clang-format off
+            std::predicate<const Condition&>... Predicate,
+            std::invocable<const Condition&>... Func // clang-format off
         > // clang-format on
         constexpr void operator()(
             const Condition& condition,
-            ::std::pair<Predicate, Func>... cases //
+            std::pair<Predicate, Func>... cases //
         ) const
             noexcept((
                 (nothrow_predicate<Predicate, Condition> && nothrow_invocable<Func, Condition>)&&...
             ))
         {
             (
-                [&condition](::std::pair<Predicate, Func>&& pair)
+                [&condition](std::pair<Predicate, Func>&& pair)
                 {
                     auto&& [first, second] = cpp_move(pair);
 
-                    if(::std::invoke(cpp_move(first), condition))
+                    if(std::invoke(cpp_move(first), condition))
                     {
-                        ::std::invoke(cpp_move(second), condition);
+                        std::invoke(cpp_move(second), condition);
                         return true;
                     }
                     return false;
@@ -37,17 +37,17 @@ namespace stdsharp
 
         template<
             typename Condition,
-            ::std::invocable<const Condition>... Func // clang-format off
+            std::invocable<const Condition>... Func // clang-format off
         > // clang-format on
         constexpr void operator()(
             const Condition& condition,
-            ::std::pair<Condition, Func>... cases //
+            std::pair<Condition, Func>... cases //
         ) const noexcept((nothrow_invocable<Func, Condition> && ...))
         {
             (*this)(
                 condition,
                 make_pair(
-                    ::std::bind_front(equal_to_v, cpp_move(cases.first)),
+                    std::bind_front(equal_to_v, cpp_move(cases.first)),
                     cpp_move(cases.second)
                 )...
             );
@@ -64,7 +64,7 @@ namespace stdsharp
             private:
                 template<typename Case>
                 static constexpr bool case_nothrow_invocable_ =
-                    logical_imply(::std::invocable<Case, T>, nothrow_invocable<Case, T>);
+                    logical_imply(std::invocable<Case, T>, nothrow_invocable<Case, T>);
 
             public:
                 template<typename... Cases>
@@ -74,9 +74,9 @@ namespace stdsharp
                     (
                         []([[maybe_unused]] Cases&& c) noexcept(case_nothrow_invocable_<Cases>)
                         {
-                            if constexpr(::std::invocable<Cases, T>)
+                            if constexpr(std::invocable<Cases, T>)
                             {
-                                ::std::invoke(cpp_forward(c), T{});
+                                std::invoke(cpp_forward(c), T{});
                                 return true;
                             }
                             else return false;
@@ -88,7 +88,7 @@ namespace stdsharp
         }
 
         template<typename ConditionT>
-        using from_type_fn = details::impl<::std::type_identity<ConditionT>>;
+        using from_type_fn = details::impl<std::type_identity<ConditionT>>;
 
         template<auto Condition>
         using from_constant_fn = details::impl<constant<Condition>>;
diff --git a/include/stdsharp/random/random.h b/include/stdsharp/random/random.h
index 90d48b8d..5f20a302 100644
--- a/include/stdsharp/random/random.h
+++ b/include/stdsharp/random/random.h
@@ -9,7 +9,7 @@ namespace stdsharp
     {
         [[nodiscard]] auto& operator()() const
         {
-            thread_local ::std::random_device random_device;
+            thread_local std::random_device random_device;
             return random_device;
         }
     } get_random_device{};
diff --git a/include/stdsharp/ranges/ranges.h b/include/stdsharp/ranges/ranges.h
index b3b57722..f698c7d8 100644
--- a/include/stdsharp/ranges/ranges.h
+++ b/include/stdsharp/ranges/ranges.h
@@ -17,29 +17,29 @@ namespace stdsharp
     template<typename T>
     using const_iterator_t =
 #if __cpp_lib_ranges_as_const >= 202207L
-        ::std::ranges::const_iterator_t<T>;
+        std::ranges::const_iterator_t<T>;
 #else
-        decltype(::std::ranges::cbegin(::std::declval<T&>()));
+        decltype(std::ranges::cbegin(std::declval<T&>()));
 #endif
 
     template<typename T>
     using const_sentinel_t =
 #if __cpp_lib_ranges_as_const >= 202207L
-        ::std::ranges::const_sentinel_t<T>;
+        std::ranges::const_sentinel_t<T>;
 #else
-        decltype(::std::ranges::cend(::std::declval<T&>()));
+        decltype(std::ranges::cend(std::declval<T&>()));
 #endif
 
     template<typename T>
     using range_const_reference_t =
 #if __cpp_lib_ranges_as_const >= 202207L
-        ::std::ranges::range_const_reference_t<T>;
+        std::ranges::range_const_reference_t<T>;
 #else
-        iter_const_reference_t<::std::ranges::iterator_t<T>>;
+        iter_const_reference_t<std::ranges::iterator_t<T>>;
 #endif
 
     template<typename T>
-    using forwarding_views = ::std::ranges::transform_view<T, forward_like_fn<T>>;
+    using forwarding_views = std::ranges::transform_view<T, forward_like_fn<T>>;
 
     namespace views
     {
diff --git a/include/stdsharp/reflection/reflection.h b/include/stdsharp/reflection/reflection.h
index 53a31aee..a81c30e0 100644
--- a/include/stdsharp/reflection/reflection.h
+++ b/include/stdsharp/reflection/reflection.h
@@ -26,7 +26,7 @@ namespace stdsharp::reflection
         struct data_meta_getter : member_pointer_traits<Ptr>
         {
             template<typename T>
-                requires ::std::invocable<cast_fwd_fn<Reflected>, T>
+                requires std::invocable<cast_fwd_fn<Reflected>, T>
             constexpr decltype(auto) operator()(T&& t) const
                 noexcept(nothrow_invocable<cast_fwd_fn<Reflected>, T>)
             {
@@ -41,9 +41,9 @@ namespace stdsharp::reflection
         struct meta_set<meta_base<Name, Getter>...> : indexed_types<meta_base<Name, Getter>...>
         {
             template<decltype(auto) N>
-                requires(::std::ranges::equal(N, Name) || ...)
-            using member_of_t = ::std::invoke_result_t< //
-                invocables<meta_base<Name, Getter> (*)(constant<::std::ranges::equal(N, Name)>)...>,
+                requires(std::ranges::equal(N, Name) || ...)
+            using member_of_t = std::invoke_result_t< //
+                invocables<meta_base<Name, Getter> (*)(constant<std::ranges::equal(N, Name)>)...>,
                 constant<true> // clang-format off
             >; // clang-format on
 
@@ -71,20 +71,20 @@ namespace stdsharp::reflection
     };
 
     template<typename Reflected>
-    inline constexpr ::std::conditional_t<dependent_false<Reflected>(), int, void> function;
+    inline constexpr std::conditional_t<dependent_false<Reflected>(), int, void> function;
 
     template<typename Reflected>
     using function_t = decltype(function<Reflected>);
 
     template<typename Reflected>
-    inline constexpr ::std::conditional_t<dependent_false<Reflected>(), int, void> data;
+    inline constexpr std::conditional_t<dependent_false<Reflected>(), int, void> data;
 
     template<typename Reflected>
     using data_t = decltype(data<Reflected>);
 
     template<typename T, typename U>
-    inline constexpr auto data<::std::pair<T, U>> =
-        member<::std::pair<T, U>>::template data_reflect<"first"_ltr, "second"_ltr>(
-            regular_value_sequence<&::std::pair<T, U>::first, &::std::pair<T, U>::second>{}
+    inline constexpr auto data<std::pair<T, U>> =
+        member<std::pair<T, U>>::template data_reflect<"first"_ltr, "second"_ltr>(
+            regular_value_sequence<&std::pair<T, U>::first, &std::pair<T, U>::second>{}
         );
 }
\ No newline at end of file
diff --git a/include/stdsharp/scope.h b/include/stdsharp/scope.h
index 0a68de77..93f3b257 100644
--- a/include/stdsharp/scope.h
+++ b/include/stdsharp/scope.h
@@ -16,13 +16,13 @@ namespace stdsharp::scope
 
     template<flag<exit_fn_policy> Policy, nothrow_invocable Fn>
     struct [[nodiscard]] scoped : // NOLINT(*-special-member-functions)
-        private ::std::optional<Fn>,
+        private std::optional<Fn>,
         unique_object
     {
     private:
         constexpr void execute() noexcept
         {
-            ::std::invoke(cpp_move(this->value()));
+            std::invoke(cpp_move(this->value()));
             this->reset();
         };
 
@@ -30,9 +30,9 @@ namespace stdsharp::scope
         using exit_fn_t = Fn;
 
         template<typename... Args>
-            requires ::std::constructible_from<Fn, Args...>
+            requires std::constructible_from<Fn, Args...>
         constexpr explicit scoped(Args&&... args) noexcept(nothrow_constructible_from<Fn, Args...>):
-            ::std::optional<Fn>(::std::in_place, cpp_forward(args)...)
+            std::optional<Fn>(std::in_place, cpp_forward(args)...)
         {
         }
 
@@ -43,7 +43,7 @@ namespace stdsharp::scope
             if(!this->has_value()) return;
 
             if constexpr(policy == exit_fn_policy::on_exit) execute();
-            else if(::std::is_constant_evaluated() || ::std::uncaught_exceptions() == 0)
+            else if(std::is_constant_evaluated() || std::uncaught_exceptions() == 0)
             {
                 if constexpr(policy.contains(exit_fn_policy::on_success)) execute();
             }
@@ -59,11 +59,11 @@ namespace stdsharp::scope
     {
     private:
         template<typename Fn>
-        using scoped_t = scoped<Policy, ::std::decay_t<Fn>>;
+        using scoped_t = scoped<Policy, std::decay_t<Fn>>;
 
     public:
         template<typename Fn>
-            requires ::std::constructible_from<scoped_t<Fn>, Fn>
+            requires std::constructible_from<scoped_t<Fn>, Fn>
         constexpr scoped_t<Fn> operator()(Fn&& fn) const
             noexcept(nothrow_constructible_from<scoped_t<Fn>, Fn>)
         {
diff --git a/include/stdsharp/type_traits/indexed_traits.h b/include/stdsharp/type_traits/indexed_traits.h
index 5704c365..c769f4cd 100644
--- a/include/stdsharp/type_traits/indexed_traits.h
+++ b/include/stdsharp/type_traits/indexed_traits.h
@@ -6,7 +6,7 @@
 
 namespace stdsharp
 {
-    template<typename T, ::std::size_t I>
+    template<typename T, std::size_t I>
     struct basic_indexed_type : type_constant<T>
     {
         static constexpr type_constant<T> get_type(const index_constant<I>) noexcept { return {}; }
@@ -17,7 +17,7 @@ namespace stdsharp
         }
     };
 
-    template<::std::size_t Index, typename T>
+    template<std::size_t Index, typename T>
     [[nodiscard]] constexpr auto get_type(const basic_indexed_type<T, Index>& v) //
         noexcept
     {
@@ -26,7 +26,7 @@ namespace stdsharp
 
     namespace details
     {
-        template<typename T, ::std::size_t I>
+        template<typename T, std::size_t I>
         struct indexed_type
         {
             struct type : basic_indexed_type<T, I>
@@ -35,30 +35,30 @@ namespace stdsharp
         };
     }
 
-    template<typename T, ::std::size_t I>
+    template<typename T, std::size_t I>
     using indexed_type = ::meta::_t<details::indexed_type<T, I>>;
 
-    template<::std::size_t I>
+    template<std::size_t I>
     struct make_indexed_type_fn
     {
         template<typename T>
-        [[nodiscard]] constexpr indexed_type<T, I> operator()(const ::std::type_identity<T>) //
+        [[nodiscard]] constexpr indexed_type<T, I> operator()(const std::type_identity<T>) //
             noexcept
         {
             return {};
         }
     };
 
-    template<::std::size_t I>
+    template<std::size_t I>
     inline constexpr make_indexed_type_fn<I> make_indexed_type{};
 
-    template<typename T, ::std::size_t I>
+    template<typename T, std::size_t I>
     struct STDSHARP_EBO basic_indexed_value : value_wrapper<T>, indexed_type<T, I>
     {
         using value_wrapper<T>::value_wrapper;
 
 #define STDSHARP_GET(const_, ref)                                                               \
-    template<::std::size_t Index>                                                               \
+    template<std::size_t Index>                                                                 \
     [[nodiscard]] constexpr decltype(auto) get(const index_constant<Index>) const_ ref noexcept \
     {                                                                                           \
         return static_cast<const_ T ref>(this->v);                                              \
@@ -73,7 +73,7 @@ namespace stdsharp
     };
 
 #define STDSHARP_GET(const_, ref_)                                                         \
-    template<::std::size_t Index, typename T>                                              \
+    template<std::size_t Index, typename T>                                                \
     [[nodiscard]] constexpr decltype(auto) get(const_ basic_indexed_value<T, Index> ref_ v \
     ) noexcept                                                                             \
     {                                                                                      \
@@ -89,7 +89,7 @@ namespace stdsharp
 
     namespace details
     {
-        template<typename T, ::std::size_t I>
+        template<typename T, std::size_t I>
         struct indexed_value
         {
             struct type : basic_indexed_value<T, I>
@@ -99,22 +99,22 @@ namespace stdsharp
         };
     }
 
-    template<typename T, ::std::size_t I>
+    template<typename T, std::size_t I>
     using indexed_value = ::meta::_t<details::indexed_value<T, I>>;
 
-    template<::std::size_t I>
+    template<std::size_t I>
     struct make_indexed_value_fn
     {
         template<typename T>
-            requires ::std::constructible_from<indexed_value<::std::decay_t<T>, I>, T>
-        [[nodiscard]] constexpr indexed_value<::std::decay_t<T>, I> operator()(T&& t) //
-            noexcept(nothrow_constructible_from<indexed_value<::std::decay_t<T>, I>, T>)
+            requires std::constructible_from<indexed_value<std::decay_t<T>, I>, T>
+        [[nodiscard]] constexpr indexed_value<std::decay_t<T>, I> operator()(T&& t) //
+            noexcept(nothrow_constructible_from<indexed_value<std::decay_t<T>, I>, T>)
         {
             return cpp_forward(t);
         }
     };
 
-    template<::std::size_t I>
+    template<std::size_t I>
     inline constexpr make_indexed_value_fn<I> make_indexed_value{};
 
     namespace details
@@ -125,7 +125,7 @@ namespace stdsharp
             template<typename = index_sequence_for<T...>>
             struct base;
 
-            template<::std::size_t... I>
+            template<std::size_t... I>
             struct STDSHARP_EBO base<regular_value_sequence<I...>> :
                 stdsharp::indexed_type<T, I>...,
                 regular_type_sequence<T...>
@@ -135,7 +135,7 @@ namespace stdsharp
                 template<typename... U>
                 constexpr base(U&&... u) //
                     noexcept((nothrow_constructible_from<stdsharp::indexed_type<T, I>, U> && ...))
-                    requires(::std::constructible_from<stdsharp::indexed_type<T, I>, U> && ...)
+                    requires(std::constructible_from<stdsharp::indexed_type<T, I>, U> && ...)
                     : stdsharp::indexed_type<T, I>(cpp_forward(u))...
                 {
                 }
@@ -145,7 +145,7 @@ namespace stdsharp
 
             struct impl : base<>
             {
-                template<::std::size_t J>
+                template<std::size_t J>
                 using get_t = ::meta::_t<decltype(get_type<J>(base{}))>;
             };
         };
@@ -157,7 +157,7 @@ namespace stdsharp
     };
 
     template<typename... T>
-    basic_indexed_types(::std::type_identity<T>...) -> basic_indexed_types<T...>;
+    basic_indexed_types(std::type_identity<T>...) -> basic_indexed_types<T...>;
 
     template<typename... T>
     using indexed_types = adl_proof_t<basic_indexed_types, T...>;
@@ -166,9 +166,7 @@ namespace stdsharp
         requires requires //
     {
         requires(
-            ::std::convertible_to<
-                template_rebind<::std::decay_t<T>, void>,
-                ::std::type_identity<void>> &&
+            std::convertible_to<template_rebind<std::decay_t<T>, void>, std::type_identity<void>> &&
             ...
         );
     }
@@ -187,7 +185,7 @@ namespace stdsharp
             template<typename = index_sequence_for<T...>>
             struct impl;
 
-            template<::std::size_t... I>
+            template<std::size_t... I>
             struct STDSHARP_EBO impl<regular_value_sequence<I...>> :
                 stdsharp::indexed_value<T, I>...,
                 stdsharp::indexed_types<T...>
@@ -195,7 +193,7 @@ namespace stdsharp
                 impl() = default;
 
                 template<typename... U>
-                    requires(::std::constructible_from<stdsharp::indexed_value<T, I>, U> && ...)
+                    requires(std::constructible_from<stdsharp::indexed_value<T, I>, U> && ...)
                 constexpr impl(U&&... u) //
                     noexcept((nothrow_constructible_from<stdsharp::indexed_value<T, I>, U> && ...)):
                     stdsharp::indexed_value<T, I>(cpp_forward(u))...
@@ -212,7 +210,7 @@ namespace stdsharp
     };
 
     template<typename... T>
-    basic_indexed_values(T&&...) -> basic_indexed_values<::std::decay_t<T>...>;
+    basic_indexed_values(T&&...) -> basic_indexed_values<std::decay_t<T>...>;
 
     template<typename... T>
     using indexed_values = adl_proof_t<basic_indexed_values, T...>;
@@ -220,39 +218,38 @@ namespace stdsharp
     inline constexpr make_template_type_fn<indexed_values> make_indexed_values{};
 
     template<typename Indexed>
-    using index_sequence_by =
-        ::std::make_index_sequence<::std::tuple_size_v<::std::decay_t<Indexed>>>;
+    using index_sequence_by = std::make_index_sequence<std::tuple_size_v<std::decay_t<Indexed>>>;
 
     inline constexpr struct indexed_apply_fn
     {
     private:
         template<
-            ::std::size_t... I,
+            std::size_t... I,
             typename Indexed,
-            ::std::invocable<get_element_t<I, Indexed>...> Fn>
+            std::invocable<get_element_t<I, Indexed>...> Fn>
         static constexpr decltype(auto) impl(
             Fn&& fn,
             Indexed&& indexed,
-            const ::std::index_sequence<I...> //
+            const std::index_sequence<I...> //
         ) noexcept(nothrow_invocable<Fn, get_element_t<I, Indexed>...>)
         {
-            return ::std::invoke(cpp_forward(fn), cpo::get_element<I>(cpp_forward(indexed))...);
+            return std::invoke(cpp_forward(fn), cpo::get_element<I>(cpp_forward(indexed))...);
         }
 
     public:
         template<typename Indexed, typename Fn>
             requires requires //
-        { impl(::std::declval<Fn>(), ::std::declval<Indexed>(), index_sequence_by<Indexed>{}); }
+        { impl(std::declval<Fn>(), std::declval<Indexed>(), index_sequence_by<Indexed>{}); }
         constexpr decltype(auto) operator()(Fn&& fn, Indexed&& indexed) const noexcept( //
             noexcept( //
-                impl(::std::declval<Fn>(), ::std::declval<Indexed>(), index_sequence_by<Indexed>{})
+                impl(std::declval<Fn>(), std::declval<Indexed>(), index_sequence_by<Indexed>{})
             )
         )
         {
             return impl(
                 cpp_forward(fn),
                 cpp_forward(indexed),
-                ::std::make_index_sequence<::std::tuple_size_v<Indexed>>{}
+                std::make_index_sequence<std::tuple_size_v<Indexed>>{}
             );
         }
     } indexed_apply{};
@@ -260,29 +257,29 @@ namespace stdsharp
 
 namespace std
 {
-    template<::std::size_t I, template<typename...> typename Template, typename... T>
-        requires(::std::same_as<::stdsharp::regular_type_sequence<T...>, Template<T...>> || ::std::same_as<::stdsharp::basic_type_sequence<T...>, Template<T...>>)
+    template<std::size_t I, template<typename...> typename Template, typename... T>
+        requires(std::same_as<stdsharp::regular_type_sequence<T...>, Template<T...>> || std::same_as<stdsharp::basic_type_sequence<T...>, Template<T...>>)
     struct tuple_element<I, Template<T...>>
     {
         using type = Template<T...>::template get_t<I>;
     };
 
     template<template<typename...> typename Template, typename... T>
-        requires(::std::same_as<::stdsharp::regular_type_sequence<T...>, Template<T...>> || ::std::same_as<::stdsharp::basic_type_sequence<T...>, Template<T...>>)
+        requires(std::same_as<stdsharp::regular_type_sequence<T...>, Template<T...>> || std::same_as<stdsharp::basic_type_sequence<T...>, Template<T...>>)
     struct tuple_size<Template<T...>>
     {
         static constexpr auto value = Template<T...>::size();
     };
 
-    template<::std::size_t I, template<auto...> typename Template, auto... V>
-        requires ::std::same_as<::stdsharp::regular_value_sequence<V...>, Template<V...>>
+    template<std::size_t I, template<auto...> typename Template, auto... V>
+        requires std::same_as<stdsharp::regular_value_sequence<V...>, Template<V...>>
     struct tuple_element<I, Template<V...>>
     {
         using type = Template<V...>::template get_t<I>;
     };
 
     template<template<auto...> typename Template, auto... V>
-        requires ::std::same_as<::stdsharp::regular_value_sequence<V...>, Template<V...>>
+        requires std::same_as<stdsharp::regular_value_sequence<V...>, Template<V...>>
     struct tuple_size<Template<V...>>
     {
         static constexpr auto value = Template<V...>::size();
diff --git a/include/stdsharp/type_traits/member.h b/include/stdsharp/type_traits/member.h
index d634e4e7..60755986 100644
--- a/include/stdsharp/type_traits/member.h
+++ b/include/stdsharp/type_traits/member.h
@@ -91,9 +91,9 @@ namespace stdsharp
 #undef STDSHARP_MEMBER_FUNCTION_TRAITS_CONST_PACK
 
     template<typename T, typename ClassT>
-    concept member_of = ::std::same_as<typename member_traits<T>::class_t, ClassT>;
+    concept member_of = std::same_as<typename member_traits<T>::class_t, ClassT>;
 
     template<typename T, typename ClassT>
     concept member_func_of =
-        ::std::is_member_pointer_v<T> && ::std::same_as<typename member_traits<T>::class_t, ClassT>;
+        std::is_member_pointer_v<T> && std::same_as<typename member_traits<T>::class_t, ClassT>;
 }
\ No newline at end of file
diff --git a/include/stdsharp/type_traits/object.h b/include/stdsharp/type_traits/object.h
index 5ed4e5f1..201a4c18 100644
--- a/include/stdsharp/type_traits/object.h
+++ b/include/stdsharp/type_traits/object.h
@@ -31,7 +31,7 @@ namespace stdsharp
         inherited() = default;
 
         template<typename... U>
-            requires ::std::constructible_from<Base, U...> && (::std::constructible_from<T> && ...)
+            requires std::constructible_from<Base, U...> && (std::constructible_from<T> && ...)
         constexpr explicit inherited(U&&... u) noexcept(
             nothrow_constructible_from<Base, U...> &&
             (nothrow_constructible_from<T> && ...) // clang-format off
@@ -42,8 +42,8 @@ namespace stdsharp
         template<typename BaseT, typename... U>
             requires requires //
         {
-            requires ::std::constructible_from<Base, BaseT>;
-            requires(::std::constructible_from<T, U> && ...);
+            requires std::constructible_from<Base, BaseT>;
+            requires(std::constructible_from<T, U> && ...);
         }
         constexpr explicit inherited(BaseT&& base, U&&... u) noexcept(
             nothrow_constructible_from<Base, BaseT> &&
@@ -53,7 +53,7 @@ namespace stdsharp
         }
 
         template<typename U>
-            requires ::std::assignable_from<Base, U>
+            requires std::assignable_from<Base, U>
         constexpr inherited& operator=(U&& u) noexcept(nothrow_assignable_from<Base, U>)
         {
             Base::operator=(cpp_forward(u));
@@ -62,17 +62,17 @@ namespace stdsharp
     };
 
     template<typename... T>
-    inherited(T&&...) -> inherited<::std::decay_t<T>...>;
+    inherited(T&&...) -> inherited<std::decay_t<T>...>;
 
     struct make_inherited_fn
     {
         template<typename Base, typename... U>
             requires requires //
         {
-            inherited{::std::declval<Base>(), ::std::declval<U>()...};
+            inherited{std::declval<Base>(), std::declval<U>()...};
         }
         [[nodiscard]] constexpr auto operator()(Base&& base, U&&... u) const
-            noexcept(noexcept(inherited{::std::declval<Base>(), ::std::declval<U>()...}))
+            noexcept(noexcept(inherited{std::declval<Base>(), std::declval<U>()...}))
         {
             return inherited{cpp_forward(base), cpp_forward(u)...};
         }
diff --git a/include/stdsharp/type_traits/special_member.h b/include/stdsharp/type_traits/special_member.h
index 6a39d1a0..68f9f66c 100644
--- a/include/stdsharp/type_traits/special_member.h
+++ b/include/stdsharp/type_traits/special_member.h
@@ -23,7 +23,7 @@ namespace stdsharp
     private:
         [[nodiscard]] constexpr auto to_rng() const noexcept
         {
-            return ::std::array{
+            return std::array{
                 move_construct,
                 copy_construct,
                 move_assign,
@@ -33,7 +33,7 @@ namespace stdsharp
             };
         }
 
-        [[nodiscard]] friend constexpr ::std::partial_ordering
+        [[nodiscard]] friend constexpr std::partial_ordering
             operator<=>(const special_mem_req left, const special_mem_req right) noexcept
         {
             return strict_compare(left.to_rng(), right.to_rng());
@@ -56,12 +56,12 @@ namespace stdsharp
         min(const special_mem_req left, const special_mem_req right) noexcept
     {
         return {
-            ::std::min(left.move_construct, right.move_construct),
-            ::std::min(left.copy_construct, right.copy_construct),
-            ::std::min(left.move_assign, right.move_assign),
-            ::std::min(left.copy_assign, right.copy_assign),
-            ::std::min(left.destruct, right.destruct),
-            ::std::min(left.swap, right.swap) //
+            std::min(left.move_construct, right.move_construct),
+            std::min(left.copy_construct, right.copy_construct),
+            std::min(left.move_assign, right.move_assign),
+            std::min(left.copy_assign, right.copy_assign),
+            std::min(left.destruct, right.destruct),
+            std::min(left.swap, right.swap) //
         };
     }
 
@@ -69,23 +69,23 @@ namespace stdsharp
         max(const special_mem_req left, const special_mem_req right) noexcept
     {
         return {
-            ::std::max(left.move_construct, right.move_construct),
-            ::std::max(left.copy_construct, right.copy_construct),
-            ::std::max(left.move_assign, right.move_assign),
-            ::std::max(left.copy_assign, right.copy_assign),
-            ::std::max(left.destruct, right.destruct),
-            ::std::max(left.swap, right.swap) //
+            std::max(left.move_construct, right.move_construct),
+            std::max(left.copy_construct, right.copy_construct),
+            std::max(left.move_assign, right.move_assign),
+            std::max(left.copy_assign, right.copy_assign),
+            std::max(left.destruct, right.destruct),
+            std::max(left.swap, right.swap) //
         };
     }
 
     template<typename T>
     inline constexpr special_mem_req special_mem_req::for_type{
-        get_expr_req(::std::move_constructible<T>, nothrow_move_constructible<T>),
-        get_expr_req(::std::copy_constructible<T>, nothrow_copy_constructible<T>),
+        get_expr_req(std::move_constructible<T>, nothrow_move_constructible<T>),
+        get_expr_req(std::copy_constructible<T>, nothrow_copy_constructible<T>),
         get_expr_req(move_assignable<T>, nothrow_move_assignable<T>),
         get_expr_req(copy_assignable<T>, nothrow_copy_assignable<T>),
-        get_expr_req(::std::is_destructible_v<T>, ::std::is_nothrow_destructible_v<T>),
-        get_expr_req(::std::swappable<T>, nothrow_swappable<T>) //
+        get_expr_req(std::is_destructible_v<T>, std::is_nothrow_destructible_v<T>),
+        get_expr_req(std::swappable<T>, nothrow_swappable<T>) //
     };
 
     inline constexpr special_mem_req special_mem_req::trivial{};
diff --git a/include/stdsharp/type_traits/type_sequence.h b/include/stdsharp/type_traits/type_sequence.h
index 4d8506b8..e51acfcd 100644
--- a/include/stdsharp/type_traits/type_sequence.h
+++ b/include/stdsharp/type_traits/type_sequence.h
@@ -15,7 +15,7 @@ namespace stdsharp
             template<typename... T>
             using regular_type_sequence = regular_type_sequence<T...>;
 
-            template<::std::size_t I>
+            template<std::size_t I>
                 requires requires { requires I < Base::size(); }
             [[nodiscard]] friend constexpr decltype(auto) get(const type_sequence) noexcept
             {
@@ -41,16 +41,16 @@ namespace stdsharp
             template<template<typename...> typename T>
             using apply_t = T<Types...>;
 
-            template<::std::size_t I>
+            template<std::size_t I>
             using type = Base::template value_type<I>::type;
 
-            template<::std::size_t... I>
+            template<std::size_t... I>
             using at_t = regular_type_sequence<type<I>...>;
 
-            template<::std::size_t Size>
+            template<std::size_t Size>
             using back_t = convert_from_value_sequence<typename Base::template back_t<Size>>;
 
-            template<::std::size_t Size>
+            template<std::size_t Size>
             using front_t = convert_from_value_sequence<typename Base::template front_t<Size>>;
 
             template<typename... Others>
@@ -65,7 +65,7 @@ namespace stdsharp
             template<typename... Others>
             using append_front_t = regular_type_sequence<Others..., Types...>;
 
-            template<::std::size_t Index, typename... Other>
+            template<std::size_t Index, typename... Other>
             using insert_t = convert_from_value_sequence< //
                 typename Base::template insert_t<
                     Index,
@@ -73,15 +73,15 @@ namespace stdsharp
                 >
             >; // clang-format on
 
-            template<::std::size_t... Index>
+            template<std::size_t... Index>
             using remove_at_t =
                 convert_from_value_sequence<typename Base::template remove_at_t<Index...>>;
 
-            template<::std::size_t Index, typename Other>
+            template<std::size_t Index, typename Other>
             using replace_t = convert_from_value_sequence<
                 typename Base::template replace_t<Index, basic_type_constant<Other>{}>>;
 
-            template<::std::size_t From, ::std::size_t Size>
+            template<std::size_t From, std::size_t Size>
             using select_range_t =
                 convert_from_value_sequence<typename Base::template select_range_t<From, Size>>;
         };
@@ -98,12 +98,12 @@ namespace stdsharp
         []<template<typename...> typename Inner, typename... U>(const Inner<U...>&) //
         {
             return type_sequence<U...>{}; //
-        }(::std::declval<T>())
+        }(std::declval<T>())
     );
 
     template<typename... T>
     using reverse_type_sequence =
-        convert_from_value_sequence<reverse_value_sequence<::std::type_identity<T>{}...>>;
+        convert_from_value_sequence<reverse_value_sequence<std::type_identity<T>{}...>>;
 
     template<typename... T>
     using unique_type_sequence =
@@ -113,13 +113,13 @@ namespace stdsharp
 namespace std
 {
     template<typename Seq>
-        requires same_as<::stdsharp::template_rebind<Seq>, ::stdsharp::type_sequence<>>
-    struct tuple_size<Seq> : ::stdsharp::index_constant<Seq::size()>
+        requires same_as<stdsharp::template_rebind<Seq>, stdsharp::type_sequence<>>
+    struct tuple_size<Seq> : stdsharp::index_constant<Seq::size()>
     {
     };
 
-    template<::std::size_t I, typename Seq>
-        requires same_as<::stdsharp::template_rebind<Seq>, ::stdsharp::type_sequence<>>
+    template<std::size_t I, typename Seq>
+        requires same_as<stdsharp::template_rebind<Seq>, stdsharp::type_sequence<>>
     struct tuple_element<I, Seq>
     {
         using type = Seq::template type<I>;
diff --git a/include/stdsharp/type_traits/value_sequence.h b/include/stdsharp/type_traits/value_sequence.h
index 2252c952..6fa2aeee 100644
--- a/include/stdsharp/type_traits/value_sequence.h
+++ b/include/stdsharp/type_traits/value_sequence.h
@@ -18,14 +18,14 @@ namespace stdsharp
            auto... Values>(const Inner<Values...>) //
         {
             return value_sequence<Values...>{}; //
-        }(::std::declval<T>())
+        }(std::declval<T>())
     );
 
     namespace details
     {
         template<decltype(auto)... Values, typename seq = value_sequence<Values...>>
         consteval to_value_sequence<
-            make_value_sequence_t<seq::size() - 1, seq::size(), ::std::minus{}>>::
+            make_value_sequence_t<seq::size() - 1, seq::size(), std::minus{}>>::
             template apply_t<seq::template at_t>
             get_reverse_value_sequence();
 
@@ -36,11 +36,11 @@ namespace stdsharp
 
             static constexpr auto unique_indices = []
             {
-                ::std::array<::std::size_t, seq::size()> indices{seq::find(Values)...};
+                std::array<std::size_t, seq::size()> indices{seq::find(Values)...};
 
-                ::std::ranges::sort(indices);
+                std::ranges::sort(indices);
 
-                const auto res = ::std::ranges::unique(indices);
+                const auto res = std::ranges::unique(indices);
 
                 if(res) res.front() = seq::size();
 
@@ -48,13 +48,13 @@ namespace stdsharp
             }();
 
             static constexpr auto unique_indices_size =
-                ::std::ranges::find(unique_indices, seq::size()) - unique_indices.cbegin();
+                std::ranges::find(unique_indices, seq::size()) - unique_indices.cbegin();
 
             static constexpr auto unique_indices_value = []
             {
-                ::std::array<::std::size_t, unique_indices_size> value{};
+                std::array<std::size_t, unique_indices_size> value{};
 
-                ::std::ranges::copy_n(unique_indices.cbegin(), value.size(), value.begin());
+                std::ranges::copy_n(unique_indices.cbegin(), value.size(), value.begin());
 
                 return value;
             }();
@@ -75,10 +75,10 @@ namespace stdsharp
             }
 
             template<typename U>
-                requires ::std::predicate<Comp, U, T>
+                requires std::predicate<Comp, U, T>
             constexpr bool operator()(const U& other) const noexcept(nothrow_predicate<Comp, U, T>)
             {
-                return ::std::invoke(comp, other, value);
+                return std::invoke(comp, other, value);
             }
 
             constexpr auto operator()(const auto&) const noexcept { return false; }
@@ -94,9 +94,9 @@ namespace stdsharp
     private:
         static constexpr basic_indexed_values values{Values...};
 
-        using values_t = ::std::decay_t<decltype(values)>;
+        using values_t = std::decay_t<decltype(values)>;
 
-        template<::std::size_t I>
+        template<std::size_t I>
             requires requires { requires I < size(); }
         [[nodiscard]] friend constexpr decltype(auto) get(const value_sequence) noexcept
         {
@@ -110,24 +110,24 @@ namespace stdsharp
             template<typename Func>
                 requires requires //
             {
-                requires(::std::invocable<Func, decltype(Values)> && ...);
-                requires ::std::same_as<ResultType, void> ||
-                    ::std::constructible_from< // clang-format off
+                requires(std::invocable<Func, decltype(Values)> && ...);
+                requires std::same_as<ResultType, void> ||
+                    std::constructible_from< // clang-format off
                         ResultType,
-                        ::std::invoke_result_t<Func, decltype(Values)>...
+                        std::invoke_result_t<Func, decltype(Values)>...
                     >; // clang-format on
             }
             constexpr auto operator()(Func&& func) const noexcept(
                 (nothrow_invocable<Func, decltype(Values)> && ...) &&
-                (::std::same_as<ResultType, void> ||
+                (std::same_as<ResultType, void> ||
                  nothrow_constructible_from<
                      ResultType,
-                     ::std::invoke_result_t<Func, decltype(Values)>... // clang-format off
+                     std::invoke_result_t<Func, decltype(Values)>... // clang-format off
                 >) // clang-format on
             )
             {
-                if constexpr(::std::same_as<ResultType, void>) (::std::invoke(func, Values), ...);
-                else return ResultType{::std::invoke(func, Values)...};
+                if constexpr(std::same_as<ResultType, void>) (std::invoke(func, Values), ...);
+                else return ResultType{std::invoke(func, Values)...};
             };
         };
 
@@ -137,13 +137,13 @@ namespace stdsharp
         template<template<auto...> typename T>
         using apply_t = T<Values...>;
 
-        template<::std::size_t I>
+        template<std::size_t I>
         using value_type = values_t::template get_t<I>;
 
-        template<::std::size_t I>
+        template<std::size_t I>
         static constexpr value_type<I> value = get<I>(values);
 
-        template<::std::size_t... I>
+        template<std::size_t... I>
         using at_t = regular_value_sequence<value<I>...>;
 
     private:
@@ -154,39 +154,39 @@ namespace stdsharp
                 requires requires //
             {
                 requires(sizeof...(Func) == 1);
-                typename value_sequence<::std::invoke(Func..., Values)...>;
+                typename value_sequence<std::invoke(Func..., Values)...>;
             }
             {
-                return value_sequence<::std::invoke(Func..., Values)...>{};
+                return value_sequence<std::invoke(Func..., Values)...>{};
             };
 
             [[nodiscard]] constexpr auto operator()() const noexcept
-                requires requires { typename value_sequence<::std::invoke(Func, Values)...>; }
+                requires requires { typename value_sequence<std::invoke(Func, Values)...>; }
             {
-                return value_sequence<::std::invoke(Func, Values)...>{}; // clang-format on
+                return value_sequence<std::invoke(Func, Values)...>{}; // clang-format on
             };
         };
 
-        template<::std::size_t From, ::std::size_t... I>
-        static consteval at_t<(From + I)...> select_range(::std::index_sequence<I...>) noexcept;
+        template<std::size_t From, std::size_t... I>
+        static consteval at_t<(From + I)...> select_range(std::index_sequence<I...>) noexcept;
 
         template<typename IfFunc>
         struct if_not_fn
         {
             template<typename Func>
-                requires ::std::invocable<IfFunc, Func>
+                requires std::invocable<IfFunc, Func>
             [[nodiscard]] constexpr auto operator()(Func&& func) const
                 noexcept(nothrow_invocable<IfFunc, Func>)
             {
-                return IfFunc{}(::std::not_fn(cpp_forward(func)));
+                return IfFunc{}(std::not_fn(cpp_forward(func)));
             }
         };
 
         template<typename IfFunc>
         struct from_value_fn
         {
-            template<typename T, typename Comp = ::std::ranges::equal_to>
-                requires ::std::invocable<IfFunc, details::value_comparer<T, Comp>>
+            template<typename T, typename Comp = std::ranges::equal_to>
+                requires std::invocable<IfFunc, details::value_comparer<T, Comp>>
             [[nodiscard]] constexpr auto operator()(const T& v, Comp comp = {}) const
                 noexcept(nothrow_invocable<IfFunc, details::value_comparer<T, Comp>>)
             {
@@ -198,7 +198,7 @@ namespace stdsharp
         struct result_compare_to_size
         {
             template<typename Func>
-                requires ::std::invocable<FindFunc, Func>
+                requires std::invocable<FindFunc, Func>
             [[nodiscard]] constexpr auto operator()(Func&& func) const
                 noexcept(nothrow_invocable<FindFunc, Func>)
             {
@@ -211,7 +211,7 @@ namespace stdsharp
         template<typename Func>
         struct predicate
         {
-            static constexpr auto value = (::std::invocable<Func, decltype(Values)> && ...);
+            static constexpr auto value = (std::invocable<Func, decltype(Values)> && ...);
         };
 
         template<typename Func>
@@ -226,7 +226,7 @@ namespace stdsharp
             template<proxy_concept<predicate> Func>
             constexpr auto operator()(Func func) const noexcept(nothrow_predicate<Func>::value)
             {
-                (::std::invoke(func, Values), ...);
+                (std::invoke(func, Values), ...);
                 return func;
             }
         } for_each{};
@@ -237,7 +237,7 @@ namespace stdsharp
             constexpr auto operator()(auto count, Func func) const
                 noexcept(nothrow_predicate<Func>::value)
             {
-                ((count == 0 ? false : (::std::invoke(func, Values), --count, true)) && ...);
+                ((count == 0 ? false : (std::invoke(func, Values), --count, true)) && ...);
                 return func;
             }
         } for_each_n{};
@@ -248,8 +248,8 @@ namespace stdsharp
             [[nodiscard]] constexpr auto operator()(Func func) const
                 noexcept(nothrow_predicate<Func>::value)
             {
-                ::std::size_t i = 0;
-                empty = ((::std::invoke(func, Values) ? false : (++i, true)) && ...);
+                std::size_t i = 0;
+                empty = ((std::invoke(func, Values) ? false : (++i, true)) && ...);
                 return i;
             }
         } find_if{};
@@ -268,13 +268,13 @@ namespace stdsharp
             [[nodiscard]] constexpr auto operator()(Func func) const
                 noexcept(nothrow_predicate<Func>::value)
             {
-                ::std::size_t i = 0;
+                std::size_t i = 0;
                 for_each(
                     [&i,
                      &func](const auto& v) noexcept(nothrow_invocable_r<Func, bool, decltype(v)> //
                     )
                     {
-                        if(::std::invoke(func, v)) ++i;
+                        if(std::invoke(func, v)) ++i;
                     } //
                 );
 
@@ -301,15 +301,15 @@ namespace stdsharp
         static constexpr struct adjacent_find_fn
         {
         private:
-            template<::std::size_t I>
+            template<std::size_t I>
             struct by_index
             {
                 template<typename Comp>
-                    requires ::std::predicate<Comp>
+                    requires std::predicate<Comp>
                 constexpr bool operator()(Comp& comp) const
                     noexcept(stdsharp::nothrow_predicate<Comp, bool>)
                 {
-                    return ::std::invoke(comp, value<I>, value<I + 1>);
+                    return std::invoke(comp, value<I>, value<I + 1>);
                 }
 
                 constexpr auto operator()(const auto&, const auto&) const noexcept { return false; }
@@ -317,18 +317,18 @@ namespace stdsharp
 
             struct impl
             {
-                template<typename Comp, ::std::size_t... I>
-                constexpr auto operator()(Comp& comp, const ::std::index_sequence<I...>) const
+                template<typename Comp, std::size_t... I>
+                constexpr auto operator()(Comp& comp, const std::index_sequence<I...>) const
                     noexcept((nothrow_invocable<by_index<I>, Comp> && ...))
                 {
-                    ::std::size_t res{};
+                    std::size_t res{};
                     ( //
                         (by_index<I>{}(comp) ? true : (++res, false)) || ... //
                     );
                     return res;
                 }
 
-                template<typename Comp, typename Seq = ::std::make_index_sequence<size() - 2>>
+                template<typename Comp, typename Seq = std::make_index_sequence<size() - 2>>
                 constexpr auto operator()(Comp& comp) const
                     noexcept(nothrow_invocable<impl, Comp&, Seq>)
                 {
@@ -337,8 +337,8 @@ namespace stdsharp
             };
 
         public:
-            template<typename Comp = ::std::ranges::equal_to>
-                requires((::std::invocable<decltype(Values)> && ...) && size() >= 2)
+            template<typename Comp = std::ranges::equal_to>
+                requires((std::invocable<decltype(Values)> && ...) && size() >= 2)
             [[nodiscard]] constexpr auto operator()(Comp comp = {}) const
                 noexcept(nothrow_invocable<impl, Comp>)
             {
@@ -355,17 +355,17 @@ namespace stdsharp
         static constexpr transform_fn<Func...> transform{};
 
         template<auto... Func>
-            requires ::std::invocable<transform_fn<Func...>>
+            requires std::invocable<transform_fn<Func...>>
         using transform_t = decltype(transform<Func...>());
 
-        template<::std::size_t From, ::std::size_t Size>
+        template<std::size_t From, std::size_t Size>
         using select_range_t = to_value_sequence<make_value_sequence_t<From, Size>>:: //
             template apply_t<at_t>;
 
-        template<::std::size_t Size>
+        template<std::size_t Size>
         using back_t = select_range_t<size() - Size, Size>;
 
-        template<::std::size_t Size>
+        template<std::size_t Size>
         using front_t = select_range_t<0, Size>;
 
         template<decltype(auto)... Others>
@@ -375,7 +375,7 @@ namespace stdsharp
         using append_front_t = regular_value_sequence<Others..., Values...>;
 
     private:
-        template<::std::size_t Index>
+        template<std::size_t Index>
         struct insert
         {
             template<decltype(auto)... Others, decltype(auto)... Front, decltype(auto)... Back>
@@ -391,21 +391,21 @@ namespace stdsharp
             using type = decltype(impl<Others...>(front_t<Index>{}, back_t<size() - Index>{}));
         };
 
-        template<::std::size_t... Index>
+        template<std::size_t... Index>
         struct remove_at
         {
-            static constexpr ::std::array select_indices = []
+            static constexpr std::array select_indices = []
             {
-                constexpr ::std::pair pair = []
+                constexpr std::pair pair = []
                 {
-                    ::std::array<::std::size_t, size()> res{};
-                    ::std::array excepted = {Index...};
+                    std::array<std::size_t, size()> res{};
+                    std::array excepted = {Index...};
 
-                    ::std::ranges::sort(excepted);
+                    std::ranges::sort(excepted);
 
-                    const auto size = static_cast<::std::size_t>(
-                        ::std::ranges::set_difference(
-                            ::std::views::iota(::std::size_t{0}, res.size()),
+                    const auto size = static_cast<std::size_t>(
+                        std::ranges::set_difference(
+                            std::views::iota(std::size_t{0}, res.size()),
                             excepted,
                             res.begin()
                         )
@@ -413,30 +413,30 @@ namespace stdsharp
                         res.cbegin()
                     );
 
-                    return ::std::pair{res, size};
+                    return std::pair{res, size};
                 }();
 
-                ::std::array<::std::size_t, pair.second> res{};
-                ::std::ranges::copy_n(pair.first.cbegin(), pair.second, res.begin());
+                std::array<std::size_t, pair.second> res{};
+                std::ranges::copy_n(pair.first.cbegin(), pair.second, res.begin());
 
                 return res;
             }();
 
-            template<::std::size_t... I>
+            template<std::size_t... I>
             static constexpr at_t<select_indices[I]...>
-                get_type(::std::index_sequence<I...>) noexcept;
+                get_type(std::index_sequence<I...>) noexcept;
 
-            using type = decltype(get_type(::std::make_index_sequence<select_indices.size()>{}));
+            using type = decltype(get_type(std::make_index_sequence<select_indices.size()>{}));
         };
 
     public:
-        template<::std::size_t Index, auto... Other>
+        template<std::size_t Index, auto... Other>
         using insert_t = insert<Index>::template type<Other...>;
 
-        template<::std::size_t... Index>
+        template<std::size_t... Index>
         using remove_at_t = ::meta::_t<remove_at<Index...>>;
 
-        template<::std::size_t Index, auto Other>
+        template<std::size_t Index, auto Other>
         using replace_t = to_value_sequence<
             typename to_value_sequence<front_t<Index>>::template append_t<Other>
             // clang-format off
@@ -453,14 +453,14 @@ namespace stdsharp
 namespace std
 {
     template<decltype(auto)... Values>
-    struct tuple_size<::stdsharp::value_sequence<Values...>> :
-        ::stdsharp::index_constant<::stdsharp::value_sequence<Values...>::size()>
+    struct tuple_size<stdsharp::value_sequence<Values...>> :
+        stdsharp::index_constant<stdsharp::value_sequence<Values...>::size()>
     {
     };
 
-    template<::std::size_t I, decltype(auto)... Values>
-    struct tuple_element<I, ::stdsharp::value_sequence<Values...>>
+    template<std::size_t I, decltype(auto)... Values>
+    struct tuple_element<I, stdsharp::value_sequence<Values...>>
     {
-        using type = typename ::stdsharp::value_sequence<Values...>::template value_type<I>;
+        using type = typename stdsharp::value_sequence<Values...>::template value_type<I>;
     };
 }
\ No newline at end of file
diff --git a/include/stdsharp/utility/constructor.h b/include/stdsharp/utility/constructor.h
index 10d8c64f..9cf9ddd5 100644
--- a/include/stdsharp/utility/constructor.h
+++ b/include/stdsharp/utility/constructor.h
@@ -8,7 +8,7 @@ namespace stdsharp
     struct constructor
     {
         template<typename... Args>
-            requires ::std::constructible_from<T, Args...>
+            requires std::constructible_from<T, Args...>
         [[nodiscard]] constexpr auto operator()(Args&&... args) const
             noexcept(nothrow_constructible_from<T, Args...>)
         {
@@ -16,7 +16,7 @@ namespace stdsharp
         }
 
         template<typename... Args>
-            requires(!::std::constructible_from<T, Args...> && list_initializable_from<T, Args...>)
+            requires(!std::constructible_from<T, Args...> && list_initializable_from<T, Args...>)
         [[nodiscard]] constexpr auto operator()(Args&&... args) const
             noexcept(nothrow_list_initializable_from<T, Args...>)
         {
@@ -24,11 +24,11 @@ namespace stdsharp
         }
 
         template<typename U>
-            requires ::std::constructible_from<::std::decay_t<U>, U> && ::std::same_as<T, void>
-        [[nodiscard]] constexpr ::std::decay_t<U> operator()(U&& u) const
-            noexcept(nothrow_constructible_from<::std::decay_t<U>, U>)
+            requires std::constructible_from<std::decay_t<U>, U> && std::same_as<T, void>
+        [[nodiscard]] constexpr std::decay_t<U> operator()(U&& u) const
+            noexcept(nothrow_constructible_from<std::decay_t<U>, U>)
         {
-            return ::std::decay_t<U>{cpp_forward(u)};
+            return std::decay_t<U>{cpp_forward(u)};
         }
     };
 
diff --git a/include/stdsharp/utility/implement_dispatcher.h b/include/stdsharp/utility/implement_dispatcher.h
index 3f2ad780..b5a6d811 100644
--- a/include/stdsharp/utility/implement_dispatcher.h
+++ b/include/stdsharp/utility/implement_dispatcher.h
@@ -13,11 +13,11 @@ namespace stdsharp
 
     template<expr_req ExprReq, typename Ret, typename... Args>
     struct implement_dispatcher :
-        ::std::reference_wrapper<details::implement_dispatcher_func<ExprReq, Ret, Args...>>
+        std::reference_wrapper<details::implement_dispatcher_func<ExprReq, Ret, Args...>>
     {
     private:
         using func = ::meta::_t<implement_dispatcher>;
-        using m_base = ::std::reference_wrapper<func>;
+        using m_base = std::reference_wrapper<func>;
 
         template<invocable_r<Ret, Args...> Closure>
             requires requires //
@@ -47,7 +47,7 @@ namespace stdsharp
         }
 
         constexpr implement_dispatcher() noexcept
-            requires ::std::same_as<void, Ret>
+            requires std::same_as<void, Ret>
             : implement_dispatcher([](const Args&...) noexcept {})
         {
         }
@@ -55,7 +55,7 @@ namespace stdsharp
         constexpr implement_dispatcher() noexcept
             requires requires //
         {
-            requires ::std::default_initializable<Ret>;
+            requires std::default_initializable<Ret>;
             requires(ExprReq != expr_req::no_exception) || noexcept(Ret{});
         }
             :
diff --git a/include/stdsharp/utility/invocable.h b/include/stdsharp/utility/invocable.h
index c6a275a2..eedc09e0 100644
--- a/include/stdsharp/utility/invocable.h
+++ b/include/stdsharp/utility/invocable.h
@@ -11,13 +11,13 @@ namespace stdsharp
 
         using base::base;
 
-#define STDSHARP_OPERATOR(const_, ref)                                                     \
-    template<typename... Args>                                                             \
-        requires ::std::invocable<const_ Func ref, Args...>                                \
-    constexpr decltype(auto) operator()(Args&&... args)                                    \
-        const_ ref noexcept(nothrow_invocable<const_ Func ref, Args...>)                   \
-    {                                                                                      \
-        return ::std::invoke(static_cast<const_ Func ref>(this->v), cpp_forward(args)...); \
+#define STDSHARP_OPERATOR(const_, ref)                                                   \
+    template<typename... Args>                                                           \
+        requires std::invocable<const_ Func ref, Args...>                                \
+    constexpr decltype(auto) operator()(Args&&... args)                                  \
+        const_ ref noexcept(nothrow_invocable<const_ Func ref, Args...>)                 \
+    {                                                                                    \
+        return std::invoke(static_cast<const_ Func ref>(this->v), cpp_forward(args)...); \
     }
 
         STDSHARP_OPERATOR(, &)
@@ -37,7 +37,7 @@ namespace stdsharp
 
 #define STDSHARP_OPERATOR(const_, ref)                                    \
     template<typename... Args>                                            \
-        requires ::std::invocable<const_ base ref, Args...>               \
+        requires std::invocable<const_ base ref, Args...>                 \
     [[nodiscard]] constexpr decltype(auto) operator()(Args&&... args)     \
         const_ ref noexcept(nothrow_invocable<const_ Func ref, Args...>)  \
     {                                                                     \
@@ -53,20 +53,20 @@ namespace stdsharp
     };
 
     template<typename Func>
-    nodiscard_invocable(Func&& func) -> nodiscard_invocable<::std::decay_t<Func>>;
+    nodiscard_invocable(Func&& func) -> nodiscard_invocable<std::decay_t<Func>>;
 
     template<typename Func>
-    struct ref_invocable_t : ::std::reference_wrapper<Func>
+    struct ref_invocable_t : std::reference_wrapper<Func>
     {
-        using ::std::reference_wrapper<Func>::reference_wrapper;
-
-#define STDSHARP_OPERATOR(const_, ref)                                                         \
-    template<typename... Args>                                                                 \
-        requires ::std::invocable<const_ Func ref, Args...>                                    \
-    constexpr decltype(auto) operator()(Args&&... args)                                        \
-        const_ ref noexcept(nothrow_invocable<const_ Func ref, Args...>)                       \
-    {                                                                                          \
-        return ::std::invoke(static_cast<const_ Func ref>(this->get()), cpp_forward(args)...); \
+        using std::reference_wrapper<Func>::reference_wrapper;
+
+#define STDSHARP_OPERATOR(const_, ref)                                                       \
+    template<typename... Args>                                                               \
+        requires std::invocable<const_ Func ref, Args...>                                    \
+    constexpr decltype(auto) operator()(Args&&... args)                                      \
+        const_ ref noexcept(nothrow_invocable<const_ Func ref, Args...>)                     \
+    {                                                                                        \
+        return std::invoke(static_cast<const_ Func ref>(this->get()), cpp_forward(args)...); \
     }
 
         STDSHARP_OPERATOR(, &)
diff --git a/include/stdsharp/utility/utility.h b/include/stdsharp/utility/utility.h
index 80d55d5f..025ffc30 100644
--- a/include/stdsharp/utility/utility.h
+++ b/include/stdsharp/utility/utility.h
@@ -5,6 +5,7 @@
 #include "cast_to.h"
 #include "constructor.h"
 #include "invocable.h"
+#include "to_lvalue.h"
 #include "../type_traits/core_traits.h"
 
 namespace stdsharp
@@ -14,11 +15,11 @@ namespace stdsharp
     {
     private:
         template<typename U>
-        using copy_const_t = ::std::conditional_t<const_<::std::remove_reference_t<T>>, const U, U>;
+        using copy_const_t = std::conditional_t<const_<std::remove_reference_t<T>>, const U, U>;
 
     public:
         template<typename U>
-        [[nodiscard]] constexpr ref_align_t<T&&, copy_const_t<::std::remove_reference_t<U>>>
+        [[nodiscard]] constexpr ref_align_t<T&&, copy_const_t<std::remove_reference_t<U>>>
             operator()(U&& u) const noexcept
         {
             return auto_cast(u);
@@ -29,5 +30,5 @@ namespace stdsharp
     inline constexpr forward_like_fn<T> forward_like{};
 
     template<typename T, typename U>
-    using forward_like_t = decltype(forward_like<T>(::std::declval<U>()));
+    using forward_like_t = decltype(forward_like<T>(std::declval<U>()));
 }
\ No newline at end of file
diff --git a/include/stdsharp/utility/value_wrapper.h b/include/stdsharp/utility/value_wrapper.h
index bbfa3bde..250d9d4a 100644
--- a/include/stdsharp/utility/value_wrapper.h
+++ b/include/stdsharp/utility/value_wrapper.h
@@ -17,7 +17,7 @@ namespace stdsharp
             value_wrapper() = default;
 
             template<typename... U>
-                requires ::std::constructible_from<T, U...>
+                requires std::constructible_from<T, U...>
             constexpr value_wrapper(U&&... u) noexcept(nothrow_constructible_from<T, U...>):
                 v(cpp_forward(u)...)
             {
@@ -30,7 +30,7 @@ namespace stdsharp
             STDSHARP_NO_UNIQUE_ADDRESS T v{};
 
             template<typename... U>
-                requires ::std::constructible_from<T, U...>
+                requires std::constructible_from<T, U...>
             constexpr value_wrapper(U&&... u) noexcept(nothrow_constructible_from<T, U...>):
                 v(cpp_forward(u)...)
             {
@@ -47,19 +47,18 @@ namespace stdsharp
 
     private:
         template<typename... Args, size_t... I>
-            requires ::std::constructible_from<T, Args...>
-        constexpr value_wrapper(::std::tuple<Args...>&& args, ::std::index_sequence<I...>):
-            details::value_wrapper<T>(::std::get<I>(cpp_move(args))...)
+            requires std::constructible_from<T, Args...>
+        constexpr value_wrapper(std::tuple<Args...>&& args, std::index_sequence<I...>):
+            details::value_wrapper<T>(std::get<I>(cpp_move(args))...)
         {
         }
 
     public:
         template<typename... Args>
-            requires ::std::constructible_from<T, Args...> &&
-            (!::std::
-                 constructible_from<T, const ::std::piecewise_construct_t&, ::std::tuple<Args...>>)
-        constexpr value_wrapper(const ::std::piecewise_construct_t, ::std::tuple<Args...> args):
-            value_wrapper(cpp_move(args), ::std::index_sequence_for<Args...>{})
+            requires std::constructible_from<T, Args...> &&
+            (!std::constructible_from<T, const std::piecewise_construct_t&, std::tuple<Args...>>)
+        constexpr value_wrapper(const std::piecewise_construct_t, std::tuple<Args...> args):
+            value_wrapper(cpp_move(args), std::index_sequence_for<Args...>{})
         {
         }
 

From f0972a772f7aa12ec4176255eac82519dc6c32de Mon Sep 17 00:00:00 2001
From: Blurring Shadow <976999484@qq.com>
Date: Fri, 26 May 2023 11:38:21 +0800
Subject: [PATCH 4/6] feat(utlity): add to_value fn

---
 include/stdsharp/type_traits/core_traits.h | 194 ++++++++++-----------
 include/stdsharp/utility/to_lvalue.h       |  28 +++
 2 files changed, 123 insertions(+), 99 deletions(-)
 create mode 100644 include/stdsharp/utility/to_lvalue.h

diff --git a/include/stdsharp/type_traits/core_traits.h b/include/stdsharp/type_traits/core_traits.h
index 6a8466b6..51987e69 100644
--- a/include/stdsharp/type_traits/core_traits.h
+++ b/include/stdsharp/type_traits/core_traits.h
@@ -11,18 +11,19 @@
 
 #include "../utility/adl_proof.h"
 #include "../macros.h"
+#include "../namespace_alias.h"
 
-using namespace ::std::literals;
+using namespace std::literals;
 
 namespace stdsharp
 {
     template<typename T>
-    concept nttp_able = requires { ::std::integer_sequence<T>{}; };
+    concept nttp_able = requires { std::integer_sequence<T>{}; };
 
     template<template<typename...> typename T, typename... Args>
     struct deduction
     {
-        using type = T<::std::decay_t<Args>...>;
+        using type = T<std::decay_t<Args>...>;
     };
 
     template<template<typename...> typename T>
@@ -33,9 +34,9 @@ namespace stdsharp
         using type = deduction<T, Args...>::type;
 
         template<typename... Args>
-            requires ::std::constructible_from<type<Args...>, Args...>
+            requires std::constructible_from<type<Args...>, Args...>
         constexpr auto operator()(Args&&... args) const
-            noexcept(::std::is_nothrow_constructible_v<type<Args...>, Args...>)
+            noexcept(std::is_nothrow_constructible_v<type<Args...>, Args...>)
         {
             return type<Args...>{cpp_forward(args)...};
         }
@@ -49,9 +50,9 @@ namespace stdsharp
     };
 
     template<typename T>
-    inline constexpr auto get_ref_qualifier = ::std::is_lvalue_reference_v<T> ? //
+    inline constexpr auto get_ref_qualifier = std::is_lvalue_reference_v<T> ? //
         ref_qualifier::lvalue :
-        ::std::is_rvalue_reference_v<T> ? ref_qualifier::rvalue : ref_qualifier::none;
+        std::is_rvalue_reference_v<T> ? ref_qualifier::rvalue : ref_qualifier::none;
 
     enum class expr_req
     {
@@ -68,29 +69,29 @@ namespace stdsharp
 
     template<typename T, typename Ret, typename... Args>
     inline constexpr auto invocable_r_test =
-        get_expr_req(::std::is_invocable_r_v<T, Ret, Args...>, ::std::is_nothrow_invocable_r_v<T, Ret, Args...>);
+        get_expr_req(std::is_invocable_r_v<T, Ret, Args...>, std::is_nothrow_invocable_r_v<T, Ret, Args...>);
 
     template<typename T, typename... Args>
     inline constexpr auto invocable_test =
-        get_expr_req(::std::is_invocable_v<T, Args...>, ::std::is_nothrow_invocable_v<T, Args...>);
+        get_expr_req(std::is_invocable_v<T, Args...>, std::is_nothrow_invocable_v<T, Args...>);
 
     template<typename T, typename... Args>
     inline constexpr auto constructible_from_test =
-        get_expr_req(::std::is_constructible_v<T, Args...>, ::std::is_nothrow_constructible_v<T, Args...>);
+        get_expr_req(std::is_constructible_v<T, Args...>, std::is_nothrow_constructible_v<T, Args...>);
 
     template<typename T, bool Const>
-    using apply_const = ::std::conditional_t<Const, ::std::add_const_t<T>, T>;
+    using apply_const = std::conditional_t<Const, std::add_const_t<T>, T>;
 
     template<typename T, bool Volatile>
-    using apply_volatile = ::std::conditional_t<Volatile, ::std::add_volatile_t<T>, T>;
+    using apply_volatile = std::conditional_t<Volatile, std::add_volatile_t<T>, T>;
 
     template<typename T, ref_qualifier ref>
-    using apply_ref = ::std::conditional_t<
-        ::std::ranges::equal_to{}(ref, ref_qualifier::lvalue),
-        ::std::add_lvalue_reference_t<T>,
-        ::std::conditional_t<
-            ::std::ranges::equal_to{}(ref, ref_qualifier::rvalue),
-            ::std::add_rvalue_reference_t<T>,
+    using apply_ref = std::conditional_t<
+        std::ranges::equal_to{}(ref, ref_qualifier::lvalue),
+        std::add_lvalue_reference_t<T>,
+        std::conditional_t<
+            std::ranges::equal_to{}(ref, ref_qualifier::rvalue),
+            std::add_rvalue_reference_t<T>,
             T // clang-format off
         >
     >; // clang-format on
@@ -104,7 +105,7 @@ namespace stdsharp
         return false;
     }
 
-    using ignore_t = decltype(::std::ignore);
+    using ignore_t = decltype(std::ignore);
 
     inline constexpr struct empty_t : ignore_t
     {
@@ -118,19 +119,19 @@ namespace stdsharp
     } empty;
 
     template<typename T>
-    using add_const_lvalue_ref_t = ::std::add_lvalue_reference_t<::std::add_const_t<T>>;
+    using add_const_lvalue_ref_t = std::add_lvalue_reference_t<std::add_const_t<T>>;
 
     template<typename T, typename U>
-    using ref_align_t = ::std::conditional_t<
-        ::std::is_lvalue_reference_v<T>,
-        ::std::add_lvalue_reference_t<U>, // clang-format off
-        ::std::conditional_t<::std::is_rvalue_reference_v<T>, ::std::add_rvalue_reference_t<U>, U>
+    using ref_align_t = std::conditional_t<
+        std::is_lvalue_reference_v<T>,
+        std::add_lvalue_reference_t<U>, // clang-format off
+        std::conditional_t<std::is_rvalue_reference_v<T>, std::add_rvalue_reference_t<U>, U>
     >; // clang-format on
 
     template<typename T, typename U>
-    using const_align_t = ::std::conditional_t<
-        ::std::is_const_v<::std::remove_reference_t<T>>,
-        ::std::add_const_t<U>, // clang-format off
+    using const_align_t = std::conditional_t<
+        std::is_const_v<std::remove_reference_t<T>>,
+        std::add_const_t<U>, // clang-format off
         U
     >; // clang-format on
 
@@ -138,7 +139,7 @@ namespace stdsharp
     using const_ref_align_t = ref_align_t<T, const_align_t<T, U>>;
 
     template<auto Value>
-    using constant = ::std::integral_constant<decltype(Value), Value>;
+    using constant = std::integral_constant<decltype(Value), Value>;
 
     template<auto Value>
     using constant_value_type = constant<Value>::value_type;
@@ -155,33 +156,29 @@ namespace stdsharp
     template<typename T>
     concept constant_value = cpp_is_constexpr(T::value);
 
-    template<::std::size_t I>
-    using index_constant = ::std::integral_constant<::std::size_t, I>;
+    template<std::size_t I>
+    using index_constant = std::integral_constant<std::size_t, I>;
 
     template<typename T>
-    using persist_t =
-        ::std::conditional_t<::std::is_rvalue_reference_v<T>, ::std::remove_reference_t<T>, T&>;
-
-    template<typename T>
-    struct basic_type_constant : ::std::type_identity<T>
+    struct basic_type_constant : std::type_identity<T>
     {
     private:
         template<typename U>
         [[nodiscard]] friend constexpr bool
             operator==(const basic_type_constant, const basic_type_constant<U>) noexcept
         {
-            return ::std::same_as<T, U>;
+            return std::same_as<T, U>;
         }
     };
 
     template<typename T>
-    basic_type_constant(::std::type_identity<T>) -> basic_type_constant<T>;
+    basic_type_constant(std::type_identity<T>) -> basic_type_constant<T>;
 
     template<typename T>
     using type_constant = adl_proof_t<basic_type_constant, T>;
 
     template<typename T>
-    struct deduction<type_constant, ::std::type_identity<T>>
+    struct deduction<type_constant, std::type_identity<T>>
     {
         using type = type_constant<T>;
     };
@@ -197,7 +194,7 @@ namespace stdsharp
     {
         [[nodiscard]] static constexpr auto size() noexcept { return sizeof...(T); }
 
-        template<template<typename> typename Converter = ::std::type_identity>
+        template<template<typename> typename Converter = std::type_identity>
             requires requires { regular_value_sequence<Converter<T>{}...>{}; }
         using convert_to_value_sequence = regular_value_sequence<Converter<T>{}...>;
     };
@@ -207,7 +204,7 @@ namespace stdsharp
     {
         [[nodiscard]] static constexpr auto size() noexcept { return 1; }
 
-        template<template<typename> typename Converter = ::std::type_identity>
+        template<template<typename> typename Converter = std::type_identity>
             requires requires { regular_value_sequence<Converter<T>{}>{}; }
         using convert_to_value_sequence = regular_value_sequence<Converter<T>{}>;
     };
@@ -229,13 +226,13 @@ namespace stdsharp
         []<template<auto...> typename Inner, auto... V>(const Inner<V...>&) //
         {
             return regular_type_sequence<Converter<V>...>{}; //
-        }(::std::declval<ValueSeq>())
+        }(std::declval<ValueSeq>())
     );
 
     template<auto... V>
     struct regular_value_sequence
     {
-        [[nodiscard]] static constexpr ::std::size_t size() noexcept { return sizeof...(V); }
+        [[nodiscard]] static constexpr std::size_t size() noexcept { return sizeof...(V); }
 
         template<template<auto> typename Converter = constant>
             requires requires { regular_type_sequence<Converter<V>...>{}; }
@@ -245,7 +242,7 @@ namespace stdsharp
     template<auto V>
     struct regular_value_sequence<V> : constant<V>
     {
-        [[nodiscard]] static constexpr ::std::size_t size() noexcept { return 1; }
+        [[nodiscard]] static constexpr std::size_t size() noexcept { return 1; }
 
         template<template<auto> typename Converter = constant>
             requires requires { regular_type_sequence<Converter<V>>{}; }
@@ -255,19 +252,19 @@ namespace stdsharp
     template<typename TypeSeq, template<auto> typename Converter = constant>
     using convert_from_type_sequence = decltype( //
         []<template<typename...> typename Inner, auto... V> //
-        (const ::std::type_identity<Inner<Converter<V>...>>) //
+        (const std::type_identity<Inner<Converter<V>...>>) //
         {
             return regular_value_sequence<V...>{}; //
-        }(::std::type_identity<TypeSeq>{})
+        }(std::type_identity<TypeSeq>{})
     );
 
-    template<::std::integral T, T First, ::std::same_as<T> auto... V>
-    struct regular_value_sequence<First, V...> : ::std::integer_sequence<T, First, V...>
+    template<std::integral T, T First, std::same_as<T> auto... V>
+    struct regular_value_sequence<First, V...> : std::integer_sequence<T, First, V...>
     {
     };
 
     template<typename T, T... V>
-    regular_value_sequence(::std::integer_sequence<T, V...>) -> regular_value_sequence<V...>;
+    regular_value_sequence(std::integer_sequence<T, V...>) -> regular_value_sequence<V...>;
 
     namespace details
     {
@@ -276,50 +273,50 @@ namespace stdsharp
 
         template<typename T, decltype(auto)... V>
         consteval regular_value_sequence<V...>
-            to_regular_value_sequence(::std::integer_sequence<T, V...>);
+            to_regular_value_sequence(std::integer_sequence<T, V...>);
 
-        template<auto From, auto PlusF, ::std::size_t... I>
-            requires requires { regular_value_sequence<::std::invoke(PlusF, From, I)...>{}; }
-        consteval regular_value_sequence<::std::invoke(PlusF, From, I)...>
-            make_value_sequence(::std::index_sequence<I...>) noexcept;
+        template<auto From, auto PlusF, std::size_t... I>
+            requires requires { regular_value_sequence<std::invoke(PlusF, From, I)...>{}; }
+        consteval regular_value_sequence<std::invoke(PlusF, From, I)...>
+            make_value_sequence(std::index_sequence<I...>) noexcept;
 
-        template<::std::array Array, ::std::size_t... Index>
+        template<std::array Array, std::size_t... Index>
             requires nttp_able<typename decltype(Array)::value_type>
         consteval regular_value_sequence<(Array[Index])...>
-            array_to_sequence(::std::index_sequence<Index...>);
+            array_to_sequence(std::index_sequence<Index...>);
 
         template<
             constant_value T,
             typename Range = decltype(T::value),
-            nttp_able ValueType = ::std::ranges::range_value_t<Range> // clang-format off
+            nttp_able ValueType = std::ranges::range_value_t<Range> // clang-format off
         > // clang-format on
             requires requires //
         {
-            index_constant<::std::ranges::size(T::value)>{};
-            ::std::array<ValueType, 1>{};
-            requires ::std::copyable<ValueType>;
+            index_constant<std::ranges::size(T::value)>{};
+            std::array<ValueType, 1>{};
+            requires std::copyable<ValueType>;
         }
         struct rng_to_sequence
         {
             static constexpr auto rng = T::value;
-            static constexpr auto size = ::std::ranges::size(rng);
+            static constexpr auto size = std::ranges::size(rng);
 
             static constexpr auto array = []
             {
                 if constexpr( //
-                    requires { array_to_sequence<rng>(::std::make_index_sequence<size>{}); }
+                    requires { array_to_sequence<rng>(std::make_index_sequence<size>{}); }
                 )
                     return rng;
                 else
                 {
-                    ::std::array<ValueType, size> array{};
-                    ::std::ranges::copy(rng, array.begin());
+                    std::array<ValueType, size> array{};
+                    std::ranges::copy(rng, array.begin());
                     return array;
                 }
             }();
 
             using type =
-                decltype(array_to_sequence<array>(::std::make_index_sequence<array.size()>{}));
+                decltype(array_to_sequence<array>(std::make_index_sequence<array.size()>{}));
         };
 
         template<typename... T, template<typename...> typename Inner, typename... U>
@@ -328,17 +325,17 @@ namespace stdsharp
 
     template<typename Seq>
     using to_regular_value_sequence =
-        decltype(details::to_regular_value_sequence(::std::declval<Seq>()));
+        decltype(details::to_regular_value_sequence(std::declval<Seq>()));
 
     template<typename T, T Size>
-    using make_integer_sequence = to_regular_value_sequence<::std::make_integer_sequence<T, Size>>;
+    using make_integer_sequence = to_regular_value_sequence<std::make_integer_sequence<T, Size>>;
 
-    template<::std::size_t N>
-    using make_index_sequence = make_integer_sequence<::std::size_t, N>;
+    template<std::size_t N>
+    using make_index_sequence = make_integer_sequence<std::size_t, N>;
 
-    template<auto From, ::std::size_t Size, auto PlusF = ::std::plus{}>
+    template<auto From, std::size_t Size, auto PlusF = std::plus{}>
     using make_value_sequence_t = decltype( //
-        details::make_value_sequence<From, PlusF>(::std::make_index_sequence<Size>{})
+        details::make_value_sequence<From, PlusF>(std::make_index_sequence<Size>{})
     );
 
     template<typename... T>
@@ -356,9 +353,9 @@ namespace stdsharp
         ttp_expend() = default;
 
         template<typename... Us>
-            requires(::std::constructible_from<T<Ts>, Us> && ...)
+            requires(std::constructible_from<T<Ts>, Us> && ...)
         constexpr ttp_expend(Us&&... us) //
-            noexcept((::std::is_nothrow_constructible_v<T<Ts>, Us> && ...)):
+            noexcept((std::is_nothrow_constructible_v<T<Ts>, Us> && ...)):
             T<Ts>(cpp_forward(us))...
         {
         }
@@ -372,8 +369,8 @@ namespace stdsharp
         decltype( //
             []<template<typename...> typename Inner, typename... U>(const Inner<U...>&)
             {
-                return ::std::type_identity<ttp_expend<T, U...>>{}; //
-            }(::std::declval<Seq>())
+                return std::type_identity<ttp_expend<T, U...>>{}; //
+            }(std::declval<Seq>())
         ) // clang-format off
     >; // clang-format on
 
@@ -383,9 +380,9 @@ namespace stdsharp
         nttp_expend() = default;
 
         template<typename... Us>
-            requires(::std::constructible_from<T<V>, Us> && ...)
+            requires(std::constructible_from<T<V>, Us> && ...)
         constexpr nttp_expend(Us&&... us) //
-            noexcept((::std::is_nothrow_constructible_v<T<V>, Us> && ...)):
+            noexcept((std::is_nothrow_constructible_v<T<V>, Us> && ...)):
             T<V>(cpp_forward(us))...
         {
         }
@@ -394,18 +391,17 @@ namespace stdsharp
     template<template<auto> typename T, decltype(auto)... V>
     nttp_expend(T<V>...) -> nttp_expend<T, V...>;
 
-    template<template<auto> typename T, ::std::size_t Size>
+    template<template<auto> typename T, std::size_t Size>
     using make_nttp_expend = decltype( //
         []<template<auto...> typename Inner, decltype(auto)... V>(const Inner<V...>) //
         {
-            return ::std::type_identity<nttp_expend<T, V...>>{}; //
+            return std::type_identity<nttp_expend<T, V...>>{}; //
         }(make_index_sequence<Size>{})
     );
 
     template<typename Template, typename... T>
-        requires requires { details::template_rebind_impl<T...>(::std::declval<Template>()); }
-    using template_rebind =
-        decltype(details::template_rebind_impl<T...>(::std::declval<Template>()));
+        requires requires { details::template_rebind_impl<T...>(std::declval<Template>()); }
+    using template_rebind = decltype(details::template_rebind_impl<T...>(std::declval<Template>()));
 
     namespace cpo
     {
@@ -413,14 +409,14 @@ namespace stdsharp
         {
             void get(auto&&) = delete;
 
-            template<::std::size_t I>
+            template<std::size_t I>
             struct get_element_fn
             {
                 [[nodiscard]] constexpr decltype(auto) operator()(auto&& t) const
-                    noexcept(noexcept(::std::get<I>(cpp_forward(t))))
-                    requires requires { ::std::get<I>(cpp_forward(t)); }
+                    noexcept(noexcept(std::get<I>(cpp_forward(t))))
+                    requires requires { std::get<I>(cpp_forward(t)); }
                 {
-                    return ::std::get<I>(cpp_forward(t));
+                    return std::get<I>(cpp_forward(t));
                 }
 
                 [[nodiscard]] constexpr decltype(auto) operator()(auto&& t) const
@@ -428,7 +424,7 @@ namespace stdsharp
                     requires requires //
                 {
                     get<I>(cpp_forward(t));
-                    requires !requires { ::std::get<I>(cpp_forward(t)); };
+                    requires !requires { std::get<I>(cpp_forward(t)); };
                 }
                 {
                     return get<I>(cpp_forward(t));
@@ -438,52 +434,52 @@ namespace stdsharp
 
         inline namespace cpo_impl
         {
-            template<::std::size_t I>
+            template<std::size_t I>
             using get_element_fn = details::get_element_fn<I>;
 
-            template<::std::size_t I>
+            template<std::size_t I>
             inline constexpr get_element_fn<I> get_element;
         }
     }
 
-    template<::std::size_t I, typename T>
-    using get_element_t = decltype(cpo::get_element<I>(::std::declval<T>()));
+    template<std::size_t I, typename T>
+    using get_element_t = decltype(cpo::get_element<I>(std::declval<T>()));
 
     template<typename T>
-    inline constexpr ::std::string_view type_id = ::nameof::nameof_full_type<T>();
+    inline constexpr std::string_view type_id = ::nameof::nameof_full_type<T>();
 
     inline namespace literals
     {
-        template<::std::size_t Size>
-        struct ltr : ::std::array<char, Size>
+        template<std::size_t Size>
+        struct ltr : std::array<char, Size>
         {
         private:
             using array_t = const char (&)[Size]; // NOLINT(*-avoid-c-arrays)
 
         public:
-            using base = ::std::array<char, Size>;
+            using base = std::array<char, Size>;
             using base::base;
 
-            constexpr ltr(array_t arr) noexcept { ::std::ranges::copy(arr, base::begin()); }
+            constexpr ltr(array_t arr) noexcept { std::ranges::copy(arr, base::begin()); }
 
             constexpr ltr& operator=(array_t arr) noexcept
             {
-                ::std::ranges::copy(arr, base::begin());
+                std::ranges::copy(arr, base::begin());
                 return *this;
             }
 
-            [[nodiscard]] constexpr operator ::std::string_view() const noexcept
+            [[nodiscard]] constexpr operator std::string_view() const noexcept
             {
                 return {base::data(), Size - 1};
             }
 
             [[nodiscard]] constexpr auto to_string_view() const noexcept
             {
-                return static_cast<::std::string_view>(*this); //
+                return static_cast<std::string_view>(*this); //
             }
         };
 
-        template<::std::size_t Size>
+        template<std::size_t Size>
         ltr(const char (&)[Size]) -> ltr<Size>; // NOLINT(*-avoid-c-arrays)
 
         template<ltr Ltr>
diff --git a/include/stdsharp/utility/to_lvalue.h b/include/stdsharp/utility/to_lvalue.h
new file mode 100644
index 00000000..88b9ad35
--- /dev/null
+++ b/include/stdsharp/utility/to_lvalue.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <concepts>
+
+#include "../macros.h"
+#include "../compilation_config_in.h"
+
+namespace stdsharp
+{
+    inline constexpr struct to_lvalue_fn
+    {
+        [[nodiscard]] STDSHARP_INTRINSIC constexpr auto& operator()(auto& t) const noexcept
+        {
+            return t;
+        }
+
+        template<::std::move_constructible T>
+        [[nodiscard]] constexpr T operator()(T&& t) const noexcept
+        {
+            return cpp_move(t);
+        }
+    } to_lvalue{};
+
+    template<typename T>
+    using to_lvalue_t = ::std::invoke_result_t<to_lvalue_fn, T>;
+}
+
+#include "../compilation_config_out.h"
\ No newline at end of file

From 994712502027ccb8ce1c0a0bbf8d12ff27577075 Mon Sep 17 00:00:00 2001
From: Blurring Shadow <976999484@qq.com>
Date: Fri, 26 May 2023 11:40:31 +0800
Subject: [PATCH 5/6] refactor(functional-bind): rename rename to
 bind_as_lvalue

---
 .../functional/{bind.h => bind_as_lvlaue.h}   | 37 ++++++++++---------
 .../functional/symmetric_operations.h         |  2 +-
 2 files changed, 20 insertions(+), 19 deletions(-)
 rename include/stdsharp/functional/{bind.h => bind_as_lvlaue.h} (60%)

diff --git a/include/stdsharp/functional/bind.h b/include/stdsharp/functional/bind_as_lvlaue.h
similarity index 60%
rename from include/stdsharp/functional/bind.h
rename to include/stdsharp/functional/bind_as_lvlaue.h
index 81f3206f..0360881d 100644
--- a/include/stdsharp/functional/bind.h
+++ b/include/stdsharp/functional/bind_as_lvlaue.h
@@ -1,10 +1,11 @@
 #pragma once
 
 #include "invoke.h"
+#include "../utility/to_lvalue.h"
 
 namespace stdsharp
 {
-    inline constexpr struct bind_fn
+    inline constexpr struct bind_as_lvalue_fn
     {
     private:
         template<typename T>
@@ -14,9 +15,9 @@ namespace stdsharp
         };
 
         template<typename T>
-        struct arg_wrapper<T&> : ::std::reference_wrapper<T>
+        struct arg_wrapper<T&> : std::reference_wrapper<T>
         {
-            using ::std::reference_wrapper<T>::reference_wrapper;
+            using std::reference_wrapper<T>::reference_wrapper;
         };
 
         template<>
@@ -24,10 +25,16 @@ namespace stdsharp
         {
         };
 
+        template<typename T>
+        arg_wrapper(T&) -> arg_wrapper<T&>;
+
+        template<typename T>
+        arg_wrapper(T&&) -> arg_wrapper<T>;
+
         static constexpr struct
         {
             template<typename T>
-                requires ::std::same_as<template_rebind<::std::decay_t<T>, void>, arg_wrapper<void>>
+                requires std::same_as<template_rebind<std::decay_t<T>, void>, arg_wrapper<void>>
             [[nodiscard]] constexpr decltype(auto) operator()(T&& wrapper) const noexcept
             {
                 return cpp_forward(wrapper).get();
@@ -40,42 +47,36 @@ namespace stdsharp
         } extract{};
 
         template<typename T>
-        using extract_t = decltype(extract(::std::declval<T>()));
+        using extract_t = decltype(extract(std::declval<T>()));
 
     public:
         template<typename Func, typename... Args>
         constexpr auto operator()(Func&& func, Args&&... args) const noexcept( //
             noexcept( //
-                ::std::bind_front(
+                std::bind_front(
                     projected_invoke,
                     cpp_forward(func),
                     extract,
-                    arg_wrapper<persist_t<Args&&>>{cpp_forward(args)}...
+                    arg_wrapper{to_lvalue(cpp_forward(args))}...
                 )
             )
         )
             requires requires //
         {
-            ::std::bind_front(
+            std::bind_front(
                 projected_invoke,
                 cpp_forward(func),
                 extract,
-                arg_wrapper<persist_t<Args&&>>{cpp_forward(args)}...
+                arg_wrapper{to_lvalue(cpp_forward(args))}...
             );
         }
         {
-            return ::std::bind_front(
+            return std::bind_front(
                 projected_invoke,
                 cpp_forward(func),
                 extract,
-                arg_wrapper<persist_t<Args&&>>{cpp_forward(args)}...
+                arg_wrapper{to_lvalue(cpp_forward(args))}...
             );
         }
-    } bind{};
-
-    template<typename... Args>
-    concept bindable = ::std::invocable<bind_fn, Args...>;
-
-    template<typename... Args>
-    concept nothrow_bindable = nothrow_invocable<bind_fn, Args...>;
+    } bind_as_lvalue{};
 }
\ No newline at end of file
diff --git a/include/stdsharp/functional/symmetric_operations.h b/include/stdsharp/functional/symmetric_operations.h
index 1416887e..776c3bb7 100644
--- a/include/stdsharp/functional/symmetric_operations.h
+++ b/include/stdsharp/functional/symmetric_operations.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "bind.h"
+#include "bind_as_lvlaue.h"
 #include "operations.h"
 
 namespace stdsharp::cpo::inline cpo_impl

From 95a541bdf1a5c436433b07795f360b690cbbd491 Mon Sep 17 00:00:00 2001
From: Blurring Shadow <976999484@qq.com>
Date: Fri, 26 May 2023 11:44:52 +0800
Subject: [PATCH 6/6] build(cmake): update project version

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 89d3a439..b3127fdb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,7 @@ include(cmake/Utils.cmake)
 #
 project(
   stdsharp
-  VERSION 0.6.1
+  VERSION 0.6.2
   LANGUAGES CXX)
 
 config_lib(${PROJECT_NAME} INTERFACE STD 23)