Rename to make_proxy_observed

Author: mingxwa

docs/spec/.pages

@@ -32,7 +32,7 @@ nav:
     - allocate_proxy_shared: allocate_proxy_shared.md
     - allocate_proxy: allocate_proxy.md
     - make_proxy_inplace: make_proxy_inplace.md
-    - make_proxy_ref: make_proxy_ref.md
+    - make_proxy_observed: make_proxy_observed.md
     - make_proxy_shared: make_proxy_shared.md
     - make_proxy_view: make_proxy_view.md
     - make_proxy: make_proxy.md

docs/spec/README.md

@@ -52,7 +52,7 @@ This document provides the API specifications for the C++ library Proxy (version
 | [`allocate_proxy_shared`](allocate_proxy_shared.md) | Creates a `proxy` object with shared ownership using an allocator |
 | [`allocate_proxy`](allocate_proxy.md)               | Creates a `proxy` object with an allocator                   |
 | [`make_proxy_inplace`](make_proxy_inplace.md)       | Creates a `proxy` object with strong no-allocation guarantee |
-| [`make_proxy_ref`](make_proxy_ref.md)               | Creates a `proxy` object with no ownership                   |
+| [`make_proxy_observed`](make_proxy_observed.md)     | Creates a `proxy` object with no ownership                   |
 | [`make_proxy_shared`](make_proxy_shared.md)         | Creates a `proxy` object with shared ownership               |
 | [`make_proxy_view`](make_proxy_view.md)             | Creates a `proxy_view` object                                |
 | [`make_proxy`](make_proxy.md)                       | Creates a `proxy` object potentially with heap allocation    |

docs/spec/make_proxy_ref.md docs/spec/make_proxy_observed.mddocs/spec/make_proxy_ref.md renamed to docs/spec/make_proxy_observed.md

@@ -1,15 +1,15 @@
-# Function template `make_proxy_ref`
+# Function template `make_proxy_observed`
 
 > Header: `proxy.h`  
 > Module: `proxy`  
 > Namespace: `pro::inline v4`  
 > Since: 4.1.0
 
-The definition of `make_proxy_ref` makes use of an exposition-only class template *observer-ptr*. `observer-ptr<T>` contains a raw pointer to an object of type `T`, and provides `operator*` for access with the same qualifiers.
+The definition of `make_proxy_observed` makes use of an exposition-only class template *observer-ptr*. `observer-ptr<T>` contains a raw pointer to an object of type `T`, and provides `operator*` for access with the same qualifiers.
 
 ```cpp
 template <facade F, class T>
-proxy<F> make_proxy_ref(T& value) noexcept;
+proxy<F> make_proxy_observed(T& value) noexcept;
 ```
 
 Creates a `proxy<F>` object containing a value `p` of type `observer-ptr<T>`, where `*p` is direct-non-list-initialized with `std::addressof(value)`. If [`proxiable_target<T, F>`](proxiable_target.md) is `false`, the program is ill-formed and diagnostic messages are generated.
@@ -32,7 +32,7 @@ struct Printable : pro::facade_builder //
 
 int main() {
   int val = 123;
-  pro::proxy<Printable> p = pro::make_proxy_ref<Printable>(val);
+  pro::proxy<Printable> p = pro::make_proxy_observed<Printable>(val);
 
   // Prints "123"
   std::cout << *p << "\n";

docs/spec/make_proxy_view.md

@@ -10,7 +10,7 @@ template <facade F, class T>
 proxy_view<F> make_proxy_view(T& value) noexcept;
 ```
 
-Equivalent to `return make_proxy_ref<observer_facade<F>>(value)`.
+Equivalent to `return make_proxy_observed<observer_facade<F>>(value)`.
 
 ## Return Value
 

docs/spec/proxiable_target.md

@@ -10,7 +10,7 @@ template <class T, class F>
 concept proxiable_target = proxiable<observer-ptr<T>, observer_facade<F>>;
 ```
 
-See [`make_proxy_ref`](make_proxy_ref.md) for the definition of the exposition-only class template *observer-ptr*.
+See [`make_proxy_observed`](make_proxy_observed.md) for the definition of the exposition-only class template *observer-ptr*.
 
 ## Example
 

include/proxy/v4/proxy.h

@@ -1819,13 +1819,13 @@ constexpr proxy<F> make_proxy_inplace(T&& value) noexcept(
 }
 
 template <facade F, class T>
-constexpr proxy<F> make_proxy_ref(T& value) noexcept {
+constexpr proxy<F> make_proxy_observed(T& value) noexcept {
   return proxy<F>{details::observer_ptr<T&, const T&, T&&, const T&&>{value}};
 }
 
 template <facade F, class T>
 constexpr proxy_view<F> make_proxy_view(T& value) noexcept {
-  return make_proxy_ref<observer_facade<F>>(value);
+  return make_proxy_observed<observer_facade<F>>(value);
 }
 
 #if __STDC_HOSTED__

include/proxy/v4/proxy.ixx

@@ -22,7 +22,7 @@ using v4::is_bitwise_trivially_relocatable;
 using v4::is_bitwise_trivially_relocatable_v;
 using v4::make_proxy;
 using v4::make_proxy_inplace;
-using v4::make_proxy_ref;
+using v4::make_proxy_observed;
 using v4::make_proxy_shared;
 using v4::make_proxy_view;
 using v4::not_implemented;

tests/proxy_creation_tests.cpp

@@ -1224,7 +1224,7 @@ TEST(ProxyCreationTests, TestMakeProxyView) {
   ASSERT_EQ((*std::move(std::as_const(p)))(), 3);
 }
 
-TEST(ProxyCreationTests, TestMakeProxyRef) {
+TEST(ProxyCreationTests, TestMakeProxyObserved) {
   struct TestFacade
       : pro::facade_builder //
         ::add_convention<pro::operator_dispatch<"()">, int() &, int() const&,
@@ -1238,12 +1238,12 @@ TEST(ProxyCreationTests, TestMakeProxyRef) {
     int operator()() const&& noexcept { return 3; }
   } test_callable;
 
-  pro::proxy<TestFacade> p = pro::make_proxy_ref<TestFacade>(test_callable);
+  pro::proxy<TestFacade> p = pro::make_proxy_observed<TestFacade>(test_callable);
   static_assert(!noexcept((*p)()));
   static_assert(noexcept((*std::move(p))()));
   ASSERT_EQ((*p)(), 0);
   ASSERT_EQ((*std::as_const(p))(), 1);
   ASSERT_EQ((*std::move(p))(), 2);
-  p = pro::make_proxy_ref<TestFacade>(test_callable);
+  p = pro::make_proxy_observed<TestFacade>(test_callable);
   ASSERT_EQ((*std::move(std::as_const(p)))(), 3);
 }