Refactor lifetime model selection into type traits (#69)

Replace the `*_impl` proxy creation functions with type traits that name the
selected lifetime model, so that the models can be reused by types other than
`proxy` (e.g. an upcoming `box`). No observable behavior change.

- Rename the internal `allocated_ptr` class template to `wide_ptr`, and add
  `allocated_ptr`, `owned_ptr` and `shared_ptr` type traits that select a
  lifetime model instead of constructing a `proxy` directly. The creation
  functions now construct `proxy<F>` from the selected pointer type.
- Let `inplace_ptr` ignore its first constructor argument so that all owning
  lifetime models share a uniform `(alloc, args...)` construction signature.
- Order the `T&& value` overload first in each creation function family, and
  renumber the corresponding specs to match.

Author: mingxwa

docs/spec/allocate_proxy.md

@@ -8,23 +8,23 @@ The definition of `allocate_proxy` makes use of an exposition-only class templat
 
 ```cpp
 // (1)
+template <facade F, class Alloc, class T>
+proxy<F> allocate_proxy(const Alloc& alloc, T&& value);  // freestanding-deleted
+
+// (2)
 template <facade F, class T, class Alloc, class... Args>
 proxy<F> allocate_proxy(const Alloc& alloc, Args&&... args);  // freestanding-deleted
 
-// (2)
+// (3)
 template <facade F, class T, class Alloc, class U, class... Args>
 proxy<F> allocate_proxy(const Alloc& alloc, std::initializer_list<U> il, Args&&... args);  // freestanding-deleted
-
-// (3)
-template <facade F, class Alloc, class T>
-proxy<F> allocate_proxy(const Alloc& alloc, T&& value);  // freestanding-deleted
 ```
 
-`(1)` Creates a `proxy<F>` object containing a value `p` of type *allocated-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<Args>(args)...`.
+`(1)` Creates a `proxy<F>` object containing a value `p` of type *allocated-ptr&lt;*`std::decay_t<T>`*, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<T>(value)`.
 
-`(2)` Creates a `proxy<F>` object containing a value `p` of type *allocated-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `il, std::forward<Args>(args)...`.
+`(2)` Creates a `proxy<F>` object containing a value `p` of type *allocated-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<Args>(args)...`.
 
-`(3)` Creates a `proxy<F>` object containing a value `p` of type *allocated-ptr&lt;*`std::decay_t<T>`*, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<T>(value)`.
+`(3)` Creates a `proxy<F>` object containing a value `p` of type *allocated-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `il, std::forward<Args>(args)...`.
 
 *Since 3.3.0*: For `(1-3)`, if [`proxiable_target<std::decay_t<T>, F>`](proxiable_target.md) is `false`, the program is ill-formed and diagnostic messages are generated.
 

docs/spec/allocate_proxy_shared.md

@@ -9,23 +9,23 @@ The definition of `allocate_proxy_shared` makes use of exposition-only class tem
 
 ```cpp
 // (1)
+template <facade F, class Alloc, class T>
+proxy<F> allocate_proxy_shared(const Alloc& alloc, T&& value);  // freestanding-deleted
+
+// (2)
 template <facade F, class T, class Alloc, class... Args>
 proxy<F> allocate_proxy_shared(const Alloc& alloc, Args&&... args);  // freestanding-deleted
 
-// (2)
+// (3)
 template <facade F, class T, class Alloc, class U, class... Args>
 proxy<F> allocate_proxy_shared(const Alloc& alloc, std::initializer_list<U> il, Args&&... args);  // freestanding-deleted
-
-// (3)
-template <facade F, class Alloc, class T>
-proxy<F> allocate_proxy_shared(const Alloc& alloc, T&& value);  // freestanding-deleted
 ```
 
-`(1)` Creates a `proxy<F>` object containing a value `p` of type *strong-compact-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<Args>(args)...`.
+`(1)` Creates a `proxy<F>` object containing a value `p` of type *strong-compact-ptr&lt;*`std::decay_t<T>`*, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<T>(value)`.
 
-`(2)` Creates a `proxy<F>` object containing a value `p` of type *strong-compact-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `il, std::forward<Args>(args)...`.
+`(2)` Creates a `proxy<F>` object containing a value `p` of type *strong-compact-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<Args>(args)...`.
 
-`(3)` Creates a `proxy<F>` object containing a value `p` of type *strong-compact-ptr&lt;*`std::decay_t<T>`*, Alloc&gt;*, where `*p` is direct-non-list-initialized with `std::forward<T>(value)`.
+`(3)` Creates a `proxy<F>` object containing a value `p` of type *strong-compact-ptr&lt;T, Alloc&gt;*, where `*p` is direct-non-list-initialized with `il, std::forward<Args>(args)...`.
 
 For `(1-3)`, if [`proxiable_target<std::decay_t<T>, F>`](proxiable_target.md) is `false`, the program is ill-formed and diagnostic messages are generated.
 

docs/spec/make_proxy.md

@@ -19,23 +19,23 @@ proxy<F> make-proxy-internal(Args&&... args) {
 
 ```cpp
 // (1)
+template <facade F, class T>
+proxy<F> make_proxy(T&& value);  // freestanding-deleted
+
+// (2)
 template <facade F, class T, class... Args>
 proxy<F> make_proxy(Args&&... args);  // freestanding-deleted
 
-// (2)
+// (3)
 template <facade F, class T, class U, class... Args>
 proxy<F> make_proxy(std::initializer_list<U> il, Args&&... args);  // freestanding-deleted
-
-// (3)
-template <facade F, class T>
-proxy<F> make_proxy(T&& value);  // freestanding-deleted
 ```
 
-`(1)` Equivalent to `return make-proxy-internal<F, T>(std::forward<Args>(args)...)`.
+`(1)` Equivalent to `return make-proxy-internal<F, std::decay_t<T>>(std::forward<T>(value))`.
 
-`(2)` Equivalent to `return make-proxy-internal<F, T>(il, std::forward<Args>(args)...)`.
+`(2)` Equivalent to `return make-proxy-internal<F, T>(std::forward<Args>(args)...)`.
 
-`(3)` Equivalent to `return make-proxy-internal<F, std::decay_t<T>>(std::forward<T>(value))`.
+`(3)` Equivalent to `return make-proxy-internal<F, T>(il, std::forward<Args>(args)...)`.
 
 *Since 3.3.0*: For `(1-3)`, if [`proxiable_target<std::decay_t<T>, F>`](proxiable_target.md) is `false`, the program is ill-formed and diagnostic messages are generated.
 

docs/spec/make_proxy_inplace.md

@@ -8,30 +8,30 @@ The definition of `make_proxy_inplace` makes use of an exposition-only class tem
 
 ```cpp
 // (1)
+template <facade F, class T>
+proxy<F> make_proxy_inplace(T&& value)
+    noexcept(std::is_nothrow_constructible_v<std::decay_t<T>, T>)
+    requires(std::is_constructible_v<std::decay_t<T>, T>);
+
+// (2)
 template <facade F, class T, class... Args>
 proxy<F> make_proxy_inplace(Args&&... args)
     noexcept(std::is_nothrow_constructible_v<T, Args...>)
     requires(std::is_constructible_v<T, Args...>);
 
-// (2)
+// (3)
 template <facade F, class T, class U, class... Args>
 proxy<F> make_proxy_inplace(std::initializer_list<U> il, Args&&... args)
     noexcept(std::is_nothrow_constructible_v<
         T, std::initializer_list<U>&, Args...>)
     requires(std::is_constructible_v<T, std::initializer_list<U>&, Args...>);
-
-// (3)
-template <facade F, class T>
-proxy<F> make_proxy_inplace(T&& value)
-    noexcept(std::is_nothrow_constructible_v<std::decay_t<T>, T>)
-    requires(std::is_constructible_v<std::decay_t<T>, T>);
 ```
 
-`(1)` Creates a `proxy<F>` object containing a value `p` of type *inplace-ptr&lt;T&gt;*, where `*p` is direct-non-list-initialized with `std::forward<Args>(args)...`.
+`(1)` Creates a `proxy<F>` object containing a value `p` of type *inplace-ptr&lt;*`std::decay_t`*&gt;*, where `*p` is direct-non-list-initialized with `std::forward<T>(value)`.
 
-`(2)` Creates a `proxy<F>` object containing a value `p` of type *inplace-ptr&lt;T&gt;*, where `*p` is direct-non-list-initialized with `il, std::forward<Args>(args)...`.
+`(2)` Creates a `proxy<F>` object containing a value `p` of type *inplace-ptr&lt;T&gt;*, where `*p` is direct-non-list-initialized with `std::forward<Args>(args)...`.
 
-`(3)` Creates a `proxy<F>` object containing a value `p` of type *inplace-ptr&lt;*`std::decay_t`*&gt;*, where `*p` is direct-non-list-initialized with `std::forward<T>(value)`.
+`(3)` Creates a `proxy<F>` object containing a value `p` of type *inplace-ptr&lt;T&gt;*, where `*p` is direct-non-list-initialized with `il, std::forward<Args>(args)...`.
 
 *Since 3.3.0*: For `(1-3)`, if [`inplace_proxiable_target<std::decay_t<T>, F>`](inplace_proxiable_target.md) is `false`, the program is ill-formed and diagnostic messages are generated.
 

docs/spec/make_proxy_shared.md

@@ -7,23 +7,23 @@
 
 ```cpp
 // (1)
+template <facade F, class T>
+proxy<F> make_proxy_shared(T&& value);  // freestanding-deleted
+
+// (2)
 template <facade F, class T, class... Args>
 proxy<F> make_proxy_shared(Args&&... args);  // freestanding-deleted
 
-// (2)
+// (3)
 template <facade F, class T, class U, class... Args>
 proxy<F> make_proxy_shared(std::initializer_list<U> il, Args&&... args);  // freestanding-deleted
-
-// (3)
-template <facade F, class T>
-proxy<F> make_proxy_shared(T&& value);  // freestanding-deleted
 ```
 
-`(1)` Equivalent to `return allocate_proxy_shared<F, T>(std::allocator<void>{}, std::forward<Args>(args)...)`.
+`(1)` Equivalent to `return allocate_proxy_shared<F, std::decay_t<T>>(std::allocator<void>{}, std::forward<T>(value))`.
 
-`(2)` Equivalent to `return allocate_proxy_shared<F, T>(std::allocator<void>{}, il, std::forward<Args>(args)...)`.
+`(2)` Equivalent to `return allocate_proxy_shared<F, T>(std::allocator<void>{}, std::forward<Args>(args)...)`.
 
-`(3)` Equivalent to `return allocate_proxy_shared<F, std::decay_t<T>>(std::allocator<void>{}, std::forward<T>(value))`.
+`(3)` Equivalent to `return allocate_proxy_shared<F, T>(std::allocator<void>{}, il, std::forward<Args>(args)...)`.
 
 *Since 3.3.0*: For `(1-3)`, if [`proxiable_target<std::decay_t<T>, F>`](proxiable_target.md) is `false`, the program is ill-formed and diagnostic messages are generated.
 

include/proxy/v4/detail/core.h

@@ -716,8 +716,8 @@ struct meta_storage : facade_traits<F>::meta_storage_base {
 template <class T>
 class inplace_ptr {
 public:
-  template <class... Args>
-  explicit inplace_ptr(std::in_place_t, Args&&... args)
+  template <class Ignore, class... Args>
+  explicit inplace_ptr(const Ignore&, Args&&... args)
       : value_(std::forward<Args>(args)...) {}
   inplace_ptr() = default;
   inplace_ptr(const inplace_ptr&) = default;