[func.wrap.ref] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp295_0okp/{from.md → to.md} +240 -0

tmp/tmp295_0okp/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,240 @@

+#### Non-owning wrapper <a id="func.wrap.ref">[[func.wrap.ref]]</a>
+##### General <a id="func.wrap.ref.general">[[func.wrap.ref.general]]</a>
+The header provides partial specializations of `function_ref` for each
+combination of the possible replacements of the placeholders cv and
+*noex* where:
+- cv is either const or empty, and
+- *noex* is either `true` or `false`.
+##### Class template `function_ref` <a id="func.wrap.ref.class">[[func.wrap.ref.class]]</a>
+``` cpp
+namespace std {
+  template<class R, class... ArgTypes>
+  class function_ref<R(ArgTypes...) cv noexcept(noex)> {
+  public:
+    // [func.wrap.ref.ctor], constructors and assignment operators
+    template<class F> function_ref(F*) noexcept;
+    template<class F> constexpr function_ref(F&&) noexcept;
+    template<auto f> constexpr function_ref(nontype_t<f>) noexcept;
+    template<auto f, class U> constexpr function_ref(nontype_t<f>, U&&) noexcept;
+    template<auto f, class T> constexpr function_ref(nontype_t<f>, cv T*) noexcept;
+    constexpr function_ref(const function_ref&) noexcept = default;
+    constexpr function_ref& operator=(const function_ref&) noexcept = default;
+    template<class T> function_ref& operator=(T) = delete;
+    // [func.wrap.ref.inv], invocation
+    R operator()(ArgTypes...) const noexcept(noex);
+  private:
+    template<class... T>
+      static constexpr bool is-invocable-using = see belownc;             // exposition only
+    R (*thunk-ptr)(BoundEntityType, ArgTypes&&...) noexcept(noex);      // exposition only
+    BoundEntityType bound-entity;                                       // exposition only
+  };
+  // [func.wrap.ref.deduct], deduction guides
+  template<class F>
+    function_ref(F*) -> function_ref<F>;
+  template<auto f>
+    function_ref(nontype_t<f>) -> function_ref<see below>;
+  template<auto f, class T>
+    function_ref(nontype_t<f>, T&&) -> function_ref<see below>;
+}
+```
+An object of class `function_ref<R(Args...) cv noexcept(noex)>` stores a
+pointer to function *`thunk-ptr`* and an object *`bound-entity`*. The
+object *`bound-entity`* has an unspecified trivially copyable type
+*`BoundEntityType`*, that models `copyable` and is capable of storing a
+pointer to object value or a pointer to function value. The type of
+*`thunk-ptr`* is `R(*)(BoundEntityType, Args&&...) noexcept(noex)`.
+Each specialization of `function_ref` is a trivially copyable type
+[[term.trivially.copyable.type]] that models `copyable`.
+Within subclause  [[func.wrap.ref]], `call-args` is an argument pack
+with elements such that
+``` cpp
+decltype((call-args))...
+```
+denote `ArgTypes&&...` respectively.
+##### Constructors and assignment operators <a id="func.wrap.ref.ctor">[[func.wrap.ref.ctor]]</a>
+``` cpp
+template<class... T>
+  static constexpr bool is-invocable-using = see below;
+```
+If *noex* is `true`, *`is-invocable-using`*`<T...>` is equal to:
+``` cpp
+is_nothrow_invocable_r_v<R, T..., ArgTypes...>
+```
+Otherwise, *`is-invocable-using`*`<T...>` is equal to:
+``` cpp
+is_invocable_r_v<R, T..., ArgTypes...>
+```
+``` cpp
+template<class F> function_ref(F* f) noexcept;
+```
+*Constraints:*
+- `is_function_v<F>` is `true`, and
+- *`is-invocable-using`*`<F>` is `true`.
+*Preconditions:* `f` is not a null pointer.
+*Effects:* Initializes *bound-entity* with `f`, and *thunk-ptr* with the
+address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, `*`call-args`*`...)`.
+``` cpp
+template<class F> constexpr function_ref(F&& f) noexcept;
+```
+Let `T` be `remove_reference_t<F>`.
+*Constraints:*
+- `remove_cvref_t<F>` is not the same type as `function_ref`,
+- `is_member_pointer_v<T>` is `false`, and
+- *`is-invocable-using`*`<cv T&>` is `true`.
+*Effects:* Initializes *bound-entity* with `addressof(f)`, and
+*thunk-ptr* with the address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(static_cast<cv T&>(f), `*`call-args`*`...)`.
+``` cpp
+template<auto f> constexpr function_ref(nontype_t<f>) noexcept;
+```
+Let `F` be `decltype(f)`.
+*Constraints:* *`is-invocable-using`*`<F>` is `true`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Effects:* Initializes *bound-entity* with a pointer to an unspecified
+object or null pointer value, and *thunk-ptr* with the address of a
+function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, `*`call-args`*`...)`.
+``` cpp
+template<auto f, class U>
+  constexpr function_ref(nontype_t<f>, U&& obj) noexcept;
+```
+Let `T` be `remove_reference_t<U>` and `F` be `decltype(f)`.
+*Constraints:*
+- `is_rvalue_reference_v<U&&>` is `false`, and
+- *`is-invocable-using`*`<F, cv T&>` is `true`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Effects:* Initializes *bound-entity* with `addressof(obj)`, and
+*thunk-ptr* with the address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, static_cast<cv T&>(obj), `*`call-args`*`...)`.
+``` cpp
+template<auto f, class T>
+  constexpr function_ref(nontype_t<f>, cv T* obj) noexcept;
+```
+Let `F` be `decltype(f)`.
+*Constraints:* *`is-invocable-using`*`<F, cv T*>` is `true`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Preconditions:* If `is_member_pointer_v<F>` is `true`, `obj` is not a
+null pointer.
+*Effects:* Initializes *bound-entity* with `obj`, and *thunk-ptr* with
+the address of a function *`thunk`* such that
+*`thunk`*`(`*`bound-entity`*`, `*`call-args`*`...)` is
+expression-equivalent [[defns.expression.equivalent]] to
+`invoke_r<R>(f, obj, `*`call-args`*`...)`.
+``` cpp
+template<class T> function_ref& operator=(T) = delete;
+```
+*Constraints:*
+- `T` is not the same type as `function_ref`,
+- `is_pointer_v<T>` is `false`, and
+- `T` is not a specialization of `nontype_t`.
+##### Invocation <a id="func.wrap.ref.inv">[[func.wrap.ref.inv]]</a>
+``` cpp
+R operator()(ArgTypes... args) const noexcept(noex);
+```
+*Effects:* Equivalent to:
+`return `*`thunk-ptr`*`(`*`bound-entity`*`, std::forward<ArgTypes>(args)...);`
+##### Deduction guides <a id="func.wrap.ref.deduct">[[func.wrap.ref.deduct]]</a>
+``` cpp
+template<class F>
+  function_ref(F*) -> function_ref<F>;
+```
+*Constraints:* `is_function_v<F>` is `true`.
+``` cpp
+template<auto f>
+  function_ref(nontype_t<f>) -> function_ref<see below>;
+```
+Let `F` be `remove_pointer_t<decltype(f)>`.
+*Constraints:* `is_function_v<F>` is `true`.
+*Remarks:* The deduced type is `function_ref<F>`.
+``` cpp
+template<auto f, class T>
+  function_ref(nontype_t<f>, T&&) -> function_ref<see below>;
+```
+Let `F` be `decltype(f)`.
+*Constraints:*
+- `F` is of the form `R(G::*)(A...) cv `\\ₒₚₜ ` noexcept(E)` for a type
+  `G`, or
+- `F` is of the form `M G::*` for a type `G` and an object type `M`, in
+  which case let `R` be `invoke_result_t<F, T&>`, `A...` be an empty
+  pack, and `E` be `false`, or
+- `F` is of the form `R(*)(G, A...) noexcept(E)` for a type `G`.
+*Remarks:* The deduced type is `function_ref<R(A...) noexcept(E)>`.

Diff to HTML by rtfpessoa