|
|
Boost-Commit : |
From: mmarcus_at_[hidden]
Date: 2008-06-24 19:45:30
Author: mmarcus
Date: 2008-06-24 19:45:29 EDT (Tue, 24 Jun 2008)
New Revision: 46664
URL: http://svn.boost.org/trac/boost/changeset/46664
Log:
Added library issues list from Sophia-Antopilis meeting. Applied
first round of changes to algorithms from Sophia meeting, with change
markers.
Added:
sandbox/committee/concepts/stdlib/lib-issues.txt (contents, props changed)
Text files modified:
sandbox/committee/concepts/stdlib/clib-algorithms.tex | 358 ++++++++++++++++++++-------------------
1 files changed, 186 insertions(+), 172 deletions(-)
Modified: sandbox/committee/concepts/stdlib/clib-algorithms.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-algorithms.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-algorithms.tex 2008-06-24 19:45:29 EDT (Tue, 24 Jun 2008)
@@ -3,8 +3,7 @@
\usepackage{pdfsync}
\input{macros}
-%%--------------------------------------------------
-%% PDF
+%%--------------------------------------------------%% PDF
\usepackage[pdftex,
pdftitle={Concepts for the C++0x Standard Library: Algorithms},
@@ -143,14 +142,14 @@
template<InputIterator Iter, class T>
requires HasEqualTo<Iter::reference, T>
Iter find(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
- template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
+ template<InputIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
Iter find_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
template<ForwardIterator Iter1, ForwardIterator Iter2>
requires HasEqualTo<Iter1::reference, Iter2::reference>
Iter1 find_end(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
Iter1 find_end(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -160,7 +159,7 @@
Iter1 find_first_of(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, ForwardIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
Iter1 find_first_of(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -168,13 +167,13 @@
template<ForwardIterator Iter>
requires EqualityComparable<Iter::reference>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
+ template<ForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, Iter::@\changedCCC{reference}{value_type}@> Pred>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
template<InputIterator Iter, class T>
requires HasEqualTo<Iter::reference, T>
@\color{addclr}@Iter::difference_type count(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
- template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
+ template<InputIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
Iter::difference_type count_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
template<InputIterator Iter1, InputIterator Iter2>
@@ -182,7 +181,7 @@
pair<Iter1, Iter2> mismatch(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
pair<Iter1, Iter2> mismatch(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
@@ -191,7 +190,7 @@
bool equal(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
bool equal(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
@@ -200,7 +199,7 @@
Iter1 search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
Iter1 search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -209,7 +208,7 @@
Iter search_n(Iter @\farg{first}@, Iter @\farg{last}@, Iter::difference_type @\farg{count}@,
const T& @\farg{value}@);
template<ForwardIterator Iter, class T,
- Predicate<auto, Iter::reference, T> Pred>
+ Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, T> Pred>
Iter search_n(Iter @\farg{first}@, Iter @\farg{last}@, Iter::difference_type @\farg{count}@,
const T& @\farg{value}@, Pred @\farg{pred}@);
@@ -265,8 +264,10 @@
template<MutableForwardIterator Iter, class T>
requires HasEqualTo<Iter::reference, T> && HasCopyAssign<Iter::reference, T>
void replace(Iter @\farg{first}@, Iter @\farg{last}@,
- const T& @\farg{old_value}@, const T& @\farg{new_value}@);
- @\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::reference> Pred, class T>
+ const T& @\farg{old_value}@, const T&
+ @\farg{new_value}@);
+% revisit (mmarcus): still a mutable iterator?
+ @\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred, class T>
requires HasCopyAssign<Iter::reference, T>
void replace_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
@@ -276,7 +277,7 @@
OutIter @\farg{result}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter,
- Predicate<auto, InIter::reference> Pred, class T>
+ Predicate<auto, InIter::@\changedCCC{reference}{value_type}@> Pred, class T>
requires HasCopyAssign<OutIter::reference, T>
OutIter replace_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
@@ -301,7 +302,7 @@
requires MoveAssignable<Iter::reference> && HasEqualTo<Iter::reference, T>
Iter remove(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::reference> Pred>
+ template<ForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
requires MoveAssignable<Iter::reference>
Iter remove_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@);
@@ -310,14 +311,14 @@
OutIter remove_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, const T& @\farg{value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter,
- Predicate<auto, InIter::reference> Pred>
+ Predicate<auto, InIter::@\changedCCC{reference}{value_type}@> Pred>
OutIter remove_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
template<ForwardIterator Iter>
requires MoveAssignable<Iter::reference> && EqualityComparable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
+ template<ForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, Iter::@\changedCCC{reference}{value_type}@> Pred>
requires MoveAssignable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@);
@@ -345,25 +346,25 @@
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
template<ForwardIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter,
- Predicate<auto, InIter::reference, InIter::reference> Pred>
+ Predicate<auto, InIter::@\changedCCC{reference}{value_type}@, InIter::@\changedCCC{reference}{value_type}@> Pred>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
template<InputIterator InIter, MutableForwardIterator OutIter,
- Predicate<auto, OutIter::reference, InIter::reference> Pred>
+ Predicate<auto, OutIter::@\changedCCC{reference}{value_type}@, InIter::@\changedCCC{reference}{value_type}@> Pred>
requires HasCopyAssign<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void reverse(Iter @\farg{first}@, Iter @\farg{last}@);
template<BidirectionalIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter>
OutIter reverse_copy(InIter @\farg{first}@,
InIter @\farg{last}@, OutIter @\farg{result}@);
template<ForwardIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void rotate(Iter @\farg{first}@, Iter @\farg{middle}@,
Iter @\farg{last}@);
template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
@@ -371,11 +372,11 @@
InIter @\farg{last}@, OutIter @\farg{result}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@);
template<RandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
- requires SwappableIterator<Iter> && Convertible<Rand::result_type, Iter::difference_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ && Convertible<Rand::result_type, Iter::difference_type>
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@,
Rand& @\farg{rand}@);
@@ -385,51 +386,51 @@
UniformRandomNumberGenerator& @\farg{rand}@);
@\textcolor{black}{// \ref{alg.partitions}, partitions:}@
- template<BidirectionalIterator Iter, Predicate<auto, Iter::reference> Pred>
- @\color{addclr}@requires SwappableIterator<Iter>
+ template<BidirectionalIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
+ @\color{addclr}@requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
Iter partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
- template<BidirectionalIterator Iter, Predicate<auto Iter::reference> Pred>
- requires SwappableIterator<Iter>
+ template<BidirectionalIterator Iter, Predicate<auto Iter::@\changedCCC{reference}{value_type}@> Pred>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
Iter stable_partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
@\textcolor{black}{// \ref{alg.sorting}, sorting and related operations:}@
@\textcolor{black}{// \ref{alg.sort}, sorting:}@
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void sort(Iter @\farg{first}@, Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@,
Compare @\farg{comp}@);
template<InputIterator InIter, RandomAccessIterator RAIter>
requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
- SwappableIterator<RAIter> &&
+ @\changedCCC{SwappableIterator<RAIter>}{Swappable<RAIter::reference>}@ &&
HasLess<InIter::value_type, RAIter::value_type> &&
HasLess<RAIter::value_type, InIter::value_type> &&
HasLess<RAIter::value_type>
@@ -437,10 +438,10 @@
RAIter @\farg{result_first}@, RAIter @\farg{result_last}@);
template<InputIterator InIter, RandomAccessIterator RAIter, class Compare>
requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
- SwappableIterator<RAIter> &&
+ @\changedCCC{SwappableIterator<RAIter>}{Swappable<RAIter::reference>}@ &&
Predicate<Compare, InIter::value_type, RAIter::value_type> &&
Predicate<Compare, RAIter::value_type, InIter::value_type> &&
- Predicate<Compare, RAIter::value_type>
+ @\changedCCC{Predicate}{StrictWeakOrder}@<Compare, RAIter::value_type>}
RAIter partial_sort_copy(InIter @\farg{first}@, InIter @\farg{last}@,
RAIter @\farg{result_first}@, RAIter @\farg{result_last}@,
Compare @\farg{comp}@);
@@ -448,22 +449,25 @@
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
bool is_sorted(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
bool is_sorted(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@);
- template<SwappableIterator<Iter>
+%% Revisit (mmarcus): not sure how to handle formatting for multiline replace here
+ template<@\changedCCC{SwappableIterator<Iter>}{RandomAccessIterator Iter,
+ StrictWeakOrder<auto, Iter::value_type> Compare>
+ requires Swappable<Iter::reference>}@
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -472,7 +476,7 @@
requires HasLess<Iter::reference, T>
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
- @\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<auto, Iter::reference, T> Compare>
+ @\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, T> Compare>
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
@@ -480,7 +484,7 @@
requires HasLess<T, Iter::reference>
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
- template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::reference> Compare>
+ template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::@\changedCCC{reference}{value_type}@> Compare>
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
@@ -491,8 +495,8 @@
equal_range(Iter @\farg{first}@,
Iter @\farg{last}@, const T& @\farg{value}@);
template<ForwardIterator Iter, class T, class Compare>
- requires Predicate<Compare, T, Iter::reference> &&
- Predicate<Compare, Iter::reference, T>
+ requires Predicate<Compare, T, Iter::@\changedCCC{reference}{value_type}@> &&
+ Predicate<Compare, Iter::@\changedCCC{reference}{value_type}@, T>
pair<Iter, Iter>
equal_range(Iter @\farg{first}@,
Iter @\farg{last}@, const T& @\farg{value}@,
@@ -504,8 +508,8 @@
bool binary_search(ForwardIterator @\farg{first}@, ForwardIterator @\farg{last}@,
const T& @\farg{value}@);
template<ForwardIterator Iter, class T, class Compare>
- requires Predicate<Compare, T, Iter::reference> &&
- Predicate<Compare, Iter::reference, T>
+ requires Predicate<Compare, T, Iter::@\changedCCC{reference}{value_type}@> &&
+ Predicate<Compare, Iter::@\changedCCC{reference}{value_type}@, T>
bool binary_search(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
@@ -513,27 +517,27 @@
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
- HasLess<InIter1::value_type>
+ @\changedCCC{HasLess}{LessThanComparable}@<InIter1::value_type>
OutIter merge(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@);
@\textcolor{addclr}{template}@<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter merge(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@);
template<BidirectionalIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -544,7 +548,7 @@
bool includes(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<auto, Iter1::value_type, Iter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, Iter1::value_type, Iter2::value_type>}{StrictWeakOrder<auto, Iter1::value_type>}@ Compare>
requires SameType<Iter1::value_type, Iter2::value_type>
bool includes(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
@@ -559,7 +563,7 @@
OutIter @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_union(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -574,7 +578,7 @@
OutIter @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_intersection(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -589,7 +593,7 @@
@\textcolor{addclr}{OutIter}@ @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -604,7 +608,7 @@
OutIter @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_symmetric_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -612,57 +616,58 @@
@\textcolor{black}{// \ref{alg.heap.operations}, heap operations:}@
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> && LessThanComparable<Iter::value_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ && LessThanComparable<Iter::value_type>
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> && LessThanComparable<Iter::value_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ && LessThanComparable<Iter::value_type>
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
requires LessThanComparable<Iter::value_type>
bool is_heap(Iter @\farg{first}@, Iter @\farg{last}@);
- template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
bool is_heap(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
+ @\addedCC{requires LessThanComparable<Iter::value_type>}@
Iter is_heap_until(Iter @\farg{first}@, Iter @\farg{last}@);
- template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter is_heap_until(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
@\textcolor{black}{// \ref{alg.min.max}, minimum and maximum:}@
template<LessThanComparable T> const T& min(const T& @\farg{a}@, const T& @\farg{b}@);
- template<class T, Predicate<auto, T, T> Compare>
+ template<class T, @\changedCCC{Predicate<auto, T, T>}{StrictWeakOrder<auto, T>}@ Compare>
requires !SameType<T, Compare>
const T& min(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
@\removedConcepts{template<LessThanComparable T> const T\& min(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
@@ -673,7 +678,7 @@
@\textcolor{black}{const T\& min(const T\& \mbox{\farg{a}}, const U\& \mbox{\farg{b}}, const Args\&... \mbox{\farg{args}});}@
template<LessThanComparable T> const T& max(const T& @\farg{a}@, const T& @\farg{b}@);
- template<class T, Predicate<auto, T, T> Compare>
+ template<class T, @\changedCCC{Predicate<auto, T, T>}{StrictWeakOrder<auto, T>}@ Compare>
requires !SameType<T, Compare>
const T& max(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
@\removedConcepts{template<LessThanComparable T> const T\& max(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
@@ -684,7 +689,7 @@
@\textcolor{black}{const T\& max(const T\& \mbox{\farg{a}}, const U\& \mbox{\farg{b}}, const Args\&... \mbox{\farg{args}});}@
template<LessThanComparable T> pair<const T&, const T&> minmax(const T& @\farg{a}@, const T& @\farg{b}@);
- template<class T, Predicate<auto, T, T> Compare>
+ template<class T, @\changedCCC{Predicate<auto, T, T>}{StrictWeakOrder<auto, T>}@ Compare>
requires !SameType<T, Compare>
pair<const T&, const T&> minmax(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
@\removedConcepts{template<LessThanComparable T>}@
@@ -698,14 +703,14 @@
template<ForwardIterator Iter>
requires LessThanComparable<Iter::reference>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
+ template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<ForwardIterator Iter>
requires LessThanComparable<Iter::reference>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
+ template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
@@ -713,7 +718,7 @@
requires LessThanComparable<Iter::value_type>
pair<Iter, Iter>
@\textcolor{addclr}{}@minmax_element(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
pair<Iter, Iter>
minmax_element(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -724,28 +729,28 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
@\textcolor{addclr}{template}@<InputIterator Iter1, InputIterator Iter2, class Compare>
- requires Predicate<Compare, Iter1::reference, Iter2::reference> &&
- Predicate<Compare, Iter2::reference, Iter1::reference>
+ requires Predicate<Compare, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> &&
+ Predicate<Compare, Iter2::@\changedCCC{reference}{value_type}@, Iter1::@\changedCCC{reference}{value_type}@>
bool lexicographical_compare(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Compare @\farg{comp}@);
@\textcolor{black}{// \ref{alg.permutation.generators}, permutations:}@
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
@\textcolor{addclr}{LessThanComparable}@<Iter::reference>
bool next_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
template<BidirectionalIterator Iter,
- Predicate<auto, Iter::reference, Iter::reference> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
@\textcolor{addclr}{}@bool next_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
@\textcolor{addclr}{}@LessThanComparable<Iter::reference>
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
template<BidirectionalIterator Iter,
- Predicate<auto, Iter::reference, Iter::reference> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
}
\end{codeblock}
@@ -981,7 +986,7 @@
requires HasEqualTo<Iter::reference, T>
Iter find(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
+template<InputIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
Iter find_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1014,7 +1019,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
Iter1 find_end(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -1058,7 +1063,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, ForwardIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
Iter1 find_first_of(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -1098,7 +1103,7 @@
requires @\changedCCC{HasEqualTo}{EqualityComparable}@<Iter::reference>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
+template<ForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, Iter::@\changedCCC{reference}{value_type}@> Pred>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1138,7 +1143,7 @@
requires HasEqualTo<Iter::reference, T>
@\color{addclr}@Iter::difference_type count(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
+template<InputIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
Iter::difference_type count_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1169,7 +1174,7 @@
Iter2 @\farg{first2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
pair<Iter1, Iter2> mismatch(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1217,7 +1222,7 @@
Iter2 @\farg{first2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
bool equal(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1251,7 +1256,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Predicate<auto, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> Pred>
@\textcolor{addclr}{Iter1}@ search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -1290,7 +1295,7 @@
const T& @\farg{value}@);
template<ForwardIterator Iter, class T,
- Predicate<auto, Iter::reference, T> Pred>
+ Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, T> Pred>
Iter search_n(Iter @\farg{first}@, Iter @\farg{last}@, Iter::difference_type @\farg{count}@,
const T& @\farg{value}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1673,7 +1678,8 @@
void replace(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
-@\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::reference> Pred, class T>
+% revisit (mmarcus): Still want Mutable iterators?
+@\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred, class T>
requires HasCopyAssign<Iter::reference, T>
void replace_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
@@ -1712,7 +1718,7 @@
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter,
- Predicate<auto, InIter::reference> Pred, class T>
+ Predicate<auto, InIter::@\changedCCC{reference}{value_type}@> Pred, class T>
requires HasCopyAssign<OutIter::reference, T>
OutIter replace_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
@@ -1856,7 +1862,7 @@
Iter remove(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::reference> Pred>
+template<ForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
requires MoveAssignable<Iter::reference>
Iter remove_if(Iter @\farg{first}@, Iter @\farg{last}@,
@\textcolor{addclr}{}@Pred @\farg{pred}@);
@@ -1899,7 +1905,7 @@
OutIter @\farg{result}@, const T& @\farg{value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter,
- Predicate<auto, InIter::reference> Pred>
+ Predicate<auto, InIter::@\changedCCC{reference}{value_type}@> Pred>
OutIter remove_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1946,7 +1952,7 @@
requires MoveAssignable<Iter::reference> && EqualityComparable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
+template<ForwardIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, Iter::@\changedCCC{reference}{value_type}@> Pred>
requires MoveAssignable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@);
@@ -2011,12 +2017,12 @@
@\textcolor{addclr}{OutIter}@ @\farg{result}@, Pred @\farg{pred}@);
template<ForwardIterator InIter, OutputIterator<auto, InIter::@\changedCCC{value_type}{reference}@> OutIter,
- Predicate<auto, InIter::reference, InIter::reference> Pred>
+ Predicate<auto, InIter::@\changedCCC{reference}{value_type}@, InIter::@\changedCCC{reference}{value_type}@> Pred>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
template<InputIterator InIter, MutableForwardIterator OutIter,
- Predicate<auto, OutIter::reference, InIter::reference> Pred>
+ Predicate<auto, OutIter::@\changedCCC{reference}{value_type}@, InIter::@\changedCCC{reference}{value_type}@> Pred>
requires HasCopyAssign<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
@@ -2077,7 +2083,7 @@
\index{reverse@\tcode{reverse}}%
\color{addclr}\begin{itemdecl}
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void reverse(Iter @\farg{first}@, Iter @\farg{last}@);
\end{itemdecl}\color{black}
@@ -2147,7 +2153,7 @@
\index{rotate@\tcode{rotate}}%
\color{addclr}\begin{itemdecl}
template<ForwardIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void rotate(Iter @\farg{first}@, Iter @\farg{middle}@,
Iter @\farg{last}@);
\end{itemdecl}\color{black}
@@ -2226,12 +2232,12 @@
\index{random_shuffle@\tcode{random_shuffle}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@);
template<RandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
- requires SwappableIterator<Iter> && Convertible<Rand::result_type, Iter::difference_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ && Convertible<Rand::result_type, Iter::difference_type>
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@,
Rand&& @\farg{rand}@);
@@ -2291,8 +2297,8 @@
\index{partition@\tcode{partition}}%
\color{addclr}\begin{itemdecl}
-@\textcolor{addclr}{}@template<BidirectionalIterator Iter, Predicate<auto, Iter::reference> Pred>
- @\color{addclr}@requires SwappableIterator<Iter>
+@\textcolor{addclr}{}@template<BidirectionalIterator Iter, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@> Pred>
+ @\color{addclr}@requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
Iter partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -2340,8 +2346,8 @@
\index{stable_partition@\tcode{stable_partition}}%
\color{addclr}\begin{itemdecl}
-template<BidirectionalIterator Iter, Predicate<auto Iter::reference> Pred>
- requires SwappableIterator<Iter>
+template<BidirectionalIterator Iter, Predicate<auto Iter::@\changedCCC{reference}{value_type}@> Pred>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
Iter stable_partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -2397,12 +2403,12 @@
\index{sort@\tcode{sort}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void sort(Iter @\farg{first}@, Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2440,12 +2446,12 @@
\index{stable_sort@\tcode{stable_sort}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2482,14 +2488,14 @@
\index{partial_sort@\tcode{partial_sort}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@,
@@ -2532,19 +2538,19 @@
\color{addclr}\begin{itemdecl}
template<InputIterator InIter, RandomAccessIterator RAIter>
requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
- SwappableIterator<RAIter> &&
+ @\changedCCC{SwappableIterator<RAIter>}{Swappable<RAIter::reference>}@ &&
HasLess<InIter::value_type, RAIter::value_type> &&
HasLess<RAIter::value_type, InIter::value_type> &&
- HasLess<RAIter::value_type>
+ @\changedCCC{HasLess}{LessThanComparable}@<RAIter::value_type>
RAIter partial_sort_copy(InIter @\farg{first}@, InIter @\farg{last}@,
RAIter @\farg{result_first}@, RAIter @\farg{result_last}@);
template<InputIterator InIter, RandomAccessIterator RAIter, class Compare>
requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
- SwappableIterator<RAIter> &&
+ @\changedCCC{SwappableIterator<RAIter>}{Swappable<RAIter::reference>}@ &&
Predicate<Compare, InIter::value_type, RAIter::value_type> &&
Predicate<Compare, RAIter::value_type, InIter::value_type> &&
- Predicate<Compare, RAIter::value_type>
+ @\changedCCC{Predicate}{StrictWeakOrder}@<Compare, RAIter::value_type>
RAIter partial_sort_copy(InIter @\farg{first}@, InIter @\farg{last}@,
RAIter @\farg{result_first}@, RAIter @\farg{result_last}@,
Compare @\farg{comp}@);
@@ -2599,7 +2605,7 @@
\index{is_sorted@\tcode{is_sorted}}%
\color{addclr}
\begin{itemdecl}
-template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
bool is_sorted(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}
@@ -2616,7 +2622,7 @@
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}
@@ -2638,14 +2644,14 @@
\index{nth_element@\tcode{nth_element}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@);
template<RandomAccessIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2707,7 +2713,7 @@
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-@\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<auto, Iter::reference, T> Compare>
+@\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<auto, Iter::@\changedCCC{reference}{value_type}@, T> Compare>
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2755,7 +2761,7 @@
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::reference> Compare>
+template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::@\changedCCC{reference}{value_type}@> Compare>
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2806,8 +2812,8 @@
Iter @\farg{last}@, const T& @\farg{value}@);
template<ForwardIterator Iter, class T, class Compare>
- requires Predicate<Compare, T, Iter::reference> &&
- Predicate<Compare, Iter::reference, T>
+ requires Predicate<Compare, T, Iter::@\changedCCC{reference}{value_type}@> &&
+ Predicate<Compare, Iter::@\changedCCC{reference}{value_type}@, T>
pair<Iter, Iter>
equal_range(Iter @\farg{first}@,
Iter @\farg{last}@, const T& @\farg{value}@,
@@ -2871,8 +2877,8 @@
const T& @\farg{value}@);
template<ForwardIterator Iter, class T, class Compare>
- requires Predicate<Compare, T, Iter::reference> &&
- Predicate<Compare, Iter::reference, T>
+ requires Predicate<Compare, T, Iter::@\changedCCC{reference}{value_type}@> &&
+ Predicate<Compare, Iter::@\changedCCC{reference}{value_type}@, T>
bool binary_search(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2935,9 +2941,11 @@
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@);
+% revisit (mmarcus): not sure if changedCCC after texcolor is right
+% way to go here
@\textcolor{addclr}{template}@<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- @\textcolor{addclr}{}@Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\textcolor{addclr}{}@@\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter merge(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -2989,15 +2997,15 @@
\index{inplace_merge@\tcode{inplace_merge}}%
\color{addclr}\begin{itemdecl}
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@);
template<BidirectionalIterator Iter,
- Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+ @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -3077,7 +3085,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<auto, Iter1::value_type, Iter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, Iter1::value_type, Iter2::value_type>}{StrictWeakOrder<auto, Iter1::value_type>}@ Compare>
requires SameType<Iter1::value_type, Iter2::value_type>
bool includes(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
@@ -3117,7 +3125,7 @@
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type, InIter2::value_type>}{StrictWeakOrder<auto, InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_union(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -3166,7 +3174,9 @@
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type,
+ InIter2::value_type>}{StrictWeakOrder<auto,
+ InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_intersection(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -3214,7 +3224,9 @@
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type,
+ InIter2::value_type>}{StrictWeakOrder<auto,
+ InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
@\textcolor{addclr}{}@InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -3275,7 +3287,9 @@
template<InputIterator InIter1, InputIterator InIter2,
OutputIterator<auto, InIter1::value_type> OutIter,
- Predicate<auto, InIter1::value_type, InIter2::value_type> Compare>
+ @\changedCCC{Predicate<auto, InIter1::value_type,
+ InIter2::value_type>}{StrictWeakOrder<auto,
+ InIter1::value_type>}@ Compare>
requires SameType<InIter1::value_type, InIter2::value_type>
OutIter set_symmetric_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@@ -3357,12 +3371,12 @@
\index{push_heap@\tcode{push_heap}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3398,11 +3412,11 @@
\index{pop_heap@\tcode{pop_heap}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> && LessThanComparable<Iter::value_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ && LessThanComparable<Iter::value_type>
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3442,12 +3456,12 @@
\index{make_heap@\tcode{make_heap}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> &&
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ &&
LessThanComparable<Iter::value_type>
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3477,11 +3491,11 @@
\index{sort_heap@\tcode{sort_heap}}%
\color{addclr}\begin{itemdecl}
template<RandomAccessIterator Iter>
- requires SwappableIterator<Iter> && LessThanComparable<Iter::value_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@ && LessThanComparable<Iter::value_type>
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
- requires SwappableIterator<Iter>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3526,7 +3540,7 @@
\color{addclr}
\begin{itemdecl}
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
bool is_heap(Iter first, Iter last, Compare comp);
\end{itemdecl}
\color{black}
@@ -3540,7 +3554,7 @@
\begin{itemdecl}
template<RandomAccessIterator Iter>
Iter is_heap_until(Iter first, Iter last);
-template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+template<RandomAccessIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter is_heap_until(Iter first, Iter last,
Compare comp);
\end{itemdecl}
@@ -3562,7 +3576,7 @@
\index{min@\tcode{min}}%
\color{addclr}\begin{itemdecl}
template<LessThanComparable T> const T& min(const T& @\farg{a}@, const T& @\farg{b}@);
-template<class T, Predicate<auto, T, T> Compare>
+template<class T, @\changedCCC{Predicate<auto, T, T>}{StrictWeakOrder<auto, T>}@ Compare>
requires !SameType<T, Compare>
const T& min(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3643,7 +3657,7 @@
\index{max@\tcode{max}}%
\color{addclr}\begin{itemdecl}
template<LessThanComparable T> const T& max(const T& @\farg{a}@, const T& @\farg{b}@);
-template<class T, Predicate<auto, T, T> Compare>
+template<class T, @\changedCCC{Predicate<auto, T, T>}{StrictWeakOrder<auto, T>}@ Compare>
@\addedConcepts{requires !SameType<T, Compare>}@
const T& max(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3719,7 +3733,7 @@
\color{addclr}
\begin{itemdecl}
template<LessThanComparable T> pair<const T&, const T&> minmax(const T& @\farg{a}@, const T& @\farg{b}@);
-template<class T, Predicate<auto, T, T> Compare>
+template<class T, @\changedCCC{Predicate<auto, T, T>}{StrictWeakOrder<auto, T>}@ Compare>
@\addedConcepts{requires !SameType<T, Compare>}@
@\textcolor{addclr}{pair}@<const T&, const T&> minmax(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
\end{itemdecl}
@@ -3831,7 +3845,7 @@
requires LessThanComparable<Iter::reference>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
+template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3869,7 +3883,7 @@
requires LessThanComparable<Iter::reference>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
+template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3908,7 +3922,7 @@
requires LessThanComparable<Iter::value_type>
pair<Iter, Iter>
minmax_element(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+template<ForwardIterator Iter, @\changedCCC{Predicate<auto, Iter::value_type, Iter::value_type>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
pair<Iter, Iter>
minmax_element(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}
@@ -3941,8 +3955,8 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, InputIterator Iter2, class Compare>
- requires Predicate<Compare, Iter1::reference, Iter2::reference> &&
- Predicate<Compare, Iter2::reference, Iter1::reference>
+ requires Predicate<Compare, Iter1::@\changedCCC{reference}{value_type}@, Iter2::@\changedCCC{reference}{value_type}@> &&
+ Predicate<Compare, Iter2::@\changedCCC{reference}{value_type}@, Iter1::@\changedCCC{reference}{value_type}@>
bool lexicographical_compare(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
@\textcolor{addclr}{}@Compare @\farg{comp}@);
@@ -3992,12 +4006,12 @@
\index{next_permutation@\tcode{next_permutation}}%
\color{addclr}\begin{itemdecl}
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
@\textcolor{addclr}{LessThanComparable}@<Iter::reference>
bool next_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
-template<BidirectionalIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
- requires SwappableIterator<Iter>
+template<BidirectionalIterator Iter, @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
@\textcolor{addclr}{bool}@ next_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -4032,12 +4046,12 @@
\index{prev_permutation@\tcode{prev_permutation}}%
\color{addclr}\begin{itemdecl}
template<BidirectionalIterator Iter>
- requires SwappableIterator<Iter>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
@\textcolor{addclr}{}@LessThanComparable<Iter::reference>
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
-template<BidirectionalIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
- requires SwappableIterator<Iter>
+template<BidirectionalIterator Iter, @\changedCCC{Predicate<auto, Iter::reference, Iter::reference>}{StrictWeakOrder<auto, Iter::value_type>}@ Compare>
+ requires @\changedCCC{SwappableIterator<Iter>}{Swappable<Iter::reference>}@
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
Added: sandbox/committee/concepts/stdlib/lib-issues.txt
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/stdlib/lib-issues.txt 2008-06-24 19:45:29 EDT (Tue, 24 Jun 2008)
@@ -0,0 +1,358 @@
+
+N2625 Issues cont.
+============
+
+In general
+ - Is only requiring Swappable<Iter::reference> and not MoveConstructible, MoveAssignable precluding
+useful/efficient algorithm implementations?
+
+- Add new concept StrictWeakOrdering (refines binary Predicate) and use it where Compare needs to provide
+ strict weak ordering. E.g. sort. (Key of LessThanComparable)
+
+- stable_partition, stable_sort, partial_sort requirements not sufficient for efficient implementation. See reference to extra memory.
+ Possible need to retain second line of removed requirements.
+
+- Check for need of NoThrowDestructible
+
+
+25.2.10/3
+ - s/InIter::value_type/InIter::reference/
+
+25.2.11
+ - Do rotate requirements provide enough latitude to allow todays optimizations based on iterator categories.
+ - Is requiring Swappable overconstraining the implementation? I.e. there are algorithms that do not require a swap function.
+
+25.2.11
+ - Should we s/InIter::value_type/InIter::reference/ for rotate_copy.
+
+25.2.12
+ - random_shuffle third overload not finished.
+
+25.2.12/4
+ - Why was the specification for rand's semantics removed. I.e. returns random number in the range (0,n]
+
+25.2.13
+ - Typo stable_partion declaration s/Predicate<auto Iter::reference>/Predicate<auto, Iter::reference>/
+
+25.3.1.1
+ - s/Iter::value_type/Iter::reference/g
+
+25.3.1.2
+ - s/Iter::value_type/Iter::reference/g
+
+25.3.1.3
+ - s/Iter::value_type/Iter::reference/g
+
+25.3.1.4
+
+First overload
+
+ - s/Iter::value_type/Iter::reference/g
+ - Do we need HasLess 1 & 2 ? gcc does not have 2
+ - partial_sort_copy single parameter HasLess requirement to be replaced with LessThanComparable concept.
+ - Add Requirements clause:
+ *in < *res == RAIter::reference(*in) < *res
+ *res < *in == *res < RAIter::reference(*in)
+
+- operator semantic requirements stated in text
+
+Second overload
+
+ - s/Iter::value_type/Iter::reference/g
+ - Do we need Predicate 1 & 2 ?
+ - partial_sort_copy two parameter Predicate requirement to be replaced with StrictWeakOrdering concept.
+ - Add Requirements clause:
+ comp(*in, *res) == comp(RAIter::reference(*in), *res)
+ comp(*res, *in) == comp(*res, RAIter::reference(*in))
+
+- operator semantic requirements stated in text
+
+===================================================================
+2008/06/11
+
+In general
+
+- s/Iter::value_type/Iter::reference/g clear up value reference issue. Proxy iterators and such
+
+- Do we always need semantic concepts in the function declaration.
+
+- Add new concept StrictWeakOrdering (refines binary Predicate) and use it where Compare needs to provide
+ strict weak ordering. E.g. sort. (Key of LessThanComparable)
+
+- Whereever we find MutableIter it's probably wrong.
+
+- Make sure Predicate takes value_type const&. See InputIterator value_type convertability requirements. Same is true for every use of value_type in concepts. Note that LessThanComparable already adds it.
+
+- Do we want to bundle MoveConstructible MoveAssingable Swappable. Howard prefers not to.
+
+25.3.1.5
+
+
+25.3.3.3
+
+- Decided that not an issues of operator semantic requirements stated in text as reqs are restricted to a specific set of values not the types in general.
+
+25.3.4
+
+- merge Predicate wants to go to StrictWeakOrdering even though three type. Look at SameType requirement. Look for this going forward.
+
+25.3.6.1
+25.3.6.3
+
+- Working draft does not require Swappable why do we require this? Alan reports Bill + Pete do say it's a defect in the standard.
+
+25.3.6.5
+
+First is_heap_until is missing LessThanComparable requirement
+
+25.3.7
+
+max/min/minmax
+
+- Make Predicate > StrictWeakOrdering move T -> T const&
+
+- We do not know how to handle one of the the variadic versions.
+
+- Consider defect in 03 that min_element max_element don't strictly need StrictWeakOrdering though requirement is made.
+
+25.3.9
+
+No need to make these Exchangable
+
+=============================
+
+N2621
+
+N = All Notes should be remarks probably or even better no qualifier.
+
+ > 06/12 Pete says keep it the way it is.
+
+Y = 20.1.1/9 Add Note that explains deviation from core language ("or a reference type").
+
+N = 20.1.1 Do we need to add UnionLikeClass?
+
+ > Not needed because no constrained template could make use of it
+
+Y = 20.1.1/28 s/describess/describes/
+
+N = 20.1.1/36 [temp.req] is dangling in N2606 (Possibly [temp.type])
+
+ > temp.req is in the core concepts paper
+
+N = 20.1.1/37 DerivedFrom and is_base_of have different parameter orders
+
+ > DerivedFrom has the right order. Thats how its written in C++ declarations.
+
+Y = 20.1.2/1 Remove note (this is a leftover from HasLess)
+
+Y = 20.1.2/1.5 concept LessThanComparable needs to refine HasLess<T, T>
+
+Y = 20.1.2/1.5 add \n after conditional in axioms
+Y = 20.1.2/1.5 Last axiom can be simplified (according to Peter G.)
+
+ > Checked, can't be simplified. Matched original STL spec.
+
+Y = 20.1.2 Move after 20.1.10 Operator concepts
+ > Moved 20.1.10 up front
+
+Y = 20.1.2/2.5 HasEqualTo<T, T>
+Y = 20.1.2/2.5 add \n after conditional in axioms
+
+Y = 20.1.3
+ Y = - Rename Destructible -> HasDestructor
+ Y = - Remove paragraph 2
+ N = - Replace 20.1.3/1 Replace with "Describes types that have a publically accessible non deleted destructor."
+ > Could not apply all because listed types are destructible yet have no destructor
+
+
+Y = - Do we need a semantic Destructible? Check with container requirements. Do we need to call it NoThrowDestructible.
+
+Y = - TriviallyDestructible refines NoThrowDestructible
+
+Y = 20.1.4
+ Y = - Remove base concept Destructible from HasConstructor
+
+Y = 20.1.5/5.5 - Make MoveAssignable refine HasAssign<T, T&&>
+
+Y = 20.1.5/7.5 - Make CopyAsignable also derive from HasAssignment<T, T const&>
+
+Y = 20.1.5/10.5
+ Y = - Refine HasSwap<T, T>
+ Y = - Remove body
+
+Y = 20.1.5/11.5 Add note it's inherited. See 20.1.5/1.5
+
+Y = 20.1.10/21.5 Remove
+Y = 20.1.10/22 Remove
+
+Y = 20.1.10/22.5 Replace
+ auto concept HasAssign<typename T, typename U>
+ {
+ typename result_type;
+ result_type T::operator=(U);
+ }
+
+Y = - Fix references to HasCopy/HasMoveAssign
+
+=================================
+2006/06/12
+
+Y = - Check placement of const
+
+
+Y = 20.1.6/0.5
+ Y= - Add nothrow versions in ingenious ways. Doug and Howard will take care of this.
+ Y = - Check whether to unbundle placement new
+
+Y = 20.1.7/0.5 - Add base of NoThrowDestructible<T>
+
+Y = 20.1.10
+ Y = - Remove all the defaults from the two type concepts in Operator concepts. See issue 40 on the concepts issues list
+ Y = - Requiring const on operators can we provide binary compatible mode that relaxes that for old non const correct code.
+ > Was discussed in lib. Found binary compatible solution to the problem
+
+Y = 20.1.10/18.5
+ Y = - Rename HasDereference
+ Y = - Rename reference result_type
+ Y = - Replace result_type operator*(const T&)
+
+Y =20.1.10/19.5
+ Y = - Rename HasAddressOf
+ Y = - Rename reference result_type
+
+Y = 20.1.10/20.5 - See Issue 15 in concepts issue list.
+
+Y = -Ask Howard about HasAssign vs. HasAssignment to be consistent with.
+
+Y = - Strip reference and cv qualifier on U in signature for Has???Assign concepts.
+
+Y = 20.1.10/31 - LaTex issue operator symbol
+
+Y = - Add concepts HasGreater HasGreaterEqual HasLessEqual
+Y = - Add all the missing operators.
+
+N = - Add concepts Incrementable Decrementable
+ > Intended implementation technique is not viable. Don't know a good way to do it.
+
+Y = 20.1.11
+ Y = - Replace refinement of LessThanComparable with HasLess HasGreater HasGreaterEqual HasLessEqual
+ Y = - replace remaining assoc funtions with refinement HasPlusAssign and friends
+ Y = - Add uintmax_t signature to ArithmeticLike
+
+Y = - Make IntgralLike refine LessThanComparable heads up the the math group
+
+Y = 20.1.12
+ Y = - Make args const&
+ N = - Remove par 2.
+ > We can't remove this because only the seed function takes const arguments. At instantiation time
+ a non const overload could be selected.
+
+Y = TriviallyDefaultConstructible is declared in Synopsis but not defined later.
+
+=============================================================
+
+
+N2624
+
+- Revisit the issue of MutableXXIterator. Is it needed? Is it overconstrained?
+
+- check whether changes affect synopsis.
+
+- check whether we can use Incrementable, Decrementable
+
+24.1/3
+
+- Replace nine iterator concepts -> several iter concepts
+- Remove swappable iterators (Do this everywhere)
+
+24.1.2
+
+- Replace
+
+concept OutputIterator<typename X, typename Value> : SemiRegular<X> {
+ MoveConstructible reference;
+ requires HasAssign<reference, Value> && MoveAssignable<Value>;
+
+ MoveConstructible postincrement_result;
+ requires Dereferenceable<postincrement_result> &&
+ Convertible<postincrement_result, const X&> &&
+ HasAssign<Dereferenceable<postincrement_result>::reference, Value>;
+
+
+
+- Replace
+
+concept BasicOutputIterator<typename X> : SemiRegular<X> {
+ typename ObjectType value_type = typename X::value_type;
+ MoveConstructible reference = typename X::reference;
+
+ requires HasAssign<reference, value_type&&>;
+
+ MoveConstructible postincrement_result;
+ requires Dereferenceable<postincrement_result> &&
+ HasAssign<Dereferenceable<postincrement_result>::reference, value_type&&> &&
+ Convertible<postincrement_result, const X&>;
+
+
+- Consider removing duplication between BasicOIter and OIter by using refinement
+
+- Replace
+
+template<BasicOutputIterator X, typename MoveAssignable Value>
+requires HasAssign<X::reference, Value>
+concept_map OutputIterator<X, Value> {
+ typedef X::reference reference;
+ typedef X::postincrement_result postincrement_result;
+}
+
+24.1.3
+
+- Remove axiom &a == &++a and replace with normative text.
+
+- Add SameType<ForwardIterator<X>::postincrement_result, BasicOutputIterator<X>::postincrement_result> to MutableForwardIterator requirements
+
+- Typo in comment "do not need do not need".
+
+24.1.4
+
+- Convertible<Dereferenceable<postdecrement_result>::reference, value_type> -> Convertible<Dereferenceable<postdecrement_result>::reference, value_type&>
+
+- Remove axiom &a == &--a and replace with normative text.
+
+24.1.5
+
+- [random.access.iterators], concept RandomAccessIterator:
+The member description of
+
+X& operator+=(X& r, difference_type m);
+
+should replace m, by n, otherwise the following effects clause doesn't make
+sense.
+
+- Add defaults for operator+/- in terms of operator+=/-=
+- Add default impl for operator[]
+
+24.1.5/10
+
+- strip std:: from std::ptrdif_t
+
+24.1.6
+
+- Remove in total
+
+
+D.10/6
+
+- Clarify. List specializations that are required.
+
+D.10.4/3
+
+- template<Integral T> void f(T); -> template<IntegralLike T> void f(T);
+
+D.10.4/4-11
+
+- Add predicate that paragraph 3 must hold.
+
+
+
+
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk