[concepts.lang] - C++17 → C++20

Files changed (1) hide show

tmp/tmps1qh905x/{from.md → to.md} +421 -0

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

	@@ -0,0 +1,421 @@

+## Language-related concepts <a id="concepts.lang">[[concepts.lang]]</a>
+### General <a id="concepts.lang.general">[[concepts.lang.general]]</a>
+Subclause [[concepts.lang]] contains the definition of concepts
+corresponding to language features. These concepts express relationships
+between types, type classifications, and fundamental type properties.
+### Concept  <a id="concept.same">[[concept.same]]</a>
+``` cpp
+template<class T, class U>
+  concept same-as-impl = is_same_v<T, U>;       // exposition only
+template<class T, class U>
+  concept same_as = same-as-impl<T, U> && same-as-impl<U, T>;
+```
+[*Note 1*: `same_as<T, U>` subsumes `same_as<U, T>` and vice
+versa. — *end note*]
+### Concept  <a id="concept.derived">[[concept.derived]]</a>
+``` cpp
+template<class Derived, class Base>
+  concept derived_from =
+    is_base_of_v<Base, Derived> &&
+    is_convertible_v<const volatile Derived*, const volatile Base*>;
+```
+[*Note 1*: `derived_from<Derived, Base>` is satisfied if and only if
+`Derived` is publicly and unambiguously derived from `Base`, or
+`Derived` and `Base` are the same class type ignoring
+cv-qualifiers. — *end note*]
+### Concept  <a id="concept.convertible">[[concept.convertible]]</a>
+Given types `From` and `To` and an expression `E` such that
+`decltype((E))` is `add_rvalue_reference_t<From>`,
+`convertible_to<From, To>` requires `E` to be both implicitly and
+explicitly convertible to type `To`. The implicit and explicit
+conversions are required to produce equal results.
+``` cpp
+template<class From, class To>
+  concept convertible_to =
+    is_convertible_v<From, To> &&
+    requires(add_rvalue_reference_t<From> (&f)()) {
+      static_cast<To>(f());
+    };
+```
+Let `FromR` be `add_rvalue_reference_t<From>` and `test` be the invented
+function:
+``` cpp
+To test(FromR (&f)()) {
+  return f();
+}
+```
+and let `f` be a function with no arguments and return type `FromR` such
+that `f()` is equality-preserving. Types `From` and `To` model
+`convertible_to<From, To>` only if:
+- `To` is not an object or reference-to-object type, or
+  `static_cast<To>(f())` is equal to `test(f)`.
+- `FromR` is not a reference-to-object type, or
+  - If `FromR` is an rvalue reference to a non const-qualified type, the
+    resulting state of the object referenced by `f()` after either above
+    expression is valid but unspecified [[lib.types.movedfrom]].
+  - Otherwise, the object referred to by `f()` is not modified by either
+    above expression.
+### Concept  <a id="concept.commonref">[[concept.commonref]]</a>
+For two types `T` and `U`, if `common_reference_t<T, U>` is well-formed
+and denotes a type `C` such that both `convertible_to<T, C>` and
+`convertible_to<U, C>` are modeled, then `T` and `U` share a *common
+reference type*, `C`.
+[*Note 1*: `C` could be the same as `T`, or `U`, or it could be a
+different type. `C` may be a reference type. — *end note*]
+``` cpp
+template<class T, class U>
+  concept common_reference_with =
+    same_as<common_reference_t<T, U>, common_reference_t<U, T>> &&
+    convertible_to<T, common_reference_t<T, U>> &&
+    convertible_to<U, common_reference_t<T, U>>;
+```
+Let `C` be `common_reference_t<T, U>`. Let `t1` and `t2` be
+equality-preserving expressions [[concepts.equality]] such that
+`decltype((t1))` and `decltype((t2))` are each `T`, and let `u1` and
+`u2` be equality-preserving expressions such that `decltype((u1))` and
+`decltype((u2))` are each `U`. `T` and `U` model
+`common_reference_with<T, U>` only if:
+- `C(t1)` equals `C(t2)` if and only if `t1` equals `t2`, and
+- `C(u1)` equals `C(u2)` if and only if `u1` equals `u2`.
+[*Note 1*: Users can customize the behavior of `common_reference_with`
+by specializing the `basic_common_reference` class
+template [[meta.trans.other]]. — *end note*]
+### Concept  <a id="concept.common">[[concept.common]]</a>
+If `T` and `U` can both be explicitly converted to some third type, `C`,
+then `T` and `U` share a *common type*, `C`.
+[*Note 1*: `C` could be the same as `T`, or `U`, or it could be a
+different type. `C` might not be unique. — *end note*]
+``` cpp
+template<class T, class U>
+  concept common_with =
+    same_as<common_type_t<T, U>, common_type_t<U, T>> &&
+    requires {
+      static_cast<common_type_t<T, U>>(declval<T>());
+      static_cast<common_type_t<T, U>>(declval<U>());
+    } &&
+    common_reference_with<
+      add_lvalue_reference_t<const T>,
+      add_lvalue_reference_t<const U>> &&
+    common_reference_with<
+      add_lvalue_reference_t<common_type_t<T, U>>,
+      common_reference_t<
+        add_lvalue_reference_t<const T>,
+        add_lvalue_reference_t<const U>>>;
+```
+Let `C` be `common_type_t<T, U>`. Let `t1` and `t2` be
+equality-preserving expressions [[concepts.equality]] such that
+`decltype((t1))` and `decltype((t2))` are each `T`, and let `u1` and
+`u2` be equality-preserving expressions such that `decltype((u1))` and
+`decltype((u2))` are each `U`. `T` and `U` model `common_with<T, U>`
+only if:
+- `C(t1)` equals `C(t2)` if and only if `t1` equals `t2`, and
+- `C(u1)` equals `C(u2)` if and only if `u1` equals `u2`.
+[*Note 1*: Users can customize the behavior of `common_with` by
+specializing the `common_type` class
+template [[meta.trans.other]]. — *end note*]
+### Arithmetic concepts <a id="concepts.arithmetic">[[concepts.arithmetic]]</a>
+``` cpp
+template<class T>
+  concept integral = is_integral_v<T>;
+template<class T>
+  concept signed_integral = integral<T> && is_signed_v<T>;
+template<class T>
+  concept unsigned_integral = integral<T> && !signed_integral<T>;
+template<class T>
+  concept floating_point = is_floating_point_v<T>;
+```
+[*Note 1*: `signed_integral` can be modeled even by types that are not
+signed integer types [[basic.fundamental]]; for example,
+`char`. — *end note*]
+[*Note 2*: `unsigned_integral` can be modeled even by types that are
+not unsigned integer types [[basic.fundamental]]; for example,
+`bool`. — *end note*]
+### Concept  <a id="concept.assignable">[[concept.assignable]]</a>
+``` cpp
+template<class LHS, class RHS>
+  concept assignable_from =
+    is_lvalue_reference_v<LHS> &&
+    common_reference_with<const remove_reference_t<LHS>&, const remove_reference_t<RHS>&> &&
+    requires(LHS lhs, RHS&& rhs) {
+      { lhs = std::forward<RHS>(rhs) } -> same_as<LHS>;
+    };
+```
+Let:
+- `lhs` be an lvalue that refers to an object `lcopy` such that
+  `decltype((lhs))` is `LHS`,
+- `rhs` be an expression such that `decltype((rhs))` is `RHS`, and
+- `rcopy` be a distinct object that is equal to `rhs`.
+`LHS` and `RHS` model `assignable_from<LHS, RHS>` only if
+- `addressof(lhs = rhs) == addressof(lcopy)`.
+- After evaluating `lhs = rhs`:
+  - `lhs` is equal to `rcopy`, unless `rhs` is a non-const xvalue that
+    refers to `lcopy`.
+  - If `rhs` is a non-`const` xvalue, the resulting state of the object
+    to which it refers is valid but unspecified [[lib.types.movedfrom]].
+  - Otherwise, if `rhs` is a glvalue, the object to which it refers is
+    not modified.
+[*Note 1*: Assignment need not be a total
+function [[structure.requirements]]; in particular, if assignment to an
+object `x` can result in a modification of some other object `y`, then
+`x = y` is likely not in the domain of `=`. — *end note*]
+### Concept  <a id="concept.swappable">[[concept.swappable]]</a>
+Let `t1` and `t2` be equality-preserving expressions that denote
+distinct equal objects of type `T`, and let `u1` and `u2` similarly
+denote distinct equal objects of type `U`.
+[*Note 1*: `t1` and `u1` can denote distinct objects, or the same
+object. — *end note*]
+An operation *exchanges the values* denoted by `t1` and `u1` if and only
+if the operation modifies neither `t2` nor `u2` and:
+- If `T` and `U` are the same type, the result of the operation is that
+  `t1` equals `u2` and `u1` equals `t2`.
+- If `T` and `U` are different types and
+  `common_reference_with<decltype((t1)), decltype((u1))>` is modeled,
+  the result of the operation is that `C(t1)` equals `C(u2)` and `C(u1)`
+  equals `C(t2)` where `C` is
+  `common_reference_t<decltype((t1)), decltype((u1))>`.
+The name `ranges::swap` denotes a customization point object
+[[customization.point.object]]. The expression `ranges::swap(E1, E2)`
+for subexpressions `E1` and `E2` is expression-equivalent to an
+expression `S` determined as follows:
+- `S` is `(void)swap(E1, E2)`[^1] if `E1` or `E2` has class or
+  enumeration type [[basic.compound]] and that expression is valid, with
+  overload resolution performed in a context that includes the
+  declaration
+  ``` cpp
+  template<class T>
+    void swap(T&, T&) = delete;
+  ```
+  and does not include a declaration of `ranges::swap`. If the function
+  selected by overload resolution does not exchange the values denoted
+  by `E1` and `E2`, the program is ill-formed, no diagnostic required.
+- Otherwise, if `E1` and `E2` are lvalues of array types
+  [[basic.compound]] with equal extent and `ranges::swap(*E1, *E2)` is a
+  valid expression, `S` is `(void)ranges::swap_ranges(E1, E2)`, except
+  that `noexcept(S)` is equal to `noexcept({}ranges::swap(*E1, *E2))`.
+- Otherwise, if `E1` and `E2` are lvalues of the same type `T` that
+  models `move_constructible<T>` and `assignable_from<T&, T>`, `S` is an
+  expression that exchanges the denoted values. `S` is a constant
+  expression if
+  - `T` is a literal type [[basic.types]],
+  - both `E1 = std::move(E2)` and `E2 = std::move(E1)` are constant
+    subexpressions [[defns.const.subexpr]], and
+  - the full-expressions of the initializers in the declarations
+    ``` cpp
+    T t1(std::move(E1));
+    T t2(std::move(E2));
+    ```
+    are constant subexpressions.
+  `noexcept(S)` is equal to
+  `is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>`.
+- Otherwise, `ranges::swap(E1, E2)` is ill-formed. \[*Note 2*: This case
+  can result in substitution failure when `ranges::swap(E1, E2)` appears
+  in the immediate context of a template instantiation. — *end note*]
+[*Note 3*: Whenever `ranges::swap(E1, E2)` is a valid expression, it
+exchanges the values denoted by `E1` and `E2` and has type
+`void`. — *end note*]
+``` cpp
+template<class T>
+  concept swappable = requires(T& a, T& b) { ranges::swap(a, b); };
+```
+``` cpp
+template<class T, class U>
+  concept swappable_with =
+    common_reference_with<T, U> &&
+    requires(T&& t, U&& u) {
+      ranges::swap(std::forward<T>(t), std::forward<T>(t));
+      ranges::swap(std::forward<U>(u), std::forward<U>(u));
+      ranges::swap(std::forward<T>(t), std::forward<U>(u));
+      ranges::swap(std::forward<U>(u), std::forward<T>(t));
+    };
+```
+[*Note 4*: The semantics of the `swappable` and `swappable_with`
+concepts are fully defined by the `ranges::swap` customization
+point. — *end note*]
+[*Example 1*:
+User code can ensure that the evaluation of `swap` calls is performed in
+an appropriate context under the various conditions as follows:
+``` cpp
+#include <cassert>
+#include <concepts>
+#include <utility>
+namespace ranges = std::ranges;
+template<class T, std::swappable_with<T> U>
+void value_swap(T&& t, U&& u) {
+  ranges::swap(std::forward<T>(t), std::forward<U>(u));
+}
+template<std::swappable T>
+void lv_swap(T& t1, T& t2) {
+  ranges::swap(t1, t2);
+}
+namespace N {
+  struct A { int m; };
+  struct Proxy {
+    A* a;
+    Proxy(A& a) : a{&a} {}
+    friend void swap(Proxy x, Proxy y) {
+      ranges::swap(*x.a, *y.a);
+    }
+  };
+  Proxy proxy(A& a) { return Proxy{ a }; }
+}
+int main() {
+  int i = 1, j = 2;
+  lv_swap(i, j);
+  assert(i == 2 && j == 1);
+  N::A a1 = { 5 }, a2 = { -5 };
+  value_swap(a1, proxy(a2));
+  assert(a1.m == -5 && a2.m == 5);
+}
+```
+— *end example*]
+### Concept  <a id="concept.destructible">[[concept.destructible]]</a>
+The `destructible` concept specifies properties of all types, instances
+of which can be destroyed at the end of their lifetime, or reference
+types.
+``` cpp
+template<class T>
+  concept destructible = is_nothrow_destructible_v<T>;
+```
+[*Note 1*: Unlike the *Cpp17Destructible*
+requirements ([[cpp17.destructible]]), this concept forbids destructors
+that are potentially throwing, even if a particular invocation of the
+destructor does not actually throw. — *end note*]
+### Concept  <a id="concept.constructible">[[concept.constructible]]</a>
+The `constructible_from` concept constrains the initialization of a
+variable of a given type with a particular set of argument types.
+``` cpp
+template<class T, class... Args>
+  concept constructible_from = destructible<T> && is_constructible_v<T, Args...>;
+```
+### Concept  <a id="concept.default.init">[[concept.default.init]]</a>
+``` cpp
+template<class T>
+  inline constexpr bool is-default-initializable = see below;  // exposition only
+template<class T>
+  concept default_initializable = constructible_from<T> &&
+                                  requires { T{}; } &&
+                                  is-default-initializable<T>;
+```
+For a type `T`, *`is-default-initializable`*`<T>` is `true` if and only
+if the variable definition
+``` cpp
+T t;
+```
+is well-formed for some invented variable `t`; otherwise it is `false`.
+Access checking is performed as if in a context unrelated to `T`. Only
+the validity of the immediate context of the variable initialization is
+considered.
+### Concept  <a id="concept.moveconstructible">[[concept.moveconstructible]]</a>
+``` cpp
+template<class T>
+  concept move_constructible = constructible_from<T, T> && convertible_to<T, T>;
+```
+If `T` is an object type, then let `rv` be an rvalue of type `T` and
+`u2` a distinct object of type `T` equal to `rv`. `T` models
+`move_constructible` only if
+- After the definition `T u = rv;`, `u` is equal to `u2`.
+- `T(rv)` is equal to `u2`.
+- If `T` is not `const`, `rv`’s resulting state is valid but
+  unspecified [[lib.types.movedfrom]]; otherwise, it is unchanged.
+### Concept  <a id="concept.copyconstructible">[[concept.copyconstructible]]</a>
+``` cpp
+template<class T>
+  concept copy_constructible =
+    move_constructible<T> &&
+    constructible_from<T, T&> && convertible_to<T&, T> &&
+    constructible_from<T, const T&> && convertible_to<const T&, T> &&
+    constructible_from<T, const T> && convertible_to<const T, T>;
+```
+If `T` is an object type, then let `v` be an lvalue of type (possibly
+`const`) `T` or an rvalue of type `const T`. `T` models
+`copy_constructible` only if
+- After the definition `T u = v;`, `u` is equal to `v`
+  [[concepts.equality]] and `v` is not modified.
+- `T(v)` is equal to `v` and does not modify `v`.

Diff to HTML by rtfpessoa