🔥 Remove memory.hpp

Problem:
- `memory.hpp` contains only `to_address`, which is a C++20 feature that has
  long since been supported in supported toolchains.
- See https://cppstat.dev/?search=to_address

Solution:
- Remove `memory.hpp`.

Author: elbeno

CMakeLists.txt

@@ -72,7 +72,6 @@ target_sources(
               include/stdx/intrusive_list.hpp
               include/stdx/iterator.hpp
               include/stdx/latched.hpp
-              include/stdx/memory.hpp
               include/stdx/numeric.hpp
               include/stdx/optional.hpp
               include/stdx/panic.hpp

docs/header_graph.mmd

@@ -19,8 +19,6 @@ flowchart BT
   type_traits --> ct_conversions
 
   %% level 3
-  memory(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/memory.hpp">memory.hpp</a>)
-  memory --> type_traits
   iterator(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/iterator.hpp">iterator.hpp</a>)
   iterator --> type_traits
   concepts(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/concepts.hpp">concepts.hpp</a>)
@@ -53,11 +51,9 @@ flowchart BT
 
   %% level 6
   span(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/span.hpp">span.hpp</a>)
-  span ----> memory
   span ----> iterator
   span --> bit
   byterator(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/byterator.hpp">byterator.hpp</a>)
-  byterator ----> memory
   byterator --> bit
   cx_set(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/cx_set.hpp">cx_set.hpp</a>)
   cx_set ---> cx_map

docs/index.adoc

@@ -33,7 +33,6 @@ include::intrusive_forward_list.adoc[]
 include::intrusive_list.adoc[]
 include::iterator.adoc[]
 include::latched.adoc[]
-include::memory.adoc[]
 include::numeric.adoc[]
 include::optional.adoc[]
 include::panic.adoc[]

docs/intro.adoc

@@ -88,7 +88,6 @@ The following headers are available:
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/intrusive_list.hpp[`intrusive_list.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/iterator.hpp[`iterator.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/latched.hpp[`latched.hpp`]
-* https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/memory.hpp[`memory.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/numeric.hpp[`numeric.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/optional.hpp[`optional.hpp`]
 * https://github.com/intel/cpp-std-extensions/blob/main/include/stdx/panic.hpp[`panic.hpp`]

docs/memory.adoc

@@ -2,14 +2,13 @@
 
 #include <stdx/bit.hpp>
 #include <stdx/concepts.hpp>
-#include <stdx/memory.hpp>
 #include <stdx/type_traits.hpp>
 #include <stdx/utility.hpp>
 
 #include <cstddef>
 #include <cstring>
-#include <functional>
 #include <iterator>
+#include <memory>
 #include <type_traits>
 
 namespace stdx {
@@ -45,7 +44,7 @@ template <typename T> class byterator {
     [[nodiscard]] friend constexpr auto operator==(byterator const &x, It y)
         -> bool {
         return static_cast<void const *>(x.ptr) ==
-               static_cast<void const *>(stdx::to_address(y));
+               static_cast<void const *>(std::to_address(y));
     }
 
     [[nodiscard]] friend constexpr auto operator<=>(byterator const &x,
@@ -56,7 +55,7 @@ template <typename T> class byterator {
         requires std::is_same_v<detail::iterator_value_t<It>, T>
     [[nodiscard]] friend constexpr auto operator<=>(byterator const &x, It y) {
         return static_cast<void const *>(x.ptr) <=>
-               static_cast<void const *>(stdx::to_address(y));
+               static_cast<void const *>(std::to_address(y));
     }
 
   public:
@@ -67,7 +66,7 @@ template <typename T> class byterator {
     using iterator_category = std::random_access_iterator_tag;
 
     template <detail::byteratorish It>
-    explicit byterator(It it) : ptr(bit_cast<byte_t *>(stdx::to_address(it))) {}
+    explicit byterator(It it) : ptr(bit_cast<byte_t *>(std::to_address(it))) {}
 
     [[nodiscard]] constexpr auto operator->() const -> byte_t * { return ptr; }
     [[nodiscard]] constexpr auto operator*() const -> byte_t & { return *ptr; }

include/stdx/byterator.hpp

@@ -4,14 +4,14 @@
 #include <stdx/compiler.hpp>
 #include <stdx/concepts.hpp>
 #include <stdx/iterator.hpp>
-#include <stdx/memory.hpp>
 #include <stdx/type_traits.hpp>
 
 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <iterator>
 #include <limits>
+#include <memory>
 #include <type_traits>
 
 namespace stdx {
@@ -85,12 +85,12 @@ class span : public detail::span_base<T, Extent> {
     template <typename It, typename SizeOrEnd>
         requires(dependent_extent<It> != dynamic_extent)
     explicit constexpr span(It first, SizeOrEnd)
-        : ptr{stdx::to_address(first)} {}
+        : ptr{std::to_address(first)} {}
 
     template <typename It, typename SizeOrEnd>
         requires(dependent_extent<It> == dynamic_extent)
     constexpr span(It first, SizeOrEnd sore)
-        : base_t{first, sore}, ptr{stdx::to_address(first)} {}
+        : base_t{first, sore}, ptr{std::to_address(first)} {}
 
     template <typename U, std::size_t N>
     constexpr explicit(false) span(std::array<U, N> &arr LIFETIMEBOUND) noexcept
@@ -120,13 +120,13 @@ class span : public detail::span_base<T, Extent> {
     template <typename R>
         requires(dependent_extent<R> != dynamic_extent)
     explicit constexpr span(R &&r)
-        : ptr{stdx::to_address(std::begin(std::forward<R>(r)))} {}
+        : ptr{std::to_address(std::begin(std::forward<R>(r)))} {}
 
     template <typename R>
         requires(dependent_extent<R> == dynamic_extent)
     explicit constexpr span(R &&r)
         : base_t{std::begin(std::forward<R>(r)), std::end(std::forward<R>(r))},
-          ptr{stdx::to_address(std::begin(std::forward<R>(r)))} {}
+          ptr{std::to_address(std::begin(std::forward<R>(r)))} {}
 
     template <class U, std::size_t N>
         requires(dependent_extent<U> != dynamic_extent and N == dynamic_extent)

include/stdx/memory.hpp

@@ -56,7 +56,6 @@ add_tests(
     is_constant_evaluated
     iterator
     latched
-    memory
     numeric
     optional
     overload

include/stdx/span.hpp

@@ -4,12 +4,13 @@
 
 #include <array>
 #include <iterator>
+#include <memory>
 
 TEST_CASE("constructible from an iterator", "[byterator]") {
     auto const a = std::array{1, 2, 3, 4};
     auto const b = stdx::byterator{std::begin(a)};
-    CHECK(static_cast<void const *>(stdx::to_address(std::begin(a))) ==
-          static_cast<void const *>(stdx::to_address(b)));
+    CHECK(static_cast<void const *>(std::to_address(std::begin(a))) ==
+          static_cast<void const *>(std::to_address(b)));
 }
 
 TEST_CASE("equality comparable to iterator", "[byterator]") {