|
|
Boost-Commit : |
From: dgregor_at_[hidden]
Date: 2008-03-04 17:12:35
Author: dgregor
Date: 2008-03-04 17:12:35 EST (Tue, 04 Mar 2008)
New Revision: 43504
URL: http://svn.boost.org/trac/boost/changeset/43504
Log:
Update Algorithms chapter
Added:
sandbox/committee/concepts/stdlib/local.bib (contents, props changed)
Text files modified:
sandbox/committee/concepts/stdlib/clib-algorithms.tex | 884 +++++++++++++++++++++------------------
sandbox/committee/concepts/stdlib/macros.tex | 4
2 files changed, 472 insertions(+), 416 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-03-04 17:12:35 EST (Tue, 04 Mar 2008)
@@ -1,6 +1,7 @@
\documentclass[american,twoside]{book}
\usepackage{refbib}
\usepackage{hyperref}
+\usepackage{pdfsync}
\input{macros}
%%--------------------------------------------------
@@ -41,7 +42,7 @@
\end{center}
\vspace{1in}
-\par\noindent Document number: NNNNN=07-XXXX\vspace{-6pt}
+\par\noindent Document number: DRAFT\vspace{-6pt}
\par\noindent Revises document number: N2084=06-0154\vspace{-6pt}
\par\noindent Date: \today\vspace{-6pt}
\par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}
@@ -55,13 +56,11 @@
\item Updated algorithm requirements to use the new iterator and
utility concepts, including the relaxed iterator requirements in
N2323 and the move concepts of N2322.
-\item Added \tcode{CopyConstructible} requirements for each of the
- function object types. These requirements were previously implicit
- (due to requirement propagation in earlier versions of the concepts
- proposal).
\item Added new algorithms \tcode{move}, \tcode{move_backward},
\tcode{is_sorted}, \tcode{is_sorted_until}, \tcode{is_heap},
- \tcode{is_heap_until}, \tcode{minmax} and \tcode{minmax_element}.
+ \tcode{is_heap_until}, \tcode{minmax} and \tcode{minmax_element},
+ and the variadic \tcode{min}, \tcode{max}, and \tcode{minmax} overloads
+ from N2551.
\end{itemize}
\end{titlepage}
@@ -117,26 +116,19 @@
\begin{codeblock}
namespace std {
@\textcolor{black}{// \ref{alg.nonmodifying}, non-modifying sequence operations:}@
- template<InputIterator Iter, Callable<Iter::reference> Function>
- requires CopyConstructible<Function>
+ template<InputIterator Iter, Callable<auto, Iter::reference> Function>
Function for_each(Iter @\farg{first}@, Iter @\farg{last}@, Function @\farg{f}@);
-
template<InputIterator Iter, class T>
requires EqualityComparable<Iter::reference, T>
Iter find(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-
- template<InputIterator Iter, Predicate<Iter::reference> Pred>
- requires CopyConstructible<Pred>
+ template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
Iter find_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
-
template<ForwardIterator Iter1, ForwardIterator Iter2>
requires EqualityComparable<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<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
Iter1 find_end(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -145,10 +137,8 @@
requires EqualityComparable<Iter1::reference, Iter2::reference>
Iter1 find_first_of(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
-
template<InputIterator Iter1, ForwardIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
Iter1 find_first_of(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -156,27 +146,21 @@
template<ForwardIterator Iter>
requires EqualityComparable<Iter::reference>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@);
-
- template<ForwardIterator Iter, Predicate<Iter::reference, Iter::reference> Pred>
- requires CopyConstructible<Pred>
+ template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
template<InputIterator Iter, class T>
requires EqualityComparable<Iter::reference, T>
@\color{addclr}@Iter::difference_type count(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-
- template<InputIterator Iter, Predicate<Iter::reference> Pred>
- requires CopyConstructible<Pred>
+ template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
Iter::difference_type count_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
template<InputIterator Iter1, InputIterator Iter2>
requires EqualityComparable<Iter1::reference, Iter2::reference>
pair<Iter1, Iter2> mismatch(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter @\farg{first2}@);
-
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
pair<Iter1, Iter2> mismatch(Iter1 @\farg{first1}@, Iter2 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
@@ -184,10 +168,8 @@
requires EqualityComparable<Iter1::reference, Iter2::reference>
bool equal(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@);
-
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
bool equal(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
@@ -195,50 +177,43 @@
requires EqualityComparable<Iter1::reference, Iter2::reference>
Iter1 search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
-
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
- @\textcolor{addclr}{Iter1}@ search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
+ Iter1 search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
-
template<ForwardIterator Iter, class T>
requires EqualityComparable<Iter::reference, T>
Iter search_n(Iter @\farg{first}@, Iter @\farg{last}@, Iter::difference_type @\farg{count}@,
const T& @\farg{value}@);
-
template<ForwardIterator Iter, class T,
- Predicate<Iter::reference, T> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter::reference, T> Pred>
Iter search_n(Iter @\farg{first}@, Iter @\farg{last}@, Iter::difference_type @\farg{count}@,
const T& @\farg{value}@, Pred @\farg{pred}@);
@\textcolor{black}{// \ref{alg.modifying.operations}, modifying sequence operations:}@
@\textcolor{black}{// \ref{alg.copy}, copy:}@
- template<InputIterator InIter, OutputIterator<InIter::reference> OutIter>
+ template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
OutIter copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-
template<BidirectionalIterator InIter, MutableBidirectionalIterator OutIter>
requires CopyAssignable<OutIter::reference, InIter::reference>
OutIter copy_backward(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
- // \ref{alg.move}, move:
- template<InputIterator InIter, OutputIterator<InIter::value_type&&> OutIter>
- OutIter move(InIter first, InIter last,
- OutIter result);
+ @\textcolor{black}{// \ref{alg.move}, move:}@
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type&&> OutIter>
+ OutIter move(InIter @\farg{first}@, InIter @\farg{last}@,
+ OutIter @\farg{result}@);
template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
requires MoveAssignable<OutIter::reference, InIter::value_type>
- OutIter move_backward(InIter first, InIter last,
- OutIter result);
+ OutIter move_backward(InIter @\farg{first}@, InIter @\farg{last}@,
+ OutIter @\farg{result}@);
@\textcolor{black}{// \ref{alg.swap}, swap:}@
template<class T>
requires MoveAssignable<T> && MoveConstructible<T>
void swap(T& @\farg{a}@, T& @\farg{b}@);
-
template<MutableForwardIterator Iter1, MutableForwardIterator Iter2>
requires SameType<Iter1::value_type, Iter2::value_type> &&
SameType<Iter1::value_type&, Iter1::reference> &&
@@ -246,7 +221,6 @@
Swappable<Iter1::value_type>
Iter2 swap_ranges(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@);
-
template<MutableForwardIterator Iter1, MutableForwardIterator Iter2>
requires SameType<Iter1::value_type, Iter2::value_type> &&
SameType<Iter1::value_type&, Iter1::reference> &&
@@ -255,14 +229,13 @@
void iter_swap(Iter1 @\farg{a}@, Iter2 @\farg{b}@);
template<InputIterator InIter, class OutIter,
- Callable<InIter::reference> Op>
- requires OutputIterator<OutIter, Op::result_type> && CopyConstructible<Op>
+ Callable<auto, InIter::reference> Op>
+ requires OutputIterator<OutIter, Op::result_type>
OutIter transform(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Op @\farg{op}@);
-
template<InputIterator InIter1, InputIterator InIter2,
- class OutIter, Callable<InIter1::reference, InIter2::reference> BinaryOp>
- requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructible<BinaryOp>
+ class OutIter, Callable<auto, InIter1::reference, InIter2::reference> BinaryOp>
+ requires OutputIterator<OutIter, BinaryOp::result_type>
OutIter transform(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, OutIter @\farg{result}@,
BinaryOp @\farg{binary_op}@);
@@ -271,21 +244,18 @@
requires EqualityComparable<Iter::reference, T> && CopyAssignable<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<Iter::reference> Pred, class T>
- requires CopyAssignable<Iter::reference, T> && CopyConstructible<Pred>
+ @\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::reference> Pred, class T>
+ requires CopyAssignable<Iter::reference, T>
void replace_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
-
- template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter, class T>
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter, class T>
requires CopyAssignable<OutIter::reference, T> && EqualityComparable<InIter::reference, T>
OutIter replace_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
-
- template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::reference> Pred, class T>
- requires CopyAssignable<OutIter::reference, T> && CopyConstructible<Pred>
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::reference> Pred, class T>
+ requires CopyAssignable<OutIter::reference, T>
OutIter replace_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
@@ -293,96 +263,80 @@
template<MutableForwardIterator Iter, class T>
requires CopyAssignable<Iter::reference, T>
void fill(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-
template<class Iter, Integral Size, class T>
requires OutputIterator<Iter, T>
void fill_n(Iter @\farg{first}@, Size @\farg{n}@, const T& @\farg{value}@);
- template<MutableForwardIterator Iter, Callable<> Generator>
- requires CopyAssignable<Iter::reference, Generator::result_type> && CopyConstructible<Generator>
+ template<MutableForwardIterator Iter, Callable Generator>
+ requires CopyAssignable<Iter::reference, Generator::result_type>
void generate(Iter @\farg{first}@, Iter @\farg{last}@,
Generator @\farg{gen}@);
-
- template<class Iter, Integral Size, Callable<> Generator>
- requires OutputIterator<Iter, Generator::result_type> && CopyConstructible<Generator>
+ template<class Iter, Integral Size, Callable Generator>
+ requires OutputIterator<Iter, Generator::result_type>
void generate_n(Iter @\farg{first}@, Size @\farg{n}@, Generator @\farg{gen}@);
template<ForwardIterator Iter, class T>
requires MoveAssignable<Iter::reference> && EqualityComparable<Iter::reference, T>
Iter remove(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-
- template<ForwardIterator Iter, Predicate<Iter::reference> Pred>
- requires MoveAssignable<Iter::reference> && CopyConstructible<Pred>
+ template<ForwardIterator Iter, Predicate<auto, Iter::reference> Pred>
+ requires MoveAssignable<Iter::reference>
Iter remove_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@);
-
- template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter, class T>
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter, class T>
requires EqualityComparable<InIter::reference, T>
OutIter remove_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, const T& @\farg{value}@);
-
- template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::reference> Pred>
- requires CopyConstructible<Pred>
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::reference> 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<Iter::reference, Iter::reference> Pred>
- requires MoveAssignable<Iter::reference> && CopyConstructible<Pred>
+ template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
+ requires MoveAssignable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@);
-
- template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter>
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
requires EqualityComparable<InIter::value_type> && CopyAssignable<InIter::value_type> &&
@\textcolor{addclr}{CopyConstructible}@<InIter::value_type> && !ForwardIterator<InIter> &&
!MutableForwardIterator<OutIter>
OutIter
unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-
- template<ForwardIterator InIter, OutputIterator<InIter::value_type> OutIter>
+ template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
requires EqualityComparable<InIter::reference>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-
template<InputIterator InIter, MutableForwardIterator OutIter>
requires EqualityComparable<OutIter::reference, InIter::value_type> &&
CopyAssignable<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-
- template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::value_type, InIter::value_type> Pred>
+ template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::value_type, InIter::value_type> Pred>
requires CopyAssignable<InIter::value_type> && CopyConstructible<InIter::value_type> &&
- !ForwardIterator<InIter> && !MutableForwardIterator<OutIter> &&
- CopyConstructible<Pred>
+ !ForwardIterator<InIter> && !MutableForwardIterator<OutIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
-
- template<ForwardIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::reference, InIter::reference> Pred>
- requires CopyConstructible<Pred>
+ template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::reference, InIter::reference> Pred>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-
template<InputIterator InIter, MutableForwardIterator OutIter,
- Predicate<OutIter::reference, InIter::reference> Pred>
+ Predicate<auto, OutIter::reference, InIter::reference> Pred>
requires CopyAssignable<OutIter::reference, InIter::reference> &&
- !ForwardIterator<InIter> && CopyConstructible<Pred>
+ !ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
template<MutableBidirectionalIterator Iter>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
void reverse(Iter @\farg{first}@, Iter @\farg{last}@);
-
- template<BidirectionalIterator InIter, OutputIterator<InIter::value_type> OutIter>
+ template<BidirectionalIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
OutIter reverse_copy(InIter @\farg{first}@,
InIter @\farg{last}@, OutIter @\farg{result}@);
@@ -390,8 +344,7 @@
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
void rotate(Iter @\farg{first}@, Iter @\farg{middle}@,
Iter @\farg{last}@);
-
- template<ForwardIterator InIter, OutputIterator<InIter::value_type> OutIter>
+ template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
OutIter rotate_copy(InIter @\farg{first}@, InIter @\farg{middle}@,
InIter @\farg{last}@, OutIter @\farg{result}@);
@@ -399,29 +352,24 @@
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@);
-
- template<MutableRandomAccessIterator Iter, Callable<Iter::difference_type> Rand>
+ template<MutableRandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- Convertible<Rand::result_type, Iter::difference_type> && CopyConstructible<Rand>
+ Convertible<Rand::result_type, Iter::difference_type>
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@,
Rand& @\farg{rand}@);
-
template<class RandomAccessIterator, class UniformRandomNumberGenerator>
void random_shuffle(RandomAccessIterator @\farg{first}@,
RandomAccessIterator @\farg{last}@,
UniformRandomNumberGenerator& @\farg{rand}@);
@\textcolor{black}{// \ref{alg.partitions}, partitions:}@
- template<BidirectionalIterator Iter, Predicate<Iter::reference> Pred>
- @\color{addclr}@requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- CopyConstructible<Pred>
+ template<BidirectionalIterator Iter, Predicate<auto, Iter::reference> Pred>
+ @\color{addclr}@requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
Iter partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
-
- template<MutableBidirectionalIterator Iter, Predicate<Iter::reference> Pred>
+ template<MutableBidirectionalIterator Iter, Predicate<auto Iter::reference> Pred>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Pred>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
Iter stable_partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
@\textcolor{black}{// \ref{alg.sorting}, sorting and related operations:}@
@@ -431,12 +379,10 @@
MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
LessThanComparable<Iter::value_type>
void sort(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
@@ -445,33 +391,28 @@
MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
LessThanComparable<Iter::value_type>
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<MutableRandomAccessIterator Iter>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> @\addedCC{\&\&}@
+ @\addedCC{LessThanComparable<Iter::value_type>}@
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@,
Compare @\farg{comp}@);
-
template<InputIterator InIter, MutableRandomAccessIterator RAIter>
requires CopyAssignable<RAIter::reference, InIter::value_type> &&
SameType<RAIter::value_type&, RAIter::reference> && Swappable<RAIter::value_type> &&
@@ -481,33 +422,29 @@
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, MutableRandomAccessIterator RAIter, class Compare>
requires CopyAssignable<RAIter::reference, InIter::value_type> &&
SameType<RAIter::value_type&, RAIter::reference> && Swappable<RAIter::value_type> &&
MoveConstructible<RAIter::value_type> && MoveAssignable<RAIter::value_type> &&
Predicate<Compare, InIter::value_type, RAIter::value_type> &&
Predicate<Compare, RAIter::value_type, InIter::value_type> &&
- Predicate<Compare, RAIter::value_type> &&
- CopyConstructible<Compare>
+ Predicate<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}@);
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
- bool is_sorted(Iter first, Iter last);
- template<ForwardIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
- bool is_sorted(Iter first, Iter last,
- Compare comp);
+ bool is_sorted(Iter @\farg{first}@, Iter @\farg{last}@);
+ template<ForwardIterator Iter, Predicate<auto, Iter::value_type, 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 first, Iter last);
- template<ForwardIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
- Iter is_sorted_until(Iter first, Iter last,
- Compare comp);
+ Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@);
+ template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@,
+ Compare @\farg{comp}@);
template<MutableRandomAccessIterator Iter>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
@@ -515,12 +452,10 @@
LessThanComparable<Iter::value_type>
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -529,9 +464,7 @@
requires LessThanComparable<Iter::reference, T>
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-
- @\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<Iter::reference, T> Compare>
- requires CopyConstructible<Compare>
+ @\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<auto, Iter::reference, T> Compare>
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
@@ -539,9 +472,7 @@
requires LessThanComparable<T, Iter::reference>
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-
- template<ForwardIterator Iter, class T, Predicate<T, Iter::reference> Compare>
- requires CopyConstructible<Compare>
+ template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::reference> Compare>
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
@@ -551,11 +482,9 @@
pair<Iter, Iter>
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> &&
- CopyConstructible<Compare>
+ Predicate<Compare, Iter::reference, T>
pair<Iter, Iter>
equal_range(Iter @\farg{first}@,
Iter @\farg{last}@, const T& @\farg{value}@,
@@ -566,28 +495,24 @@
LessThanComparable<Iter::reference, T>
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> &&
- CopyConstructible<Compare>
+ Predicate<Compare, Iter::reference, T>
bool binary_search(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
@\textcolor{black}{// \ref{alg.merge}, merge:}@
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
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<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> &&
- CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@);
@@ -599,12 +524,10 @@
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@);
-
template<MutableBidirectionalIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -614,74 +537,69 @@
requires SameType<Iter1::value_type, Iter2::value_type> && LessThanComparable<Iter1::value_type>
bool includes(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
-
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<Iter1::value_type, Iter2::value_type> Compare>
- requires SameType<Iter1::value_type, Iter2::value_type> && CopyConstructible<Compare>
+ Predicate<auto, Iter1::value_type, Iter2::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}@,
Compare @\farg{comp}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_union(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@);
-
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_intersection(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@);
-
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
@\textcolor{addclr}{OutIter}@ @\farg{result}@);
-
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_symmetric_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@);
-
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
@@ -691,11 +609,9 @@
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
LessThanComparable<Iter::value_type>
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
- requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
@@ -703,11 +619,10 @@
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
Swappable<Iter::value_type> && LessThanComparable<Iter::value_type>
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- Swappable<Iter::value_type> && CopyConstructible<Compare>
+ Swappable<Iter::value_type>
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
@@ -715,11 +630,9 @@
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
LessThanComparable<Iter::value_type>
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
- requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
@@ -727,71 +640,78 @@
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
Swappable<Iter::value_type> && LessThanComparable<Iter::value_type>
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableRandomAccessIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- Swappable<Iter::value_type> && CopyConstructible<Compare>
+ Swappable<Iter::value_type>
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
requires LessThanComparable<Iter::value_type>
- bool is_heap(Iter first, Iter last);
- template<RandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
- bool is_heap(Iter first, Iter last, Compare comp);
+ bool is_heap(Iter @\farg{first}@, Iter @\farg{last}@);
+ template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ bool is_heap(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
template<RandomAccessIterator Iter>
- Iter is_heap_until(Iter first, Iter last);
- template<RandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
- Iter is_heap_until(Iter first, Iter last,
- Compare comp);
+ Iter is_heap_until(Iter @\farg{first}@, Iter @\farg{last}@);
+ template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, 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<T, T> Compare>
- requires CopyConstructible<Compare>
+ template<class T, Predicate<auto, T, T> Compare>
const T& min(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
+ @\addedCC{template<LessThanComparable T> const T\& min(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
+ @\addedCC{template<LessThanComparable T, LessThanComparable... Args>}@
+ @\addedCC{requires SameType<T, Args>...}@
+ @\addedCC{const T\& min(const T\& \mbox{\farg{a}}, const Args\&... \mbox{\farg{args}});}@
+ @\textcolor{black}{template<class T, class U, class... Args>}@
+ @\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<T, T> Compare>
- requires CopyConstructible<Compare>
+ template<class T, Predicate<auto, T, T> Compare>
const T& max(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
+ @\addedCC{template<LessThanComparable T> const T\& max(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
+ @\addedCC{template<LessThanComparable T, LessThanComparable... Args>}@
+ @\addedCC{requires SameType<T, Args>...}@
+ @\addedCC{const T\& max(const T\& \mbox{\farg{a}}, const Args\&... \mbox{\farg{args}});}@
+ @\textcolor{black}{template<class T, class U, class... Args>}@
+ @\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<T, T> Compare>
- requires CopyConstructible<Compare>
+ template<class T, Predicate<auto, T, T> Compare>
pair<const T&, const T&> minmax(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
+ @\addedCC{template<LessThanComparable T>}@
+ @\addedCC{pair<const T\&, const T\&> minmax(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
+ @\addedCC{template<LessThanComparable T, LessThanComparable... Args>}@
+ @\addedCC{requires SameType<T, Args>...}@
+ @\addedCC{pair<const T\&, const T\&> minmax(const T\& \mbox{\farg{a}}, const Args\&... \mbox{\farg{args}});}@
+ @\textcolor{black}{template<class T, class U, class... Args>}@
+ @\textcolor{black}{pair<const T\&, const T\&> minmax(const T\& \mbox{\farg{a}}, const U\& \mbox{\farg{b}}, const Args\&... \mbox{\farg{args}});}@
template<ForwardIterator Iter>
requires LessThanComparable<Iter::reference>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@);
-
- template<ForwardIterator Iter, Predicate<Iter::reference, Iter::reference> Compare>
- requires CopyConstructible<Compare>
+ template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> 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<Iter::reference, Iter::reference> Compare>
- requires CopyConstructible<Compare>
+ template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
pair<Iter, Iter>
- minmax_element(Iter @\farg{first}@, Iter @\farg{last}@);
- template<ForwardIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
+ @\textcolor{addclr}{}@minmax_element(Iter @\farg{first}@, Iter @\farg{last}@);
+ template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
pair<Iter, Iter>
minmax_element(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
- @\textcolor{black}{// \ref{alg.permutation.generators}, permutations:}@
template<InputIterator Iter1, InputIterator Iter2>
@\textcolor{addclr}{requires}@ LessThanComparable<Iter1::reference, Iter2::reference> &&
LessThanComparable<Iter2::reference, Iter1::reference>
@@ -800,32 +720,27 @@
@\textcolor{addclr}{template}@<InputIterator Iter1, InputIterator Iter2, class Compare>
requires Predicate<Compare, Iter1::reference, Iter2::reference> &&
- Predicate<Compare, Iter2::reference, Iter1::reference> &&
- CopyConstructible<Compare>
+ Predicate<Compare, Iter2::reference, Iter1::reference>
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<MutableBidirectionalIterator Iter>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
@\textcolor{addclr}{LessThanComparable}@<Iter::reference>
bool next_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableBidirectionalIterator Iter,
- Predicate<Iter::reference, Iter::reference> Compare>
- requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- CopyConstructible<Compare>
+ Predicate<auto, Iter::reference, Iter::reference> Compare>
+ requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
bool next_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
-
template<MutableBidirectionalIterator Iter>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- LessThanComparable<Iter::reference>
+ @\textcolor{addclr}{}@LessThanComparable<Iter::reference>
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
-
template<MutableBidirectionalIterator Iter,
- Predicate<Iter::reference, Iter::reference> Compare>
- requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- CopyConstructible<Compare>
+ Predicate<auto, Iter::reference, Iter::reference> Compare>
+ requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
}
\end{codeblock}
@@ -967,7 +882,8 @@
\enternote\
Unless otherwise specified, algorithms that take function objects as arguments
are permitted to copy those function objects freely. Programmers for whom object
-identity is important should consider using a wrapper class that points to a
+identity is important should consider using a wrapper class that
+points \textcolor{black}{}to a
noncopied implementation object, or some equivalent solution.
\exitnote\
@@ -1020,8 +936,7 @@
\color{addclr}
\begin{itemdecl}
-template<InputIterator Iter, Callable<Iter::reference> Function>
- requires CopyConstructible<Function>
+template<InputIterator Iter, Callable<auto, Iter::reference> Function>
Function for_each(Iter @\farg{first}@, Iter @\farg{last}@, Function @\farg{f}@);
\end{itemdecl}
\color{black}
@@ -1061,8 +976,7 @@
requires EqualityComparable<Iter::reference, T>
Iter find(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-template<InputIterator Iter, Predicate<Iter::reference> Pred>
- requires CopyConstructible<Pred>
+template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
Iter find_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1095,8 +1009,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
Iter1 find_end(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -1108,7 +1021,7 @@
Finds a subsequence of equal values in a sequence.
\pnum
-\returns\
+\textcolor{black}{}\returns\
The last iterator
\tcode{i}\
in the range \range{\farg{first1}}{\farg{last1} - (\farg{last2} - \farg{first2})}\
@@ -1140,8 +1053,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, ForwardIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
Iter1 find_first_of(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -1181,8 +1093,7 @@
requires EqualityComparable<Iter::reference>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<Iter::reference, Iter::reference> Pred>
- requires CopyConstructible<Pred>
+template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
Iter adjacent_find(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1222,8 +1133,7 @@
requires EqualityComparable<Iter::reference, T>
@\color{addclr}@Iter::difference_type count(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
-template<InputIterator Iter, Predicate<Iter::reference> Pred>
- requires CopyConstructible<Pred>
+template<InputIterator Iter, Predicate<auto, Iter::reference> Pred>
Iter::difference_type count_if(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1254,8 +1164,7 @@
Iter @\farg{first2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
pair<Iter1, Iter2> mismatch(Iter1 @\farg{first1}@, Iter2 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1303,8 +1212,7 @@
Iter2 @\farg{first2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
bool equal(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -1338,8 +1246,7 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<ForwardIterator Iter1, ForwardIterator Iter2,
- Predicate<Iter1::reference, Iter2::reference> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter1::reference, Iter2::reference> Pred>
@\textcolor{addclr}{Iter1}@ search(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
Pred @\farg{pred}@);
@@ -1378,8 +1285,7 @@
const T& @\farg{value}@);
template<ForwardIterator Iter, class T,
- Predicate<Iter::reference, T> Pred>
- requires CopyConstructible<Pred>
+ Predicate<auto, Iter::reference, 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}
@@ -1421,7 +1327,7 @@
if no such iterator is found.
\pnum
-\complexity\
+\textcolor{black}{}\complexity\
At most
\tcode{(\farg{last}\ - \farg{first}) * \farg{count}}
applications of the corresponding predicate if \farg{count} is positive, or
@@ -1434,7 +1340,7 @@
\index{copy@\tcode{copy}}%
\color{addclr}\begin{itemdecl}
-template<InputIterator InIter, OutputIterator<InIter::reference> OutIter>
+template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
OutIter copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
\end{itemdecl}\color{black}
@@ -1517,7 +1423,7 @@
\index{move\tcode{move}}%
\color{addclr}
\begin{itemdecl}
-template<InputIterator InIter, OutputIterator<InIter::value_type&&> OutIter>
+@\textcolor{addclr}{}@template<InputIterator InIter, OutputIterator<auto, InIter::value_type&&> OutIter>
OutIter move(InIter first, InIter last,
OutIter result);
\end{itemdecl}
@@ -1646,7 +1552,7 @@
\tcode{swap(*(\farg{first1}\ + n), *(\farg{first2}\ + n))}.
\pnum
-\requires\
+\textcolor{black}{}\requires\
The two ranges \range{\farg{first1}}{\farg{last1}}\
and
\range{\farg{first2}}{\farg{first2}\ + (\farg{last1}\ - \farg{first1})}\
@@ -1696,14 +1602,14 @@
\index{transform@\tcode{transform}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter, class OutIter,
- Callable<InIter::reference> Op>
- requires OutputIterator<OutIter, Op::result_type> && CopyConstructible<Op>
+ Callable<auto, InIter::reference> Op>
+ requires OutputIterator<OutIter, Op::result_type>
OutIter transform(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Op @\farg{op}@);
template<InputIterator InIter1, InputIterator InIter2,
- class OutIter, Callable<InIter1::reference, InIter2::reference> BinaryOp>
- requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructible<BinaryOp>
+ class OutIter, Callable<auto, InIter1::reference, InIter2::reference> BinaryOp>
+ requires OutputIterator<OutIter, BinaryOp::result_type>
OutIter transform(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
InIter2 @\farg{first2}@, OutIter @\farg{result}@,
BinaryOp @\farg{binary_op}@);
@@ -1762,8 +1668,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<Iter::reference> Pred, class T>
- requires CopyAssignable<Iter::reference, T> && CopyConstructible<Pred>
+@\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::reference> Pred, class T>
+ requires CopyAssignable<Iter::reference, T>
void replace_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
\end{itemdecl}\color{black}
@@ -1794,15 +1700,15 @@
\index{replace_copy@\tcode{replace_copy}}%
\index{replace_copy_if@\tcode{replace_copy_if}}%
\color{addclr}\begin{itemdecl}
-template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter, class T>
+template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter, class T>
requires CopyAssignable<OutIter::reference, T> && EqualityComparable<InIter::reference, T>
OutIter replace_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
-template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::reference> Pred, class T>
- requires CopyAssignable<OutIter::reference, T> && CopyConstructible<Pred>
+template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::reference> Pred, class T>
+ requires CopyAssignable<OutIter::reference, T>
OutIter replace_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
@@ -1897,15 +1803,13 @@
\index{generate@\tcode{generate}}%
\index{generate_n@\tcode{generate_n}}%
\color{addclr}\begin{itemdecl}
-template<MutableForwardIterator Iter, Callable<> Generator>
- requires CopyAssignable<Iter::reference, Generator::result_type> &&
- CopyConstructible<Generator>
+template<MutableForwardIterator Iter, Callable Generator>
+ requires CopyAssignable<Iter::reference, Generator::result_type>
void generate(Iter @\farg{first}@, Iter @\farg{last}@,
Generator @\farg{gen}@);
-template<class Iter, Integral Size, Callable<> Generator>
- requires OutputIterator<Iter, Generator::result_type> &&
- CopyConstructible<Generator>
+template<class Iter, Integral Size, Callable Generator>
+ requires OutputIterator<Iter, Generator::result_type>
void generate_n(Iter @\farg{first}@, Size @\farg{n}@, Generator @\farg{gen}@);
\end{itemdecl}\color{black}
@@ -1947,10 +1851,10 @@
Iter remove(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-template<ForwardIterator Iter, Predicate<Iter::reference> Pred>
- requires MoveAssignable<Iter::reference> && CopyConstructible<Pred>
+template<ForwardIterator Iter, Predicate<auto, Iter::reference> Pred>
+ requires MoveAssignable<Iter::reference>
Iter remove_if(Iter @\farg{first}@, Iter @\farg{last}@,
- Pred @\farg{pred}@);
+ @\textcolor{addclr}{}@Pred @\farg{pred}@);
\end{itemdecl}\color{black}
\begin{itemdescr}
@@ -1975,7 +1879,7 @@
Stable.
\pnum
-\complexity\
+\textcolor{black}{}\complexity\
Exactly
\tcode{\farg{last} - \farg{first}}\
applications of the corresponding predicate.
@@ -1984,14 +1888,13 @@
\index{remove_copy@\tcode{remove_copy}}%
\index{remove_copy_if@\tcode{remove_copy_if}}%
\color{addclr}\begin{itemdecl}
-template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter, class T>
+template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter, class T>
requires EqualityComparable<InIter::reference, T>
OutIter remove_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, const T& @\farg{value}@);
-template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::reference> Pred>
- requires CopyConstructible<Pred>
+template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::reference> Pred>
OutIter remove_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -2038,8 +1941,8 @@
requires MoveAssignable<Iter::reference> && EqualityComparable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<Iter::reference, Iter::reference> Pred>
- requires MoveAssignable<Iter::reference> && CopyConstructible<Pred>
+template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Pred>
+ requires MoveAssignable<Iter::reference>
Iter unique(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -2075,7 +1978,7 @@
\index{unique_copy@\tcode{unique_copy}}%
\color{addclr}
\begin{itemdecl}
-template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter>
+template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
requires EqualityComparable<InIter::value_type> && CopyAssignable<InIter::value_type> &&
CopyConstructible<InIter::value_type> && !ForwardIterator<InIter> &&
!MutableForwardIterator<OutIter>
@@ -2083,7 +1986,7 @@
unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-template<ForwardIterator InIter, OutputIterator<InIter::value_type> OutIter>
+template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
requires EqualityComparable<InIter::reference>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
@@ -2095,24 +1998,22 @@
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
-template<InputIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::value_type, InIter::value_type> Pred>
+template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::value_type, InIter::value_type> Pred>
requires CopyAssignable<InIter::value_type> && CopyConstructible<InIter::value_type> &&
- !ForwardIterator<InIter> && !MutableForwardIterator<OutIter> &&
- CopyConstructible<Pred>
+ !ForwardIterator<InIter> && !MutableForwardIterator<OutIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
@\textcolor{addclr}{OutIter}@ @\farg{result}@, Pred @\farg{pred}@);
-template<ForwardIterator InIter, OutputIterator<InIter::value_type> OutIter,
- Predicate<InIter::reference, InIter::reference> Pred>
- requires CopyConstructible<Pred>
+template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
+ Predicate<auto, InIter::reference, InIter::reference> Pred>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
template<InputIterator InIter, MutableForwardIterator OutIter,
- Predicate<OutIter::reference, InIter::reference> Pred>
+ Predicate<auto, OutIter::reference, InIter::reference> Pred>
requires CopyAssignable<OutIter::reference, InIter::reference> &&
- !ForwardIterator<InIter> && CopyConstructible<Pred>
+ !ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
\end{itemdecl}
@@ -2144,7 +2045,7 @@
Otherwise CopyConstructible is not required.}
\pnum
-\effects\
+\textcolor{black}{}\effects\
Copies only the first element from every consecutive group of equal elements referred to by
the iterator \color{black}
\tcode{i}\
@@ -2199,7 +2100,7 @@
\index{reverse_copy@\tcode{reverse_copy}}%
\color{addclr}\begin{itemdecl}
-template<BidirectionalIterator InIter, OutputIterator<InIter::value_type> OutIter>
+template<BidirectionalIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
OutIter reverse_copy(InIter @\farg{first}@,
InIter @\farg{last}@, OutIter @\farg{result}@);
\end{itemdecl}\color{black}
@@ -2278,7 +2179,7 @@
\index{rotate_copy@\tcode{rotate_copy}}%
\color{addclr}\begin{itemdecl}
-template<ForwardIterator InIter, OutputIterator<InIter::value_type> OutIter>
+template<ForwardIterator InIter, OutputIterator<auto, InIter::value_type> OutIter>
OutIter rotate_copy(InIter @\farg{first}@, InIter @\farg{middle}@,
InIter @\farg{last}@, OutIter @\farg{result}@);
\end{itemdecl}\color{black}
@@ -2324,9 +2225,9 @@
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Callable<Iter::difference_type> Rand>
+template<MutableRandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- Convertible<Rand::result_type, Iter::difference_type> && CopyConstructible<Rand>
+ Convertible<Rand::result_type, Iter::difference_type>
void random_shuffle(Iter @\farg{first}@,
Iter @\farg{last}@,
Rand&& @\farg{rand}@);
@@ -2386,9 +2287,8 @@
\index{partition@\tcode{partition}}%
\color{addclr}\begin{itemdecl}
-template<BidirectionalIterator Iter, Predicate<Iter::reference> Pred>
- @\color{addclr}@requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- CopyConstructible<Pred>
+@\textcolor{addclr}{}@template<BidirectionalIterator Iter, Predicate<auto, Iter::reference> Pred>
+ @\color{addclr}@requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
Iter partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -2436,10 +2336,9 @@
\index{stable_partition@\tcode{stable_partition}}%
\color{addclr}\begin{itemdecl}
-template<MutableBidirectionalIterator Iter, Predicate<Iter::reference> Pred>
+template<MutableBidirectionalIterator Iter, Predicate<auto, Iter::reference> Pred>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Pred>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
Iter stable_partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
\end{itemdecl}\color{black}
@@ -2500,10 +2399,9 @@
LessThanComparable<Iter::value_type>
void sort(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2546,10 +2444,9 @@
LessThanComparable<Iter::value_type>
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2593,10 +2490,9 @@
Iter @\farg{middle}@,
Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void partial_sort(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@,
@@ -2653,8 +2549,7 @@
MoveConstructible<RAIter::value_type> && MoveAssignable<RAIter::value_type> &&
Predicate<Compare, InIter::value_type, RAIter::value_type> &&
Predicate<Compare, RAIter::value_type, InIter::value_type> &&
- Predicate<Compare, RAIter::value_type> &&
- CopyConstructible<Compare>
+ Predicate<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}@);
@@ -2697,7 +2592,7 @@
\begin{itemdecl}
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
- bool is_sorted(Iter first, Iter last);
+ bool is_sorted(Iter @\farg{first}@, Iter @\farg{last}@);
\end{itemdecl}
\color{black}
@@ -2709,10 +2604,9 @@
\index{is_sorted@\tcode{is_sorted}}%
\color{addclr}
\begin{itemdecl}
-template<ForwardIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
- bool is_sorted(Iter first, Iter last,
- Compare comp);
+template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ bool is_sorted(Iter @\farg{first}@, Iter @\farg{last}@,
+ Compare @\farg{comp}@);
\end{itemdecl}
\color{black}
@@ -2726,11 +2620,10 @@
\begin{itemdecl}
template<ForwardIterator Iter>
requires LessThanComparable<Iter::value_type>
- Iter is_sorted_until(Iter first, Iter last);
-template<ForwardIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
- Iter is_sorted_until(Iter first, Iter last,
- Compare comp);
+ Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@);
+template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ Iter is_sorted_until(Iter @\farg{first}@, Iter @\farg{last}@,
+ Compare @\farg{comp}@);
\end{itemdecl}
\color{black}
@@ -2756,10 +2649,9 @@
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2808,7 +2700,7 @@
They work on non-random access iterators minimizing the number of comparisons,
which will be logarithmic for all types of iterators.
They are especially appropriate for random access iterators,
-because these algorithms do a logarithmic number of steps
+because these \textcolor{black}{}algorithms do a logarithmic number of steps
through the data structure.
For non-random access iterators they execute a linear number of steps.
@@ -2821,8 +2713,7 @@
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-@\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<Iter::reference, T> Compare>
- requires CopyConstructible<Compare>
+@\textcolor{addclr}{template}@<ForwardIterator Iter, class T, Predicate<auto, Iter::reference, T> Compare>
Iter lower_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2870,8 +2761,7 @@
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@);
-template<ForwardIterator Iter, class T, Predicate<T, Iter::reference> Compare>
- requires CopyConstructible<Compare>
+template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::reference> Compare>
Iter upper_bound(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -2923,8 +2813,7 @@
template<ForwardIterator Iter, class T, class Compare>
requires Predicate<Compare, T, Iter::reference> &&
- Predicate<Compare, Iter::reference, T> &&
- CopyConstructible<Compare>
+ Predicate<Compare, Iter::reference, T>
pair<Iter, Iter>
equal_range(Iter @\farg{first}@,
Iter @\farg{last}@, const T& @\farg{value}@,
@@ -2951,7 +2840,7 @@
of
\tcode{[\farg{first}, \farg{last})},
\tcode{e < value}\
-implies
+\textcolor{black}{}implies
\tcode{!(value < e)}\
or
\tcode{\farg{comp}(e, value)}\
@@ -2989,8 +2878,7 @@
template<ForwardIterator Iter, class T, class Compare>
requires Predicate<Compare, T, Iter::reference> &&
- Predicate<Compare, Iter::reference, T> &&
- CopyConstructible<Compare>
+ Predicate<Compare, Iter::reference, T>
bool binary_search(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{value}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3045,8 +2933,8 @@
\index{merge@\tcode{merge}}%
\color{addclr}\begin{itemdecl}
-template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+@\textcolor{addclr}{}@template<InputIterator InIter1, InputIterator InIter2,
+ OutputIterator<auto, InIter1::value_type> OutIter>
@\textcolor{addclr}{requires}@ SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter merge(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
@@ -3054,10 +2942,9 @@
OutIter @\farg{result}@);
@\textcolor{addclr}{template}@<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> &&
- CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ @\textcolor{addclr}{}@Predicate<auto, InIter1::value_type, InIter2::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}@);
@@ -3116,10 +3003,9 @@
Iter @\farg{last}@);
template<MutableBidirectionalIterator Iter,
- Predicate<Iter::value_type, Iter::value_type> Compare>
+ Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+ MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void inplace_merge(Iter @\farg{first}@,
Iter @\farg{middle}@,
Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -3199,8 +3085,8 @@
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@);
template<InputIterator Iter1, InputIterator Iter2,
- Predicate<Iter1::value_type, Iter2::value_type> Compare>
- requires SameType<Iter1::value_type, Iter2::value_type> && CopyConstructible<Compare>
+ Predicate<auto, Iter1::value_type, Iter2::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}@,
Compare @\farg{comp}@);
@@ -3230,7 +3116,7 @@
\index{set_union@\tcode{set_union}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_union(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
@@ -3238,9 +3124,9 @@
OutIter @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
@@ -3270,7 +3156,7 @@
\notes\ If \range{first1}{last1}\ contains $m$ elements that are equivalent to
each other and \range{first2}{last2}\ contains $n$ elements that are equivalent
to them, then all $m$ elements from the first range shall be copied to the output
-range, in order, and then $\max(n - m, 0)$ elements from the second range shall
+\textcolor{black}{}range, in order, and then $\max(n - m, 0)$ elements from the second range shall
be copied to the output range, in order.
\end{itemdescr}
@@ -3279,7 +3165,7 @@
\index{set_intersection@\tcode{set_intersection}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_intersection(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
@@ -3287,9 +3173,9 @@
OutIter @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
@@ -3327,7 +3213,7 @@
\index{set_difference@\tcode{set_difference}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
@\textcolor{addclr}{LessThanComparable}@<InIter1::value_type>
OutIter set_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
@@ -3335,11 +3221,11 @@
@\textcolor{addclr}{OutIter}@ @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
+ @\textcolor{addclr}{}@InIter2 @\farg{first2}@, InIter2 @\farg{last2}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3388,7 +3274,7 @@
\index{set_symmetric_difference@\tcode{set_symmetric_difference}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter>
+ OutputIterator<auto, InIter1::value_type> OutIter>
requires SameType<InIter1::value_type, InIter2::value_type> &&
LessThanComparable<InIter1::value_type>
OutIter set_symmetric_difference(InIter1 @\farg{first1}@, InIter1 @\farg{last1}@,
@@ -3396,9 +3282,9 @@
OutIter @\farg{result}@);
template<InputIterator InIter1, InputIterator InIter2,
- OutputIterator<InIter1::value_type> OutIter,
- Predicate<InIter1::value_type, InIter2::value_type> Compare>
- requires SameType<InIter1::value_type, InIter2::value_type> && CopyConstructible<Compare>
+ OutputIterator<auto, InIter1::value_type> OutIter,
+ Predicate<auto, InIter1::value_type, InIter2::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}@,
OutIter @\farg{result}@, Compare @\farg{comp}@);
@@ -3483,9 +3369,8 @@
LessThanComparable<Iter::value_type>
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void push_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3525,9 +3410,9 @@
Swappable<Iter::value_type> && LessThanComparable<Iter::value_type>
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- Swappable<Iter::value_type> && CopyConstructible<Compare>
+ Swappable<Iter::value_type>
void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3556,7 +3441,7 @@
(Table~\mbox{\ref{moveassignable}}).}
\pnum
-\complexity\
+\textcolor{black}{}\complexity\
At most
\tcode{2 * log(\farg{last}\ - \farg{first})}\
comparisons.
@@ -3571,9 +3456,8 @@
LessThanComparable<Iter::value_type>
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-@\color{addclr}@template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- CopyConstructible<Compare>
+@\color{addclr}@template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
+ requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type>
void make_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3607,9 +3491,9 @@
Swappable<Iter::value_type> && LessThanComparable<Iter::value_type>
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableRandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
+template<MutableRandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
requires MoveConstructible<Iter::value_type> && MoveAssignable<Iter::value_type> &&
- Swappable<Iter::value_type> && CopyConstructible<Compare>
+ Swappable<Iter::value_type>
void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3654,8 +3538,7 @@
\color{addclr}
\begin{itemdecl}
-template<RandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
+template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
bool is_heap(Iter first, Iter last, Compare comp);
\end{itemdecl}
\color{black}
@@ -3669,8 +3552,7 @@
\begin{itemdecl}
template<RandomAccessIterator Iter>
Iter is_heap_until(Iter first, Iter last);
-template<RandomAccessIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
+template<RandomAccessIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
Iter is_heap_until(Iter first, Iter last,
Compare comp);
\end{itemdecl}
@@ -3692,8 +3574,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<T, T> Compare>
- requires CopyConstructible<Compare>
+template<class T, Predicate<auto, T, T> Compare>
const T& min(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3714,11 +3595,66 @@
Returns the first argument when the arguments are equivalent.
\end{itemdescr}
+\begin{itemdecl}
+@\addedCC{template<LessThanComparable T> const T\& min(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
+@\addedCC{template<LessThanComparable T, LessThanComparable... Args>}@
+ @\addedCC{requires SameType<T, Args>...}@
+ @\addedCC{const T\& min(const T\& \mbox{\farg{a}}, const Args\&... \mbox{\farg{args}});}@
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\removedCC{\mbox{\requires} Type \mbox{\tcode{T}} is
+ \mbox{\tcode{LessThanComparable}}, and all types forming
+ \mbox{\tcode{Args...}} are the same as \mbox{\tcode{T}}.}
+
+\pnum
+\mbox{\returns} The smallest value in the set of all
+ arguments.
+
+\pnum
+\mbox{\notes} Returns the leftmost argument when several
+ arguments are equivalent to the smallest. Returns \mbox{\farg{a}} if
+ \mbox{\tcode{sizeof...(Args)}} is 0.
+\end{itemdescr}
+
+\begin{itemdecl}
+template<class T, class U, class... Args>
+ const T& min(const T& @\farg{a}@, const U& @\farg{b}@, const Args&... @\farg{args}@);
+\end{itemdecl}
+
+\editorial{At present, we do not know how to write concept constraints
+ for this variant of \mbox{\tcode{min}}, because we cannot directly
+ express the idea of splitting \mbox{\tcode{Args}} into its first N-1
+ arguments (all of which are the same at \mbox{\tcode{T}}) and its
+ Nth argument (the binary predicate). Most likely this is possible
+ with what is effectively metaprogramming of the concept system to
+ ``walk'' through the arguments, but such an implementation would
+ make a poor specification. For now, we leave this version
+ unconstrained.}
+
+\begin{itemdescr}
+\pnum
+\requires\
+The types of all arguments except the last one are the same as \tcode{T}.
+The last argument is a binary predicate over \tcode{T}.
+
+\pnum
+\returns\
+The first element in a partial ordering of all the arguments except
+the last one, where the ordering is defined by the predicate.
+
+\pnum
+\notes\
+Returns the leftmost argument when several arguments are equivalent to
+the first element in the ordering. Returns \farg{a} if
+\tcode{sizeof...(Args)} is 0.
+\end{itemdescr}
+
\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<T, T> Compare>
- requires CopyConstructible<Compare>
+template<class T, Predicate<auto, T, T> Compare>
const T& max(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3739,12 +3675,61 @@
Returns the first argument when the arguments are equivalent.
\end{itemdescr}
+\begin{itemdecl}
+@\addedCC{template<LessThanComparable T> const T\& max(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
+@\addedCC{template<LessThanComparable T, LessThanComparable... Args>}@
+ @\addedCC{requires SameType<T, Args>...}@
+ @\addedCC{const T\& max(const T\& \mbox{\farg{a}}, const Args\&... \mbox{\farg{args}});}@
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\removedCC{\mbox{\requires} Type \mbox{\tcode{T}} is
+ \mbox{\tcode{LessThanComparable}}, and all types forming
+ \mbox{\tcode{Args...}} are the same as \mbox{\tcode{T}}.}
+
+\pnum
+\mbox{\returns} The largest value in the set of all
+ arguments.
+
+\pnum
+\mbox{\notes} Returns the leftmost argument when several
+ arguments are equivalent to the largest. Returns \mbox{\farg{a}} if
+ \mbox{\tcode{sizeof...(Args)}} is 0.
+\end{itemdescr}
+
+\begin{itemdecl}
+template<class T, class U, class... Args>
+ const T& max(const T& @\farg{a}@, const U& @\farg{b}@, const Args&... @\farg{args}@);
+\end{itemdecl}
+
+\editorial{As with the corresponding \mbox{\tcode{min}} function, we
+ do not know how to write the constraints, so we leave this version
+ unconstrained.}
+
+\begin{itemdescr}
+\pnum
+\requires\
+The types of all arguments except the last one are the same as \tcode{T}.
+The last argument is a binary predicate over \tcode{T}.
+
+\pnum
+\returns\
+The last element in a partial ordering of all the arguments except
+the last one, where the ordering is defined by the predicate.
+
+\pnum
+\notes\
+Returns the leftmost argument when several arguments are equivalent to
+the last element in the ordering. Returns \farg{a} if
+\tcode{sizeof...(Args)} is 0.
+\end{itemdescr}
+
\index{minmax@\tcode{minmax}}%
\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<T, T> Compare>
- requires CopyConstructible<Compare>
+template<class T, Predicate<auto, T, T> Compare>
@\textcolor{addclr}{pair}@<const T&, const T&> minmax(const T& @\farg{a}@, const T& @\farg{b}@, Compare @\farg{comp}@);
\end{itemdecl}
\color{black}
@@ -3772,14 +3757,90 @@
Exactly one comparison.}
\end{itemdescr}
+\begin{itemdecl}
+@\addedCC{template<LessThanComparable T>}@
+ @\addedCC{pair<const T\&, const T\&> minmax(const T\& \mbox{\farg{a}}, const T\& \mbox{\farg{b}}, const T\& \mbox{\farg{c}});}@
+@\addedCC{template<LessThanComparable T, LessThanComparable... Args>}@
+ @\addedCC{requires SameType<T, Args>...}@
+ @\addedCC{pair<const T\&, const T\&> minmax(const T\& \mbox{\farg{a}}, const Args\&... \mbox{\farg{args}});}@
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\removedCC{\mbox{\requires} Type \mbox{\tcode{T}} is
+ \mbox{\tcode{LessThanComparable}}, and all types forming
+ \mbox{\tcode{Args...}} are the same as \mbox{\tcode{T}}.}
+
+\pnum
+\returns\
+\tcode{pair<const T\&, const T\&>(x, y)}\
+where \tcode{x} is the first element and \tcode{y} the last element in
+a partial ordering of all the arguments.
+
+\pnum
+\notes\
+\tcode{x}\
+is the leftmost argument when several arguments are
+equivalent to the smallest.
+\tcode{y}\
+is the rightmost argument when several arguments are equivalent to the
+largest.
+Returns
+\tcode{pair<const T\&, const T\&>(a, a)}\
+if
+\tcode{sizeof...(Args)}\
+is 0.
+
+\pnum
+\complexity\
+At most (3/2)\tcode{sizeof...(Args)} applications of the corresponding
+predicate.
+\end{itemdescr}
+
+\begin{itemdecl}
+@\textcolor{black}{template<class T, class U, class... Args>}@
+ @\textcolor{black}{pair<const T\&, const T\&> minmax(const T\& \mbox{\farg{a}}, const U\& \mbox{\farg{b}}, const Args\&... \mbox{\farg{args}});}@
+\end{itemdecl}
+
+\editorial{As with the corresponding \mbox{\tcode{min}} and
+ \mbox{\tcode{max}} functions, we
+ do not know how to write the constraints, so we leave this version
+ unconstrained.}
+
+\begin{itemdescr}
+\pnum
+\requires\
+The types of all arguments except the last one are the same as
+\tcode{T}. The last argument is a binary predicate over \tcode{T}.
+
+\pnum
+\returns\
+\tcode{pair<const T\&, const T\&>(x, y)}\
+where \tcode{x} is the first element and \tcode{y} the last element in
+a partial ordering of all the arguments defined by the predicate.
+
+\pnum
+\notes\
+\tcode{x} is the leftmost argument when several arguments would order
+equivalent as the first in the ordering.
+\tcode{y} is the rightmost argument when several arguments would order
+equivalent as the last in the ordering.
+Returns \tcode{pair<const T\&, const T\&>(a, a)} if
+\tcode{sizeof...(Args)} is 0.
+
+\pnum
+\complexity\
+At most (3/2)\tcode{sizeof...(Args)} applications of the corresponding
+predicate.
+\end{itemdescr}
+
\index{min_element@\tcode{min_element}}%
\color{addclr}\begin{itemdecl}
template<ForwardIterator Iter>
requires LessThanComparable<Iter::reference>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<Iter::reference, Iter::reference> Compare>
- requires CopyConstructible<Compare>
+template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
Iter min_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3817,8 +3878,7 @@
requires LessThanComparable<Iter::reference>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<Iter::reference, Iter::reference> Compare>
- requires CopyConstructible<Compare>
+template<ForwardIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
Iter max_element(Iter @\farg{first}@, Iter @\farg{last}@,
Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3857,8 +3917,7 @@
requires LessThanComparable<Iter::value_type>
pair<Iter, Iter>
minmax_element(Iter @\farg{first}@, Iter @\farg{last}@);
-template<ForwardIterator Iter, Predicate<Iter::value_type, Iter::value_type> Compare>
- requires CopyConstructible<Compare>
+template<ForwardIterator Iter, Predicate<auto, Iter::value_type, Iter::value_type> Compare>
pair<Iter, Iter>
minmax_element(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}
@@ -3893,10 +3952,9 @@
template<InputIterator Iter1, InputIterator Iter2, class Compare>
requires Predicate<Compare, Iter1::reference, Iter2::reference> &&
Predicate<Compare, Iter2::reference, Iter1::reference>
- CopyConstructible<Compare>
bool lexicographical_compare(Iter1 @\farg{first1}@, Iter1 @\farg{last1}@,
Iter2 @\farg{first2}@, Iter2 @\farg{last2}@,
- Compare @\farg{comp}@);
+ @\textcolor{addclr}{}@Compare @\farg{comp}@);
\end{itemdecl}\color{black}
\begin{itemdescr}
@@ -3947,9 +4005,8 @@
LessThanComparable<Iter::reference>
bool next_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableBidirectionalIterator Iter, Predicate<Iter::reference, Iter::reference> Compare>
- requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- CopyConstructible<Compare>
+template<MutableBidirectionalIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
+ requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
@\textcolor{addclr}{bool}@ next_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -3988,9 +4045,8 @@
LessThanComparable<Iter::reference>
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@);
-template<MutableBidirectionalIterator Iter, Predicate<Iter::reference, Iter::reference> Compare>
- requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type> &&
- CopyConstructible<Compare>
+template<MutableBidirectionalIterator Iter, Predicate<auto, Iter::reference, Iter::reference> Compare>
+ requires SameType<Iter::value_type&, Iter::reference> && Swappable<Iter::value_type>
bool prev_permutation(Iter @\farg{first}@, Iter @\farg{last}@, Compare @\farg{comp}@);
\end{itemdecl}\color{black}
@@ -4028,6 +4084,6 @@
\end{paras}
\bibliographystyle{plain}
-\bibliography{../local}
+\bibliography{local}
\end{document}
\ No newline at end of file
Added: sandbox/committee/concepts/stdlib/local.bib
==============================================================================
--- (empty file)
+++ sandbox/committee/concepts/stdlib/local.bib 2008-03-04 17:12:35 EST (Tue, 04 Mar 2008)
@@ -0,0 +1,396 @@
+@techreport{stroustrup_concept_checking03,
+ author = {Bjarne Stroustrup},
+ title = "Concepts -- A more abstract complement to type
+ checking",
+ institution = "ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}",
+ number = "N1510=03-0093",
+ year = 2003,
+ month = oct,
+ note = {\url{http://www.open-std.org/jtc1/sc22/wg21}}
+}
+
+@TechReport{siek06:_scoped_concept_maps,
+ author = {Jeremy Siek},
+ title = {Scoped Concept Maps},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2098=06-0168},
+ month = {September},
+ note = {\url{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2098.pdf}}
+}
+
+@techreport{stroustrup_concept_design_choices03,
+ author = {Bjarne Stroustrup and Dos Reis, Gabriel},
+ title = "Concepts -- Design choices for template argument
+ checking",
+ institution = "ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}",
+ number = "N1522=03-0105",
+ year = 2003,
+ month = oct,
+ note = {\url{http://www.open-std.org/jtc1/sc22/wg21}}
+}
+
+@Book{C++ARM,
+ author = {Margaret A. Ellis and Bjarne Stroustrup},
+ title = {The {Annotated} {C++} {Reference} {Manual}},
+ publisher = {Addison-Wesley},
+ year = 1990,
+ address = {Reading, MA.}
+}
+
+@techreport{stroustrup_concept_syntax03,
+ author = {Bjarne Stroustrup and Dos Reis, Gabriel},
+ title = "Concepts -- syntax and composition",
+ institution = "ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}",
+ number = "N1536=03-0119",
+ year = 2003,
+ month = oct,
+ note = {\url{http://www.open-std.org/jtc1/sc22/wg21}}
+}
+
+@TechReport{siek05:concepts_c++0x,
+ author = {Jeremy Siek and Douglas Gregor and Ronald Garcia and Jeremiah Willcock and Jaakko J\"{a}rvi and Andrew Lumsdaine},
+ title = {Concepts for {C++0x}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2005,
+ number = {N1758=05-0018},
+ month = {January}
+}
+
+@Unpublished{stroustrup05:concept_design,
+ author = {Bjarne Stroustrup and Gabriel {Dos Reis}},
+ title = {A concept design},
+ note = {{C++} Extensions reflector message {c++std-ext-7073}},
+ month = {April},
+ year = 2005
+}
+
+@TechReport{stroustrup05:concept_design_rev_1,
+ author = {Bjarne Stroustrup and Gabriel {Dos Reis}},
+ title = {A concept design (Rev. 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2005,
+ month = {May},
+ number = {N1782=05-0042}
+}
+
+@TechReport{stroustrup05:concept_design_rev_1,
+ author = {Bjarne Stroustrup and Gabriel {Dos Reis}},
+ title = {A concept design (Rev. 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2005,
+ month = {May},
+ number = {N1782=05-0042}
+}
+
+@TechReport{gregor05:explicit_models,
+ author = {Douglas Gregor and Jeremy Siek},
+ title = {Explicit model definitions are necessary},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2005,
+ month = {May},
+ number = {N1798=05-0058}
+}
+
+@TechReport{gregor05:implementing_concepts,
+ author = {Douglas Gregor and Jeremy Siek},
+ title = {Implementing Concepts},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2005,
+ number = {N1848=05-0108},
+ month = {August}
+}
+
+@TechReport{gregor05:concepts_c++0x,
+ author = {Douglas Gregor and Jeremy Siek and Jeremiah Willcock and Jaakko J\"{a}rvi and Ronald Garcia and Andrew Lumsdaine},
+ title = {Concepts for {C++0x} (Revision 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2005,
+ number = {N1849=05-0109},
+ month = {August}
+}
+
+@Misc{gregor05:ConceptGCC,
+ title = {{ConceptGCC}: Concept extensions for {C++}},
+ author = {Douglas Gregor},
+ howpublished = {\url{http://www.generic-programming.org/software/ConceptGCC}},
+ year = 2006
+}
+
+@TechReport{GregorStroustrup06:concepts,
+ author = {Douglas Gregor and Bjarne Stroustrup},
+ title = {Concepts},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2042=06-0112},
+ month = {June}
+}
+
+@TechReport{GregorStroustrup06:concepts_rev_1,
+ author = {Douglas Gregor and Bjarne Stroustrup},
+ title = {Concepts (Revision 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2081=06-0151},
+ month = {October}
+}
+
+@TechReport{gregor06:concepts_stdlib_approach,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Approach}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2036=06-0106},
+ month = {June}
+}
+
+@TechReport{gregor06:concepts_stdlib_intro,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Introduction}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2037=06-0107},
+ month = {June}
+}
+
+@TechReport{gregor06:concepts_stdlib_utilities,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Utilities}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2038=06-0108},
+ month = {June}
+}
+
+@TechReport{gregor06:concepts_stdlib_utilities_rev_1,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Utilities} (Revision 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2082=06-0152},
+ month = {October}
+}
+
+@TechReport{gregor06:concepts_stdlib_containers,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Containers}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2085=06-0155},
+ month = {October}
+}
+
+@TechReport{gregor06:concepts_stdlib_iterators,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Iterators}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2039=06-0109},
+ month = {June}
+}
+
+@TechReport{gregor06:concepts_stdlib_iterators_rev_1,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Iterators} (Revision 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2083=06-0153},
+ month = {October}
+}
+
+
+@TechReport{gregor06:concepts_stdlib_algorithms,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Algorithms}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2040=06-0110},
+ month = {June}
+}
+
+@TechReport{gregor06:concepts_stdlib_algorithms_rev_1,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Algorithms} (Revision 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2084=06-0154},
+ month = {October}
+}
+
+@TechReport{gregor06:concepts_stdlib_numerics,
+ author = {Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine},
+ title = {Concepts for the {C++0x} {Standard} {Library}: {Numerics}},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2041=06-0111},
+ month = {June}
+}
+
+@InProceedings{RvalueReferences,
+ author = {Howard E. Hinnant and David Abrahams and J. Stephen Adamczyk and Peter Dimov and Andreas Hommel},
+ title = {A Proposal to Add an Rvalue Reference to the {C++} Language},
+ year = {2005},
+ number = {N1770=05-0030},
+ series = {ANSI/ISO C++ Standard Committee Pre-Lillehammer mailing},
+ month = {March}
+}
+
+
+
+@TechReport{DosReis06:ConstExpr4,
+ author = {Gabriel Dos~Reis and Bjarne Stroustrup and Jens Maurer},
+ title = {Generalized Constant Expressions -- Revision 4},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2116=06-0186},
+ month = {November}
+}
+
+@InProceedings{Gregor06:Concepts,
+ author = {Douglas Gregor and Jaakko J\"arvi and Jeremy Siek and Bjarne Stroustrup and Gabriel Dos~Reis and Andrew Lumsdaine},
+ title = {Concepts: Linguistic Support for Generic Programming in {C++}},
+ booktitle = {Proceedings of the 2006 {ACM} {SIGPLAN} conference on {O}bject-oriented programming, systems, languages, and applications ({OOPSLA} '06)},
+ year = 2006,
+ month = {October},
+ note = {Accepted}
+}
+
+
+@TechReport{gregor07:cccc,
+ author = {Douglas Gregor and Andrew Lumsdaine},
+ title = {Considering Concept Constraint Combinators},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2161=07-0021},
+ month = {January}}
+
+@TechReport{dawes06:keywords,
+ author = {Beman Dawes},
+ title = {Proposed {C++}0x Keywords Considered},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2006,
+ number = {N2105=06-0175},
+ month = {November}}
+
+@TechReport{stroustrup07:intersection,
+ author = {Bjarne Stroustrup and Gabriel Dos Reis},
+ title = {An analysis of concept intersection},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2221=07-0081},
+ month = {March}}
+
+@TechReport{GregorStroustrup07:concepts_wording,
+ author = {Douglas Gregor and Bjarne Stroustrup},
+ title = {Proposed Wording for Concepts},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2193=07-0053},
+ month = {March}
+}
+
+@TechReport{GregorStroustrup07:concepts_wording_rev_1,
+ author = {Douglas Gregor and Bjarne Stroustrup},
+ title = {Proposed Wording for Concepts (Revision 1)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2307=07-0167},
+ month = {July}
+}
+
+@TechReport{GregorStroustrup07:concepts_wording_rev_2,
+ author = {Douglas Gregor and Bjarne Stroustrup},
+ title = {Proposed Wording for Concepts (Revision 2)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2398=07-0258},
+ month = {September}
+}
+
+@TechReport{GregorStroustrup07:concepts_wording_rev_3,
+ author = {Douglas Gregor and Bjarne Stroustrup and Jeremy Siek and James Widman},
+ title = {Proposed Wording for Concepts (Revision 3)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2421=07-0281},
+ month = {October}
+}
+
+@TechReport{GregorStroustrup07:concepts_wording_rev_4,
+ author = {Douglas Gregor and Bjarne Stroustrup and Jeremy Siek and James Widman},
+ title = {Proposed Wording for Concepts (Revision 4)},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2008,
+ number = {N2501=08-0011},
+ month = {January}
+}
+
+@TechReport{SiekWidman07:ScopedConceptMaps,
+ author = {Jeremy Siek and James Widman},
+ title = {Proposed Wording for Scoped Concept Maps},
+ institution = {ISO/IEC JTC 1, Information Technology, Subcommittee
+ SC 22, Programming Language {C++}},
+ year = 2007,
+ number = {N2414=07-0274},
+ month = {September}
+}
+
+@Misc{Hinnant08:Concerns,
+ author = {Howard Hinnant},
+ title = {Some concerns about concepts},
+ howpublished = {C++ Library Reflector message c++std-lib-20050},
+ month = {January},
+ year = 2008}
+
+
+@Misc{Parent08:Concerns,
+ author = {Sean Parent},
+ title = {Re: Some concerns about concepts},
+ howpublished = {C++ Library Reflector message c++std-lib-20052},
+ month = {January},
+ year = 2008}
+
+@inproceedings{Jarvi06:Specialization,
+ author = {Jaakko J\"arvi and Douglas Gregor and Jeremiah Willcock and Andrew Lumsdaine and Jeremy Siek},
+ title = {Algorithm Specialization in Generic Programming: Challenges of Constrained Generics in {C++}},
+ booktitle = {PLDI '06: Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation},
+ year = {2006},
+ isbn = {1-59593-320-4},
+ pages = {272--282},
+ location = {Ottawa, Ontario, Canada},
+ doi = {http://doi.acm.org/10.1145/1133981.1134014},
+ publisher = {ACM Press},
+ address = {New York, NY, USA},
+ }
+
Modified: sandbox/committee/concepts/stdlib/macros.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/macros.tex (original)
+++ sandbox/committee/concepts/stdlib/macros.tex 2008-03-04 17:12:35 EST (Tue, 04 Mar 2008)
@@ -1110,7 +1110,7 @@
% Text common to all of the library proposals
\newcommand{\libintrotext}[1]{This document proposes changes to #1 of
the \Cpp{} Standard Library in order to make full use of
- concepts~\cite{GregorStroustrup07:concepts_wording_rev_1}. Many of
+ concepts~\cite{GregorStroustrup07:concepts_wording_rev_4}. Many of
the changes in this document have been verified to work with
ConceptGCC and its modified Standard Library implementation. We make
every attempt to provide complete backward compatibility with the
@@ -1118,7 +1118,7 @@
knowingly changed semantics.
This document is formatted in the same manner as the working draft of
-the \Cpp{} standard (N2284). Future versions of this document will
+the \Cpp{} standard (N2521). Future versions of this document will
track the working draft and the concepts proposal as they
evolve. Wherever the numbering of a (sub)section matches a section of
the working paper, the text in this document should be considered
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