From Jason Turner

[alg.find]

C++23 → Trunk 4.5 KB 40 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpb7e8wtpa/{from.md → to.md} +32 -4
tmp/tmpb7e8wtpa/{from.md → to.md} RENAMED
@@ -1,12 +1,13 @@
1
  ### Find <a id="alg.find">[[alg.find]]</a>
2
 
3
  ``` cpp
4
- template<class InputIterator, class T>
5
  constexpr InputIterator find(InputIterator first, InputIterator last,
6
  const T& value);
7
- template<class ExecutionPolicy, class ForwardIterator, class T>
 
8
  ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
9
  const T& value);
10
 
11
  template<class InputIterator, class Predicate>
12
  constexpr InputIterator find_if(InputIterator first, InputIterator last,
@@ -21,31 +22,58 @@ template<class InputIterator, class Predicate>
21
  template<class ExecutionPolicy, class ForwardIterator, class Predicate>
22
  ForwardIterator find_if_not(ExecutionPolicy&& exec,
23
  ForwardIterator first, ForwardIterator last,
24
  Predicate pred);
25
 
26
- template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
 
27
  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
28
  constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
29
- template<input_range R, class T, class Proj = identity>
30
  requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
31
  constexpr borrowed_iterator_t<R>
32
  ranges::find(R&& r, const T& value, Proj proj = {});
 
 
 
 
 
 
 
 
 
 
 
33
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
34
  indirect_unary_predicate<projected<I, Proj>> Pred>
35
  constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
36
  template<input_range R, class Proj = identity,
37
  indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
38
  constexpr borrowed_iterator_t<R>
39
  ranges::find_if(R&& r, Pred pred, Proj proj = {});
 
 
 
 
 
 
 
 
40
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
41
  indirect_unary_predicate<projected<I, Proj>> Pred>
42
  constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
43
  template<input_range R, class Proj = identity,
44
  indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
45
  constexpr borrowed_iterator_t<R>
46
  ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
 
 
 
 
 
 
 
47
  ```
48
 
49
  Let E be:
50
 
51
  - `*i == value` for `find`;
 
1
  ### Find <a id="alg.find">[[alg.find]]</a>
2
 
3
  ``` cpp
4
+ template<class InputIterator, class T = iterator_traits<InputIterator>::value_type>
5
  constexpr InputIterator find(InputIterator first, InputIterator last,
6
  const T& value);
7
+ template<class ExecutionPolicy, class ForwardIterator,
8
+ class T = iterator_traits<ForwardIterator>::value_type>
9
  ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
10
  const T& value);
11
 
12
  template<class InputIterator, class Predicate>
13
  constexpr InputIterator find_if(InputIterator first, InputIterator last,
 
22
  template<class ExecutionPolicy, class ForwardIterator, class Predicate>
23
  ForwardIterator find_if_not(ExecutionPolicy&& exec,
24
  ForwardIterator first, ForwardIterator last,
25
  Predicate pred);
26
 
27
+ template<input_iterator I, sentinel_for<I> S, class Proj = identity,
28
+ class T = projected_value_t<I, Proj>>
29
  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
30
  constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
31
+ template<input_range R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>>
32
  requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
33
  constexpr borrowed_iterator_t<R>
34
  ranges::find(R&& r, const T& value, Proj proj = {});
35
+
36
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
37
+ class Proj = identity, class T = projected_value_t<I, Proj>>
38
+ requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
39
+ I ranges::find(Ep&& exec, I first, S last, const T& value, Proj proj = {});
40
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
41
+ class T = projected_value_t<iterator_t<R>, Proj>>
42
+ requires indirect_binary_predicate<ranges::equal_to,
43
+ projected<iterator_t<R>, Proj>, const T*>
44
+ borrowed_iterator_t<R> ranges::find(Ep&& exec, R&& r, const T& value, Proj proj = {});
45
+
46
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
47
  indirect_unary_predicate<projected<I, Proj>> Pred>
48
  constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
49
  template<input_range R, class Proj = identity,
50
  indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
51
  constexpr borrowed_iterator_t<R>
52
  ranges::find_if(R&& r, Pred pred, Proj proj = {});
53
+
54
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
55
+ class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
56
+ I ranges::find_if(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
57
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
58
+ indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
59
+ borrowed_iterator_t<R> ranges::find_if(Ep&& exec, R&& r, Pred pred, Proj proj = {});
60
+
61
  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
62
  indirect_unary_predicate<projected<I, Proj>> Pred>
63
  constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
64
  template<input_range R, class Proj = identity,
65
  indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
66
  constexpr borrowed_iterator_t<R>
67
  ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
68
+
69
+ template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S,
70
+ class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
71
+ I ranges::find_if_not(Ep&& exec, I first, S last, Pred pred, Proj proj = {});
72
+ template<execution-policy Ep, sized-random-access-range R, class Proj = identity,
73
+ indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
74
+ borrowed_iterator_t<R> ranges::find_if_not(Ep&& exec, R&& r, Pred pred, Proj proj = {});
75
  ```
76
 
77
  Let E be:
78
 
79
  - `*i == value` for `find`;