Init

2025-10-25 03:02:53 +03:00
commit 043225d523
3416 changed files with 681196 additions and 0 deletions
--- a/cppdraft/arithmetic/operations.md
+++ b/cppdraft/arithmetic/operations.md
@@ -0,0 +1,268 @@
+[arithmetic.operations]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations)
+
+### 22.10.7 Arithmetic operations [arithmetic.operations]
+
+#### [22.10.7.1](#general) General [[arithmetic.operations.general]](arithmetic.operations.general)
+
+[1](#general-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L11999)
+
+The library provides basic function object classes for all of the arithmetic
+operators in the language ([[expr.mul]](expr.mul "7.6.5 Multiplicative operators"), [[expr.add]](expr.add "7.6.6 Additive operators"))[.](#general-1.sentence-1)
+
+#### [22.10.7.2](#plus) Class template plus [[arithmetic.operations.plus]](arithmetic.operations.plus)
+
+[ð](#lib:plus)
+
+`template<class T = void> struct plus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),plus)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#plus-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12018)
+
+*Returns*: x + y[.](#plus-1.sentence-1)
+
+[ð](#lib:plus%3c%3e)
+
+`template<> struct plus<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) + std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),plus%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) + std::forward<U>(u));
+`
+
+[2](#plus-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12040)
+
+*Returns*: std::forward<T>(t) + std::forward<U>(u)[.](#plus-2.sentence-1)
+
+#### [22.10.7.3](#minus) Class template minus [[arithmetic.operations.minus]](arithmetic.operations.minus)
+
+[ð](#lib:minus)
+
+`template<class T = void> struct minus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),minus)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#minus-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12060)
+
+*Returns*: x - y[.](#minus-1.sentence-1)
+
+[ð](#lib:minus%3c%3e)
+
+`template<> struct minus<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) - std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),minus%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) - std::forward<U>(u));
+`
+
+[2](#minus-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12082)
+
+*Returns*: std::forward<T>(t) - std::forward<U>(u)[.](#minus-2.sentence-1)
+
+#### [22.10.7.4](#multiplies) Class template multiplies [[arithmetic.operations.multiplies]](arithmetic.operations.multiplies)
+
+[ð](#lib:multiplies)
+
+`template<class T = void> struct multiplies {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),multiplies)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#multiplies-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12102)
+
+*Returns*: x * y[.](#multiplies-1.sentence-1)
+
+[ð](#lib:multiplies%3c%3e)
+
+`template<> struct multiplies<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) * std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),multiplies%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) * std::forward<U>(u));
+`
+
+[2](#multiplies-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12124)
+
+*Returns*: std::forward<T>(t) * std::forward<U>(u)[.](#multiplies-2.sentence-1)
+
+#### [22.10.7.5](#divides) Class template divides [[arithmetic.operations.divides]](arithmetic.operations.divides)
+
+[ð](#lib:divides)
+
+`template<class T = void> struct divides {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),divides)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#divides-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12144)
+
+*Returns*: x / y[.](#divides-1.sentence-1)
+
+[ð](#lib:divides%3c%3e)
+
+`template<> struct divides<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) / std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),divides%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) / std::forward<U>(u));
+`
+
+[2](#divides-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12166)
+
+*Returns*: std::forward<T>(t) / std::forward<U>(u)[.](#divides-2.sentence-1)
+
+#### [22.10.7.6](#modulus) Class template modulus [[arithmetic.operations.modulus]](arithmetic.operations.modulus)
+
+[ð](#lib:modulus)
+
+`template<class T = void> struct modulus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),modulus)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#modulus-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12186)
+
+*Returns*: x % y[.](#modulus-1.sentence-1)
+
+[ð](#lib:modulus%3c%3e)
+
+`template<> struct modulus<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) % std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),modulus%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) % std::forward<U>(u));
+`
+
+[2](#modulus-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12208)
+
+*Returns*: std::forward<T>(t) % std::forward<U>(u)[.](#modulus-2.sentence-1)
+
+#### [22.10.7.7](#negate) Class template negate [[arithmetic.operations.negate]](arithmetic.operations.negate)
+
+[ð](#lib:negate)
+
+`template<class T = void> struct negate {
+  constexpr T operator()(const T& x) const;
+};
+`
+
+[ð](#lib:operator(),negate)
+
+`constexpr T operator()(const T& x) const;
+`
+
+[1](#negate-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12228)
+
+*Returns*: -x[.](#negate-1.sentence-1)
+
+[ð](#lib:negate%3c%3e)
+
+`template<> struct negate<void> {
+  template<class T> constexpr auto operator()(T&& t) const
+    -> decltype(-std::forward<T>(t));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),negate%3c%3e)
+
+`template<class T> constexpr auto operator()(T&& t) const
+    -> decltype(-std::forward<T>(t));
+`
+
+[2](#negate-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12250)
+
+*Returns*: -std::forward<T>(t)[.](#negate-2.sentence-1)
--- a/cppdraft/arithmetic/operations/divides.md
+++ b/cppdraft/arithmetic/operations/divides.md
@@ -0,0 +1,49 @@
+[arithmetic.operations.divides]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.divides)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#divides)
+
+#### 22.10.7.5 Class template divides [arithmetic.operations.divides]
+
+[ð](#lib:divides)
+
+`template<class T = void> struct divides {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),divides)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12144)
+
+*Returns*: x / y[.](#1.sentence-1)
+
+[ð](#lib:divides%3c%3e)
+
+`template<> struct divides<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) / std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),divides%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) / std::forward<U>(u));
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12166)
+
+*Returns*: std::forward<T>(t) / std::forward<U>(u)[.](#2.sentence-1)
--- a/cppdraft/arithmetic/operations/general.md
+++ b/cppdraft/arithmetic/operations/general.md
@@ -0,0 +1,16 @@
+[arithmetic.operations.general]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.general)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#general)
+
+#### 22.10.7.1 General [arithmetic.operations.general]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L11999)
+
+The library provides basic function object classes for all of the arithmetic
+operators in the language ([[expr.mul]](expr.mul "7.6.5 Multiplicative operators"), [[expr.add]](expr.add "7.6.6 Additive operators"))[.](#1.sentence-1)
--- a/cppdraft/arithmetic/operations/minus.md
+++ b/cppdraft/arithmetic/operations/minus.md
@@ -0,0 +1,49 @@
+[arithmetic.operations.minus]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.minus)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#minus)
+
+#### 22.10.7.3 Class template minus [arithmetic.operations.minus]
+
+[ð](#lib:minus)
+
+`template<class T = void> struct minus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),minus)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12060)
+
+*Returns*: x - y[.](#1.sentence-1)
+
+[ð](#lib:minus%3c%3e)
+
+`template<> struct minus<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) - std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),minus%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) - std::forward<U>(u));
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12082)
+
+*Returns*: std::forward<T>(t) - std::forward<U>(u)[.](#2.sentence-1)
--- a/cppdraft/arithmetic/operations/modulus.md
+++ b/cppdraft/arithmetic/operations/modulus.md
@@ -0,0 +1,49 @@
+[arithmetic.operations.modulus]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.modulus)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#modulus)
+
+#### 22.10.7.6 Class template modulus [arithmetic.operations.modulus]
+
+[ð](#lib:modulus)
+
+`template<class T = void> struct modulus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),modulus)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12186)
+
+*Returns*: x % y[.](#1.sentence-1)
+
+[ð](#lib:modulus%3c%3e)
+
+`template<> struct modulus<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) % std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),modulus%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) % std::forward<U>(u));
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12208)
+
+*Returns*: std::forward<T>(t) % std::forward<U>(u)[.](#2.sentence-1)
--- a/cppdraft/arithmetic/operations/multiplies.md
+++ b/cppdraft/arithmetic/operations/multiplies.md
@@ -0,0 +1,49 @@
+[arithmetic.operations.multiplies]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.multiplies)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#multiplies)
+
+#### 22.10.7.4 Class template multiplies [arithmetic.operations.multiplies]
+
+[ð](#lib:multiplies)
+
+`template<class T = void> struct multiplies {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),multiplies)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12102)
+
+*Returns*: x * y[.](#1.sentence-1)
+
+[ð](#lib:multiplies%3c%3e)
+
+`template<> struct multiplies<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) * std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),multiplies%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) * std::forward<U>(u));
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12124)
+
+*Returns*: std::forward<T>(t) * std::forward<U>(u)[.](#2.sentence-1)
--- a/cppdraft/arithmetic/operations/negate.md
+++ b/cppdraft/arithmetic/operations/negate.md
@@ -0,0 +1,49 @@
+[arithmetic.operations.negate]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.negate)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#negate)
+
+#### 22.10.7.7 Class template negate [arithmetic.operations.negate]
+
+[ð](#lib:negate)
+
+`template<class T = void> struct negate {
+  constexpr T operator()(const T& x) const;
+};
+`
+
+[ð](#lib:operator(),negate)
+
+`constexpr T operator()(const T& x) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12228)
+
+*Returns*: -x[.](#1.sentence-1)
+
+[ð](#lib:negate%3c%3e)
+
+`template<> struct negate<void> {
+  template<class T> constexpr auto operator()(T&& t) const
+    -> decltype(-std::forward<T>(t));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),negate%3c%3e)
+
+`template<class T> constexpr auto operator()(T&& t) const
+    -> decltype(-std::forward<T>(t));
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12250)
+
+*Returns*: -std::forward<T>(t)[.](#2.sentence-1)
--- a/cppdraft/arithmetic/operations/plus.md
+++ b/cppdraft/arithmetic/operations/plus.md
@@ -0,0 +1,49 @@
+[arithmetic.operations.plus]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#arithmetic.operations.plus)
+
+### 22.10.7 Arithmetic operations [[arithmetic.operations]](arithmetic.operations#plus)
+
+#### 22.10.7.2 Class template plus [arithmetic.operations.plus]
+
+[ð](#lib:plus)
+
+`template<class T = void> struct plus {
+  constexpr T operator()(const T& x, const T& y) const;
+};
+`
+
+[ð](#lib:operator(),plus)
+
+`constexpr T operator()(const T& x, const T& y) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12018)
+
+*Returns*: x + y[.](#1.sentence-1)
+
+[ð](#lib:plus%3c%3e)
+
+`template<> struct plus<void> {
+  template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) + std::forward<U>(u));
+
+  using is_transparent = unspecified;
+};
+`
+
+[ð](#lib:operator(),plus%3c%3e)
+
+`template<class T, class U> constexpr auto operator()(T&& t, U&& u) const
+    -> decltype(std::forward<T>(t) + std::forward<U>(u));
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12040)
+
+*Returns*: std::forward<T>(t) + std::forward<U>(u)[.](#2.sentence-1)