add deduction guide with range to some containers.

Author: suomesta

reference/deque/deque/op_deduction_guide.md

@@ -9,13 +9,25 @@ namespace std {
   template <class InputIterator,
             class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
   deque(InputIterator, InputIterator, Allocator = Allocator())
-    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
+    -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>; // (1)
+
+  template <ranges::input_range R,
+            class Allocator = allocator<ranges::range_value_t<R>>>
+  deque(from_range_t, R&&, Allocator = Allocator())
+    -> deque<ranges::range_value_t<R>, Allocator>;                            // (2) C++23から
 }
 ```
 * iterator_traits[link /reference/iterator/iterator_traits.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* allocator[link /reference/memory/allocator.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
-`std::deque`クラステンプレートの型推論補助。イテレータ範囲から推論する。
+`std::deque`クラステンプレートの型推論補助。
+
+- (1) : イテレータ範囲から推論する。
+- (2) : Rangeから推論する。
 
 
 ## 例

reference/forward_list/forward_list/op_deduction_guide.md

@@ -9,13 +9,25 @@ namespace std {
   template <class InputIterator,
             class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
   forward_list(InputIterator, InputIterator, Allocator = Allocator())
-    -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;
+    -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>; // (1)
+
+  template <ranges::input_range R,
+            class Allocator = allocator<ranges::range_value_t<R>>>
+  forward_list(from_range_t, R&&, Allocator = Allocator())
+    -> forward_list<ranges::range_value_t<R>, Allocator>;                            // (2) C++23から
 }
 ```
 * iterator_traits[link /reference/iterator/iterator_traits.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* allocator[link /reference/memory/allocator.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
-`std::forward_list`クラステンプレートの型推論補助。イテレータ範囲から推論する。
+`std::forward_list`クラステンプレートの型推論補助。
+
+- (1) : イテレータ範囲から推論する。
+- (2) : Rangeから推論する。
 
 
 ## 例

reference/list/list/op_constructor.md

@@ -35,7 +35,7 @@ list(from_range_t, R&& rg,
      const Allocator& a = Allocator());          // (11) C++23 から
 ```
 * initializer_list[link /reference/initializer_list/initializer_list.md]
-* from_range_t[link ../../ranges/from_range_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 
 ## 概要

reference/list/list/op_deduction_guide.md

@@ -9,13 +9,25 @@ namespace std {
   template <class InputIterator,
             class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
   list(InputIterator, InputIterator, Allocator = Allocator())
-    -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;
+    -> list<typename iterator_traits<InputIterator>::value_type, Allocator>; // (1)
+
+  template <ranges::input_range R,
+            class Allocator = allocator<ranges::range_value_t<R>>>
+  list(from_range_t, R&&, Allocator = Allocator())
+    -> list<ranges::range_value_t<R>, Allocator>;                            // (2) C++23から
 }
 ```
 * iterator_traits[link /reference/iterator/iterator_traits.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* allocator[link /reference/memory/allocator.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
-`std::list`クラステンプレートの型推論補助。イテレータ範囲から推論する。
+`std::list`クラステンプレートの型推論補助。
+
+- (1) : イテレータ範囲から推論する。
+- (2) : Rangeから推論する。
 
 
 ## 例

reference/map/map/op_deduction_guide.md

@@ -14,6 +14,10 @@ namespace std {
   template <class InputIterator>
   using iter_to_alloc_t = pair<add_const_t<typename iterator_traits<InputIterator>::value_type::first_type>,
                                typename iterator_traits<InputIterator>::value_type::second_type>;
+  template <ranges::input_range Range>
+  using range_key_t = remove_const_t<typename ranges::range_value_t<Range>::first_type>;
+  template <ranges::input_range Range>
+  using range_val_t = typename ranges::range_value_t<Range>::second_type;
 
   template <class InputIterator,
             class Compare = less<iter_key_t<InputIterator>>,
@@ -36,6 +40,10 @@ namespace std {
   template <class Key, class T, class Allocator>
   map(initializer_list<pair<Key, T>>, Allocator)
     -> map<Key, T, less<Key>, Allocator>;                                             // (4)
+
+  template <ranges::input_range R, class Allocator>
+  map(from_range_t, R&&, Allocator)
+    -> map<range_key_t<R>, range_val_t<R>, less<range_key_t<R>>, Allocator>;          // (5) C++23から
 }
 ```
 * remove_const_t[link /reference/type_traits/remove_const.md]
@@ -45,6 +53,9 @@ namespace std {
 * less[link /reference/functional/less.md]
 * allocator[link /reference/memory/allocator.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
 `std::map`クラステンプレートの型推論補助。
@@ -53,6 +64,7 @@ namespace std {
 - (2) : 初期化子リストからの推論
 - (3) : イテレータ範囲とアロケータからの推論
 - (4) : 初期化子リストとアロケータからの推論
+- (5) : Rangeからの推論
 
 
 ## 備考

reference/map/multimap/op_deduction_guide.md

@@ -14,6 +14,10 @@ namespace std {
   template <class InputIterator>
   using iter_to_alloc_t = pair<add_const_t<typename iterator_traits<InputIterator>::value_type::first_type>,
                                typename iterator_traits<InputIterator>::value_type::second_type>;
+  template <ranges::input_range Range>
+  using range_key_t = remove_const_t<typename ranges::range_value_t<Range>::first_type>;
+  template <ranges::input_range Range>
+  using range_val_t = typename ranges::range_value_t<Range>::second_type;
 
   template <class InputIterator,
             class Compare = less<iter_key_t<InputIterator>>,
@@ -36,6 +40,10 @@ namespace std {
   template <class Key, class T, class Allocator>
   multimap(initializer_list<pair<Key, T>>, Allocator)
     -> multimap<Key, T, less<Key>, Allocator>;                                             // (4)
+
+  template <ranges::input_range R, class Allocator>
+  multimap(from_range_t, R&&, Allocator)
+    -> multimap<range_key_t<R>, range_val_t<R>, less<range_key_t<R>>, Allocator>;          // (5) C++23から
 }
 ```
 * remove_const_t[link /reference/type_traits/remove_const.md]
@@ -45,6 +53,9 @@ namespace std {
 * less[link /reference/functional/less.md]
 * allocator[link /reference/memory/allocator.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
 `std::multimap`クラステンプレートの型推論補助。
@@ -53,6 +64,7 @@ namespace std {
 - (2) : 初期化子リストからの推論
 - (3) : イテレータ範囲とアロケータからの推論
 - (4) : 初期化子リストとアロケータからの推論
+- (5) : Rangeからの推論
 
 
 ## 備考

reference/queue/priority_queue/op_deduction_guide.md

@@ -6,32 +6,76 @@
 
 ```cpp
 namespace std {
-  template <class Compare, class Container>
+  // 説明用の型
+  template <class InputIterator>
+  using iter_val_t = typename iterator_traits<InputIterator>::value_type;
+
+template <class Compare, class Container>
   priority_queue(Compare, Container)
     -> priority_queue<typename Container::value_type, Container, Compare>; // (1)
 
   template <class InputIterator,
-            class Compare = less<typename iterator_traits<InputIterator>::value_type>,
-            class Container = std::vector<typename iterator_traits<InputIterator>::value_type>>
+            class Compare = less<iter_val_t<InputIterator>>,
+            class Container = std::vector<iter_val_t<InputIterator>>>
   priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
-    -> priority_queue<
-         typename iterator_traits<InputIterator>::value_type,
-         Container, Compare>;                                              // (2)
+    -> priority_queue<iter_val_t<InputIterator>, Container, Compare>;      // (2)
+
+  template <ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+  priority_queue(from_range_t, R&&, Compare = Compare())
+    -> priority_queue<ranges::range_value_t<R>,
+                      vector<ranges::range_value_t<R>>, Compare>;          // (3) C++23から
 
   template <class Compare, class Container, class Allocator>
   priority_queue(Compare, Container, Allocator)
-    -> priority_queue<typename Container::value_type, Container, Compare>; // (3)
+    -> priority_queue<typename Container::value_type, Container, Compare>; // (4)
+
+  template <class InputIterator, class Allocator>
+  priority_queue(InputIterator, InputIterator, Allocator)
+    -> priority_queue<iter_val_t<InputIterator>,
+                      vector<iter_val_t<InputIterator>, Allocator>,
+                      less<iter_val_t<InputIterator>>>;                    // (5) C++23から
+
+  template <class InputIterator, class Compare, class Allocator>
+  priority_queue(InputIterator, InputIterator, Compare, Allocator)
+    -> priority_queue<iter_val_t<InputIterator>,
+                      vector<iter_val_t<InputIterator>, Allocator>,
+                      Compare>;                                            // (6) C++23から
+
+  template <class InputIterator, class Compare, class Container, class Allocator>
+  priority_queue(InputIterator, InputIterator, Compare, Container, Allocator)
+    -> priority_queue<typename Container::value_type, Container, Compare>; // (7) C++23から
+
+  template <ranges::input_range R, class Compare, class Allocator>
+  priority_queue(from_range_t, R&&, Compare, Allocator)
+    -> priority_queue<ranges::range_value_t<R>,
+                      vector<ranges::range_value_t<R>, Allocator>,
+                      Compare>;                                            // (8) C++23から
+
+  template <ranges::input_range R, class Allocator>
+  priority_queue(from_range_t, R&&, Allocator)
+    -> priority_queue<ranges::range_value_t<R>,
+                      vector<ranges::range_value_t<R>, Allocator>>;        // (9) C++23から
 }
 ```
 * iterator_traits[link /reference/iterator/iterator_traits.md]
 * less[link /reference/functional/less.md]
+* vector[link /reference/vector/vector.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
 `std::priority_queue`クラステンプレートの型推論補助。
 
 - (1) : 比較関数オブジェクトと、元となるコンテナから推論する
 - (2) : イテレータ範囲、比較関数オブジェクト、元となるコンテナから推論する
-- (3) : 比較関数オブジェクトと、元となるコンテナ、アロケータから推論する
+- (3) : Rangeと比較関数オブジェクトから推論する
+- (4) : 比較関数オブジェクトと、元となるコンテナ、アロケータから推論する
+- (5) : イテレータ範囲とアロケータから推論する
+- (6) : イテレータ範囲、比較関数オブジェクト、アロケータから推論する
+- (7) : イテレータ範囲、比較関数オブジェクト、元となるコンテナ、アロケータから推論する
+- (8) : Range、比較関数オブジェクト、元となるコンテナから推論する
+- (9) : Rangeとアロケータから推論する
 
 
 ## 例

reference/queue/queue/op_deduction_guide.md

@@ -8,26 +8,47 @@
 namespace std {
   template <class Container>
   queue(Container)
-    -> queue<typename Container::value_type, Container>; // (1)
+    -> queue<typename Container::value_type, Container>;       // (1)
 
-  template<class InputIterator>
+  template <class InputIterator>
   queue(InputIterator, InputIterator)
-    -> queue<<InputIterator>>;  // (2) C++23
+    -> queue<<InputIterator>>;                                 // (2) C++23
+
+  template <ranges::input_range R>
+  queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // (3) C++23
+
 
   template <class Container, class Allocator>
   queue(Container, Allocator)
-    -> queue<typename Container::value_type, Container>; // (3)
+    -> queue<typename Container::value_type, Container>;       // (4)
 
-  template<class InputIterator, class Allocator>
+  template <class InputIterator, class Allocator>
   queue(InputIterator, InputIterator, Allocator)
     -> queue<iter-value-type<InputIterator>, deque<iter-value-type<InputIterator>,
-             Allocator>>;  // (4) C++23
+             Allocator>>;                                      // (5) C++23
+
+  template <ranges::input_range R, class Allocator>
+  queue(from_range_t, R&&, Allocator)
+    -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>,
+             Allocator>>;                                      // (6) C++23
+
 }
 ```
 * iter-value-type[italic]
+* deque[link /reference/deque/deque.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
-`std::queue`クラステンプレートの型推論補助。元となるコンテナから推論する。
+`std::queue`クラステンプレートの型推論補助。
+
+- (1) : 元となるコンテナから推論する。
+- (2) : イテレータ範囲から推論する。
+- (3) : Rangeからの推論する。
+- (4) : 元となるコンテナとアロケータから推論する。
+- (5) : イテレータ範囲とアロケータから推論する。
+- (6) : Rangeとアロケータからの推論する。
 
 
 ## 例

reference/set/multiset/op_deduction_guide.md

@@ -20,16 +20,23 @@ namespace std {
   template <class InputIterator, class Allocator>
   multiset(InputIterator, InputIterator, Allocator)
     -> multiset<typename iterator_traits<InputIterator>::value_type,
-           less<typename iterator_traits<InputIterator>::value_type>, Allocator>;    // (3)
+           less<typename iterator_traits<InputIterator>::value_type>, Allocator>;         // (3)
 
   template <class Key, class Allocator>
-  multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>;           // (4)
+  multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>;      // (4)
+
+  template <ranges::input_range R, class Allocator>
+  multiset(from_range_t, R&&, Allocator)
+    -> multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>;     // (5) C++23から
 }
 ```
 * less[link /reference/functional/less.md]
 * iterator_traits[link /reference/iterator/iterator_traits.md]
 * allocator[link /reference/memory/allocator.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
 `std::multiset`クラステンプレートの型推論補助。
@@ -38,6 +45,7 @@ namespace std {
 - (2) : 初期化子リストと比較関数オブジェクトからの推論
 - (3) : イテレータ範囲とアロケータからの推論
 - (4) : 初期化子リストとアロケータからの推論
+- (5) : Rangeからの推論
 
 
 ## 例

reference/set/set/op_deduction_guide.md

@@ -24,12 +24,19 @@ namespace std {
 
   template <class Key, class Allocator>
   set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>;           // (4)
+
+  template <ranges::input_range R, class Allocator>
+  set(from_range_t, R&&, Allocator)
+    -> set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>;     // (5) C++23から
 }
 ```
 * less[link /reference/functional/less.md]
 * iterator_traits[link /reference/iterator/iterator_traits.md]
 * allocator[link /reference/memory/allocator.md]
 * initializer_list[link /reference/initializer_list/initializer_list.md]
+* ranges::input_range[link /reference/ranges/input_range.md]
+* ranges::range_value_t[link /reference/ranges/range_value_t.md]
+* from_range_t[link /reference/ranges/from_range_t.md]
 
 ## 概要
 `std::set`クラステンプレートの型推論補助。
@@ -38,6 +45,7 @@ namespace std {
 - (2) : 初期化子リストと比較関数オブジェクトからの推論
 - (3) : イテレータ範囲とアロケータからの推論
 - (4) : 初期化子リストとアロケータからの推論
+- (5) : Rangeからの推論
 
 
 ## 例