Order library comparisons canonically

The order [==, !=, <, >, <=, >=] seems to be most common. Let's make it canonical and use it uniformly.

Author: CaseyCarter

source/containers.tex

@@ -887,8 +887,6 @@
   error_condition make_error_condition(errc e) noexcept;
 
   // \ref{syserr.compare}, comparison functions
-  bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
-  bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
   bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
   bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
   bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
@@ -897,6 +895,8 @@
   bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
   bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
   bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
+  bool operator< (const error_code& lhs, const error_code& rhs) noexcept;
+  bool operator< (const error_condition& lhs, const error_condition& rhs) noexcept;
 
   // \ref{syserr.hash}, hash support
   template<class T> struct hash;
@@ -957,7 +957,7 @@
 
     bool operator==(const error_category& rhs) const noexcept;
     bool operator!=(const error_category& rhs) const noexcept;
-    bool operator<(const error_category& rhs) const noexcept;
+    bool operator< (const error_category& rhs) const noexcept;
   };
 
   const error_category& generic_category() noexcept;
@@ -1549,34 +1549,6 @@
 
 \rSec2[syserr.compare]{Comparison functions}
 
-\indexlibrarymember{operator<}{error_code}%
-\begin{itemdecl}
-bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\returns
-\begin{codeblock}
-lhs.category() < rhs.category() ||
-(lhs.category() == rhs.category() && lhs.value() < rhs.value())
-\end{codeblock}
-\end{itemdescr}
-
-\indexlibrarymember{operator<}{error_condition}%
-\begin{itemdecl}
-bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\returns
-\begin{codeblock}
-lhs.category() < rhs.category() ||
-(lhs.category() == rhs.category() && lhs.value() < rhs.value())
-\end{codeblock}
-\end{itemdescr}
-
 \indexlibrarymember{operator==}{error_code}%
 \begin{itemdecl}
 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
@@ -1645,6 +1617,34 @@
 \returns \tcode{!(lhs == rhs)}.
 \end{itemdescr}
 
+\indexlibrarymember{operator<}{error_code}%
+\begin{itemdecl}
+bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\returns
+\begin{codeblock}
+lhs.category() < rhs.category() ||
+(lhs.category() == rhs.category() && lhs.value() < rhs.value())
+\end{codeblock}
+\end{itemdescr}
+
+\indexlibrarymember{operator<}{error_condition}%
+\begin{itemdecl}
+bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\returns
+\begin{codeblock}
+lhs.category() < rhs.category() ||
+(lhs.category() == rhs.category() && lhs.value() < rhs.value())
+\end{codeblock}
+\end{itemdescr}
+
 \rSec2[syserr.hash]{System error hash support}
 
 \indexlibrary{\idxcode{hash}!\idxcode{error_code}}%

source/diagnostics.tex

@@ -12735,81 +12735,81 @@
   for two paths, \tcode{p1 == p2} then \tcode{hash_value(p1) == hash_value(p2)}.
 \end{itemdescr}
 
-\indexlibrarymember{operator<}{path}%
+\indexlibrarymember{operator==}{path}%
 \begin{itemdecl}
-bool operator< (const path& lhs, const path& rhs) noexcept;
+bool operator==(const path& lhs, const path& rhs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{lhs.compare(rhs) < 0}.
+\returns \tcode{!(lhs < rhs) \&\& !(rhs < lhs)}.
+
+\indextext{path equality}
+\pnum
+\begin{note} Path equality and path equivalence have different semantics.
+\begin{itemize}
+\item Equality is determined by the \tcode{path} non-member \tcode{operator==},
+which considers the two paths' lexical representations only.
+\begin{example} \tcode{path("foo") == "bar"} is never \tcode{true}. \end{example}
+\item Equivalence is determined by the \tcode{equivalent()} non-member function, which
+determines if two paths resolve\iref{fs.class.path} to the same file system entity.
+\begin{example}
+\tcode{equivalent("foo", "bar")} will be \tcode{true} when both paths resolve to the same file.
+\end{example}
+\end{itemize}
+Programmers wishing to determine if two paths are ``the same'' must decide if
+  ``the same'' means ``the same representation'' or ``resolve to the same actual
+  file'', and choose the appropriate function accordingly. \end{note}
 \end{itemdescr}
 
-\indexlibrarymember{operator<=}{path}%
+\indexlibrarymember{operator"!=}{path}%
 \begin{itemdecl}
-bool operator<=(const path& lhs, const path& rhs) noexcept;
+bool operator!=(const path& lhs, const path& rhs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{!(rhs < lhs)}.
+\returns \tcode{!(lhs == rhs)}.
 \end{itemdescr}
 
-\indexlibrarymember{operator>}{path}%
+\indexlibrarymember{operator<}{path}%
 \begin{itemdecl}
-bool operator> (const path& lhs, const path& rhs) noexcept;
+bool operator< (const path& lhs, const path& rhs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{rhs < lhs}.
+\returns \tcode{lhs.compare(rhs) < 0}.
 \end{itemdescr}
 
-\indexlibrarymember{operator>=}{path}%
+\indexlibrarymember{operator<=}{path}%
 \begin{itemdecl}
-bool operator>=(const path& lhs, const path& rhs) noexcept;
+bool operator<=(const path& lhs, const path& rhs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{!(lhs < rhs)}.
+\returns \tcode{!(rhs < lhs)}.
 \end{itemdescr}
 
-\indexlibrarymember{operator==}{path}%
+\indexlibrarymember{operator>}{path}%
 \begin{itemdecl}
-bool operator==(const path& lhs, const path& rhs) noexcept;
+bool operator> (const path& lhs, const path& rhs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{!(lhs < rhs) \&\& !(rhs < lhs)}.
-
-\indextext{path equality}
-\pnum
-\begin{note} Path equality and path equivalence have different semantics.
-\begin{itemize}
-\item Equality is determined by the \tcode{path} non-member \tcode{operator==},
-which considers the two paths' lexical representations only.
-\begin{example} \tcode{path("foo") == "bar"} is never \tcode{true}. \end{example}
-\item Equivalence is determined by the \tcode{equivalent()} non-member function, which
-determines if two paths resolve\iref{fs.class.path} to the same file system entity.
-\begin{example}
-\tcode{equivalent("foo", "bar")} will be \tcode{true} when both paths resolve to the same file.
-\end{example}
-\end{itemize}
-Programmers wishing to determine if two paths are ``the same'' must decide if
-  ``the same'' means ``the same representation'' or ``resolve to the same actual
-  file'', and choose the appropriate function accordingly. \end{note}
+\returns \tcode{rhs < lhs}.
 \end{itemdescr}
 
-\indexlibrarymember{operator"!=}{path}%
+\indexlibrarymember{operator>=}{path}%
 \begin{itemdecl}
-bool operator!=(const path& lhs, const path& rhs) noexcept;
+bool operator>=(const path& lhs, const path& rhs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{!(lhs == rhs)}.
+\returns \tcode{!(lhs < rhs)}.
 \end{itemdescr}
 
 \indexlibrarymember{operator/}{path}%
@@ -13391,11 +13391,11 @@
     file_status symlink_status() const;
     file_status symlink_status(error_code& ec) const noexcept;
 
-    bool operator< (const directory_entry& rhs) const noexcept;
     bool operator==(const directory_entry& rhs) const noexcept;
     bool operator!=(const directory_entry& rhs) const noexcept;
-    bool operator<=(const directory_entry& rhs) const noexcept;
+    bool operator< (const directory_entry& rhs) const noexcept;
     bool operator> (const directory_entry& rhs) const noexcept;
+    bool operator<=(const directory_entry& rhs) const noexcept;
     bool operator>=(const directory_entry& rhs) const noexcept;
 
   private:
@@ -13788,24 +13788,24 @@
 \returns \tcode{pathobject < rhs.pathobject}.
 \end{itemdescr}
 
-\indexlibrarymember{operator<=}{directory_entry}%
+\indexlibrarymember{operator>}{directory_entry}%
 \begin{itemdecl}
-bool operator<=(const directory_entry& rhs) const noexcept;
+bool operator> (const directory_entry& rhs) const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{pathobject <= rhs.pathobject}.
+\returns \tcode{pathobject > rhs.pathobject}.
 \end{itemdescr}
 
-\indexlibrarymember{operator>}{directory_entry}%
+\indexlibrarymember{operator<=}{directory_entry}%
 \begin{itemdecl}
-bool operator> (const directory_entry& rhs) const noexcept;
+bool operator<=(const directory_entry& rhs) const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{pathobject > rhs.pathobject}.
+\returns \tcode{pathobject <= rhs.pathobject}.
 \end{itemdescr}
 
 \indexlibrarymember{operator>=}{directory_entry}%
@@ -14939,7 +14939,7 @@
 
 \pnum
 \begin{note} The current path as returned by many operating systems is a dangerous
-  global variable. It may be changed unexpectedly by a third-party or system
+  global variable. It may be changed unexpectedly by third-party or system
   library functions, or by another thread. \end{note}
 \end{itemdescr}