<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang xml:lang>
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="mpark/wg21" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <meta name="dcterms.date" content="2019-07-17" />
  <title>The Mothership has Landed</title>
  <style>
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
  </style>
  <style>
code.sourceCode > span { display: inline-block; line-height: 1.25; }
code.sourceCode > span { color: inherit; text-decoration: inherit; }
code.sourceCode > span:empty { height: 1.2em; }
.sourceCode { overflow: visible; }
code.sourceCode { white-space: pre; position: relative; }
div.sourceCode { margin: 1em 0; }
pre.sourceCode { margin: 0; }
@media screen {
div.sourceCode { overflow: auto; }
}
@media print {
code.sourceCode { white-space: pre-wrap; }
code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
}
pre.numberSource code
  { counter-reset: source-line 0; }
pre.numberSource code > span
  { position: relative; left: -4em; counter-increment: source-line; }
pre.numberSource code > span > a:first-child::before
  { content: counter(source-line);
    position: relative; left: -1em; text-align: right; vertical-align: baseline;
    border: none; display: inline-block;
    -webkit-touch-callout: none; -webkit-user-select: none;
    -khtml-user-select: none; -moz-user-select: none;
    -ms-user-select: none; user-select: none;
    padding: 0 4px; width: 4em;
    color: #aaaaaa;
  }
pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
div.sourceCode
  {  background-color: #f6f8fa; }
@media screen {
code.sourceCode > span > a:first-child::before { text-decoration: underline; }
}
code span. { } /* Normal */
code span.al { color: #ff0000; } /* Alert */
code span.an { } /* Annotation */
code span.at { } /* Attribute */
code span.bn { color: #9f6807; } /* BaseN */
code span.bu { color: #9f6807; } /* BuiltIn */
code span.cf { color: #00607c; } /* ControlFlow */
code span.ch { color: #9f6807; } /* Char */
code span.cn { } /* Constant */
code span.co { color: #008000; font-style: italic; } /* Comment */
code span.cv { color: #008000; font-style: italic; } /* CommentVar */
code span.do { color: #008000; } /* Documentation */
code span.dt { color: #00607c; } /* DataType */
code span.dv { color: #9f6807; } /* DecVal */
code span.er { color: #ff0000; font-weight: bold; } /* Error */
code span.ex { } /* Extension */
code span.fl { color: #9f6807; } /* Float */
code span.fu { } /* Function */
code span.im { } /* Import */
code span.in { color: #008000; } /* Information */
code span.kw { color: #00607c; } /* Keyword */
code span.op { color: #af1915; } /* Operator */
code span.ot { } /* Other */
code span.pp { color: #6f4e37; } /* Preprocessor */
code span.re { } /* RegionMarker */
code span.sc { color: #9f6807; } /* SpecialChar */
code span.ss { color: #9f6807; } /* SpecialString */
code span.st { color: #9f6807; } /* String */
code span.va { } /* Variable */
code span.vs { color: #9f6807; } /* VerbatimString */
code span.wa { color: #008000; font-weight: bold; } /* Warning */
code.diff {color: #898887}
code.diff span.va {color: #006e28}
code.diff span.st {color: #bf0303}
  </style>
  <style type="text/css">
body {
margin: 5em;
font-family: serif;

hyphens: auto;
line-height: 1.35;
}
div.wrapper {
max-width: 60em;
margin: auto;
}
ul {
list-style-type: none;
padding-left: 2em;
margin-top: -0.2em;
margin-bottom: -0.2em;
}
a {
text-decoration: none;
color: #4183C4;
}
a.hidden_link {
text-decoration: none;
color: inherit;
}
li {
margin-top: 0.6em;
margin-bottom: 0.6em;
}
h1, h2, h3, h4 {
position: relative;
line-height: 1;
}
a.self-link {
position: absolute;
top: 0;
left: calc(-1 * (3.5rem - 26px));
width: calc(3.5rem - 26px);
height: 2em;
text-align: center;
border: none;
transition: opacity .2s;
opacity: .5;
font-family: sans-serif;
font-weight: normal;
font-size: 83%;
}
a.self-link:hover { opacity: 1; }
a.self-link::before { content: "§"; }
ul > li:before {
content: "\2014";
position: absolute;
margin-left: -1.5em;
}
:target { background-color: #C9FBC9; }
:target .codeblock { background-color: #C9FBC9; }
:target ul { background-color: #C9FBC9; }
.abbr_ref { float: right; }
.folded_abbr_ref { float: right; }
:target .folded_abbr_ref { display: none; }
:target .unfolded_abbr_ref { float: right; display: inherit; }
.unfolded_abbr_ref { display: none; }
.secnum { display: inline-block; min-width: 35pt; }
.header-section-number { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }
div.sourceLinkParent {
float: right;
}
a.sourceLink {
position: absolute;
opacity: 0;
margin-left: 10pt;
}
a.sourceLink:hover {
opacity: 1;
}
a.itemDeclLink {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
opacity: 0;
}
a.itemDeclLink:hover { opacity: 1; }
span.marginalizedparent {
position: relative;
left: -5em;
}
li span.marginalizedparent { left: -7em; }
li ul > li span.marginalizedparent { left: -9em; }
li ul > li ul > li span.marginalizedparent { left: -11em; }
li ul > li ul > li ul > li span.marginalizedparent { left: -13em; }
div.footnoteNumberParent {
position: relative;
left: -4.7em;
}
a.marginalized {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
}
a.enumerated_item_num {
position: relative;
left: -3.5em;
display: inline-block;
margin-right: -3em;
text-align: right;
width: 3em;
}
div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.section { text-align: justify; }
div.sentence { display: inline; }
span.indexparent {
display: inline;
position: relative;
float: right;
right: -1em;
}
a.index {
position: absolute;
display: none;
}
a.index:before { content: "⟵"; }

a.index:target {
display: inline;
}
.indexitems {
margin-left: 2em;
text-indent: -2em;
}
div.itemdescr {
margin-left: 3em;
}
.bnf {
font-family: serif;
margin-left: 40pt;
margin-top: 0.5em;
margin-bottom: 0.5em;
}
.ncbnf {
font-family: serif;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
}
.ncsimplebnf {
font-family: serif;
font-style: italic;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
background: inherit; 
}
span.textnormal {
font-style: normal;
font-family: serif;
white-space: normal;
display: inline-block;
}
span.rlap {
display: inline-block;
width: 0px;
}
span.descr { font-style: normal; font-family: serif; }
span.grammarterm { font-style: italic; }
span.term { font-style: italic; }
span.terminal { font-family: monospace; font-style: normal; }
span.nonterminal { font-style: italic; }
span.tcode { font-family: monospace; font-style: normal; }
span.textbf { font-weight: bold; }
span.textsc { font-variant: small-caps; }
a.nontermdef { font-style: italic; font-family: serif; }
span.emph { font-style: italic; }
span.techterm { font-style: italic; }
span.mathit { font-style: italic; }
span.mathsf { font-family: sans-serif; }
span.mathrm { font-family: serif; font-style: normal; }
span.textrm { font-family: serif; }
span.textsl { font-style: italic; }
span.mathtt { font-family: monospace; font-style: normal; }
span.mbox { font-family: serif; font-style: normal; }
span.ungap { display: inline-block; width: 2pt; }
span.textit { font-style: italic; }
span.texttt { font-family: monospace; }
span.tcode_in_codeblock { font-family: monospace; font-style: normal; }
span.phantom { color: white; }

span.math { font-style: normal; }
span.mathblock {
display: block;
margin-left: auto;
margin-right: auto;
margin-top: 1.2em;
margin-bottom: 1.2em;
text-align: center;
}
span.mathalpha {
font-style: italic;
}
span.synopsis {
font-weight: bold;
margin-top: 0.5em;
display: block;
}
span.definition {
font-weight: bold;
display: block;
}
.codeblock {
margin-left: 1.2em;
line-height: 127%;
}
.outputblock {
margin-left: 1.2em;
line-height: 127%;
}
div.itemdecl {
margin-top: 2ex;
}
code.itemdeclcode {
white-space: pre;
display: block;
}
span.textsuperscript {
vertical-align: super;
font-size: smaller;
line-height: 0;
}
.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }
.footnote {
font-size: small;
margin-left: 2em;
margin-right: 2em;
margin-top: 0.6em;
margin-bottom: 0.6em;
}
div.minipage {
display: inline-block;
margin-right: 3em;
}
div.numberedTable {
text-align: center;
margin: 2em;
}
div.figure {
text-align: center;
margin: 2em;
}
table {
border: 1px solid black;
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
margin-top: 0.8em;
text-align: left;
hyphens: none; 
}
td, th {
padding-left: 1em;
padding-right: 1em;
vertical-align: top;
}
td.empty {
padding: 0px;
padding-left: 1px;
}
td.left {
text-align: left;
}
td.right {
text-align: right;
}
td.center {
text-align: center;
}
td.justify {
text-align: justify;
}
td.border {
border-left: 1px solid black;
}
tr.rowsep, td.cline {
border-top: 1px solid black;
}
tr.even, tr.odd {
border-bottom: 1px solid black;
}
tr.capsep {
border-top: 3px solid black;
border-top-style: double;
}
tr.header {
border-bottom: 3px solid black;
border-bottom-style: double;
}
th {
border-bottom: 1px solid black;
}
span.centry {
font-weight: bold;
}
div.table {
display: block;
margin-left: auto;
margin-right: auto;
text-align: center;
width: 90%;
}
span.indented {
display: block;
margin-left: 2em;
margin-bottom: 1em;
margin-top: 1em;
}
ol.enumeratea { list-style-type: none; background: inherit; }
ol.enumerate { list-style-type: none; background: inherit; }

code.sourceCode > span { display: inline; }

div#refs p { padding-left: 32px; text-indent: -32px; }
</style>
  <style type="text/css">a {
color : #4183C4;
text-decoration: underline;
}
a.marginalized {
text-decoration: none;
}
a.self-link {
text-decoration: none;
}
h1#toctitle {
border-bottom: 1px solid #cccccc;
}
#TOC li {
margin-top: 1px;
margin-bottom: 1px;
}
#TOC ul>li:before { display: none; }
h3.subtitle { margin-top: -15px; }
h1:target { background-color: transparent; }
h2:target { background-color: transparent; }
h3:target { background-color: transparent; }
h4:target { background-color: transparent; }
h5:target { background-color: transparent; }
h6:target { background-color: transparent; }
code span.co { font-family: monospace; }
table tr {
background-color: white;
}
table tr:nth-child(2n) {
background-color: #f6f8fa;
}
#title-block-header > table tr:nth-child(2n) {
background-color: white;
}
td > div.sourceCode {
background-color: inherit;
}
table {
border-collapse: collapse;
}
table td, table th {
border: 1px solid #cccccc;
}
table th {
border-bottom: 1px solid black;
}
table tr:first-child th {
border-top: 0;
}
table tr:last-child td {
border-bottom: 0;
}
table tr td:first-child,
table tr th:first-child {
border-left: 0;
}
table tr td:last-child,
table tr th:last-child {
border-right: 0;
}
table tbody tr:first-child td {
border-top: 1px solid black;
}
#title-block-header td { border: 0; }
@media all {
body {
margin: 2em;
}
}
@media screen and (min-width: 480px) {
body {
margin: 5em;
}
}
#refs code{padding-left: 0px; text-indent: 0px;}
:root {
--diff-ins: #e6ffed;
--diff-strongins: #acf2bd;
--diff-del: #ffdddd;
--diff-strongdel: #ff8888;
}
span.diffins {
background-color: var(--diff-strongins);
}
span.diffdel {
background-color: var(--diff-strongdel);
}
div.rm { text-decoration: line-through; }
div.rm code.sourceCode { text-decoration: line-through; }
div.addu, span.addu {
color: #006e28;
background-color: var(--diff-ins);
}

div.rm pre, div.add pre { background-color: #f6f8fa; }
div.addu pre { background-color: var(--diff-ins); }
div.add, div.add pre { background-color: var(--diff-ins); }
div.addu blockquote {
border-left: 4px solid #00a000;
padding: 0 15px;
color: #006e28;
text-decoration: none;
}
div.addu blockquote code.sourceCode { text-decoration: none; }
div.addu blockquote pre { text-decoration: none; }
div.addu blockquote pre code { text-decoration: none; }
code.diff span.va { color: #000000; background-color: var(--diff-ins); }
code.diff span.st { color: #000000; background-color: var(--diff-del); }
</style>
  <link href="data:image/vnd.microsoft.icon;base64,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" rel="icon" />
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
  
</head>
<body>
<div class="wrapper">
<header id="title-block-header">
<h1 class="title" style="text-align:center">The Mothership has Landed</h1>
<h3 class="subtitle" style="text-align:center">Adding <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to the Library</h3>

<table style="border:none;float:right">
  <tr>
    <td>Document #: </td>
    <td>P1614R2</td>
  </tr>
  <tr>
    <td>Date: </td>
    <td>2019-07-17</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project: </td>
    <td>Programming Language C++<br>
      LWG<br>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to: </td>
    <td>
      Barry Revzin<br>&lt;<a href="mailto:barry.revzin@gmail.com" class="email">barry.revzin@gmail.com</a>&gt;<br>
    </td>
  </tr>
</table>

</header>
<div style="clear:both">
<div id="TOC" role="doc-toc">
<h1 id="toctitle">Contents</h1>
<ul>
<li><a href="#revision-history"><span class="toc-section-number">1</span> Revision History<span></span></a></li>
<li><a href="#introduction"><span class="toc-section-number">2</span> Introduction<span></span></a></li>
<li><a href="#friendship"><span class="toc-section-number">3</span> Friendship<span></span></a><ul>
<li><a href="#was-well-formed-now-ill-formed"><span class="toc-section-number">3.1</span> Was well-formed, now ill-formed<span></span></a></li>
<li><a href="#was-ill-formed-now-well-formed"><span class="toc-section-number">3.2</span> Was ill-formed, now well-formed<span></span></a></li>
<li><a href="#alternatives"><span class="toc-section-number">3.3</span> Alternatives<span></span></a></li>
<li><a href="#proposed-direction"><span class="toc-section-number">3.4</span> Proposed Direction<span></span></a></li>
</ul></li>
<li><a href="#acknowledgements"><span class="toc-section-number">4</span> Acknowledgements<span></span></a></li>
<li><a href="#wording"><span class="toc-section-number">5</span> Wording<span></span></a><ul>
<li><a href="#clause-16-library-introduction"><span class="toc-section-number">5.1</span> Clause 16: Library Introduction<span></span></a></li>
<li><a href="#clause-17-language-support-library"><span class="toc-section-number">5.2</span> Clause 17: Language support library<span></span></a></li>
<li><a href="#clause-18-concepts-library"><span class="toc-section-number">5.3</span> Clause 18: Concepts Library<span></span></a></li>
<li><a href="#clause-19-diagnostics-library"><span class="toc-section-number">5.4</span> Clause 19: Diagnostics Library<span></span></a></li>
<li><a href="#clause-20-general-utilities-library"><span class="toc-section-number">5.5</span> Clause 20: General utilities library<span></span></a></li>
<li><a href="#clause-21-strings-library"><span class="toc-section-number">5.6</span> Clause 21: Strings library<span></span></a></li>
<li><a href="#clause-22-containers-library"><span class="toc-section-number">5.7</span> Clause 22: Containers library<span></span></a></li>
<li><a href="#clause-23-iterators-library"><span class="toc-section-number">5.8</span> Clause 23: Iterators library<span></span></a></li>
<li><a href="#clause-24-ranges-library"><span class="toc-section-number">5.9</span> Clause 24: Ranges library<span></span></a></li>
<li><a href="#clause-25-algorithms-library"><span class="toc-section-number">5.10</span> Clause 25: Algorithms library<span></span></a></li>
<li><a href="#clause-26-numerics-library"><span class="toc-section-number">5.11</span> Clause 26: Numerics library<span></span></a></li>
<li><a href="#clause-27-time-library"><span class="toc-section-number">5.12</span> Clause 27: Time library<span></span></a></li>
<li><a href="#clause-28-localization-library"><span class="toc-section-number">5.13</span> Clause 28: Localization library<span></span></a></li>
<li><a href="#clause-29-inputoutput-library"><span class="toc-section-number">5.14</span> Clause 29: Input/output library<span></span></a></li>
<li><a href="#clause-30-regular-expressions-library"><span class="toc-section-number">5.15</span> Clause 30: Regular expressions library<span></span></a></li>
<li><a href="#clause-31-atomic-operations-library"><span class="toc-section-number">5.16</span> Clause 31: Atomic operations library<span></span></a></li>
<li><a href="#clause-32-thread-support-library"><span class="toc-section-number">5.17</span> Clause 32: Thread support library<span></span></a></li>
</ul></li>
<li><a href="#references"><span class="toc-section-number">6</span> References<span></span></a></li>
</ul>
</div>
<h1 id="revision-history" style="border-bottom:1px solid #cccccc"><span class="header-section-number">1</span> Revision History<a href="#revision-history" class="self-link"></a></h1>
<p><span class="citation" data-cites="P1614R0">[<a href="#ref-P1614R0" role="doc-biblioref">P1614R0</a>]</span> took the route of adding the new comparison operators as hidden friends. This paper instead preserves the current method of declaring comparisons - typically as non-member functions. See <a href="#friendship">friendship</a> for a more thorough discussion.</p>
<p>The comparisons between <code class="sourceCode cpp">unique_ptr<span class="op">&lt;</span>T, D<span class="op">&gt;</span></code> and <code class="sourceCode cpp"><span class="kw">nullptr</span></code> were originally removed and replaced with a <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>, but this was reverted.</p>
<p>Additionally, R0 used the <code class="sourceCode default">3WAY</code><code class="sourceCode cpp"><span class="op">&lt;</span>R<span class="op">&gt;</span></code> wording from <span class="citation" data-cites="P1186R1">[<a href="#ref-P1186R1" role="doc-biblioref">P1186R1</a>]</span>, which was removed in the subsequent <span class="citation" data-cites="P1186R2">[<a href="#ref-P1186R2" role="doc-biblioref">P1186R2</a>]</span> - so the relevant wording for the fallback objects was changed as well.</p>
<h1 id="introduction" style="border-bottom:1px solid #cccccc"><span class="header-section-number">2</span> Introduction<a href="#introduction" class="self-link"></a></h1>
<p>The work of integrating <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code> into the library has been performed by multiple different papers, each addressing a different aspect of the integration. In the interest of streamlining review by the Library Working Group, the wording has been combined into a single paper. This is that paper.</p>
<p>In San Diego and Kona, several papers were approved by LEWG adding functionality to the library related to comparisons. What follows is the list of those papers, in alphabetical order, with a brief description of what those papers are. The complete motivation and design rationale for each can be found within the papers themselves.</p>
<ul>
<li><span class="citation" data-cites="P0790R2">[<a href="#ref-P0790R2" role="doc-biblioref">P0790R2</a>]</span> - adding <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code> to the standard library types whose behavior is not dependent on a template parameter.</li>
<li><span class="citation" data-cites="P0891R2">[<a href="#ref-P0891R2" role="doc-biblioref">P0891R2</a>]</span> - making the <code class="sourceCode cpp">XXX_order</code> algorithms customization points and introducing <code class="sourceCode cpp">compare_XXX_order_fallback</code> algorithms that preferentially invoke the former algorithm and fallback to synthesizing an ordering from <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">&lt;</span></code> (using the rules from <span class="citation" data-cites="P1186R1">[<a href="#ref-P1186R1" role="doc-biblioref">P1186R1</a>]</span>).</li>
<li><span class="citation" data-cites="P1154R1">[<a href="#ref-P1154R1" role="doc-biblioref">P1154R1</a>]</span> - adding the type trait <code class="sourceCode cpp">has_strong_structural_equality<span class="op">&lt;</span>T<span class="op">&gt;</span></code> (useful to check if a type can be used as a non-type template parameter).</li>
<li><span class="citation" data-cites="P1188R0">[<a href="#ref-P1188R0" role="doc-biblioref">P1188R0</a>]</span> - adding the type trait <code class="sourceCode cpp">compare_three_way_result<span class="op">&lt;</span>T<span class="op">&gt;</span></code>, the concepts <code class="sourceCode cpp">ThreeWayComparable<span class="op">&lt;</span>T<span class="op">&gt;</span></code> and <code class="sourceCode cpp">ThreeWayComparableWith<span class="op">&lt;</span>T,U<span class="op">&gt;</span></code>, removing the algorithm <code class="sourceCode cpp">compare_3way</code> and replacing it with a function comparison object <code class="sourceCode cpp">compare_three_way</code> (i.e. the <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> version of <code class="sourceCode cpp">std<span class="op">::</span>ranges<span class="op">::</span>less</code>).</li>
<li><span class="citation" data-cites="P1189R0">[<a href="#ref-P1189R0" role="doc-biblioref">P1189R0</a>]</span> - adding <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code> to the standard library types whose behavior is dependent on a template parameter, removing those equality operators made redundant by <span class="citation" data-cites="P1185R2">[<a href="#ref-P1185R2" role="doc-biblioref">P1185R2</a>]</span> and defaulting <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> where appropriate.</li>
<li><span class="citation" data-cites="P1191R0">[<a href="#ref-P1191R0" role="doc-biblioref">P1191R0</a>]</span> - adding equality to several previously incomparable standard library types.</li>
<li><span class="citation" data-cites="P1295R0">[<a href="#ref-P1295R0" role="doc-biblioref">P1295R0</a>]</span> - adding equality and <code class="sourceCode cpp">common_type</code> for the comparison categories.</li>
<li><span class="citation" data-cites="P1380R1">[<a href="#ref-P1380R1" role="doc-biblioref">P1380R1</a>]</span> - extending the floating point customization points for <code class="sourceCode cpp">strong_order</code> and <code class="sourceCode cpp">weak_order</code>.</li>
</ul>
<p>A significant amount of the wording in this paper is removing equality operators that have now become redundant. After <span class="citation" data-cites="P1185R2">[<a href="#ref-P1185R2" role="doc-biblioref">P1185R2</a>]</span>, <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code> have been tied together at the language level. For the simple case where you need two types to have heterogeous equality, it is enough to simply write one <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==(</span>T, U<span class="op">)</span></code> and that will now work for both equality and inequality in both directions.</p>
<h1 id="friendship" style="border-bottom:1px solid #cccccc"><span class="header-section-number">3</span> Friendship<a href="#friendship" class="self-link"></a></h1>
<p>LEWG’s unanimous preference was that the new <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code>s be declared as hidden friends. It would follow therefore that we would move the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code>s to be declared the same way as well, since it would be pretty odd if the two different comparison operators had different semantics.</p>
<p>However, a few issues have come up with this approach that are worth presenting clearly here.</p>
<h2 id="was-well-formed-now-ill-formed"><span class="header-section-number">3.1</span> Was well-formed, now ill-formed<a href="#was-well-formed-now-ill-formed" class="self-link"></a></h2>
<p>Here is an example that came up while I attempted to implement these changes to measure any improvements in build time that might come up. This is a reproduction from the LLVM codebase:</p>
<div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1"></a><span class="kw">struct</span> StringRef <span class="op">{</span></span>
<span id="cb1-2"><a href="#cb1-2"></a>    StringRef<span class="op">(</span>std<span class="op">::</span>string <span class="kw">const</span><span class="op">&amp;)</span>; <span class="co">// NB: non-explicit</span></span>
<span id="cb1-3"><a href="#cb1-3"></a>    <span class="kw">operator</span> std<span class="op">::</span>string<span class="op">()</span> <span class="kw">const</span>;  <span class="co">// NB: non-explicit</span></span>
<span id="cb1-4"><a href="#cb1-4"></a><span class="op">}</span>;</span>
<span id="cb1-5"><a href="#cb1-5"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>StringRef, StringRef<span class="op">)</span>;</span>
<span id="cb1-6"><a href="#cb1-6"></a></span>
<span id="cb1-7"><a href="#cb1-7"></a><span class="dt">bool</span> f<span class="op">(</span>StringRef a, std<span class="op">::</span>string b<span class="op">)</span> <span class="op">{</span></span>
<span id="cb1-8"><a href="#cb1-8"></a>    <span class="cf">return</span> a <span class="op">==</span> b; <span class="co">// (*)</span></span>
<span id="cb1-9"><a href="#cb1-9"></a><span class="op">}</span></span></code></pre></div>
<p>In C++17, the marked line is well-formed. The <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> for <code class="sourceCode cpp">basic_string</code> is a non-member function template, and so would not be considered a candidate; the only viable candidate is the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> taking two <code class="sourceCode cpp">StringRef</code>s. With the proposed changes, the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> for <code class="sourceCode cpp">basic_string</code> becomes a non-member hidden friend, <em>non-template</em>, which makes it a candidate (converting <code class="sourceCode cpp">a</code> to a <code class="sourceCode cpp">string</code>). That candidate is ambiguous with the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==(</span>StringRef, StringRef<span class="op">)</span></code> candidate - each requires a conversion in one argument, so the call becomes ill-formed.</p>
<p>Many people might consider such a type - implicitly convertible in both directions (note that <code class="sourceCode cpp">string</code> to <code class="sourceCode cpp">string_view</code> is implicit, but <code class="sourceCode cpp">string_view</code> to <code class="sourceCode cpp">string</code> is explicit) - questionable. But this is still a breaking change to consider.</p>
<h2 id="was-ill-formed-now-well-formed"><span class="header-section-number">3.2</span> Was ill-formed, now well-formed<a href="#was-ill-formed-now-well-formed" class="self-link"></a></h2>
<div class="sourceCode" id="cb2"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb2-1"><a href="#cb2-1"></a><span class="dt">bool</span> ref_equal<span class="op">(</span>std<span class="op">::</span>reference_wrapper<span class="op">&lt;</span>std<span class="op">::</span>string<span class="op">&gt;</span> a,</span>
<span id="cb2-2"><a href="#cb2-2"></a>               std<span class="op">::</span>reference_wrapper<span class="op">&lt;</span>std<span class="op">::</span>string<span class="op">&gt;</span> b<span class="op">)</span></span>
<span id="cb2-3"><a href="#cb2-3"></a><span class="op">{</span></span>
<span id="cb2-4"><a href="#cb2-4"></a>    <span class="cf">return</span> a <span class="op">==</span> b;</span>
<span id="cb2-5"><a href="#cb2-5"></a><span class="op">}</span></span></code></pre></div>
<p>The comparisons for <code class="sourceCode cpp">std<span class="op">::</span>reference_wrapper<span class="op">&lt;</span>T<span class="op">&gt;</span></code> are very strange. It’s not that this type is comparable based on <em>whether</em> <code class="sourceCode cpp">T</code> is comparable. It’s actually that this type is comparable based on <em>how</em> <code class="sourceCode cpp">T</code> is comparable. We can compare <code class="sourceCode cpp">std<span class="op">::</span>reference_wrapper<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span></code>s, but we cannot compare <code class="sourceCode cpp">std<span class="op">::</span>reference_wrapper<span class="op">&lt;</span>std<span class="op">::</span>string<span class="op">&gt;</span></code>s because the comparisons for <code class="sourceCode cpp">basic_string</code> are non-member function templates. That’s just weird. This change wouldn’t actually resolve that weirdness generally (it wouldn’t affect any user types whose comparisons are non-member function templates), but it would at least reduce it for the standard library. Arguably an improvement.</p>
<p>However, the more interesting case is:</p>
<div class="sourceCode" id="cb3"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb3-1"><a href="#cb3-1"></a><span class="dt">bool</span> is42<span class="op">(</span>std<span class="op">::</span>variant<span class="op">&lt;</span><span class="dt">int</span>, std<span class="op">::</span>string<span class="op">&gt;</span> <span class="kw">const</span><span class="op">&amp;</span> v<span class="op">)</span> <span class="op">{</span></span>
<span id="cb3-2"><a href="#cb3-2"></a>    <span class="cf">return</span> v <span class="op">==</span> <span class="dv">42</span>; <span class="co">// (*)</span></span>
<span id="cb3-3"><a href="#cb3-3"></a><span class="op">}</span></span></code></pre></div>
<p>In C++17, the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> for <code class="sourceCode cpp">variant</code> is a non-member function template and is thus not a viable candidate for the marked line. That check is ill-formed. With the proposed changes, the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> for <code class="sourceCode cpp">variant</code> becomes a non-member hidden friend, <em>non-template</em>, which makes it a candidate (converting <code class="sourceCode cpp"><span class="dv">42</span></code> to a <code class="sourceCode cpp">variant<span class="op">&lt;</span><span class="dt">int</span>, string<span class="op">&gt;</span></code>). Many would argue that this a fix, since both <code class="sourceCode cpp">variant<span class="op">&lt;</span><span class="dt">int</span>, string<span class="op">&gt;</span> v <span class="op">=</span> <span class="dv">42</span>;</code> and <code class="sourceCode cpp">v <span class="op">=</span> <span class="dv">42</span>;</code> are already well-formed, so it is surely reasonable that <code class="sourceCode cpp">v <span class="op">==</span> <span class="dv">42</span></code> is as well.</p>
<p>But we already had a proposal to do precisely this: <span class="citation" data-cites="P1201R0">[<a href="#ref-P1201R0" role="doc-biblioref">P1201R0</a>]</span>, which failed to gain consensus in LEWGI in San Diego (vote was 2-6-2-3-3).</p>
<h2 id="alternatives"><span class="header-section-number">3.3</span> Alternatives<a href="#alternatives" class="self-link"></a></h2>
<p>The benefit of the hidden friend technique wasn’t the only way to achieve the ultimate goal of reducing the overload candidate set. Casey Carter suggested another:</p>
<div class="sourceCode" id="cb4"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb4-1"><a href="#cb4-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> Traits <span class="op">=</span> char_traits<span class="op">&lt;</span>T<span class="op">&gt;</span>, <span class="kw">class</span> Alloc <span class="op">=</span> allocator<span class="op">&lt;</span>T<span class="op">&gt;&gt;</span> <span class="kw">class</span> basic_string;</span>
<span id="cb4-2"><a href="#cb4-2"></a></span>
<span id="cb4-3"><a href="#cb4-3"></a><span class="kw">namespace</span> __foo <span class="op">{</span></span>
<span id="cb4-4"><a href="#cb4-4"></a>  <span class="kw">struct</span> __tag <span class="op">{}</span>;</span>
<span id="cb4-5"><a href="#cb4-5"></a></span>
<span id="cb4-6"><a href="#cb4-6"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> Traits, <span class="kw">class</span> Alloc<span class="op">&gt;</span> </span>
<span id="cb4-7"><a href="#cb4-7"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> basic_string<span class="op">&lt;</span>T, Traits, Alloc<span class="op">&gt;&amp;</span>, <span class="kw">const</span> basic_string<span class="op">&lt;</span>T, Traits, Alloc<span class="op">&gt;&amp;)</span>;</span>
<span id="cb4-8"><a href="#cb4-8"></a></span>
<span id="cb4-9"><a href="#cb4-9"></a>  <span class="co">/* ... */</span></span>
<span id="cb4-10"><a href="#cb4-10"></a><span class="op">}</span></span>
<span id="cb4-11"><a href="#cb4-11"></a></span>
<span id="cb4-12"><a href="#cb4-12"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> Traits, <span class="kw">class</span> Alloc<span class="op">&gt;</span> <span class="kw">class</span> basic_string <span class="op">:</span> <span class="kw">private</span> __foo<span class="op">::</span>__tag <span class="op">{</span></span>
<span id="cb4-13"><a href="#cb4-13"></a>  <span class="co">/* ... */</span></span>
<span id="cb4-14"><a href="#cb4-14"></a><span class="op">}</span>;</span></code></pre></div>
<p>That is, we keep <code class="sourceCode cpp">basic_string</code>’s comparisons as non-member function templates – but we move them into a different namespace that is <em>only</em> associated with <code class="sourceCode cpp">basic_string</code>. This is an interesting direction to take, but is novel and has some specification burden.</p>
<h2 id="proposed-direction"><span class="header-section-number">3.4</span> Proposed Direction<a href="#proposed-direction" class="self-link"></a></h2>
<p>Ultimately, the goal here is to add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to all the types in the standard library. While I think the goal of reducing the candidate set for comparisons with standard library types is absolutely worth pursuing, it is a completely orthogonal goal and can be addressed by a different proposal in the future.</p>
<p>Given that we’ve said that users aren’t allowed to take the address of most standard library functions, Casey’s proposed implementation might even be valid under today’s wording for those standard library class templates whose comparisons are non-member templates, so I’d encourage implementors to experiment there.</p>
<p>The direction this paper is taking is the path of least resistance: keep all the comparison operators as they are. Add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> in the same form that <code class="sourceCode cpp"><span class="op">&lt;</span></code> appears today. With a few exceptions: those types for which adding a defaulted <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> would allow them to be used as non-type template parameters after <span class="citation" data-cites="P0732R2">[<a href="#ref-P0732R2" role="doc-biblioref">P0732R2</a>]</span> (and only those types) will have their comparisons implemented as hidden friends.</p>
<h1 id="acknowledgements" style="border-bottom:1px solid #cccccc"><span class="header-section-number">4</span> Acknowledgements<a href="#acknowledgements" class="self-link"></a></h1>
<p>Thank you to all the paper authors that have committed time to making sure all this works: Gašper Ažman, Walter Brown, Lawrence Crowl, Tomasz Kamiński, Arthur O’Dwyer, Jeff Snyder, David Stone, and Herb Sutter.</p>
<p>Thank you to Casey Carter for the tremendous wording review.</p>
<h1 id="wording" style="border-bottom:1px solid #cccccc"><span class="header-section-number">5</span> Wording<a href="#wording" class="self-link"></a></h1>
<h2 id="clause-16-library-introduction"><span class="header-section-number">5.1</span> Clause 16: Library Introduction<a href="#clause-16-library-introduction" class="self-link"></a></h2>
<p>Change 16.4.2.1/2 [expos.only.func]:</p>
<blockquote>
<p>The following <span class="rm" style="color: #bf0303"><del>function is</del></span> <span class="addu">are</span> defined for exposition only to aid in the specification of the library:</p>
</blockquote>
<p>and append:</p>
<blockquote>
<div class="add" style="color: #006e28">

<div class="sourceCode" id="cb5"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb5-1"><a href="#cb5-1"></a>constexpr auto <em>synth-three-way</em> =</span>
<span id="cb5-2"><a href="#cb5-2"></a>  []&lt;class T, class U&gt;(const T&amp; t, const U&amp; u)</span>
<span id="cb5-3"><a href="#cb5-3"></a>    requires requires {</span>
<span id="cb5-4"><a href="#cb5-4"></a>      { t &lt; u } -&gt; bool;</span>
<span id="cb5-5"><a href="#cb5-5"></a>      { u &lt; t } -&gt; bool;</span>
<span id="cb5-6"><a href="#cb5-6"></a>    }</span>
<span id="cb5-7"><a href="#cb5-7"></a>  {</span>
<span id="cb5-8"><a href="#cb5-8"></a>    if constexpr (ThreeWayComparableWith&lt;T, U&gt;) {</span>
<span id="cb5-9"><a href="#cb5-9"></a>      return t &lt;=&gt; u;</span>
<span id="cb5-10"><a href="#cb5-10"></a>    } else {</span>
<span id="cb5-11"><a href="#cb5-11"></a>      if (t &lt; u) return weak_ordering::less;</span>
<span id="cb5-12"><a href="#cb5-12"></a>      if (u &lt; t) return weak_ordering::greater;</span>
<span id="cb5-13"><a href="#cb5-13"></a>      return weak_ordering::equivalent;</span>
<span id="cb5-14"><a href="#cb5-14"></a>    }</span>
<span id="cb5-15"><a href="#cb5-15"></a>  };</span>
<span id="cb5-16"><a href="#cb5-16"></a></span>
<span id="cb5-17"><a href="#cb5-17"></a>template&lt;class T, class U=T&gt;</span>
<span id="cb5-18"><a href="#cb5-18"></a>using <em>synth-three-way-result</em> = decltype(<em>synth-three-way</em>(declval&lt;T&amp;&gt;(), declval&lt;U&amp;&gt;()));</span></code></pre></div>

</div>
</blockquote>
<p>Remove all of 16.4.2.3 [operators], which begins:</p>
<blockquote>
<p><span class="rm" style="color: #bf0303"><del>In this library, whenever a declaration is provided for an <span><code class="sourceCode cpp"><span class="kw">operator</span><span class="op">!=</span></code></span>, <span><code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&gt;</span></code></span>, <span><code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=</span></code></span>, or <span><code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&gt;=</span></code></span> for a type <span><code class="sourceCode cpp">T</code></span>, its requirements and semantics are as follows, unless explicitly specified otherwise.</del></span></p>
</blockquote>
<h2 id="clause-17-language-support-library"><span class="header-section-number">5.2</span> Clause 17: Language support library<a href="#clause-17-language-support-library" class="self-link"></a></h2>
<p>Added: <code class="sourceCode cpp">compare_three_way_result</code>, concepts <code class="sourceCode cpp">ThreeWayComparable</code> and <code class="sourceCode cpp">ThreeWayComparableWith</code>, <code class="sourceCode cpp">compare_three_way</code> and <code class="sourceCode cpp">compare_XXX_order_fallback</code></p>
<p>Changed operators for: <code class="sourceCode cpp">type_info</code></p>
<p>Respecified: <code class="sourceCode cpp">strong_order<span class="op">()</span></code>, <code class="sourceCode cpp">weak_order<span class="op">()</span></code>, and <code class="sourceCode cpp">partial_order<span class="op">()</span></code></p>
<p>Removed: <code class="sourceCode cpp">compare_3way<span class="op">()</span></code>, <code class="sourceCode cpp">strong_equal<span class="op">()</span></code>, and <code class="sourceCode cpp">weak_equal<span class="op">()</span></code></p>
<p>In 17.3.1 [support.limits.general], add a feature test macro:</p>
<table>
<tr>
<th>
Macro Name
</th>
<th>
Value
</th>
<th>
Header(s)
</th>
</tr>
<tr>
<td>
<span class="addu"><code class="sourceCode cpp">__cpp_lib_spaceship</code></span>
</td>
<td>
<span class="addu"><code class="sourceCode cpp"><span class="op">??????</span>L</code></span>
</td>
<td>
<span class="addu"><code class="sourceCode cpp"><span class="op">&lt;</span>compare<span class="op">&gt;</span></code></span>
</td>
</tr>
</table>
<p>In 17.7.2 [type.info], remove <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">!=</span></code>:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb6"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb6-1"><a href="#cb6-1"></a>namespace std {</span>
<span id="cb6-2"><a href="#cb6-2"></a>  class type_info {</span>
<span id="cb6-3"><a href="#cb6-3"></a>  public:</span>
<span id="cb6-4"><a href="#cb6-4"></a>    virtual ~type_info();</span>
<span id="cb6-5"><a href="#cb6-5"></a>    bool operator==(const type_info&amp; rhs) const noexcept;</span>
<span id="cb6-6"><a href="#cb6-6"></a><span class="st">-   bool operator!=(const type_info&amp; rhs) const noexcept;</span></span>
<span id="cb6-7"><a href="#cb6-7"></a>    bool before(const type_info&amp; rhs) const noexcept;</span>
<span id="cb6-8"><a href="#cb6-8"></a>    size_t hash_code() const noexcept;</span>
<span id="cb6-9"><a href="#cb6-9"></a>    const char* name() const noexcept;</span>
<span id="cb6-10"><a href="#cb6-10"></a>    type_info(const type_info&amp; rhs) = delete; // cannot be copied</span>
<span id="cb6-11"><a href="#cb6-11"></a>    type_info&amp; operator=(const type_info&amp; rhs) = delete; // cannot be copied</span>
<span id="cb6-12"><a href="#cb6-12"></a>  };</span>
<span id="cb6-13"><a href="#cb6-13"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>and:</p>
<blockquote>
<div class="sourceCode" id="cb7"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb7-1"><a href="#cb7-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> type_info<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Compares the current object with <code class="sourceCode cpp">rhs</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if the two values describe the same type.</p>
<div class="sourceCode" id="cb8"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb8-1"><a href="#cb8-1"></a><span class="rm" style="color: #bf0303"><del>bool operator!=(const type_info&amp; rhs) const noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <span class="rm" style="color: #bf0303"><del><em>Returns</em>: <span><code class="sourceCode cpp"><span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> rhs<span class="op">)</span></code></span>.</del></span></p>
</blockquote>
<p>Add into 17.11.1 [compare.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb9"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb9-1"><a href="#cb9-1"></a>namespace std {</span>
<span id="cb9-2"><a href="#cb9-2"></a>  // [cmp.categories], comparison category types</span>
<span id="cb9-3"><a href="#cb9-3"></a>  class weak_equality;</span>
<span id="cb9-4"><a href="#cb9-4"></a>  class strong_equality;</span>
<span id="cb9-5"><a href="#cb9-5"></a>  class partial_ordering;</span>
<span id="cb9-6"><a href="#cb9-6"></a>  class weak_ordering;</span>
<span id="cb9-7"><a href="#cb9-7"></a>  class strong_ordering;</span>
<span id="cb9-8"><a href="#cb9-8"></a></span>
<span id="cb9-9"><a href="#cb9-9"></a>  // named comparison functions</span>
<span id="cb9-10"><a href="#cb9-10"></a>  constexpr bool is_eq  (weak_equality cmp) noexcept    { return cmp == 0; }</span>
<span id="cb9-11"><a href="#cb9-11"></a>  constexpr bool is_neq (weak_equality cmp) noexcept    { return cmp != 0; }</span>
<span id="cb9-12"><a href="#cb9-12"></a>  constexpr bool is_lt  (partial_ordering cmp) noexcept { return cmp &lt; 0; }</span>
<span id="cb9-13"><a href="#cb9-13"></a>  constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp &lt;= 0; }</span>
<span id="cb9-14"><a href="#cb9-14"></a>  constexpr bool is_gt  (partial_ordering cmp) noexcept { return cmp &gt; 0; }</span>
<span id="cb9-15"><a href="#cb9-15"></a>  constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp &gt;= 0; }</span>
<span id="cb9-16"><a href="#cb9-16"></a></span>
<span id="cb9-17"><a href="#cb9-17"></a>  // [cmp.common], common comparison category type</span>
<span id="cb9-18"><a href="#cb9-18"></a>  template&lt;class... Ts&gt;</span>
<span id="cb9-19"><a href="#cb9-19"></a>  struct common_comparison_category {</span>
<span id="cb9-20"><a href="#cb9-20"></a>    using type = <em>see below</em>;</span>
<span id="cb9-21"><a href="#cb9-21"></a>  };</span>
<span id="cb9-22"><a href="#cb9-22"></a>  template&lt;class... Ts&gt;</span>
<span id="cb9-23"><a href="#cb9-23"></a>    using common_comparison_category_t = typename common_comparison_category&lt;Ts...&gt;::type;</span>
<span id="cb9-24"><a href="#cb9-24"></a></span>
<span id="cb9-25"><a href="#cb9-25"></a><span class="va">+ // [cmp.concept], concept ThreeWayComparable</span></span>
<span id="cb9-26"><a href="#cb9-26"></a><span class="va">+ template&lt;class T, class Cat = partial_ordering&gt;</span></span>
<span id="cb9-27"><a href="#cb9-27"></a><span class="va">+   concept ThreeWayComparable = <em>see below</em>;</span></span>
<span id="cb9-28"><a href="#cb9-28"></a><span class="va">+ template&lt;class T, class U, class Cat = partial_ordering&gt;</span></span>
<span id="cb9-29"><a href="#cb9-29"></a><span class="va">+   concept ThreeWayComparableWith = <em>see below</em>;</span></span>
<span id="cb9-30"><a href="#cb9-30"></a><span class="va">+</span></span>
<span id="cb9-31"><a href="#cb9-31"></a><span class="va">+ // [cmp.result], spaceship invocation result</span></span>
<span id="cb9-32"><a href="#cb9-32"></a><span class="va">+ template&lt;class T, class U = T&gt; struct compare_three_way_result;</span></span>
<span id="cb9-33"><a href="#cb9-33"></a><span class="va">+</span></span>
<span id="cb9-34"><a href="#cb9-34"></a><span class="va">+ template&lt;class T, class U = T&gt;</span></span>
<span id="cb9-35"><a href="#cb9-35"></a><span class="va">+   using compare_three_way_result_t = typename compare_three_way_result&lt;T, U&gt;::type;</span></span>
<span id="cb9-36"><a href="#cb9-36"></a><span class="va">+</span></span>
<span id="cb9-37"><a href="#cb9-37"></a><span class="va">+ // [cmp.object], spaceship object</span></span>
<span id="cb9-38"><a href="#cb9-38"></a><span class="va">+ struct compare_three_way;</span></span>
<span id="cb9-39"><a href="#cb9-39"></a></span>
<span id="cb9-40"><a href="#cb9-40"></a>  // [cmp.alg], comparison algorithms</span>
<span id="cb9-41"><a href="#cb9-41"></a><span class="st">- template&lt;class T&gt; constexpr strong_ordering strong_order(const T&amp; a, const T&amp; b);</span></span>
<span id="cb9-42"><a href="#cb9-42"></a><span class="st">- template&lt;class T&gt; constexpr weak_ordering weak_order(const T&amp; a, const T&amp; b);</span></span>
<span id="cb9-43"><a href="#cb9-43"></a><span class="st">- template&lt;class T&gt; constexpr partial_ordering partial_order(const T&amp; a, const T&amp; b);</span></span>
<span id="cb9-44"><a href="#cb9-44"></a><span class="st">- template&lt;class T&gt; constexpr strong_equality strong_equal(const T&amp; a, const T&amp; b);</span></span>
<span id="cb9-45"><a href="#cb9-45"></a><span class="st">- template&lt;class T&gt; constexpr weak_equality weak_equal(const T&amp; a, const T&amp; b);</span></span>
<span id="cb9-46"><a href="#cb9-46"></a><span class="va">+ inline namespace <em>unspecified</em> {</span></span>
<span id="cb9-47"><a href="#cb9-47"></a><span class="va">+   inline constexpr <em>unspecified</em> strong_order = <em>unspecified</em>;</span></span>
<span id="cb9-48"><a href="#cb9-48"></a><span class="va">+   inline constexpr <em>unspecified</em> weak_order = <em>unspecified</em>;</span></span>
<span id="cb9-49"><a href="#cb9-49"></a><span class="va">+   inline constexpr <em>unspecified</em> partial_order = <em>unspecified</em>;</span></span>
<span id="cb9-50"><a href="#cb9-50"></a><span class="va">+   inline constexpr <em>unspecified</em> compare_strong_order_fallback = <em>unspecified</em>;</span></span>
<span id="cb9-51"><a href="#cb9-51"></a><span class="va">+   inline constexpr <em>unspecified</em> compare_weak_order_fallback = <em>unspecified</em>;</span></span>
<span id="cb9-52"><a href="#cb9-52"></a><span class="va">+   inline constexpr <em>unspecified</em> compare_partial_order_fallback = <em>unspecified</em>;</span></span>
<span id="cb9-53"><a href="#cb9-53"></a><span class="va">+ }</span></span>
<span id="cb9-54"><a href="#cb9-54"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 17.11.2.2 [cmp.weakeq]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb10"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb10-1"><a href="#cb10-1"></a>namespace std {</span>
<span id="cb10-2"><a href="#cb10-2"></a>  class weak_equality {</span>
<span id="cb10-3"><a href="#cb10-3"></a>    int value;  // exposition only</span>
<span id="cb10-4"><a href="#cb10-4"></a></span>
<span id="cb10-5"><a href="#cb10-5"></a>    [...]</span>
<span id="cb10-6"><a href="#cb10-6"></a></span>
<span id="cb10-7"><a href="#cb10-7"></a>    // comparisons</span>
<span id="cb10-8"><a href="#cb10-8"></a>    friend constexpr bool operator==(weak_equality v, <em>unspecified</em>) noexcept;</span>
<span id="cb10-9"><a href="#cb10-9"></a><span class="st">-   friend constexpr bool operator!=(weak_equality v, <em>unspecified</em>) noexcept;</span></span>
<span id="cb10-10"><a href="#cb10-10"></a><span class="st">-   friend constexpr bool operator==(<em>unspecified</em>, weak_equality v) noexcept;</span></span>
<span id="cb10-11"><a href="#cb10-11"></a><span class="st">-   friend constexpr bool operator!=(<em>unspecified</em>, weak_equality v) noexcept;</span></span>
<span id="cb10-12"><a href="#cb10-12"></a><span class="va">+   friend constexpr bool operator==(weak_equality v, weak_equality w) noexcept = default;</span></span>
<span id="cb10-13"><a href="#cb10-13"></a>    friend constexpr weak_equality operator&lt;=&gt;(weak_equality v, <em>unspecified</em>) noexcept;</span>
<span id="cb10-14"><a href="#cb10-14"></a>    friend constexpr weak_equality operator&lt;=&gt;(<em>unspecified</em>, weak_equality v) noexcept;</span>
<span id="cb10-15"><a href="#cb10-15"></a>  };</span>
<span id="cb10-16"><a href="#cb10-16"></a></span>
<span id="cb10-17"><a href="#cb10-17"></a>  [...]</span>
<span id="cb10-18"><a href="#cb10-18"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>and remove those functions from the description:</p>
<blockquote>
<div class="sourceCode" id="cb11"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb11-1"><a href="#cb11-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>weak_equality v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-2"><a href="#cb11-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator==(<em>unspecified</em>, weak_equality v) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">v<span class="op">.</span>value <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb12"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb12-1"><a href="#cb12-1"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(weak_equality v, <em>unspecified</em>) noexcept;</del></span></span>
<span id="cb12-2"><a href="#cb12-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(<em>unspecified</em>, weak_equality v) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <span class="rm" style="color: #bf0303"><del><em>Returns</em>: <span><code class="sourceCode cpp">v<span class="op">.</span>value <span class="op">!=</span> <span class="dv">0</span></code></span>.</del></span></p>
</blockquote>
<p>Change 17.11.2.3 [cmp.strongeq]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb13"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb13-1"><a href="#cb13-1"></a>namespace std {</span>
<span id="cb13-2"><a href="#cb13-2"></a>  class strong_equality {</span>
<span id="cb13-3"><a href="#cb13-3"></a>    int value;  // exposition only</span>
<span id="cb13-4"><a href="#cb13-4"></a></span>
<span id="cb13-5"><a href="#cb13-5"></a>    [...]</span>
<span id="cb13-6"><a href="#cb13-6"></a></span>
<span id="cb13-7"><a href="#cb13-7"></a>    // comparisons</span>
<span id="cb13-8"><a href="#cb13-8"></a>    friend constexpr bool operator==(strong_equality v, <em>unspecified</em>) noexcept;</span>
<span id="cb13-9"><a href="#cb13-9"></a><span class="st">-   friend constexpr bool operator!=(strong_equality v, <em>unspecified</em>) noexcept;</span></span>
<span id="cb13-10"><a href="#cb13-10"></a><span class="st">-   friend constexpr bool operator==(<em>unspecified</em>, strong_equality v) noexcept;</span></span>
<span id="cb13-11"><a href="#cb13-11"></a><span class="st">-   friend constexpr bool operator!=(<em>unspecified</em>, strong_equality v) noexcept;</span></span>
<span id="cb13-12"><a href="#cb13-12"></a><span class="va">+   friend constexpr bool operator==(strong_equality v, strong_equality w) noexcept = default;  </span></span>
<span id="cb13-13"><a href="#cb13-13"></a>    friend constexpr strong_equality operator&lt;=&gt;(strong_equality v, <em>unspecified</em>) noexcept;</span>
<span id="cb13-14"><a href="#cb13-14"></a>    friend constexpr strong_equality operator&lt;=&gt;(<em>unspecified</em>, strong_equality v) noexcept;</span>
<span id="cb13-15"><a href="#cb13-15"></a>  };</span>
<span id="cb13-16"><a href="#cb13-16"></a></span>
<span id="cb13-17"><a href="#cb13-17"></a>  [...]</span>
<span id="cb13-18"><a href="#cb13-18"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>and remove those functions from the description:</p>
<blockquote>
<div class="sourceCode" id="cb14"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb14-1"><a href="#cb14-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>strong_equality v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb14-2"><a href="#cb14-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator==(<em>unspecified</em>, strong_equality v) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">v<span class="op">.</span>value <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb15"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb15-1"><a href="#cb15-1"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(strong_equality v, <em>unspecified</em>) noexcept;</del></span></span>
<span id="cb15-2"><a href="#cb15-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(<em>unspecified</em>, strong_equality v) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <span class="rm" style="color: #bf0303"><del><em>Returns</em>: <span><code class="sourceCode cpp">v<span class="op">.</span>value <span class="op">!=</span> <span class="dv">0</span></code></span>.</del></span></p>
</blockquote>
<p>Change 17.11.2.4 [cmp.partialord]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb16"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb16-1"><a href="#cb16-1"></a>namespace std {</span>
<span id="cb16-2"><a href="#cb16-2"></a>  class partial_ordering {</span>
<span id="cb16-3"><a href="#cb16-3"></a>    int value;          // exposition only</span>
<span id="cb16-4"><a href="#cb16-4"></a>    bool is_ordered;    // exposition only</span>
<span id="cb16-5"><a href="#cb16-5"></a></span>
<span id="cb16-6"><a href="#cb16-6"></a>    [...]</span>
<span id="cb16-7"><a href="#cb16-7"></a></span>
<span id="cb16-8"><a href="#cb16-8"></a>    // conversion</span>
<span id="cb16-9"><a href="#cb16-9"></a>    constexpr operator weak_equality() const noexcept;</span>
<span id="cb16-10"><a href="#cb16-10"></a></span>
<span id="cb16-11"><a href="#cb16-11"></a>    // comparisons</span>
<span id="cb16-12"><a href="#cb16-12"></a>    friend constexpr bool operator==(partial_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb16-13"><a href="#cb16-13"></a><span class="st">-   friend constexpr bool operator!=(partial_ordering v, <em>unspecified</em>) noexcept;</span></span>
<span id="cb16-14"><a href="#cb16-14"></a><span class="va">+   friend constexpr bool operator==(partial_ordering v, partial_ordering w) noexcept = default;</span></span>
<span id="cb16-15"><a href="#cb16-15"></a>    friend constexpr bool operator&lt; (partial_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb16-16"><a href="#cb16-16"></a>    friend constexpr bool operator&gt; (partial_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb16-17"><a href="#cb16-17"></a>    friend constexpr bool operator&lt;=(partial_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb16-18"><a href="#cb16-18"></a>    friend constexpr bool operator&gt;=(partial_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb16-19"><a href="#cb16-19"></a><span class="st">-   friend constexpr bool operator==(<em>unspecified</em>, partial_ordering v) noexcept;</span></span>
<span id="cb16-20"><a href="#cb16-20"></a><span class="st">-   friend constexpr bool operator!=(<em>unspecified</em>, partial_ordering v) noexcept;</span></span>
<span id="cb16-21"><a href="#cb16-21"></a>    friend constexpr bool operator&lt; (<em>unspecified</em>, partial_ordering v) noexcept;</span>
<span id="cb16-22"><a href="#cb16-22"></a>    friend constexpr bool operator&gt; (<em>unspecified</em>, partial_ordering v) noexcept;</span>
<span id="cb16-23"><a href="#cb16-23"></a>    friend constexpr bool operator&lt;=(<em>unspecified</em>, partial_ordering v) noexcept;</span>
<span id="cb16-24"><a href="#cb16-24"></a>    friend constexpr bool operator&gt;=(<em>unspecified</em>, partial_ordering v) noexcept;</span>
<span id="cb16-25"><a href="#cb16-25"></a>    friend constexpr partial_ordering operator&lt;=&gt;(partial_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb16-26"><a href="#cb16-26"></a>    friend constexpr partial_ordering operator&lt;=&gt;(<em>unspecified</em>, partial_ordering v) noexcept;</span>
<span id="cb16-27"><a href="#cb16-27"></a>  };</span>
<span id="cb16-28"><a href="#cb16-28"></a></span>
<span id="cb16-29"><a href="#cb16-29"></a>  [...]</span>
<span id="cb16-30"><a href="#cb16-30"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Remove just the extra <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code> operators in 17.11.2.4 [cmp.partialord]/4-5:</p>
<blockquote>
<div class="sourceCode" id="cb17"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb17-1"><a href="#cb17-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>partial_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb17-2"><a href="#cb17-2"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;</span> <span class="op">(</span>partial_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb17-3"><a href="#cb17-3"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;</span> <span class="op">(</span>partial_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb17-4"><a href="#cb17-4"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span>partial_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb17-5"><a href="#cb17-5"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span>partial_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: For <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code>, <code class="sourceCode cpp">v<span class="op">.</span>is_ordered <span class="op">&amp;&amp;</span> v<span class="op">.</span>value <span class="op">@</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb18"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb18-1"><a href="#cb18-1"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator==(<em>unspecified</em>, partial_ordering v) noexcept;</del></span></span>
<span id="cb18-2"><a href="#cb18-2"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;</span> <span class="op">(</span><em>unspecified</em>, partial_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-3"><a href="#cb18-3"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;</span> <span class="op">(</span><em>unspecified</em>, partial_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-4"><a href="#cb18-4"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><em>unspecified</em>, partial_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-5"><a href="#cb18-5"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><em>unspecified</em>, partial_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: For <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code>, <code class="sourceCode cpp">v<span class="op">.</span>is_ordered <span class="op">&amp;&amp;</span> <span class="dv">0</span> <span class="op">@</span> v<span class="op">.</span>value</code>.</p>
<div class="sourceCode" id="cb19"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb19-1"><a href="#cb19-1"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(partial_ordering v, <em>unspecified</em>) noexcept;</del></span></span>
<span id="cb19-2"><a href="#cb19-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(<em>unspecified</em>, partial_ordering v) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <span class="rm" style="color: #bf0303"><del><em>Returns</em>: For <span><code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code></span>, <span><code class="sourceCode cpp"><span class="op">!</span>v<span class="op">.</span>is_ordered <span class="op">||</span> v<span class="op">.</span>value <span class="op">!=</span> <span class="dv">0</span></code></span>.</del></span></p>
</blockquote>
<p>Change 17.11.2.5 [cmp.weakord]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb20"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb20-1"><a href="#cb20-1"></a>namespace std {</span>
<span id="cb20-2"><a href="#cb20-2"></a>  class weak_ordering {</span>
<span id="cb20-3"><a href="#cb20-3"></a>    int value;  // exposition only</span>
<span id="cb20-4"><a href="#cb20-4"></a></span>
<span id="cb20-5"><a href="#cb20-5"></a>    [...]</span>
<span id="cb20-6"><a href="#cb20-6"></a>    // comparisons</span>
<span id="cb20-7"><a href="#cb20-7"></a>    friend constexpr bool operator==(weak_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb20-8"><a href="#cb20-8"></a><span class="va">+   friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default;</span></span>
<span id="cb20-9"><a href="#cb20-9"></a><span class="st">-   friend constexpr bool operator!=(weak_ordering v, <em>unspecified</em>) noexcept;</span></span>
<span id="cb20-10"><a href="#cb20-10"></a>    friend constexpr bool operator&lt; (weak_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb20-11"><a href="#cb20-11"></a>    friend constexpr bool operator&gt; (weak_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb20-12"><a href="#cb20-12"></a>    friend constexpr bool operator&lt;=(weak_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb20-13"><a href="#cb20-13"></a>    friend constexpr bool operator&gt;=(weak_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb20-14"><a href="#cb20-14"></a><span class="st">-   friend constexpr bool operator==(<em>unspecified</em>, weak_ordering v) noexcept;</span></span>
<span id="cb20-15"><a href="#cb20-15"></a><span class="st">-   friend constexpr bool operator!=(<em>unspecified</em>, weak_ordering v) noexcept;</span></span>
<span id="cb20-16"><a href="#cb20-16"></a>    friend constexpr bool operator&lt; (<em>unspecified</em>, weak_ordering v) noexcept;</span>
<span id="cb20-17"><a href="#cb20-17"></a>    friend constexpr bool operator&gt; (<em>unspecified</em>, weak_ordering v) noexcept;</span>
<span id="cb20-18"><a href="#cb20-18"></a>    friend constexpr bool operator&lt;=(<em>unspecified</em>, weak_ordering v) noexcept;</span>
<span id="cb20-19"><a href="#cb20-19"></a>    friend constexpr bool operator&gt;=(<em>unspecified</em>, weak_ordering v) noexcept;</span>
<span id="cb20-20"><a href="#cb20-20"></a>    friend constexpr weak_ordering operator&lt;=&gt;(weak_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb20-21"><a href="#cb20-21"></a>    friend constexpr weak_ordering operator&lt;=&gt;(<em>unspecified</em>, weak_ordering v) noexcept;</span>
<span id="cb20-22"><a href="#cb20-22"></a>  };</span>
<span id="cb20-23"><a href="#cb20-23"></a></span>
<span id="cb20-24"><a href="#cb20-24"></a>  [...]</span>
<span id="cb20-25"><a href="#cb20-25"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Remove just the extra <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code> operators from 17.11.2.5 [cmp.weakord]/4 and /5:</p>
<blockquote>
<div class="sourceCode" id="cb21"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb21-1"><a href="#cb21-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>weak_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb21-2"><a href="#cb21-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(weak_ordering v, <em>unspecified</em>) noexcept;</del></span></span>
<span id="cb21-3"><a href="#cb21-3"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;</span> <span class="op">(</span>weak_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb21-4"><a href="#cb21-4"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;</span> <span class="op">(</span>weak_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb21-5"><a href="#cb21-5"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span>weak_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb21-6"><a href="#cb21-6"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span>weak_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">v<span class="op">.</span>value <span class="op">@</span> <span class="dv">0</span></code> for <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code>.</p>
<div class="sourceCode" id="cb22"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb22-1"><a href="#cb22-1"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator==(<em>unspecified</em>, weak_ordering v) noexcept;</del></span></span>
<span id="cb22-2"><a href="#cb22-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(<em>unspecified</em>, weak_ordering v) noexcept;</del></span></span>
<span id="cb22-3"><a href="#cb22-3"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;</span> <span class="op">(</span><em>unspecified</em>, weak_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-4"><a href="#cb22-4"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;</span> <span class="op">(</span><em>unspecified</em>, weak_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-5"><a href="#cb22-5"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><em>unspecified</em>, weak_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-6"><a href="#cb22-6"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><em>unspecified</em>, weak_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dv">0</span> <span class="op">@</span> v<span class="op">.</span>value</code> for <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code>.</p>
</blockquote>
<p>Change 17.11.2.6 [cmp.strongord]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb23"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb23-1"><a href="#cb23-1"></a>namespace std {</span>
<span id="cb23-2"><a href="#cb23-2"></a>  class strong_ordering {</span>
<span id="cb23-3"><a href="#cb23-3"></a>    int value;  // exposition only</span>
<span id="cb23-4"><a href="#cb23-4"></a></span>
<span id="cb23-5"><a href="#cb23-5"></a>    [...]</span>
<span id="cb23-6"><a href="#cb23-6"></a></span>
<span id="cb23-7"><a href="#cb23-7"></a>    // comparisons</span>
<span id="cb23-8"><a href="#cb23-8"></a>    friend constexpr bool operator==(strong_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb23-9"><a href="#cb23-9"></a><span class="va">+   friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default;</span></span>
<span id="cb23-10"><a href="#cb23-10"></a><span class="st">-   friend constexpr bool operator!=(strong_ordering v, <em>unspecified</em>) noexcept;</span></span>
<span id="cb23-11"><a href="#cb23-11"></a>    friend constexpr bool operator&lt; (strong_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb23-12"><a href="#cb23-12"></a>    friend constexpr bool operator&gt; (strong_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb23-13"><a href="#cb23-13"></a>    friend constexpr bool operator&lt;=(strong_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb23-14"><a href="#cb23-14"></a>    friend constexpr bool operator&gt;=(strong_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb23-15"><a href="#cb23-15"></a><span class="st">-   friend constexpr bool operator==(<em>unspecified</em>, strong_ordering v) noexcept;</span></span>
<span id="cb23-16"><a href="#cb23-16"></a><span class="st">-   friend constexpr bool operator!=(<em>unspecified</em>, strong_ordering v) noexcept;</span></span>
<span id="cb23-17"><a href="#cb23-17"></a>    friend constexpr bool operator&lt; (<em>unspecified</em>, strong_ordering v) noexcept;</span>
<span id="cb23-18"><a href="#cb23-18"></a>    friend constexpr bool operator&gt; (<em>unspecified</em>, strong_ordering v) noexcept;</span>
<span id="cb23-19"><a href="#cb23-19"></a>    friend constexpr bool operator&lt;=(<em>unspecified</em>, strong_ordering v) noexcept;</span>
<span id="cb23-20"><a href="#cb23-20"></a>    friend constexpr bool operator&gt;=(<em>unspecified</em>, strong_ordering v) noexcept;</span>
<span id="cb23-21"><a href="#cb23-21"></a>    friend constexpr strong_ordering operator&lt;=&gt;(strong_ordering v, <em>unspecified</em>) noexcept;</span>
<span id="cb23-22"><a href="#cb23-22"></a>    friend constexpr strong_ordering operator&lt;=&gt;(<em>unspecified</em>, strong_ordering v) noexcept;</span>
<span id="cb23-23"><a href="#cb23-23"></a>  };</span>
<span id="cb23-24"><a href="#cb23-24"></a></span>
<span id="cb23-25"><a href="#cb23-25"></a>  [...]</span>
<span id="cb23-26"><a href="#cb23-26"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Remove just the extra <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code> operators from 17.11.2.6 [cmp.strongord]/6 and /7:</p>
<blockquote>
<div class="sourceCode" id="cb24"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb24-1"><a href="#cb24-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>strong_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb24-2"><a href="#cb24-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(strong_ordering v, <em>unspecified</em>) noexcept;</del></span></span>
<span id="cb24-3"><a href="#cb24-3"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;</span> <span class="op">(</span>strong_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb24-4"><a href="#cb24-4"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;</span> <span class="op">(</span>strong_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb24-5"><a href="#cb24-5"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span>strong_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb24-6"><a href="#cb24-6"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span>strong_ordering v, <em>unspecified</em><span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">v<span class="op">.</span>value <span class="op">@</span> <span class="dv">0</span></code> for <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code>.</p>
<div class="sourceCode" id="cb25"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb25-1"><a href="#cb25-1"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator==(<em>unspecified</em>, strong_ordering v) noexcept;</del></span></span>
<span id="cb25-2"><a href="#cb25-2"></a><span class="rm" style="color: #bf0303"><del>constexpr bool operator!=(<em>unspecified</em>, strong_ordering v) noexcept;</del></span></span>
<span id="cb25-3"><a href="#cb25-3"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;</span> <span class="op">(</span><em>unspecified</em>, strong_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb25-4"><a href="#cb25-4"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;</span> <span class="op">(</span><em>unspecified</em>, strong_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb25-5"><a href="#cb25-5"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><em>unspecified</em>, strong_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb25-6"><a href="#cb25-6"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><em>unspecified</em>, strong_ordering v<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dv">0</span> <span class="op">@</span> v<span class="op">.</span>value</code> for <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">@</span></code>.</p>
</blockquote>
<p>Add a new subclause [cmp.concept] “concept ThreeWayComparable”:</p>
<blockquote>
<div class="add" style="color: #006e28">

<div class="sourceCode" id="cb26"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb26-1"><a href="#cb26-1"></a>template &lt;typename T, typename Cat&gt;</span>
<span id="cb26-2"><a href="#cb26-2"></a>  concept <em>compares-as</em> = // exposition only</span>
<span id="cb26-3"><a href="#cb26-3"></a>    Same&lt;common_comparison_category_t&lt;T, Cat&gt;, Cat&gt;;</span></code></pre></div>
<div class="sourceCode" id="cb27"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb27-1"><a href="#cb27-1"></a>template&lt;class T, class U&gt;</span>
<span id="cb27-2"><a href="#cb27-2"></a>  concept <em>partially-ordered-with</em> = // exposition only</span>
<span id="cb27-3"><a href="#cb27-3"></a>    requires(const remove_reference_t&lt;T&gt;&amp; t,</span>
<span id="cb27-4"><a href="#cb27-4"></a>             const remove_reference_t&lt;U&gt;&amp; u) {</span>
<span id="cb27-5"><a href="#cb27-5"></a>      { t &lt; u } -&gt; Boolean;</span>
<span id="cb27-6"><a href="#cb27-6"></a>      { t &gt; u } -&gt; Boolean;</span>
<span id="cb27-7"><a href="#cb27-7"></a>      { t &lt;= u } -&gt; Boolean;</span>
<span id="cb27-8"><a href="#cb27-8"></a>      { t &gt;= u } -&gt; Boolean;</span>
<span id="cb27-9"><a href="#cb27-9"></a>      { u &lt; t } -&gt; Boolean;</span>
<span id="cb27-10"><a href="#cb27-10"></a>      { u &gt; t } -&gt; Boolean;</span>
<span id="cb27-11"><a href="#cb27-11"></a>      { u &lt;= t } -&gt; Boolean;</span>
<span id="cb27-12"><a href="#cb27-12"></a>      { u &gt;= t } -&gt; Boolean;    </span>
<span id="cb27-13"><a href="#cb27-13"></a>    };</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> Let <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code> be lvalues of types <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> and <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>U<span class="op">&gt;</span></code> respectively. <em><code class="sourceCode cpp">partially<span class="op">-</span>ordered<span class="op">-</span>with</code></em><code class="sourceCode cpp"><span class="op">&lt;</span>T, U<span class="op">&gt;</span></code> is satisfied only if:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> <code class="sourceCode cpp">t <span class="op">&lt;</span> u</code>, <code class="sourceCode cpp">t <span class="op">&lt;=</span> u</code>, <code class="sourceCode cpp">t <span class="op">&gt;</span> u</code>, <code class="sourceCode cpp">t <span class="op">&gt;=</span> u</code>, <code class="sourceCode cpp">u <span class="op">&lt;</span> t</code>, <code class="sourceCode cpp">u <span class="op">&lt;=</span> t</code>, <code class="sourceCode cpp">u <span class="op">&gt;</span> t</code>, and <code class="sourceCode cpp">u <span class="op">&gt;=</span> t</code> have the same domain.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>t <span class="op">&lt;</span> u<span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>u <span class="op">&gt;</span> t<span class="op">)</span></code></li>
<li><span class="marginalizedparent"><a class="marginalized">(1.3)</a></span> <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>u <span class="op">&lt;</span> t<span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">&gt;</span> u<span class="op">)</span></code></li>
<li><span class="marginalizedparent"><a class="marginalized">(1.4)</a></span> <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>t <span class="op">&lt;=</span> u<span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>u <span class="op">&gt;=</span> t<span class="op">)</span></code></li>
<li><span class="marginalizedparent"><a class="marginalized">(1.5)</a></span> <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>u <span class="op">&lt;=</span> t<span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">&gt;=</span> u<span class="op">)</span></code></li>
</ul>
<div class="sourceCode" id="cb28"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb28-1"><a href="#cb28-1"></a>template &lt;typename T, typename Cat = partial_ordering&gt;</span>
<span id="cb28-2"><a href="#cb28-2"></a>  concept ThreeWayComparable =</span>
<span id="cb28-3"><a href="#cb28-3"></a>    <em>weakly-equality-comparable-with</em>&lt;T, T&gt; &amp;&amp;</span>
<span id="cb28-4"><a href="#cb28-4"></a>    (!ConvertibleTo&lt;Cat, partial_ordering&gt; || <em>partially-ordered-with</em>&lt;T, T&gt;) &amp;&amp;</span>
<span id="cb28-5"><a href="#cb28-5"></a>    requires(const remove_reference_t&lt;T&gt;&amp; a,</span>
<span id="cb28-6"><a href="#cb28-6"></a>             const remove_reference_t&lt;T&gt;&amp; b) {</span>
<span id="cb28-7"><a href="#cb28-7"></a>      { a &lt;=&gt; b } -&gt; <em>compares-as</em>&lt;Cat&gt;;</span>
<span id="cb28-8"><a href="#cb28-8"></a>    };</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> Let <code class="sourceCode cpp">a</code> and <code class="sourceCode cpp">b</code> be lvalues of type <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code>. <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">Cat</code> model <code class="sourceCode cpp">ThreeWayComparable<span class="op">&lt;</span>T, Cat<span class="op">&gt;</span></code> only if:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> <code class="sourceCode cpp"><span class="op">(</span>a <span class="op">&lt;=&gt;</span> b <span class="op">==</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>a <span class="op">==</span> b<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> <code class="sourceCode cpp"><span class="op">(</span>a <span class="op">&lt;=&gt;</span> b <span class="op">!=</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>a <span class="op">!=</span> b<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3)</a></span> <code class="sourceCode cpp"><span class="op">((</span>a <span class="op">&lt;=&gt;</span> b<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dv">0</span><span class="op">)</span></code> and <code class="sourceCode cpp"><span class="op">(</span><span class="dv">0</span> <span class="op">&lt;=&gt;</span> <span class="op">(</span>b <span class="op">&lt;=&gt;</span> a<span class="op">))</span></code> are equal.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.4)</a></span> If <code class="sourceCode cpp">Cat</code> is convertible to <code class="sourceCode cpp">strong_equality</code>, <code class="sourceCode cpp">T</code> models <code class="sourceCode cpp">EqualityComparable</code> ([concept.equalitycomparable]).</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5)</a></span> If <code class="sourceCode cpp">Cat</code> is convertible to <code class="sourceCode cpp">partial_ordering</code>:
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.5.1)</a></span> <code class="sourceCode cpp"><span class="op">(</span>a <span class="op">&lt;=&gt;</span> b <span class="op">&lt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>a <span class="op">&lt;</span> b<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5.2)</a></span> <code class="sourceCode cpp"><span class="op">(</span>a <span class="op">&lt;=&gt;</span> b <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>a <span class="op">&gt;</span> b<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5.3)</a></span> <code class="sourceCode cpp"><span class="op">(</span>a <span class="op">&lt;=&gt;</span> b <span class="op">&lt;=</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>a <span class="op">&lt;=</span> b<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5.4)</a></span> <code class="sourceCode cpp"><span class="op">(</span>a <span class="op">&lt;=&gt;</span> b <span class="op">&gt;=</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>a <span class="op">&gt;=</span> b<span class="op">)</span></code>.</li>
</ul></li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5.5)</a></span> If <code class="sourceCode cpp">Cat</code> is convertible to <code class="sourceCode cpp">strong_ordering</code>, <code class="sourceCode cpp">T</code> models <code class="sourceCode cpp">StrictTotallyOrdered</code> ([concept.stricttotallyordered]).</li>
</ul>
<div class="sourceCode" id="cb29"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb29-1"><a href="#cb29-1"></a>template &lt;typename T, typename U,</span>
<span id="cb29-2"><a href="#cb29-2"></a>          typename Cat = partial_ordering&gt;</span>
<span id="cb29-3"><a href="#cb29-3"></a>  concept ThreeWayComparableWith = </span>
<span id="cb29-4"><a href="#cb29-4"></a>    <em>weakly-equality-comparable-with</em>&lt;T, U&gt; &amp;&amp;</span>
<span id="cb29-5"><a href="#cb29-5"></a>    (!ConvertibleTo&lt;Cat, partial_ordering&gt; || <em>partially-ordered-with</em>&lt;T, U&gt;) &amp;&amp;</span>
<span id="cb29-6"><a href="#cb29-6"></a>    ThreeWayComparable&lt;T, Cat&gt; &amp;&amp;</span>
<span id="cb29-7"><a href="#cb29-7"></a>    ThreeWayComparable&lt;U, Cat&gt; &amp;&amp;</span>
<span id="cb29-8"><a href="#cb29-8"></a>    CommonReference&lt;const remove_reference_t&lt;T&gt;&amp;, const remove_reference_t&lt;U&gt;&amp;&gt; &amp;&amp;</span>
<span id="cb29-9"><a href="#cb29-9"></a>    ThreeWayComparable&lt;</span>
<span id="cb29-10"><a href="#cb29-10"></a>      common_reference_t&lt;const remove_reference_t&lt;T&gt;&amp;, const remove_reference_t&lt;U&gt;&amp;&gt;,</span>
<span id="cb29-11"><a href="#cb29-11"></a>      Cat&gt; &amp;&amp;</span>
<span id="cb29-12"><a href="#cb29-12"></a>    requires(const remove_reference_t&lt;T&gt;&amp; t,</span>
<span id="cb29-13"><a href="#cb29-13"></a>             const remove_reference_t&lt;U&gt;&amp; u) {</span>
<span id="cb29-14"><a href="#cb29-14"></a>      { t &lt;=&gt; u } -&gt; <em>compares-as</em>&lt;Cat&gt;;</span>
<span id="cb29-15"><a href="#cb29-15"></a>      { u &lt;=&gt; t } -&gt; <em>compares-as</em>&lt;Cat&gt;;</span>
<span id="cb29-16"><a href="#cb29-16"></a>    };</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> Let <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code> be lvalues of types <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> and <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>U<span class="op">&gt;</span></code>, respectively. Let <code class="sourceCode cpp">C</code> be <code class="sourceCode cpp">common_reference_t<span class="op">&lt;</span><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span>, <span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>U<span class="op">&gt;&amp;&gt;</span></code>. <code class="sourceCode cpp">T</code>, <code class="sourceCode cpp">U</code>, and <code class="sourceCode cpp">Cat</code> model <code class="sourceCode cpp">ThreeWayComparableWith<span class="op">&lt;</span>T, U, Cat<span class="op">&gt;</span></code> only if:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> <code class="sourceCode cpp">t <span class="op">&lt;=&gt;</span> u</code> and <code class="sourceCode cpp">u <span class="op">&lt;=&gt;</span> t</code> have the same domain.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.2)</a></span> <code class="sourceCode cpp"><span class="op">((</span>t <span class="op">&lt;=&gt;</span> u<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dv">0</span><span class="op">)</span></code> and <code class="sourceCode cpp"><span class="op">(</span><span class="dv">0</span> <span class="op">&lt;=&gt;</span> <span class="op">(</span>u <span class="op">&lt;=&gt;</span> t<span class="op">))</span></code> are equal.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3)</a></span> <code class="sourceCode cpp"><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u <span class="op">==</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">==</span> u<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.4)</a></span> <code class="sourceCode cpp"><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u <span class="op">!=</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">!=</span> u<span class="op">)</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.5)</a></span> <code class="sourceCode cpp">Cat<span class="op">(</span>t <span class="op">&lt;=&gt;</span> u<span class="op">)</span> <span class="op">==</span> Cat<span class="op">(</span>C<span class="op">(</span>t<span class="op">)</span> <span class="op">&lt;=&gt;</span> C<span class="op">(</span>u<span class="op">))</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.6)</a></span> If <code class="sourceCode cpp">Cat</code> is convertible to <code class="sourceCode cpp">strong_equality</code>, <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code> model <code class="sourceCode cpp">EqualityComparableWith<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code> ([concepts.equalitycomparable]).</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.7)</a></span> If <code class="sourceCode cpp">Cat</code> is convertible to <code class="sourceCode cpp">partial_ordering</code>:
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.7.1)</a></span> <code class="sourceCode cpp"><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u <span class="op">&lt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">&lt;</span> u<span class="op">)</span></code></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.7.2)</a></span> <code class="sourceCode cpp"><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">&gt;</span> u<span class="op">)</span></code></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.7.3)</a></span> <code class="sourceCode cpp"><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u <span class="op">&lt;=</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">&lt;=</span> u<span class="op">)</span></code></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.7.4)</a></span> <code class="sourceCode cpp"><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u <span class="op">&gt;=</span> <span class="dv">0</span><span class="op">)</span> <span class="op">==</span> <span class="dt">bool</span><span class="op">(</span>t <span class="op">&gt;=</span> u<span class="op">)</span></code></li>
</ul></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.8)</a></span> If <code class="sourceCode cpp">Cat</code> is convertible to <code class="sourceCode cpp">strong_ordering</code>, <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code> model <code class="sourceCode cpp">StrictTotallyOrderedWith<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code> ([concepts.stricttotallyordered]).</li>
</ul>

</div>
</blockquote>
<p>Add a new subclause [cmp.result] “spaceship invocation result”:</p>
<div class="add" style="color: #006e28">

<blockquote>
<p>The behavior of a program that adds specializations for the <code class="sourceCode cpp">compare_three_way_result</code> template defined in this subclause is undefined.</p>
</blockquote>
<blockquote>
<p>For the <code class="sourceCode cpp">compare_three_way_result</code> type trait applied to the types <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code>, let <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code> denote lvalues of types <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> and <code class="sourceCode cpp"><span class="kw">const</span> remove_reference_t<span class="op">&lt;</span>U<span class="op">&gt;</span></code>, respectively. If the expression <code class="sourceCode cpp">t <span class="op">&lt;=&gt;</span> u</code> is well-formed when treated as an unevaluated operand ([expr.context]), the member <em>typedef-name</em> <code class="sourceCode cpp">type</code> denotes the type <code class="sourceCode cpp"><span class="kw">decltype</span><span class="op">(</span>t <span class="op">&lt;=&gt;</span> u<span class="op">)</span></code>. Otherwise, there is no member <code class="sourceCode cpp">type</code>.</p>
</blockquote>

</div>
<p>Add a new subclause [cmp.object] “spaceship object”:</p>
<div class="add" style="color: #006e28">

<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> In this subclause, <code><i>BUILTIN_PTR_THREE_WAY</i>(T, U)</code> for types <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code> is a boolean constant expression. <code><i>BUILTIN_PTR_THREE_WAY</i>(T, U)</code> is <code class="sourceCode cpp"><span class="kw">true</span></code> if and only if <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> in the expression <code class="sourceCode cpp">declval<span class="op">&lt;</span>T<span class="op">&gt;()</span> <span class="op">&lt;=&gt;</span> declval<span class="op">&lt;</span>U<span class="op">&gt;()</span></code> resolves to a built-in operator comparing pointers.</p>
<div class="sourceCode" id="cb30"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb30-1"><a href="#cb30-1"></a>struct compare_three_way {</span>
<span id="cb30-2"><a href="#cb30-2"></a>  template&lt;class T, class U&gt;</span>
<span id="cb30-3"><a href="#cb30-3"></a>    requires ThreeWayComparableWith&lt;T, U&gt; || <em>BUILTIN_PTR_THREE_WAY</em>(T, U)</span>
<span id="cb30-4"><a href="#cb30-4"></a>  constexpr auto operator()(T&amp;&amp; t, U&amp;&amp; u) const;</span>
<span id="cb30-5"><a href="#cb30-5"></a>  </span>
<span id="cb30-6"><a href="#cb30-6"></a>  using is_transparent = <em>unspecified</em>;</span>
<span id="cb30-7"><a href="#cb30-7"></a>};</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Expects</em>: If the expression <code class="sourceCode cpp">std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">&lt;=&gt;</span> std<span class="op">::</span>forward<span class="op">&lt;</span>U<span class="op">&gt;(</span>u<span class="op">)</span></code> results in a call to a built-in operator <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> comparing pointers of type <code class="sourceCode cpp">P</code>, the conversion sequences from both <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code> to <code class="sourceCode cpp">P</code> are equality-preserving ([concepts.equality]).</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> If the expression <code class="sourceCode cpp">std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">&lt;=&gt;</span> std<span class="op">::</span>forward<span class="op">&lt;</span>U<span class="op">&gt;(</span>u<span class="op">)</span></code> results in a call to a built-in operator <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> comparing pointers of type <code class="sourceCode cpp">P</code>: returns <code class="sourceCode cpp">strong_ordering<span class="op">::</span>less</code> if (the converted value of) <code class="sourceCode cpp">t</code> precedes <code class="sourceCode cpp">u</code> in the implementation-defined strict total order ([range.cmp]) over pointers of type <code class="sourceCode cpp">P</code>, <code class="sourceCode cpp">strong_ordering<span class="op">::</span>greater</code> if <code class="sourceCode cpp">u</code> precedes <code class="sourceCode cpp">t</code>, and otherwise <code class="sourceCode cpp">strong_ordering<span class="op">::</span>equal</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.2)</a></span> Otherwise, equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">&lt;=&gt;</span> std<span class="op">::</span>forward<span class="op">&lt;</span>U<span class="op">&gt;(</span>u<span class="op">)</span>;</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> In addition to being available via inclusion of the <code class="sourceCode cpp"><span class="op">&lt;</span>compare<span class="op">&gt;</span></code> header, the class <code class="sourceCode cpp">compare_three_way</code> is available when the header <code class="sourceCode cpp"><span class="op">&lt;</span>functional<span class="op">&gt;</span></code> is included.</p>
</blockquote>

</div>
<p>Replace the entirety of 17.11.4 [cmp.alg]. This section had the original design for <code class="sourceCode cpp">strong_order<span class="op">()</span></code>, <code class="sourceCode cpp">weak_order<span class="op">()</span></code>, <code class="sourceCode cpp">partial_order<span class="op">()</span></code>, <code class="sourceCode cpp">strong_equal<span class="op">()</span></code>, and <code class="sourceCode cpp">weak_equal<span class="op">()</span></code>. The new wording makes them CPOs.</p>
<blockquote>
<div class="addu">
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The name <code class="sourceCode cpp">strong_order</code> denotes a customization point object ([customization.point.object]). The expression <code class="sourceCode cpp">strong_order<span class="op">(</span>E, F<span class="op">)</span></code> for some subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> is expression-equivalent ([defns.expression-equivalent]) to the following:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> If the decayed types of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> differ, <code class="sourceCode cpp">strong_order<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> Otherwise, <code class="sourceCode cpp">strong_ordering<span class="op">(</span>strong_order<span class="op">(</span>E, F<span class="op">))</span></code> if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of <code class="sourceCode cpp">std<span class="op">::</span>strong_order</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.3)</a></span> Otherwise, if the decayed type <code class="sourceCode cpp">T</code> of <code class="sourceCode cpp">E</code> is a floating point type, yields a value of type <code class="sourceCode cpp">strong_ordering</code> that is consistent with the ordering observed by <code class="sourceCode cpp">T</code>’s comparison operators, and if <code class="sourceCode cpp">numeric_limits<span class="op">&lt;</span>T<span class="op">&gt;::</span>is_iec559</code> is <code class="sourceCode cpp"><span class="kw">true</span></code> is additionally consistent with the <code class="sourceCode cpp">totalOrder</code> operation as specified in ISO/IEC/IEEE 60599.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.4)</a></span> Otherwise, <code class="sourceCode cpp">strong_ordering<span class="op">(</span>E <span class="op">&lt;=&gt;</span> F<span class="op">)</span></code> if it is a well-formed expression.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.5)</a></span> Otherwise, <code class="sourceCode cpp">strong_order<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed. [<em>Note</em>: This case can result in substitution failure when <code class="sourceCode cpp">strong_order<span class="op">(</span>E, F<span class="op">)</span></code> appears in the immediate context of a template instantiation. —<em>end note</em>]</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The name <code class="sourceCode cpp">weak_order</code> denotes a customization point object ([customization.point.object]). The expression <code class="sourceCode cpp">weak_order<span class="op">(</span>E, F<span class="op">)</span></code> for some subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> is expression-equivalent ([defns.expression-equivalent]) to the following:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> If the decayed types of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> differ, <code class="sourceCode cpp">weak_order<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> Otherwise, <code class="sourceCode cpp">weak_ordering<span class="op">(</span>weak_order<span class="op">(</span>E, F<span class="op">))</span></code> if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of <code class="sourceCode cpp">std<span class="op">::</span>weak_order</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3)</a></span> Otherwise, if the decayed type <code class="sourceCode cpp">T</code> of <code class="sourceCode cpp">E</code> is a floating point type, yields a value of type <code class="sourceCode cpp">weak_ordering</code> that is consistent with the ordering observed by <code class="sourceCode cpp">T</code>’s comparison operators and <code class="sourceCode cpp">strong_order</code>, and if <code class="sourceCode cpp">numeric_limits<span class="op">&lt;</span>T<span class="op">&gt;::</span>is_iec559</code> is <code class="sourceCode cpp"><span class="kw">true</span></code> is additionally consistent with the following equivalence classes, ordered from lesser to greater:
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.1)</a></span> Together, all negative NaN values</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.2)</a></span> Negative infinity</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.3)</a></span> Each normal negative value</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.4)</a></span> Each subnormal negative value</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.5)</a></span> Together, both zero values</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.6)</a></span> Each subnormal positive value</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.7)</a></span> Each normal positive value</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.8)</a></span> Positive infinity</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.3.9)</a></span> Together, all positive NaN values</li>
</ul></li>
<li><span class="marginalizedparent"><a class="marginalized">(2.4)</a></span> Otherwise, <code class="sourceCode cpp">weak_ordering<span class="op">(</span>E <span class="op">&lt;=&gt;</span> F<span class="op">)</span></code> if it is a well-formed expression.<br />
</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5)</a></span> Otherwise, <code class="sourceCode cpp">weak_ordering<span class="op">(</span>strong_order<span class="op">(</span>E, F<span class="op">))</span></code> if it is a well-formed expression.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.6)</a></span> Otherwise, <code class="sourceCode cpp">weak_order<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed. [<em>Note</em>: This case can result in substitution failure when <code class="sourceCode cpp">std<span class="op">::</span>weak_order<span class="op">(</span>E, F<span class="op">)</span></code> appears in the immediate context of a template instantiation. —<em>end note</em>]</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> The name <code class="sourceCode cpp">partial_order</code> denotes a customization point object ([customization.point.object]). The expression <code class="sourceCode cpp">partial_order<span class="op">(</span>E, F<span class="op">)</span></code> for some subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> is expression-equivalent ([defns.expression-equivalent]) to the following:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> If the decayed types of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> differ, <code class="sourceCode cpp">partial_order<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.2)</a></span> Otherwise, <code class="sourceCode cpp">partial_ordering<span class="op">(</span>partial_order<span class="op">(</span>E, F<span class="op">))</span></code> if it is a well-formed expression with overload resolution performed in a context that does not include a declaration of <code class="sourceCode cpp">std<span class="op">::</span>partial_order</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3)</a></span> Otherwise, <code class="sourceCode cpp">partial_ordering<span class="op">(</span>E <span class="op">&lt;=&gt;</span> F<span class="op">)</span></code> if it is a well-formed expression.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.4)</a></span> Otherwise, <code class="sourceCode cpp">partial_ordering<span class="op">(</span>weak_order<span class="op">(</span>E, F<span class="op">))</span></code> if it is a well-formed expression.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.5)</a></span> Otherwise, <code class="sourceCode cpp">partial_order<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed. [<em>Note</em>: This case can result in substitution failure when <code class="sourceCode cpp">std<span class="op">::</span>partial_order<span class="op">(</span>E, F<span class="op">)</span></code> appears in the immediate context of a template instantiation. —<em>end note</em>]</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> The name <code class="sourceCode cpp">compare_strong_order_fallback</code> denotes a customization point object ([customization.point.object]). The expression <code class="sourceCode cpp">compare_strong_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> for some subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> is expression-equivalent ([defns.expression-equivalent]) to:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> If the decayed types of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> differ, <code class="sourceCode cpp">compare_strong_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> Otherwise, <code class="sourceCode cpp">strong_order<span class="op">(</span>E, F<span class="op">)</span></code> if it is a well-formed expression.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.3)</a></span> Otherwise, if the expressions <code class="sourceCode cpp">E <span class="op">==</span> F</code> and <code class="sourceCode cpp">E <span class="op">&lt;</span> F</code> are both well-formed and convertible to bool,</p>
<blockquote>
<div class="sourceCode" id="cb31"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb31-1"><a href="#cb31-1"></a>E == F ? strong_ordering::equal :</span>
<span id="cb31-2"><a href="#cb31-2"></a>E &lt; F  ? strong_ordering::less :</span>
<span id="cb31-3"><a href="#cb31-3"></a>         strong_ordering::greater</span></code></pre></div>
</blockquote>
<p>except that <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> are only evaluated once.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.4)</a></span> Otherwise, <code class="sourceCode cpp">compare_strong_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</p></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> The name <code class="sourceCode cpp">compare_weak_order_fallback</code> denotes a customization point object ([customization.point.object]). The expression <code class="sourceCode cpp">compare_weak_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> for some subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> is expression-equivalent ([defns.expression-equivalent]) to:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.1)</a></span> If the decayed types of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> differ, <code class="sourceCode cpp">compare_weak_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.2)</a></span> Otherwise, <code class="sourceCode cpp">weak_order<span class="op">(</span>E, F<span class="op">)</span></code> if it is a well-formed expression.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.3)</a></span> Otherwise, if the expressions <code class="sourceCode cpp">E <span class="op">==</span> F</code> and <code class="sourceCode cpp">E <span class="op">&lt;</span> F</code> are both well-formed and convertible to bool,</p>
<blockquote>
<div class="sourceCode" id="cb32"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb32-1"><a href="#cb32-1"></a>E == F ? weak_ordering::equal :</span>
<span id="cb32-2"><a href="#cb32-2"></a>E &lt; F  ? weak_ordering::less :</span>
<span id="cb32-3"><a href="#cb32-3"></a>         weak_ordering::greater</span></code></pre></div>
</blockquote>
<p>except that <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> are only evaluated once.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.4)</a></span> Otherwise, <code class="sourceCode cpp">compare_weak_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</p></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> The name <code class="sourceCode cpp">compare_partial_order_fallback</code> denotes a customization point object ([customization.point.object]). The expression <code class="sourceCode cpp">compare_partial_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> for some subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> is expression-equivalent ([defns.expression-equivalent]) to:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.1)</a></span> If the decayed types of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> differ, <code class="sourceCode cpp">compare_partial_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.2)</a></span> Otherwise, <code class="sourceCode cpp">partial_order<span class="op">(</span>E, F<span class="op">)</span></code> if it is a well-formed expression.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.3)</a></span> Otherwise, if the expressions <code class="sourceCode cpp">E <span class="op">==</span> F</code> and <code class="sourceCode cpp">E <span class="op">&lt;</span> F</code> are both well-formed and convertible to bool,</p>
<blockquote>
<div class="sourceCode" id="cb33"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb33-1"><a href="#cb33-1"></a>E == F ? partial_ordering::equivalent :</span>
<span id="cb33-2"><a href="#cb33-2"></a>E &lt; F  ? partial_ordering::less :</span>
<span id="cb33-3"><a href="#cb33-3"></a>F &lt; E  ? partial_ordering::greater :</span>
<span id="cb33-4"><a href="#cb33-4"></a>       partial_ordering::unordered</span></code></pre></div>
</blockquote>
<p>except that <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> are only evaluated once.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.4)</a></span> Otherwise, <code class="sourceCode cpp">compare_partial_order_fallback<span class="op">(</span>E, F<span class="op">)</span></code> is ill-formed.</p></li>
</ul>
</div>
</blockquote>
<p>Change 17.13.1 [coroutine.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb34"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb34-1"><a href="#cb34-1"></a>namespace std {</span>
<span id="cb34-2"><a href="#cb34-2"></a>  [...]</span>
<span id="cb34-3"><a href="#cb34-3"></a>  // 17.13.5 noop coroutine</span>
<span id="cb34-4"><a href="#cb34-4"></a>  noop_coroutine_handle noop_coroutine() noexcept;</span>
<span id="cb34-5"><a href="#cb34-5"></a></span>
<span id="cb34-6"><a href="#cb34-6"></a>  // 17.13.3.6 comparison operators:</span>
<span id="cb34-7"><a href="#cb34-7"></a>  constexpr bool operator==(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span>
<span id="cb34-8"><a href="#cb34-8"></a><span class="st">- constexpr bool operator!=(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></span>
<span id="cb34-9"><a href="#cb34-9"></a><span class="st">- constexpr bool operator&lt;(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></span>
<span id="cb34-10"><a href="#cb34-10"></a><span class="st">- constexpr bool operator&gt;(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></span>
<span id="cb34-11"><a href="#cb34-11"></a><span class="st">- constexpr bool operator&lt;=(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></span>
<span id="cb34-12"><a href="#cb34-12"></a><span class="st">- constexpr bool operator&gt;=(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></span>
<span id="cb34-13"><a href="#cb34-13"></a><span class="va">+ constexpr strong_ordering operator&lt;=&gt;(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></span>
<span id="cb34-14"><a href="#cb34-14"></a></span>
<span id="cb34-15"><a href="#cb34-15"></a>  // 17.13.6 trivial awaitables</span>
<span id="cb34-16"><a href="#cb34-16"></a>  [...]</span>
<span id="cb34-17"><a href="#cb34-17"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Replace the <code class="sourceCode cpp"><span class="op">&lt;</span></code> in 17.13.3.6 [coroutine.handle.compare] with the new <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>:</p>
<blockquote>
<div class="sourceCode" id="cb35"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb35-1"><a href="#cb35-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>coroutine_handle<span class="op">&lt;&gt;</span> x, coroutine_handle<span class="op">&lt;&gt;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>address<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>address<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb36"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb36-1"><a href="#cb36-1"></a>constexpr bool operator&lt;(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">less<span class="op">&lt;&gt;()(</span>x<span class="op">.</span>address<span class="op">()</span>, y<span class="op">.</span>address<span class="op">())</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb37"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb37-1"><a href="#cb37-1"></a>constexpr strong_ordering operator&lt;=&gt;(coroutine_handle&lt;&gt; x, coroutine_handle&lt;&gt; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">compare_three_way<span class="op">()(</span>x<span class="op">.</span>address<span class="op">()</span>, y<span class="op">.</span>address<span class="op">())</span></code>.</p>
</div>
</blockquote>
<h2 id="clause-18-concepts-library"><span class="header-section-number">5.3</span> Clause 18: Concepts Library<a href="#clause-18-concepts-library" class="self-link"></a></h2>
<p>No changes.</p>
<h2 id="clause-19-diagnostics-library"><span class="header-section-number">5.4</span> Clause 19: Diagnostics Library<a href="#clause-19-diagnostics-library" class="self-link"></a></h2>
<p>Changed operators for: <code class="sourceCode cpp">error_category</code>, <code class="sourceCode cpp">error_code</code>, and <code class="sourceCode cpp">error_condition</code></p>
<p>Change 19.5.1 [system.error.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb38"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb38-1"><a href="#cb38-1"></a>namespace std {</span>
<span id="cb38-2"><a href="#cb38-2"></a>  [...]</span>
<span id="cb38-3"><a href="#cb38-3"></a>  // [syserr.compare], comparison functions</span>
<span id="cb38-4"><a href="#cb38-4"></a>  bool operator==(const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span>
<span id="cb38-5"><a href="#cb38-5"></a>  bool operator==(const error_code&amp; lhs, const error_condition&amp; rhs) noexcept;</span>
<span id="cb38-6"><a href="#cb38-6"></a><span class="st">- bool operator==(const error_condition&amp; lhs, const error_code&amp; rhs) noexcept;</span></span>
<span id="cb38-7"><a href="#cb38-7"></a>  bool operator==(const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span>
<span id="cb38-8"><a href="#cb38-8"></a><span class="st">- bool operator!=(const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span></span>
<span id="cb38-9"><a href="#cb38-9"></a><span class="st">- bool operator!=(const error_code&amp; lhs, const error_condition&amp; rhs) noexcept;</span></span>
<span id="cb38-10"><a href="#cb38-10"></a><span class="st">- bool operator!=(const error_condition&amp; lhs, const error_code&amp; rhs) noexcept;</span></span>
<span id="cb38-11"><a href="#cb38-11"></a><span class="st">- bool operator!=(const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span></span>
<span id="cb38-12"><a href="#cb38-12"></a><span class="st">- bool operator&lt; (const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span></span>
<span id="cb38-13"><a href="#cb38-13"></a><span class="st">- bool operator&lt; (const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span></span>
<span id="cb38-14"><a href="#cb38-14"></a><span class="va">+ strong_ordering operator&lt;=&gt;(const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span></span>
<span id="cb38-15"><a href="#cb38-15"></a><span class="va">+ strong_ordering operator&lt;=&gt;(const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span></span>
<span id="cb38-16"><a href="#cb38-16"></a>  [...]  </span>
<span id="cb38-17"><a href="#cb38-17"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 19.5.2.1 [syserr.errcat.overview]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb39"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb39-1"><a href="#cb39-1"></a>namespace std {</span>
<span id="cb39-2"><a href="#cb39-2"></a>  class error_category {</span>
<span id="cb39-3"><a href="#cb39-3"></a>  public:</span>
<span id="cb39-4"><a href="#cb39-4"></a>    [...]</span>
<span id="cb39-5"><a href="#cb39-5"></a></span>
<span id="cb39-6"><a href="#cb39-6"></a>    bool operator==(const error_category&amp; rhs) const noexcept;</span>
<span id="cb39-7"><a href="#cb39-7"></a><span class="st">-   bool operator!=(const error_category&amp; rhs) const noexcept;</span></span>
<span id="cb39-8"><a href="#cb39-8"></a><span class="st">-   bool operator&lt; (const error_category&amp; rhs) const noexcept;</span></span>
<span id="cb39-9"><a href="#cb39-9"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const error_category&amp; rhs) const noexcept;</span></span>
<span id="cb39-10"><a href="#cb39-10"></a>  };</span>
<span id="cb39-11"><a href="#cb39-11"></a></span>
<span id="cb39-12"><a href="#cb39-12"></a>  const error_category&amp; generic_category() noexcept;</span>
<span id="cb39-13"><a href="#cb39-13"></a>  const error_category&amp; system_category() noexcept;</span>
<span id="cb39-14"><a href="#cb39-14"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 19.5.2.3 [syserr.errcat.nonvirtuals]:</p>
<blockquote>
<div class="sourceCode" id="cb40"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb40-1"><a href="#cb40-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> error_category<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">this</span> <span class="op">==</span> <span class="op">&amp;</span>rhs</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb41"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb41-1"><a href="#cb41-1"></a>bool operator!=(const error_category&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb42"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb42-1"><a href="#cb42-1"></a>bool operator&lt;(const error_category&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">less<span class="op">&lt;</span><span class="kw">const</span> error_category<span class="op">*&gt;()(</span><span class="kw">this</span>, <span class="op">&amp;</span>rhs<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb43"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb43-1"><a href="#cb43-1"></a>strong_ordering operator&lt;=&gt;(const error_category&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">compare_three_way<span class="op">()(</span><span class="kw">this</span>, <span class="op">&amp;</span>rhs<span class="op">)</span></code>.</p>
</div>
<p>[<em>Note</em>: <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">less</code></span></del></span> <span class="addu"><code class="sourceCode cpp">compare_three_way</code> ([cmp.object])</span> provides a total ordering for pointers. —<em>end note</em>]</p>
</blockquote>
<p>Change 19.5.5 [syserr.compare]:</p>
<blockquote>
<div class="sourceCode" id="cb44"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb44-1"><a href="#cb44-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> error_code<span class="op">&amp;</span> lhs, <span class="kw">const</span> error_code<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>category<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>category<span class="op">()</span> <span class="op">&amp;&amp;</span> lhs<span class="op">.</span>value<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>value<span class="op">()</span></code></p>
<div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> error_code<span class="op">&amp;</span> lhs, <span class="kw">const</span> error_condition<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>category<span class="op">().</span>equivalent<span class="op">(</span>lhs<span class="op">.</span>value<span class="op">()</span>, rhs<span class="op">)</span> <span class="op">||</span> rhs<span class="op">.</span>category<span class="op">().</span>equivalent<span class="op">(</span>lhs, rhs<span class="op">.</span>value<span class="op">())</span></code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb46"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb46-1"><a href="#cb46-1"></a>bool operator==(const error_condition&amp; lhs, const error_code&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs<span class="op">.</span>category<span class="op">().</span>equivalent<span class="op">(</span>rhs<span class="op">.</span>value<span class="op">()</span>, lhs<span class="op">)</span> <span class="op">||</span> lhs<span class="op">.</span>category<span class="op">().</span>equivalent<span class="op">(</span>rhs, lhs<span class="op">.</span>value<span class="op">())</span></code></p>
</div>
<div class="sourceCode" id="cb47"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb47-1"><a href="#cb47-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> error_condition<span class="op">&amp;</span> lhs, <span class="kw">const</span> error_condition<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>category<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>category<span class="op">()</span> <span class="op">&amp;&amp;</span> lhs<span class="op">.</span>value<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>value<span class="op">()</span></code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb48"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb48-1"><a href="#cb48-1"></a>bool operator!=(const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span>
<span id="cb48-2"><a href="#cb48-2"></a>bool operator!=(const error_code&amp; lhs, const error_condition&amp; rhs) noexcept;</span>
<span id="cb48-3"><a href="#cb48-3"></a>bool operator!=(const error_condition&amp; lhs, const error_code&amp; rhs) noexcept;</span>
<span id="cb48-4"><a href="#cb48-4"></a>bool operator!=(const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb49"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb49-1"><a href="#cb49-1"></a>bool operator&lt;(const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>category<span class="op">()</span> <span class="op">&lt;</span> rhs<span class="op">.</span>category<span class="op">()</span> <span class="op">||</span> <span class="op">(</span>lhs<span class="op">.</span>category<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>category<span class="op">()</span> <span class="op">&amp;&amp;</span> lhs<span class="op">.</span>value<span class="op">()</span> <span class="op">&lt;</span> rhs<span class="op">.</span>value<span class="op">())</span></code></p>
<div class="sourceCode" id="cb50"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb50-1"><a href="#cb50-1"></a>bool operator&lt;(const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>category<span class="op">()</span> <span class="op">&lt;</span> rhs<span class="op">.</span>category<span class="op">()</span> <span class="op">||</span> <span class="op">(</span>lhs<span class="op">.</span>category<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>category<span class="op">()</span> <span class="op">&amp;&amp;</span> lhs<span class="op">.</span>value<span class="op">()</span> <span class="op">&lt;</span> rhs<span class="op">.</span>value<span class="op">())</span></code></p>
</div>
<div class="addu">
<div class="sourceCode" id="cb51"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb51-1"><a href="#cb51-1"></a>strong_ordering operator&lt;=&gt;(const error_code&amp; lhs, const error_code&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb52"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb52-1"><a href="#cb52-1"></a>if (auto c = lhs.category() &lt;=&gt; rhs.category(); c != 0) return c;</span>
<span id="cb52-2"><a href="#cb52-2"></a>return lhs.value() &lt;=&gt; rhs.value();</span></code></pre></div>
</blockquote>
<div class="sourceCode" id="cb53"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb53-1"><a href="#cb53-1"></a>strong_ordering operator&lt;=&gt;(const error_condition&amp; lhs, const error_condition&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb54"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb54-1"><a href="#cb54-1"></a>if (auto c = lhs.category() &lt;=&gt; rhs.category(); c != 0) return c;</span>
<span id="cb54-2"><a href="#cb54-2"></a>return lhs.value() &lt;=&gt; rhs.value();</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<h2 id="clause-20-general-utilities-library"><span class="header-section-number">5.5</span> Clause 20: General utilities library<a href="#clause-20-general-utilities-library" class="self-link"></a></h2>
<p>Changed operators for: <code class="sourceCode cpp">pair</code>, <code class="sourceCode cpp">tuple</code>, <code class="sourceCode cpp">optional</code>, <code class="sourceCode cpp">variant</code>, <code class="sourceCode cpp">monostate</code>, <code class="sourceCode cpp">bitset</code>, <code class="sourceCode cpp">allocator</code>, <code class="sourceCode cpp">unique_ptr</code>, <code class="sourceCode cpp">shared_ptr</code>, <code class="sourceCode cpp">memory_resource</code> <code class="sourceCode cpp">polymorphic_allocator</code>, <code class="sourceCode cpp">scoped_allocator_adaptor</code>, <code class="sourceCode cpp">function</code>, <code class="sourceCode cpp">type_index</code>.</p>
<p>Change 20.2.1 [utility.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb55"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb55-1"><a href="#cb55-1"></a>#include &lt;initializer_list&gt;     // see [initializer.list.syn]</span>
<span id="cb55-2"><a href="#cb55-2"></a></span>
<span id="cb55-3"><a href="#cb55-3"></a>namespace std {</span>
<span id="cb55-4"><a href="#cb55-4"></a>  [...]</span>
<span id="cb55-5"><a href="#cb55-5"></a></span>
<span id="cb55-6"><a href="#cb55-6"></a>  // [pairs], class template pair</span>
<span id="cb55-7"><a href="#cb55-7"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb55-8"><a href="#cb55-8"></a>    struct pair;</span>
<span id="cb55-9"><a href="#cb55-9"></a>  </span>
<span id="cb55-10"><a href="#cb55-10"></a><span class="st">- // [pairs.spec], pair specialized algorithms</span></span>
<span id="cb55-11"><a href="#cb55-11"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb55-12"><a href="#cb55-12"></a><span class="st">-   constexpr bool operator==(const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span></span>
<span id="cb55-13"><a href="#cb55-13"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb55-14"><a href="#cb55-14"></a><span class="st">-   constexpr bool operator!=(const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span></span>
<span id="cb55-15"><a href="#cb55-15"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb55-16"><a href="#cb55-16"></a><span class="st">-   constexpr bool operator&lt; (const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span></span>
<span id="cb55-17"><a href="#cb55-17"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb55-18"><a href="#cb55-18"></a><span class="st">-   constexpr bool operator&gt; (const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span></span>
<span id="cb55-19"><a href="#cb55-19"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb55-20"><a href="#cb55-20"></a><span class="st">-   constexpr bool operator&lt;=(const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span></span>
<span id="cb55-21"><a href="#cb55-21"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb55-22"><a href="#cb55-22"></a><span class="st">-   constexpr bool operator&gt;=(const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);  </span></span>
<span id="cb55-23"><a href="#cb55-23"></a></span>
<span id="cb55-24"><a href="#cb55-24"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb55-25"><a href="#cb55-25"></a>    constexpr void swap(pair&lt;T1, T2&gt;&amp; x, pair&lt;T1, T2&gt;&amp; y) noexcept(noexcept(x.swap(y)));</span>
<span id="cb55-26"><a href="#cb55-26"></a></span>
<span id="cb55-27"><a href="#cb55-27"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb55-28"><a href="#cb55-28"></a>    constexpr <em>see below</em> make_pair(T1&amp;&amp;, T2&amp;&amp;);</span>
<span id="cb55-29"><a href="#cb55-29"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.4.2 [pairs.pair]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb56"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb56-1"><a href="#cb56-1"></a>namespace std {</span>
<span id="cb56-2"><a href="#cb56-2"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb56-3"><a href="#cb56-3"></a>  struct pair {</span>
<span id="cb56-4"><a href="#cb56-4"></a>    using first_type  = T1;</span>
<span id="cb56-5"><a href="#cb56-5"></a>    using second_type = T2;</span>
<span id="cb56-6"><a href="#cb56-6"></a></span>
<span id="cb56-7"><a href="#cb56-7"></a>    T1 first;</span>
<span id="cb56-8"><a href="#cb56-8"></a>    T2 second;</span>
<span id="cb56-9"><a href="#cb56-9"></a></span>
<span id="cb56-10"><a href="#cb56-10"></a>    [...]</span>
<span id="cb56-11"><a href="#cb56-11"></a></span>
<span id="cb56-12"><a href="#cb56-12"></a>    constexpr void swap(pair&amp; p) noexcept(<em>see below</em>);</span>
<span id="cb56-13"><a href="#cb56-13"></a>    </span>
<span id="cb56-14"><a href="#cb56-14"></a><span class="va">+   // 20.4.3, pair specialized algorithms</span></span>
<span id="cb56-15"><a href="#cb56-15"></a><span class="va">+   friend constexpr bool operator==(const pair&amp;, const pair&amp;) = default;</span></span>
<span id="cb56-16"><a href="#cb56-16"></a><span class="va">+   friend constexpr bool operator==(const pair&amp; x, const pair&amp; y)</span></span>
<span id="cb56-17"><a href="#cb56-17"></a><span class="va">+       requires (is_reference_v&lt;T1&gt; || is_reference_v&lt;T2&gt;)</span></span>
<span id="cb56-18"><a href="#cb56-18"></a><span class="va">+     { return x.first == y.first &amp;&amp; x.second == y.second; }</span></span>
<span id="cb56-19"><a href="#cb56-19"></a><span class="va">+   friend constexpr common_comparison_category_t&lt;<em>synth-three-way-result</em>&lt;T1&gt;, <em>synth-three-way-result</em>&lt;T2&gt;&gt;</span></span>
<span id="cb56-20"><a href="#cb56-20"></a><span class="va">+     operator&lt;=&gt;(const pair&amp; x, const pair&amp; y)</span></span>
<span id="cb56-21"><a href="#cb56-21"></a><span class="va">+     { <em>see below</em> }</span></span>
<span id="cb56-22"><a href="#cb56-22"></a>  };</span>
<span id="cb56-23"><a href="#cb56-23"></a></span>
<span id="cb56-24"><a href="#cb56-24"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb56-25"><a href="#cb56-25"></a>    pair(T1, T2) -&gt; pair&lt;T1, T2&gt;;</span>
<span id="cb56-26"><a href="#cb56-26"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.4.3 [pairs.spec]:</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb57"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb57-1"><a href="#cb57-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb57-2"><a href="#cb57-2"></a>  constexpr bool operator==(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>first <span class="op">==</span> y<span class="op">.</span>first <span class="op">&amp;&amp;</span> x<span class="op">.</span>second <span class="op">==</span> y<span class="op">.</span>second</code>.</p>
<div class="sourceCode" id="cb58"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb58-1"><a href="#cb58-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb58-2"><a href="#cb58-2"></a>  constexpr bool operator!=(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb59"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb59-1"><a href="#cb59-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb59-2"><a href="#cb59-2"></a>  constexpr bool operator&lt;(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>first <span class="op">&lt;</span> y<span class="op">.</span>first <span class="op">||</span> <span class="op">(!(</span>y<span class="op">.</span>first <span class="op">&lt;</span> x<span class="op">.</span>first<span class="op">)</span> <span class="op">&amp;&amp;</span> x<span class="op">.</span>second <span class="op">&lt;</span> y<span class="op">.</span>second<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb60"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb60-1"><a href="#cb60-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb60-2"><a href="#cb60-2"></a>  constexpr bool operator&gt;(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">y <span class="op">&lt;</span> x</code>.</p>
<div class="sourceCode" id="cb61"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb61-1"><a href="#cb61-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb61-2"><a href="#cb61-2"></a>  constexpr bool operator&lt;=(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb62"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb62-1"><a href="#cb62-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb62-2"><a href="#cb62-2"></a>  constexpr bool operator&gt;=(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb63"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb63-1"><a href="#cb63-1"></a>friend constexpr</span>
<span id="cb63-2"><a href="#cb63-2"></a>  common_comparison_category_t&lt;<em>synth-three-way-result</em>&lt;T1&gt;, <em>synth-three-way-result</em>&lt;T2&gt;&gt;</span>
<span id="cb63-3"><a href="#cb63-3"></a>    operator&lt;=&gt;(const pair&amp; x, const pair&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb64"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb64-1"><a href="#cb64-1"></a>if (auto c = <em>synth-three-way</em>(x.first, y.first); c != 0) return c;</span>
<span id="cb64-2"><a href="#cb64-2"></a>return <em>synth-three-way</em>(x.second, y.second);</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<p>Change 20.5.3 [tuple.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb65"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb65-1"><a href="#cb65-1"></a>namespace std {</span>
<span id="cb65-2"><a href="#cb65-2"></a>  // [tuple.tuple], class template tuple</span>
<span id="cb65-3"><a href="#cb65-3"></a>  template&lt;class... Types&gt;</span>
<span id="cb65-4"><a href="#cb65-4"></a>    class tuple;</span>
<span id="cb65-5"><a href="#cb65-5"></a></span>
<span id="cb65-6"><a href="#cb65-6"></a>  [...]</span>
<span id="cb65-7"><a href="#cb65-7"></a>  </span>
<span id="cb65-8"><a href="#cb65-8"></a>  // [tuple.rel], relational operators</span>
<span id="cb65-9"><a href="#cb65-9"></a>  template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb65-10"><a href="#cb65-10"></a>    constexpr bool operator==(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span>
<span id="cb65-11"><a href="#cb65-11"></a><span class="st">- template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb65-12"><a href="#cb65-12"></a><span class="st">-   constexpr bool operator!=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb65-13"><a href="#cb65-13"></a><span class="st">- template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb65-14"><a href="#cb65-14"></a><span class="st">-   constexpr bool operator&lt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb65-15"><a href="#cb65-15"></a><span class="st">- template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb65-16"><a href="#cb65-16"></a><span class="st">-   constexpr bool operator&gt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb65-17"><a href="#cb65-17"></a><span class="st">- template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb65-18"><a href="#cb65-18"></a><span class="st">-   constexpr bool operator&lt;=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb65-19"><a href="#cb65-19"></a><span class="st">- template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb65-20"><a href="#cb65-20"></a><span class="st">-   constexpr bool operator&gt;=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb65-21"><a href="#cb65-21"></a><span class="va">+ template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb65-22"><a href="#cb65-22"></a><span class="va">+   constexpr common_comparison_category_t&lt;<em>synth-three-way-result</em>&lt;TTypes, UTypes&gt;...&gt;</span></span>
<span id="cb65-23"><a href="#cb65-23"></a><span class="va">+     operator&lt;=&gt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb65-24"><a href="#cb65-24"></a></span>
<span id="cb65-25"><a href="#cb65-25"></a>  [...]</span>
<span id="cb65-26"><a href="#cb65-26"></a>}  </span></code></pre></div>
</div>
</blockquote>
<p>Change 20.5.3.8 [tuple.rel]:</p>
<blockquote>
<div class="sourceCode" id="cb66"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb66-1"><a href="#cb66-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> TTypes, <span class="kw">class</span><span class="op">...</span> UTypes<span class="op">&gt;</span></span>
<span id="cb66-2"><a href="#cb66-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> tuple<span class="op">&lt;</span>TTypes<span class="op">...&gt;&amp;</span> t, <span class="kw">const</span> tuple<span class="op">&lt;</span>UTypes<span class="op">...&gt;&amp;</span> u<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Requires</em>: For all <code class="sourceCode cpp">i</code>, where <code class="sourceCode cpp"><span class="dv">0</span> <span class="op">&lt;=</span> i</code> and <code class="sourceCode cpp">i <span class="op">&lt;</span> <span class="kw">sizeof</span><span class="op">...(</span>TTypes<span class="op">)</span></code>, <code class="sourceCode cpp">get<span class="op">&lt;</span>i<span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">==</span> get<span class="op">&lt;</span>i<span class="op">&gt;(</span>u<span class="op">)</span></code> is a valid expression returning a type that is convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>. <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>TTypes<span class="op">)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">...(</span>UTypes<span class="op">)</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">get<span class="op">&lt;</span>i<span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">==</span> get<span class="op">&lt;</span>i<span class="op">&gt;(</span>u<span class="op">)</span></code> for all <code class="sourceCode cpp">i</code>, otherwise <code class="sourceCode cpp"><span class="kw">false</span></code>. For any two zero-length tuples <code class="sourceCode cpp">e</code> and <code class="sourceCode cpp">f</code>, <code class="sourceCode cpp">e <span class="op">==</span> f</code> returns <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: The elementary comparisons are performed in order from the zeroth index upwards. No comparisons or element accesses are performed after the first equality comparison that evaluates to <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb67"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb67-1"><a href="#cb67-1"></a>template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb67-2"><a href="#cb67-2"></a>  constexpr bool operator!=(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>t <span class="op">==</span> u<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb68"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb68-1"><a href="#cb68-1"></a>template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb68-2"><a href="#cb68-2"></a>  constexpr bool operator&lt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Requires</em>: For all <code class="sourceCode cpp">i</code>, where <code class="sourceCode cpp"><span class="dv">0</span> <span class="op">&lt;=</span> i</code> and <code class="sourceCode cpp">i <span class="op">&lt;</span> <span class="kw">sizeof</span><span class="op">...(</span>TTypes<span class="op">)</span></code>, both <code class="sourceCode cpp">get<span class="op">&lt;</span>i<span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">&lt;</span> get<span class="op">&lt;</span>i<span class="op">&gt;(</span>u<span class="op">)</span></code> and <code class="sourceCode cpp">get<span class="op">&lt;</span>i<span class="op">&gt;(</span>u<span class="op">)</span> <span class="op">&lt;</span> get<span class="op">&lt;</span>i<span class="op">&gt;(</span>t<span class="op">)</span></code> are valid expressions returning types that are convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>. <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>TTypes<span class="op">)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">...(</span>UTypes<span class="op">)</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: The result of a lexicographical comparison between <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code>. The result is defined as: <code class="sourceCode cpp"><span class="op">(</span><span class="dt">bool</span><span class="op">)(</span>get<span class="op">&lt;</span><span class="dv">0</span><span class="op">&gt;(</span>t<span class="op">)</span> <span class="op">&lt;</span> get<span class="op">&lt;</span><span class="dv">0</span><span class="op">&gt;(</span>u<span class="op">))</span> <span class="op">||</span> <span class="op">(!(</span><span class="dt">bool</span><span class="op">)(</span>get<span class="op">&lt;</span><span class="dv">0</span><span class="op">&gt;(</span>u<span class="op">)</span> <span class="op">&lt;</span> get<span class="op">&lt;</span><span class="dv">0</span><span class="op">&gt;(</span>t<span class="op">))</span> <span class="op">&amp;&amp;</span></code><code>t<sub>tail</sub> &lt; u<sub>tail</sub></code><code class="sourceCode cpp"><span class="op">)</span></code>, where <code>r<sub>tail</sub></code> for some tuple <code class="sourceCode cpp">r</code> is a tuple containing all but the first element of <code class="sourceCode cpp">r</code>. For any two zero-length tuples <code class="sourceCode cpp">e</code> and <code class="sourceCode cpp">f</code>, <code class="sourceCode cpp">e <span class="op">&lt;</span> f</code> returns <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
<div class="sourceCode" id="cb69"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb69-1"><a href="#cb69-1"></a>template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb69-2"><a href="#cb69-2"></a>  constexpr bool operator&gt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">u <span class="op">&lt;</span> t</code>.</p>
<div class="sourceCode" id="cb70"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb70-1"><a href="#cb70-1"></a>template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb70-2"><a href="#cb70-2"></a>  constexpr bool operator&lt;=(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>u <span class="op">&lt;</span> t<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb71"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb71-1"><a href="#cb71-1"></a>template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb71-2"><a href="#cb71-2"></a>  constexpr bool operator&gt;=(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>t <span class="op">&lt;</span> u<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb72"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb72-1"><a href="#cb72-1"></a>template&lt;class... TTypes, class... UTypes&gt;</span>
<span id="cb72-2"><a href="#cb72-2"></a>  constexpr common_comparison_category_t&lt;<em>synth-three-way-result</em>&lt;TTypes, UTypes&gt;...&gt;</span>
<span id="cb72-3"><a href="#cb72-3"></a>    operator&lt;=&gt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Performs a lexicographical comparison between <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code>. For any two zero-length tuples <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code>, <code class="sourceCode cpp">t <span class="op">&lt;=&gt;</span> u</code> returns <code class="sourceCode cpp">strong_ordering<span class="op">::</span>equal</code>. Otherwise, equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb73"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb73-1"><a href="#cb73-1"></a>if (auto c = <em>synth-three-way</em>(get&lt;0&gt;(t), get&lt;0&gt;(u)); c != 0) return c;</span>
<span id="cb73-2"><a href="#cb73-2"></a>return t<sub>tail</sub> &lt;=&gt; u<sub>tail</sub>;</span></code></pre></div>
</blockquote>
<p>where <code>r<sub>tail</sub></code> for some tuple <code class="sourceCode cpp">r</code> is a tuple containing all but the first element of <code class="sourceCode cpp">r</code>.</p>
</div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> [<em>Note</em>: The above <span class="rm" style="color: #bf0303"><del>definitions for comparison functions do not require</del></span> <span class="addu">definition does not require</span> <code>t<sub>tail</sub></code> (or <code>u<sub>tail</sub></code>) to be constructed. It may not even be possible, as <code class="sourceCode cpp">t</code> and <code class="sourceCode cpp">u</code> are not required to be copy constructible. Also, all comparison functions are short circuited; they do not perform element accesses beyond what is required to determine the result of the comparison. —<em>end note</em>]</p>
</blockquote>
<p>Change 20.6.2 [optional.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb74"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb74-1"><a href="#cb74-1"></a>namespace std {</span>
<span id="cb74-2"><a href="#cb74-2"></a>  // [optional.optional], class template optional</span>
<span id="cb74-3"><a href="#cb74-3"></a>  template&lt;class T&gt;</span>
<span id="cb74-4"><a href="#cb74-4"></a>    class optional;</span>
<span id="cb74-5"><a href="#cb74-5"></a></span>
<span id="cb74-6"><a href="#cb74-6"></a>  // [optional.nullopt], no-value state indicator</span>
<span id="cb74-7"><a href="#cb74-7"></a>  struct nullopt_t{see below};</span>
<span id="cb74-8"><a href="#cb74-8"></a>  inline constexpr nullopt_t nullopt(unspecified);</span>
<span id="cb74-9"><a href="#cb74-9"></a></span>
<span id="cb74-10"><a href="#cb74-10"></a>  // [optional.bad.access], class bad_optional_access</span>
<span id="cb74-11"><a href="#cb74-11"></a>  class bad_optional_access;</span>
<span id="cb74-12"><a href="#cb74-12"></a></span>
<span id="cb74-13"><a href="#cb74-13"></a>  // [optional.relops], relational operators</span>
<span id="cb74-14"><a href="#cb74-14"></a>  template&lt;class T, class U&gt;</span>
<span id="cb74-15"><a href="#cb74-15"></a>    constexpr bool operator==(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-16"><a href="#cb74-16"></a>  template&lt;class T, class U&gt;</span>
<span id="cb74-17"><a href="#cb74-17"></a>    constexpr bool operator!=(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-18"><a href="#cb74-18"></a>  template&lt;class T, class U&gt;</span>
<span id="cb74-19"><a href="#cb74-19"></a>    constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-20"><a href="#cb74-20"></a>  template&lt;class T, class U&gt;</span>
<span id="cb74-21"><a href="#cb74-21"></a>    constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-22"><a href="#cb74-22"></a>  template&lt;class T, class U&gt;</span>
<span id="cb74-23"><a href="#cb74-23"></a>    constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-24"><a href="#cb74-24"></a>  template&lt;class T, class U&gt;</span>
<span id="cb74-25"><a href="#cb74-25"></a>    constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-26"><a href="#cb74-26"></a><span class="va">+ template&lt;class T, ThreeWayComparableWith&lt;T&gt; U&gt;</span></span>
<span id="cb74-27"><a href="#cb74-27"></a><span class="va">+   constexpr compare_three_way_result_t&lt;T,U&gt;</span></span>
<span id="cb74-28"><a href="#cb74-28"></a><span class="va">+     operator&lt;=&gt;(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;);</span></span>
<span id="cb74-29"><a href="#cb74-29"></a></span>
<span id="cb74-30"><a href="#cb74-30"></a>  // [optional.nullops], comparison with nullopt</span>
<span id="cb74-31"><a href="#cb74-31"></a>  template&lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span>
<span id="cb74-32"><a href="#cb74-32"></a><span class="st">- template&lt;class T&gt; constexpr bool operator==(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;</span></span>
<span id="cb74-33"><a href="#cb74-33"></a><span class="st">- template&lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span></span>
<span id="cb74-34"><a href="#cb74-34"></a><span class="st">- template&lt;class T&gt; constexpr bool operator!=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;</span></span>
<span id="cb74-35"><a href="#cb74-35"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span></span>
<span id="cb74-36"><a href="#cb74-36"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&lt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;</span></span>
<span id="cb74-37"><a href="#cb74-37"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span></span>
<span id="cb74-38"><a href="#cb74-38"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&gt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;</span></span>
<span id="cb74-39"><a href="#cb74-39"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span></span>
<span id="cb74-40"><a href="#cb74-40"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&lt;=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;</span></span>
<span id="cb74-41"><a href="#cb74-41"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span></span>
<span id="cb74-42"><a href="#cb74-42"></a><span class="st">- template&lt;class T&gt; constexpr bool operator&gt;=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;</span></span>
<span id="cb74-43"><a href="#cb74-43"></a><span class="va">+ template&lt;class T&gt; constexpr strong_ordering operator&lt;=&gt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;</span></span>
<span id="cb74-44"><a href="#cb74-44"></a></span>
<span id="cb74-45"><a href="#cb74-45"></a>  // [optional.comp.with.t], comparison with T</span>
<span id="cb74-46"><a href="#cb74-46"></a>  template&lt;class T, class U&gt; constexpr bool operator==(const optional&lt;T&gt;&amp;, const U&amp;);</span>
<span id="cb74-47"><a href="#cb74-47"></a>  template&lt;class T, class U&gt; constexpr bool operator==(const T&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-48"><a href="#cb74-48"></a>  template&lt;class T, class U&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp;, const U&amp;);</span>
<span id="cb74-49"><a href="#cb74-49"></a>  template&lt;class T, class U&gt; constexpr bool operator!=(const T&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-50"><a href="#cb74-50"></a>  template&lt;class T, class U&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const U&amp;);</span>
<span id="cb74-51"><a href="#cb74-51"></a>  template&lt;class T, class U&gt; constexpr bool operator&lt;(const T&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-52"><a href="#cb74-52"></a>  template&lt;class T, class U&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, const U&amp;);</span>
<span id="cb74-53"><a href="#cb74-53"></a>  template&lt;class T, class U&gt; constexpr bool operator&gt;(const T&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-54"><a href="#cb74-54"></a>  template&lt;class T, class U&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, const U&amp;);</span>
<span id="cb74-55"><a href="#cb74-55"></a>  template&lt;class T, class U&gt; constexpr bool operator&lt;=(const T&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-56"><a href="#cb74-56"></a>  template&lt;class T, class U&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, const U&amp;);</span>
<span id="cb74-57"><a href="#cb74-57"></a>  template&lt;class T, class U&gt; constexpr bool operator&gt;=(const T&amp;, const optional&lt;U&gt;&amp;);</span>
<span id="cb74-58"><a href="#cb74-58"></a><span class="va">+ template&lt;class T, ThreeWayComparableWith&lt;T&gt; U&gt;</span></span>
<span id="cb74-59"><a href="#cb74-59"></a><span class="va">+   constexpr compare_three_way_result_t&lt;T,U&gt;</span></span>
<span id="cb74-60"><a href="#cb74-60"></a><span class="va">+     operator&lt;=&gt;(const optional&lt;T&gt;&amp;, const U&amp;);</span></span>
<span id="cb74-61"><a href="#cb74-61"></a></span>
<span id="cb74-62"><a href="#cb74-62"></a>  // [optional.specalg], specialized algorithms</span>
<span id="cb74-63"><a href="#cb74-63"></a>  template&lt;class T&gt;</span>
<span id="cb74-64"><a href="#cb74-64"></a>    void swap(optional&lt;T&gt;&amp;, optional&lt;T&gt;&amp;) noexcept(<em>see below</em>);</span>
<span id="cb74-65"><a href="#cb74-65"></a>    </span>
<span id="cb74-66"><a href="#cb74-66"></a>  [...]</span>
<span id="cb74-67"><a href="#cb74-67"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Add to 20.6.6 [optional.relops]:</p>
<blockquote>
<div class="sourceCode" id="cb75"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb75-1"><a href="#cb75-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> U<span class="op">&gt;</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> optional<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> optional<span class="op">&lt;</span>U<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Requires</em>: The expression <code class="sourceCode cpp"><span class="op">*</span>x <span class="op">&gt;=</span> <span class="op">*</span>y</code> shall be well-formed and its result shall be convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Returns</em>: If <code class="sourceCode cpp"><span class="op">!</span>y</code>, <code class="sourceCode cpp"><span class="kw">true</span></code>; otherwise, if <code class="sourceCode cpp"><span class="op">!</span>x</code>, <code class="sourceCode cpp"><span class="kw">false</span></code>; otherwise <code class="sourceCode cpp"><span class="op">*</span>x <span class="op">&gt;=</span> <span class="op">*</span>y</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Remarks</em>: Specializations of this function template for which <code class="sourceCode cpp"><span class="op">*</span>x <span class="op">&gt;=</span> <span class="op">*</span>y</code> is a core constant expression shall be constexpr functions.</p>
<div class="addu">
<div class="sourceCode" id="cb76"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb76-1"><a href="#cb76-1"></a>template&lt;class T, ThreeWayComparableWith&lt;T&gt; U&gt;</span>
<span id="cb76-2"><a href="#cb76-2"></a>  constexpr compare_three_way_result_t&lt;T,U&gt;</span>
<span id="cb76-3"><a href="#cb76-3"></a>    operator&lt;=&gt;(const optional&lt;T&gt;&amp; x, const optional&lt;U&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Returns</em>: If <code class="sourceCode cpp">x <span class="op">&amp;&amp;</span> y</code>, <code class="sourceCode cpp"><span class="op">*</span>x <span class="op">&lt;=&gt;</span> <span class="op">*</span>y</code>; otherwise <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dt">bool</span><span class="op">(</span>y<span class="op">)</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">20</a></span> <em>Remarks</em>: Specializations of this function template for which <code class="sourceCode cpp"><span class="op">*</span>x <span class="op">&lt;=&gt;</span> <span class="op">*</span>y</code> is a core constant expression shall be constexpr functions.</p>
</div>
</blockquote>
<p>Change 20.6.7 [optional.nullops], removing most of the comparisons:</p>
<blockquote>
<div class="sourceCode" id="cb77"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb77-1"><a href="#cb77-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> optional<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> x, nullopt_t<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb77-2"><a href="#cb77-2"></a><span class="rm" style="color: #bf0303"><del>template&lt;class T&gt; constexpr bool operator==(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>x</code>.</p>
<div class="addu">
<div class="sourceCode" id="cb78"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb78-1"><a href="#cb78-1"></a>template&lt;class T&gt; constexpr strong_ordering operator&lt;=&gt;(const optional&lt;T&gt;&amp; x, nullopt_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="kw">false</span></code>.</p>
</div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb79"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb79-1"><a href="#cb79-1"></a>template&lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp; x, nullopt_t) noexcept;</span>
<span id="cb79-2"><a href="#cb79-2"></a>template&lt;class T&gt; constexpr bool operator!=(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb80"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb80-1"><a href="#cb80-1"></a>template&lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp; x, nullopt_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
<div class="sourceCode" id="cb81"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb81-1"><a href="#cb81-1"></a>template&lt;class T&gt; constexpr bool operator&lt;(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb82"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb82-1"><a href="#cb82-1"></a>template&lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp; x, nullopt_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb83"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb83-1"><a href="#cb83-1"></a>template&lt;class T&gt; constexpr bool operator&gt;(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
<div class="sourceCode" id="cb84"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb84-1"><a href="#cb84-1"></a>template&lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp; x, nullopt_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>x</code>.</p>
<div class="sourceCode" id="cb85"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb85-1"><a href="#cb85-1"></a>template&lt;class T&gt; constexpr bool operator&lt;=(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
<div class="sourceCode" id="cb86"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb86-1"><a href="#cb86-1"></a>template&lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp; x, nullopt_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
<div class="sourceCode" id="cb87"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb87-1"><a href="#cb87-1"></a>template&lt;class T&gt; constexpr bool operator&gt;=(nullopt_t, const optional&lt;T&gt;&amp; x) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>x</code>.</p>
</div>
</blockquote>
<p>Add to 20.6.8 [optional.comp.with.t]:</p>
<blockquote>
<div class="sourceCode" id="cb88"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb88-1"><a href="#cb88-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> U<span class="op">&gt;</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> T<span class="op">&amp;</span> v, <span class="kw">const</span> optional<span class="op">&lt;</span>U<span class="op">&gt;&amp;</span> x<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">23</a></span> <em>Requires</em>: The expression <code class="sourceCode cpp">v <span class="op">&gt;=</span> <span class="op">*</span>x</code> shall be well-formed and its result shall be convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">24</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span> <span class="op">?</span> v <span class="op">&gt;=</span> <span class="op">*</span>x <span class="op">:</span> <span class="kw">true</span>;</code></p>
<div class="addu">
<div class="sourceCode" id="cb89"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb89-1"><a href="#cb89-1"></a>template&lt;class T, ThreeWayComparableWith&lt;T&gt; U&gt;</span>
<span id="cb89-2"><a href="#cb89-2"></a>  constexpr compare_three_way_result_t&lt;T,U&gt;</span>
<span id="cb89-3"><a href="#cb89-3"></a>    operator&lt;=&gt;(const optional&lt;T&gt;&amp; x, const U&amp; v);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="dt">bool</span><span class="op">(</span>x<span class="op">)</span> <span class="op">?</span> <span class="op">*</span>x <span class="op">&lt;=&gt;</span> v <span class="op">:</span> strong_ordering<span class="op">::</span>less;</code></p>
</div>
</blockquote>
<p>Change 20.7.2 [variant.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb90"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb90-1"><a href="#cb90-1"></a>namespace std {</span>
<span id="cb90-2"><a href="#cb90-2"></a>  // [variant.variant], class template variant</span>
<span id="cb90-3"><a href="#cb90-3"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-4"><a href="#cb90-4"></a>    class variant;</span>
<span id="cb90-5"><a href="#cb90-5"></a></span>
<span id="cb90-6"><a href="#cb90-6"></a>  [...]</span>
<span id="cb90-7"><a href="#cb90-7"></a>  </span>
<span id="cb90-8"><a href="#cb90-8"></a>  // [variant.relops], relational operators</span>
<span id="cb90-9"><a href="#cb90-9"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-10"><a href="#cb90-10"></a>    constexpr bool operator==(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span>
<span id="cb90-11"><a href="#cb90-11"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-12"><a href="#cb90-12"></a>    constexpr bool operator!=(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span>
<span id="cb90-13"><a href="#cb90-13"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-14"><a href="#cb90-14"></a>    constexpr bool operator&lt;(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span>
<span id="cb90-15"><a href="#cb90-15"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-16"><a href="#cb90-16"></a>    constexpr bool operator&gt;(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span>
<span id="cb90-17"><a href="#cb90-17"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-18"><a href="#cb90-18"></a>    constexpr bool operator&lt;=(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span>
<span id="cb90-19"><a href="#cb90-19"></a>  template&lt;class... Types&gt;</span>
<span id="cb90-20"><a href="#cb90-20"></a>    constexpr bool operator&gt;=(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span>
<span id="cb90-21"><a href="#cb90-21"></a><span class="va">+ template&lt;class... Types&gt; requires (ThreeWayComparable&lt;Types&gt; &amp;&amp; ...)  </span></span>
<span id="cb90-22"><a href="#cb90-22"></a><span class="va">+   constexpr common_comparison_category_t&lt;compare_three_way_result_t&lt;Types&gt;...&gt;</span></span>
<span id="cb90-23"><a href="#cb90-23"></a><span class="va">+     operator&lt;=&gt;(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);</span></span>
<span id="cb90-24"><a href="#cb90-24"></a>  </span>
<span id="cb90-25"><a href="#cb90-25"></a>  // [variant.visit], visitation</span>
<span id="cb90-26"><a href="#cb90-26"></a>  template&lt;class Visitor, class... Variants&gt;</span>
<span id="cb90-27"><a href="#cb90-27"></a>    constexpr see below visit(Visitor&amp;&amp;, Variants&amp;&amp;...);</span>
<span id="cb90-28"><a href="#cb90-28"></a>  template&lt;class R, class Visitor, class... Variants&gt;</span>
<span id="cb90-29"><a href="#cb90-29"></a>    constexpr R visit(Visitor&amp;&amp;, Variants&amp;&amp;...);</span>
<span id="cb90-30"><a href="#cb90-30"></a></span>
<span id="cb90-31"><a href="#cb90-31"></a>  // [variant.monostate], class monostate</span>
<span id="cb90-32"><a href="#cb90-32"></a>  struct monostate;</span>
<span id="cb90-33"><a href="#cb90-33"></a></span>
<span id="cb90-34"><a href="#cb90-34"></a>  // [variant.monostate.relops], monostate relational operators</span>
<span id="cb90-35"><a href="#cb90-35"></a>  constexpr bool operator==(monostate, monostate) noexcept;</span>
<span id="cb90-36"><a href="#cb90-36"></a><span class="st">- constexpr bool operator!=(monostate, monostate) noexcept;</span></span>
<span id="cb90-37"><a href="#cb90-37"></a><span class="st">- constexpr bool operator&lt;(monostate, monostate) noexcept;</span></span>
<span id="cb90-38"><a href="#cb90-38"></a><span class="st">- constexpr bool operator&gt;(monostate, monostate) noexcept;</span></span>
<span id="cb90-39"><a href="#cb90-39"></a><span class="st">- constexpr bool operator&lt;=(monostate, monostate) noexcept;</span></span>
<span id="cb90-40"><a href="#cb90-40"></a><span class="st">- constexpr bool operator&gt;=(monostate, monostate) noexcept;</span></span>
<span id="cb90-41"><a href="#cb90-41"></a><span class="va">+ constexpr strong_ordering operator&lt;=&gt;(monostate, monostate) noexcept;</span></span>
<span id="cb90-42"><a href="#cb90-42"></a>    </span>
<span id="cb90-43"><a href="#cb90-43"></a>  [...]</span>
<span id="cb90-44"><a href="#cb90-44"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Add to 20.7.6 [variant.relops]:</p>
<blockquote>
<div class="sourceCode" id="cb91"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb91-1"><a href="#cb91-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Types<span class="op">&gt;</span></span>
<span id="cb91-2"><a href="#cb91-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> variant<span class="op">&lt;</span>Types<span class="op">...&gt;&amp;</span> v, <span class="kw">const</span> variant<span class="op">&lt;</span>Types<span class="op">...&gt;&amp;</span> w<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Requires</em>: <code class="sourceCode cpp">get<span class="op">&lt;</span>i<span class="op">&gt;(</span>v<span class="op">)</span> <span class="op">&gt;=</span> get<span class="op">&lt;</span>i<span class="op">&gt;(</span>w<span class="op">)</span></code> is a valid expression returning a type that is convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>, for all <code class="sourceCode cpp">i</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: If <code class="sourceCode cpp">w<span class="op">.</span>valueless_by_exception<span class="op">()</span></code>, <code class="sourceCode cpp"><span class="kw">true</span></code>; otherwise if <code class="sourceCode cpp">v<span class="op">.</span>valueless_by_exception<span class="op">()</span></code>, <code class="sourceCode cpp"><span class="kw">false</span></code>; otherwise, if <code class="sourceCode cpp">v<span class="op">.</span>index<span class="op">()</span> <span class="op">&gt;</span> w<span class="op">.</span>index<span class="op">()</span></code>, <code class="sourceCode cpp"><span class="kw">true</span></code>; otherwise if <code class="sourceCode cpp">v<span class="op">.</span>index<span class="op">()</span> <span class="op">&lt;</span> w<span class="op">.</span>index<span class="op">()</span></code>, <code class="sourceCode cpp"><span class="kw">false</span></code>; otherwise <code class="sourceCode cpp">get<span class="op">&lt;</span>i<span class="op">&gt;(</span>v<span class="op">)</span> <span class="op">&gt;=</span> get<span class="op">&lt;</span>i<span class="op">&gt;(</span>w<span class="op">)</span></code> with <code class="sourceCode cpp">i</code> being <code class="sourceCode cpp">v<span class="op">.</span>index<span class="op">()</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb92"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb92-1"><a href="#cb92-1"></a>template&lt;class... Types&gt; requires (ThreeWayComparable&lt;Types&gt; &amp;&amp; ...)  </span>
<span id="cb92-2"><a href="#cb92-2"></a>  constexpr common_comparison_category_t&lt;compare_three_way_result_t&lt;Types&gt;...&gt;</span>
<span id="cb92-3"><a href="#cb92-3"></a>    operator&lt;=&gt;(const variant&lt;Types...&gt;&amp; v, const variant&lt;Types...&gt;&amp; w);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb93"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb93-1"><a href="#cb93-1"></a>if (v.valueless_by_exception() &amp;&amp; w.valueless_by_exception())</span>
<span id="cb93-2"><a href="#cb93-2"></a>  return strong_ordering::equal;</span>
<span id="cb93-3"><a href="#cb93-3"></a>if (v.valueless_by_exception()) return strong_ordering::less;</span>
<span id="cb93-4"><a href="#cb93-4"></a>if (w.valueless_by_exception()) return strong_ordering::greater;</span>
<span id="cb93-5"><a href="#cb93-5"></a>if (auto c = v.index() &lt;=&gt; w.index(); c != 0) return c;</span>
<span id="cb93-6"><a href="#cb93-6"></a>return get&lt;i&gt;(v) &lt;=&gt; get&lt;i&gt;(w);</span></code></pre></div>
</blockquote>
<p>with <code class="sourceCode cpp">i</code> being <code class="sourceCode cpp">v<span class="op">.</span>index<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Simplify 20.7.9 [variant.monostate.relops]:</p>
<blockquote>
<div class="sourceCode" id="cb94"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb94-1"><a href="#cb94-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>monostate, monostate<span class="op">)</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span></code></pre></div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb95"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb95-1"><a href="#cb95-1"></a>constexpr bool operator!=(monostate, monostate) noexcept { return false; }</span>
<span id="cb95-2"><a href="#cb95-2"></a>constexpr bool operator&lt;(monostate, monostate) noexcept { return false; }</span>
<span id="cb95-3"><a href="#cb95-3"></a>constexpr bool operator&gt;(monostate, monostate) noexcept { return false; }</span>
<span id="cb95-4"><a href="#cb95-4"></a>constexpr bool operator&lt;=(monostate, monostate) noexcept { return true; }</span>
<span id="cb95-5"><a href="#cb95-5"></a>constexpr bool operator&gt;=(monostate, monostate) noexcept { return true; }</span></code></pre></div>

</div>
<div class="addu">
<div class="sourceCode" id="cb96"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb96-1"><a href="#cb96-1"></a>constexpr strong_ordering operator&lt;=&gt;(monostate, monostate) noexcept { return strong_ordering::equal; }</span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> [<em>Note</em>: monostate objects have only a single state; they thus always compare equal. —<em>end note</em>]</p>
</blockquote>
<p>Change 20.9.2 [template.bitset]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb97"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb97-1"><a href="#cb97-1"></a>namespace std {</span>
<span id="cb97-2"><a href="#cb97-2"></a>  template&lt;size_t N&gt; class bitset {</span>
<span id="cb97-3"><a href="#cb97-3"></a>  public:</span>
<span id="cb97-4"><a href="#cb97-4"></a>    [...]</span>
<span id="cb97-5"><a href="#cb97-5"></a>    size_t count() const noexcept;</span>
<span id="cb97-6"><a href="#cb97-6"></a>    constexpr size_t size() const noexcept;</span>
<span id="cb97-7"><a href="#cb97-7"></a>    bool operator==(const bitset&lt;N&gt;&amp; rhs) const noexcept;</span>
<span id="cb97-8"><a href="#cb97-8"></a><span class="st">-   bool operator!=(const bitset&lt;N&gt;&amp; rhs) const noexcept;</span></span>
<span id="cb97-9"><a href="#cb97-9"></a>    bool test(size_t pos) const;</span>
<span id="cb97-10"><a href="#cb97-10"></a>    [...]   </span>
<span id="cb97-11"><a href="#cb97-11"></a>  };</span>
<span id="cb97-12"><a href="#cb97-12"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.9.2.2 [bitset.members]:</p>
<blockquote>
<div class="sourceCode" id="cb98"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb98-1"><a href="#cb98-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> bitset<span class="op">&lt;</span>N<span class="op">&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">36</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if the value of each bit in <code class="sourceCode cpp"><span class="op">*</span><span class="kw">this</span></code> equals the value of the corresponding bit in <code class="sourceCode cpp">rhs</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb99"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb99-1"><a href="#cb99-1"></a>bool operator!=(const bitset&lt;N&gt;&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">37</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp"><span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 20.10.2 [memory.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb100"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb100-1"><a href="#cb100-1"></a>namespace std{</span>
<span id="cb100-2"><a href="#cb100-2"></a>  [...]</span>
<span id="cb100-3"><a href="#cb100-3"></a></span>
<span id="cb100-4"><a href="#cb100-4"></a>  // [default.allocator], the default allocator</span>
<span id="cb100-5"><a href="#cb100-5"></a>  template&lt;class T&gt; class allocator;</span>
<span id="cb100-6"><a href="#cb100-6"></a>  template&lt;class T, class U&gt;</span>
<span id="cb100-7"><a href="#cb100-7"></a>    bool operator==(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;</span>
<span id="cb100-8"><a href="#cb100-8"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb100-9"><a href="#cb100-9"></a><span class="st">-   bool operator!=(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;  </span></span>
<span id="cb100-10"><a href="#cb100-10"></a></span>
<span id="cb100-11"><a href="#cb100-11"></a>  [...]</span>
<span id="cb100-12"><a href="#cb100-12"></a>  </span>
<span id="cb100-13"><a href="#cb100-13"></a>  // [unique.ptr], class template unique_ptr</span>
<span id="cb100-14"><a href="#cb100-14"></a>  [...]</span>
<span id="cb100-15"><a href="#cb100-15"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-16"><a href="#cb100-16"></a>    void swap(unique_ptr&lt;T, D&gt;&amp; x, unique_ptr&lt;T, D&gt;&amp; y) noexcept;</span>
<span id="cb100-17"><a href="#cb100-17"></a></span>
<span id="cb100-18"><a href="#cb100-18"></a>  template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb100-19"><a href="#cb100-19"></a>    bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span>
<span id="cb100-20"><a href="#cb100-20"></a><span class="st">- template&lt;class T1, class D1, class T2, class D2&gt;</span></span>
<span id="cb100-21"><a href="#cb100-21"></a><span class="st">-   bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span></span>
<span id="cb100-22"><a href="#cb100-22"></a>  template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb100-23"><a href="#cb100-23"></a>    bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span>
<span id="cb100-24"><a href="#cb100-24"></a>  template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb100-25"><a href="#cb100-25"></a>    bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span>
<span id="cb100-26"><a href="#cb100-26"></a>  template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb100-27"><a href="#cb100-27"></a>    bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span>
<span id="cb100-28"><a href="#cb100-28"></a>  template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb100-29"><a href="#cb100-29"></a>    bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span>
<span id="cb100-30"><a href="#cb100-30"></a><span class="va">+ template&lt;class T1, class D1, class T2, class D2&gt;</span></span>
<span id="cb100-31"><a href="#cb100-31"></a><span class="va">+     requires ThreeWayComparableWith&lt;typename unique_ptr&lt;T1, D1&gt;::pointer,</span></span>
<span id="cb100-32"><a href="#cb100-32"></a><span class="va">+                                     typename unique_ptr&lt;T2, D2&gt;::pointer&gt;</span></span>
<span id="cb100-33"><a href="#cb100-33"></a><span class="va">+   compare_three_way_result_t&lt;typename unique_ptr&lt;T1, D1&gt;::pointer, typename unique_ptr&lt;T2, D2&gt;::pointer&gt;</span></span>
<span id="cb100-34"><a href="#cb100-34"></a><span class="va">+     operator&lt;=&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span></span>
<span id="cb100-35"><a href="#cb100-35"></a></span>
<span id="cb100-36"><a href="#cb100-36"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-37"><a href="#cb100-37"></a>    bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</span>
<span id="cb100-38"><a href="#cb100-38"></a><span class="st">- template&lt;class T, class D&gt;</span></span>
<span id="cb100-39"><a href="#cb100-39"></a><span class="st">-   bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y) noexcept;</span></span>
<span id="cb100-40"><a href="#cb100-40"></a><span class="st">- template&lt;class T, class D&gt;</span></span>
<span id="cb100-41"><a href="#cb100-41"></a><span class="st">-   bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-42"><a href="#cb100-42"></a><span class="st">- template&lt;class T, class D&gt;</span></span>
<span id="cb100-43"><a href="#cb100-43"></a><span class="st">-   bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y) noexcept;</span></span>
<span id="cb100-44"><a href="#cb100-44"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-45"><a href="#cb100-45"></a>    bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</span>
<span id="cb100-46"><a href="#cb100-46"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-47"><a href="#cb100-47"></a>    bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);</span>
<span id="cb100-48"><a href="#cb100-48"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-49"><a href="#cb100-49"></a>    bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</span>
<span id="cb100-50"><a href="#cb100-50"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-51"><a href="#cb100-51"></a>    bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);</span>
<span id="cb100-52"><a href="#cb100-52"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-53"><a href="#cb100-53"></a>    bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</span>
<span id="cb100-54"><a href="#cb100-54"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-55"><a href="#cb100-55"></a>    bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);</span>
<span id="cb100-56"><a href="#cb100-56"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-57"><a href="#cb100-57"></a>    bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</span>
<span id="cb100-58"><a href="#cb100-58"></a>  template&lt;class T, class D&gt;</span>
<span id="cb100-59"><a href="#cb100-59"></a>    bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);</span>
<span id="cb100-60"><a href="#cb100-60"></a><span class="va">+ template&lt;class T, class D&gt;</span></span>
<span id="cb100-61"><a href="#cb100-61"></a><span class="va">+     requires ThreeWayComparableWith&lt;typename unique_ptr&lt;T, D&gt;::pointer, nullptr_t&gt;</span></span>
<span id="cb100-62"><a href="#cb100-62"></a><span class="va">+   compare_three_way_result_t&lt;typename unique_ptr&lt;T, D&gt;::pointer, nullptr_t&gt;</span></span>
<span id="cb100-63"><a href="#cb100-63"></a><span class="va">+     operator&lt;=&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</span></span>
<span id="cb100-64"><a href="#cb100-64"></a></span>
<span id="cb100-65"><a href="#cb100-65"></a>  template&lt;class E, class T, class Y, class D&gt;</span>
<span id="cb100-66"><a href="#cb100-66"></a>    basic_ostream&lt;E, T&gt;&amp; operator&lt;&lt;(basic_ostream&lt;E, T&gt;&amp; os, const unique_ptr&lt;Y, D&gt;&amp; p);  </span>
<span id="cb100-67"><a href="#cb100-67"></a>    </span>
<span id="cb100-68"><a href="#cb100-68"></a>  [...]</span>
<span id="cb100-69"><a href="#cb100-69"></a></span>
<span id="cb100-70"><a href="#cb100-70"></a></span>
<span id="cb100-71"><a href="#cb100-71"></a>  // [util.smartptr.shared.cmp], shared_ptr comparisons</span>
<span id="cb100-72"><a href="#cb100-72"></a>  template&lt;class T, class U&gt;</span>
<span id="cb100-73"><a href="#cb100-73"></a>    bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span>
<span id="cb100-74"><a href="#cb100-74"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb100-75"><a href="#cb100-75"></a><span class="st">-   bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></span>
<span id="cb100-76"><a href="#cb100-76"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb100-77"><a href="#cb100-77"></a><span class="st">-   bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></span>
<span id="cb100-78"><a href="#cb100-78"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb100-79"><a href="#cb100-79"></a><span class="st">-   bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></span>
<span id="cb100-80"><a href="#cb100-80"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb100-81"><a href="#cb100-81"></a><span class="st">-   bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></span>
<span id="cb100-82"><a href="#cb100-82"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb100-83"><a href="#cb100-83"></a><span class="st">-   bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></span>
<span id="cb100-84"><a href="#cb100-84"></a><span class="va">+ template&lt;class T, class U&gt;</span></span>
<span id="cb100-85"><a href="#cb100-85"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></span>
<span id="cb100-86"><a href="#cb100-86"></a></span>
<span id="cb100-87"><a href="#cb100-87"></a>  template&lt;class T&gt;</span>
<span id="cb100-88"><a href="#cb100-88"></a>    bool operator==(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span>
<span id="cb100-89"><a href="#cb100-89"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-90"><a href="#cb100-90"></a><span class="st">-   bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;</span></span>
<span id="cb100-91"><a href="#cb100-91"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-92"><a href="#cb100-92"></a><span class="st">-   bool operator!=(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-93"><a href="#cb100-93"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-94"><a href="#cb100-94"></a><span class="st">-   bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;</span></span>
<span id="cb100-95"><a href="#cb100-95"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-96"><a href="#cb100-96"></a><span class="st">-   bool operator&lt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-97"><a href="#cb100-97"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-98"><a href="#cb100-98"></a><span class="st">-   bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;</span></span>
<span id="cb100-99"><a href="#cb100-99"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-100"><a href="#cb100-100"></a><span class="st">-   bool operator&gt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-101"><a href="#cb100-101"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-102"><a href="#cb100-102"></a><span class="st">-   bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;</span></span>
<span id="cb100-103"><a href="#cb100-103"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-104"><a href="#cb100-104"></a><span class="st">-   bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-105"><a href="#cb100-105"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-106"><a href="#cb100-106"></a><span class="st">-   bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;</span></span>
<span id="cb100-107"><a href="#cb100-107"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-108"><a href="#cb100-108"></a><span class="st">-   bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-109"><a href="#cb100-109"></a><span class="st">- template&lt;class T&gt;</span></span>
<span id="cb100-110"><a href="#cb100-110"></a><span class="st">-   bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;  </span></span>
<span id="cb100-111"><a href="#cb100-111"></a><span class="va">+ template&lt;class T&gt;</span></span>
<span id="cb100-112"><a href="#cb100-112"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;</span></span>
<span id="cb100-113"><a href="#cb100-113"></a></span>
<span id="cb100-114"><a href="#cb100-114"></a>  [...]</span>
<span id="cb100-115"><a href="#cb100-115"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Remove from 20.10.10.2 [allocator.globals]:</p>
<blockquote>
<div class="sourceCode" id="cb101"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb101-1"><a href="#cb101-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb101-2"><a href="#cb101-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> allocator<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span>, <span class="kw">const</span> allocator<span class="op">&lt;</span>U<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb102"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb102-1"><a href="#cb102-1"></a>template&lt;class T, class U&gt;</span>
<span id="cb102-2"><a href="#cb102-2"></a>  bool operator!=(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
</div>
</blockquote>
<p>Change 20.11.1.5 [unique.ptr.special]:</p>
<blockquote>
<div class="sourceCode" id="cb103"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb103-1"><a href="#cb103-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T1, <span class="kw">class</span> D1, <span class="kw">class</span> T2, <span class="kw">class</span> D2<span class="op">&gt;</span></span>
<span id="cb103-2"><a href="#cb103-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T1, D1<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T2, D2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>get<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>get<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb104"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb104-1"><a href="#cb104-1"></a>template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb104-2"><a href="#cb104-2"></a>  bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>get<span class="op">()</span> <span class="op">!=</span> y<span class="op">.</span>get<span class="op">()</span></code>.</p>
</div>
<p>[…]</p>
<div class="sourceCode" id="cb105"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb105-1"><a href="#cb105-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T1, <span class="kw">class</span> D1, <span class="kw">class</span> T2, <span class="kw">class</span> D2<span class="op">&gt;</span></span>
<span id="cb105-2"><a href="#cb105-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T1, D1<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T2, D2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb106"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb106-1"><a href="#cb106-1"></a>template&lt;class T1, class D1, class T2, class D2&gt;</span>
<span id="cb106-2"><a href="#cb106-2"></a>    requires ThreeWayComparableWith&lt;typename unique_ptr&lt;T1, D1&gt;::pointer,</span>
<span id="cb106-3"><a href="#cb106-3"></a>                                    typename unique_ptr&lt;T2, D2&gt;::pointer&gt;</span>
<span id="cb106-4"><a href="#cb106-4"></a>  compare_three_way_result_t&lt;typename unique_ptr&lt;T1, D1&gt;::pointer, typename unique_ptr&lt;T2, D2&gt;::pointer&gt;</span>
<span id="cb106-5"><a href="#cb106-5"></a>    operator&lt;=&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10*</a></span> <em>Returns</em>: <code class="sourceCode cpp">compare_three_way<span class="op">()(</span>x<span class="op">.</span>get<span class="op">()</span>, y<span class="op">.</span>get<span class="op">())</span></code>.</p>
</div>
<div class="sourceCode" id="cb107"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb107-1"><a href="#cb107-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> D<span class="op">&gt;</span></span>
<span id="cb107-2"><a href="#cb107-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T, D<span class="op">&gt;&amp;</span> x, nullptr_t<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb107-3"><a href="#cb107-3"></a><span class="rm" style="color: #bf0303"><del>template&lt;class T, class D&gt;</del></span></span>
<span id="cb107-4"><a href="#cb107-4"></a><span class="rm" style="color: #bf0303"><del>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>x</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb108"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb108-1"><a href="#cb108-1"></a>template&lt;class T, class D&gt;</span>
<span id="cb108-2"><a href="#cb108-2"></a>  bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</span>
<span id="cb108-3"><a href="#cb108-3"></a>template&lt;class T, class D&gt;</span>
<span id="cb108-4"><a href="#cb108-4"></a>  bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">(</span><span class="dt">bool</span><span class="op">)</span>x</code>.</p>
</div>
<p>[…]</p>
<div class="sourceCode" id="cb109"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb109-1"><a href="#cb109-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> D<span class="op">&gt;</span></span>
<span id="cb109-2"><a href="#cb109-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T, D<span class="op">&gt;&amp;</span> x, nullptr_t<span class="op">)</span>;</span>
<span id="cb109-3"><a href="#cb109-3"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> D<span class="op">&gt;</span></span>
<span id="cb109-4"><a href="#cb109-4"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span>nullptr_t, <span class="kw">const</span> unique_ptr<span class="op">&lt;</span>T, D<span class="op">&gt;&amp;</span> x<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Returns</em>: The first function template returns <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> <span class="kw">nullptr</span><span class="op">)</span></code>. The second function template returns <code class="sourceCode cpp"><span class="op">!(</span><span class="kw">nullptr</span> <span class="op">&lt;</span> x<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb110"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb110-1"><a href="#cb110-1"></a>template&lt;class T, class D&gt;</span>
<span id="cb110-2"><a href="#cb110-2"></a>    requires ThreeWayComparableWith&lt;typename unique_ptr&lt;T, D&gt;::pointer, nullptr_t&gt;</span>
<span id="cb110-3"><a href="#cb110-3"></a>  compare_three_way_result_t&lt;typename unique_ptr&lt;T, D&gt;::pointer, nullptr_t&gt;</span>
<span id="cb110-4"><a href="#cb110-4"></a>    operator&lt;=&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Returns</em>: <code class="sourceCode cpp">compare_three_way<span class="op">()(</span>x<span class="op">.</span>get<span class="op">()</span>, <span class="kw">nullptr</span><span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 20.11.3.7 [util.smartptr.shared.cmp]:</p>
<blockquote>
<div class="sourceCode" id="cb111"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb111-1"><a href="#cb111-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb111-2"><a href="#cb111-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> shared_ptr<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> a, <span class="kw">const</span> shared_ptr<span class="op">&lt;</span>U<span class="op">&gt;&amp;</span> b<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">a<span class="op">.</span>get<span class="op">()</span> <span class="op">==</span> b<span class="op">.</span>get<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb112"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb112-1"><a href="#cb112-1"></a>template&lt;class T, class U&gt;</span>
<span id="cb112-2"><a href="#cb112-2"></a>  bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">less<span class="op">&lt;&gt;()(</span>a<span class="op">.</span>get<span class="op">()</span>, b<span class="op">.</span>get<span class="op">())</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> [<em>Note</em>: Defining a comparison function allows <code class="sourceCode cpp">shared_ptr</code> objects to be used as keys in associative containers. —<em>end note</em>]</p>
</div>
<div class="sourceCode" id="cb113"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb113-1"><a href="#cb113-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb113-2"><a href="#cb113-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> shared_ptr<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> a, nullptr_t<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb113-3"><a href="#cb113-3"></a><span class="rm" style="color: #bf0303"><del>template&lt;class T&gt;</del></span></span>
<span id="cb113-4"><a href="#cb113-4"></a><span class="rm" style="color: #bf0303"><del>bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>a</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb114"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb114-1"><a href="#cb114-1"></a>template&lt;class T&gt;</span>
<span id="cb114-2"><a href="#cb114-2"></a>  bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</span>
<span id="cb114-3"><a href="#cb114-3"></a>template&lt;class T&gt;</span>
<span id="cb114-4"><a href="#cb114-4"></a>  bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">(</span><span class="dt">bool</span><span class="op">)</span>a</code>.</p>
<div class="sourceCode" id="cb115"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb115-1"><a href="#cb115-1"></a>template&lt;class T&gt;</span>
<span id="cb115-2"><a href="#cb115-2"></a>  bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</span>
<span id="cb115-3"><a href="#cb115-3"></a>template&lt;class T&gt;</span>
<span id="cb115-4"><a href="#cb115-4"></a>  bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: The first function template returns <code class="sourceCode cpp">less<span class="op">&lt;</span><span class="kw">typename</span> shared_ptr<span class="op">&lt;</span>T<span class="op">&gt;::</span>element_type<span class="op">*&gt;()(</span>a<span class="op">.</span>get<span class="op">()</span>, <span class="kw">nullptr</span><span class="op">)</span></code> The second function template returns <code class="sourceCode cpp">less<span class="op">&lt;</span><span class="kw">typename</span> shared_ptr<span class="op">&lt;</span>T<span class="op">&gt;::</span>element_type<span class="op">*&gt;()(</span><span class="kw">nullptr</span>, a<span class="op">.</span>get<span class="op">())</span></code></p>
<div class="sourceCode" id="cb116"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb116-1"><a href="#cb116-1"></a>template&lt;class T&gt;</span>
<span id="cb116-2"><a href="#cb116-2"></a>  bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</span>
<span id="cb116-3"><a href="#cb116-3"></a>template&lt;class T&gt;</span>
<span id="cb116-4"><a href="#cb116-4"></a>  bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: The first function template returns <code class="sourceCode cpp"><span class="kw">nullptr</span> <span class="op">&lt;</span> a</code>. The second function template returns <code class="sourceCode cpp">a <span class="op">&lt;</span> <span class="kw">nullptr</span></code>.</p>
<div class="sourceCode" id="cb117"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb117-1"><a href="#cb117-1"></a>template&lt;class T&gt;</span>
<span id="cb117-2"><a href="#cb117-2"></a>  bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</span>
<span id="cb117-3"><a href="#cb117-3"></a>template&lt;class T&gt;</span>
<span id="cb117-4"><a href="#cb117-4"></a>  bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: The first function template returns <code class="sourceCode cpp"><span class="op">!(</span><span class="kw">nullptr</span> <span class="op">&lt;</span> a<span class="op">)</span></code>. The second function template returns <code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">&lt;</span> <span class="kw">nullptr</span><span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb118"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb118-1"><a href="#cb118-1"></a>template&lt;class T&gt;</span>
<span id="cb118-2"><a href="#cb118-2"></a>  bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</span>
<span id="cb118-3"><a href="#cb118-3"></a>template&lt;class T&gt;</span>
<span id="cb118-4"><a href="#cb118-4"></a>  bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: The first function template returns <code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">&lt;</span> <span class="kw">nullptr</span><span class="op">)</span></code>. The second function template returns <code class="sourceCode cpp"><span class="op">!(</span><span class="kw">nullptr</span> <span class="op">&lt;</span> a<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb119"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb119-1"><a href="#cb119-1"></a>template&lt;class T, class U&gt;</span>
<span id="cb119-2"><a href="#cb119-2"></a>  strong_ordering operator&lt;=&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp">compare_three_way<span class="op">()(</span>a<span class="op">.</span>get<span class="op">()</span>, b<span class="op">.</span>get<span class="op">())</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> [<em>Note</em>: Defining a comparison function allows <code class="sourceCode cpp">shared_ptr</code> objects to be used as keys in associative containers. —<em>end note</em>]</p>
<div class="sourceCode" id="cb120"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb120-1"><a href="#cb120-1"></a>template&lt;class T&gt;</span>
<span id="cb120-2"><a href="#cb120-2"></a>  strong_ordering operator&lt;=&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp">compare_three_way<span class="op">()(</span>a<span class="op">.</span>get<span class="op">()</span>, <span class="kw">nullptr</span><span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 20.12.1 [mem.res.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb121"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb121-1"><a href="#cb121-1"></a>namespace std::pmr {</span>
<span id="cb121-2"><a href="#cb121-2"></a>  // [mem.res.class], class memory_resource</span>
<span id="cb121-3"><a href="#cb121-3"></a>  class memory_resource;</span>
<span id="cb121-4"><a href="#cb121-4"></a></span>
<span id="cb121-5"><a href="#cb121-5"></a>  bool operator==(const memory_resource&amp; a, const memory_resource&amp; b) noexcept;</span>
<span id="cb121-6"><a href="#cb121-6"></a><span class="st">- bool operator!=(const memory_resource&amp; a, const memory_resource&amp; b) noexcept;</span></span>
<span id="cb121-7"><a href="#cb121-7"></a></span>
<span id="cb121-8"><a href="#cb121-8"></a>  // [mem.poly.allocator.class], class template polymorphic_allocator</span>
<span id="cb121-9"><a href="#cb121-9"></a>  template&lt;class Tp&gt; class polymorphic_allocator;</span>
<span id="cb121-10"><a href="#cb121-10"></a></span>
<span id="cb121-11"><a href="#cb121-11"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb121-12"><a href="#cb121-12"></a>    bool operator==(const polymorphic_allocator&lt;T1&gt;&amp; a,</span>
<span id="cb121-13"><a href="#cb121-13"></a>                    const polymorphic_allocator&lt;T2&gt;&amp; b) noexcept;</span>
<span id="cb121-14"><a href="#cb121-14"></a><span class="st">- template&lt;class T1, class T2&gt;</span></span>
<span id="cb121-15"><a href="#cb121-15"></a><span class="st">-   bool operator!=(const polymorphic_allocator&lt;T1&gt;&amp; a,</span></span>
<span id="cb121-16"><a href="#cb121-16"></a><span class="st">-                   const polymorphic_allocator&lt;T2&gt;&amp; b) noexcept;</span></span>
<span id="cb121-17"><a href="#cb121-17"></a></span>
<span id="cb121-18"><a href="#cb121-18"></a>  [...]</span>
<span id="cb121-19"><a href="#cb121-19"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.12.2.3 [mem.res.eq]:</p>
<blockquote>
<div class="sourceCode" id="cb122"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb122-1"><a href="#cb122-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> memory_resource<span class="op">&amp;</span> a, <span class="kw">const</span> memory_resource<span class="op">&amp;</span> b<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">&amp;</span>a <span class="op">==</span> <span class="op">&amp;</span>b <span class="op">||</span> a<span class="op">.</span>is_equal<span class="op">(</span>b<span class="op">)</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb123"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb123-1"><a href="#cb123-1"></a>bool operator!=(const memory_resource&amp; a, const memory_resource&amp; b) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">==</span> b<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 20.12.3.3 [mem.poly.allocator.eq]:</p>
<blockquote>
<div class="sourceCode" id="cb124"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb124-1"><a href="#cb124-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T1, <span class="kw">class</span> T2<span class="op">&gt;</span></span>
<span id="cb124-2"><a href="#cb124-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> polymorphic_allocator<span class="op">&lt;</span>T1<span class="op">&gt;&amp;</span> a,</span>
<span id="cb124-3"><a href="#cb124-3"></a>                  <span class="kw">const</span> polymorphic_allocator<span class="op">&lt;</span>T2<span class="op">&gt;&amp;</span> b<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">*</span>a<span class="op">.</span>resource<span class="op">()</span> <span class="op">==</span> <span class="op">*</span>b<span class="op">.</span>resource<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb125"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb125-1"><a href="#cb125-1"></a>template&lt;class T1, class T2&gt;</span>
<span id="cb125-2"><a href="#cb125-2"></a>  bool operator!=(const polymorphic_allocator&lt;T1&gt;&amp; a,</span>
<span id="cb125-3"><a href="#cb125-3"></a>                  const polymorphic_allocator&lt;T2&gt;&amp; b) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">==</span> b<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 20.13.1 [allocator.adaptor.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb126"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb126-1"><a href="#cb126-1"></a>namespace std {</span>
<span id="cb126-2"><a href="#cb126-2"></a>  // class template scoped allocator adaptor</span>
<span id="cb126-3"><a href="#cb126-3"></a>  template&lt;class OuterAlloc, class... InnerAlloc&gt;</span>
<span id="cb126-4"><a href="#cb126-4"></a>    class scoped_allocator_adaptor;</span>
<span id="cb126-5"><a href="#cb126-5"></a></span>
<span id="cb126-6"><a href="#cb126-6"></a>  // [scoped.adaptor.operators], scoped allocator operators</span>
<span id="cb126-7"><a href="#cb126-7"></a>  template&lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;</span>
<span id="cb126-8"><a href="#cb126-8"></a>    bool operator==(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,</span>
<span id="cb126-9"><a href="#cb126-9"></a>                    const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b) noexcept;</span>
<span id="cb126-10"><a href="#cb126-10"></a><span class="st">- template&lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;</span></span>
<span id="cb126-11"><a href="#cb126-11"></a><span class="st">-   bool operator!=(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,</span></span>
<span id="cb126-12"><a href="#cb126-12"></a><span class="st">-                   const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b) noexcept;</span></span>
<span id="cb126-13"><a href="#cb126-13"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.13.5 [scoped.adaptor.operators]:</p>
<blockquote>
<div class="sourceCode" id="cb127"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb127-1"><a href="#cb127-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OuterA1, <span class="kw">class</span> OuterA2, <span class="kw">class</span><span class="op">...</span> InnerAllocs<span class="op">&gt;</span></span>
<span id="cb127-2"><a href="#cb127-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> scoped_allocator_adaptor<span class="op">&lt;</span>OuterA1, InnerAllocs<span class="op">...&gt;&amp;</span> a,</span>
<span id="cb127-3"><a href="#cb127-3"></a>                  <span class="kw">const</span> scoped_allocator_adaptor<span class="op">&lt;</span>OuterA2, InnerAllocs<span class="op">...&gt;&amp;</span> b<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: If <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>InnerAllocs<span class="op">)</span></code> is zero, <code class="sourceCode cpp">a<span class="op">.</span>outer_allocator<span class="op">()</span> <span class="op">==</span> b<span class="op">.</span>outer_allocator<span class="op">()</span></code> otherwise <code class="sourceCode cpp">a<span class="op">.</span>outer_allocator<span class="op">()</span> <span class="op">==</span> b<span class="op">.</span>outer_allocator<span class="op">()</span> <span class="op">&amp;&amp;</span> a<span class="op">.</span>inner_allocator<span class="op">()</span> <span class="op">==</span> b<span class="op">.</span>inner_allocator<span class="op">()</span></code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb128"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb128-1"><a href="#cb128-1"></a>template&lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;</span>
<span id="cb128-2"><a href="#cb128-2"></a>  bool operator!=(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,</span>
<span id="cb128-3"><a href="#cb128-3"></a>                  const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">==</span> b<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 20.14.1 [functional.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb129"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb129-1"><a href="#cb129-1"></a>namespace std {</span>
<span id="cb129-2"><a href="#cb129-2"></a>  [...]</span>
<span id="cb129-3"><a href="#cb129-3"></a>  template&lt;class R, class... ArgTypes&gt;</span>
<span id="cb129-4"><a href="#cb129-4"></a>    void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;) noexcept;</span>
<span id="cb129-5"><a href="#cb129-5"></a></span>
<span id="cb129-6"><a href="#cb129-6"></a>  template&lt;class R, class... ArgTypes&gt;</span>
<span id="cb129-7"><a href="#cb129-7"></a>    bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;</span>
<span id="cb129-8"><a href="#cb129-8"></a><span class="st">- template&lt;class R, class... ArgTypes&gt;</span></span>
<span id="cb129-9"><a href="#cb129-9"></a><span class="st">-   bool operator==(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;</span></span>
<span id="cb129-10"><a href="#cb129-10"></a><span class="st">- template&lt;class R, class... ArgTypes&gt;</span></span>
<span id="cb129-11"><a href="#cb129-11"></a><span class="st">-   bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;</span></span>
<span id="cb129-12"><a href="#cb129-12"></a><span class="st">- template&lt;class R, class... ArgTypes&gt;</span></span>
<span id="cb129-13"><a href="#cb129-13"></a><span class="st">-   bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;</span></span>
<span id="cb129-14"><a href="#cb129-14"></a></span>
<span id="cb129-15"><a href="#cb129-15"></a>  // [func.search], searchers</span>
<span id="cb129-16"><a href="#cb129-16"></a>  template&lt;class ForwardIterator, class BinaryPredicate = equal_to&lt;&gt;&gt;</span>
<span id="cb129-17"><a href="#cb129-17"></a>    class default_searcher;</span>
<span id="cb129-18"><a href="#cb129-18"></a>  [...] </span>
<span id="cb129-19"><a href="#cb129-19"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.14.8 [range.cmp]/2 to add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>:</p>
<blockquote>
<p>There is an implementation-defined strict total ordering over all pointer values of a given type. This total ordering is consistent with the partial order imposed by the builtin operators <code class="sourceCode cpp"><span class="op">&lt;</span></code>, <code class="sourceCode cpp"><span class="op">&gt;</span></code>, <code class="sourceCode cpp"><span class="op">&lt;=</span></code>, <span class="rm" style="color: #bf0303"><del>and</del></span> <code class="sourceCode cpp"><span class="op">&gt;=</span></code> <span class="addu">, and <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code></span>.</p>
</blockquote>
<p>Change 20.14.16.2 [func.wrap.func]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb130"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb130-1"><a href="#cb130-1"></a>namespace std {</span>
<span id="cb130-2"><a href="#cb130-2"></a>  template&lt;class&gt; class function; // not defined</span>
<span id="cb130-3"><a href="#cb130-3"></a>  </span>
<span id="cb130-4"><a href="#cb130-4"></a>  [...]</span>
<span id="cb130-5"><a href="#cb130-5"></a>  </span>
<span id="cb130-6"><a href="#cb130-6"></a>  // [func.wrap.func.nullptr], Null pointer comparisons</span>
<span id="cb130-7"><a href="#cb130-7"></a>  template&lt;class R, class... ArgTypes&gt;</span>
<span id="cb130-8"><a href="#cb130-8"></a>    bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;</span>
<span id="cb130-9"><a href="#cb130-9"></a></span>
<span id="cb130-10"><a href="#cb130-10"></a><span class="st">- template&lt;class R, class... ArgTypes&gt;</span></span>
<span id="cb130-11"><a href="#cb130-11"></a><span class="st">-   bool operator==(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;</span></span>
<span id="cb130-12"><a href="#cb130-12"></a><span class="st">-</span></span>
<span id="cb130-13"><a href="#cb130-13"></a><span class="st">- template&lt;class R, class... ArgTypes&gt;</span></span>
<span id="cb130-14"><a href="#cb130-14"></a><span class="st">-   bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;</span></span>
<span id="cb130-15"><a href="#cb130-15"></a><span class="st">-</span></span>
<span id="cb130-16"><a href="#cb130-16"></a><span class="st">- template&lt;class R, class... ArgTypes&gt;</span></span>
<span id="cb130-17"><a href="#cb130-17"></a><span class="st">-   bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;</span></span>
<span id="cb130-18"><a href="#cb130-18"></a></span>
<span id="cb130-19"><a href="#cb130-19"></a>  [...]</span>
<span id="cb130-20"><a href="#cb130-20"></a>}  </span></code></pre></div>
</div>
</blockquote>
<p>Change 20.14.16.2.6 [func.wrap.func.nullptr]:</p>
<blockquote>
<div class="sourceCode" id="cb131"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb131-1"><a href="#cb131-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> R, <span class="kw">class</span><span class="op">...</span> ArgTypes<span class="op">&gt;</span></span>
<span id="cb131-2"><a href="#cb131-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> function<span class="op">&lt;</span>R<span class="op">(</span>ArgTypes<span class="op">...)&gt;&amp;</span> f, nullptr_t<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb131-3"><a href="#cb131-3"></a><span class="rm" style="color: #bf0303"><del>template&lt;class R, class… ArgTypes&gt;</del></span></span>
<span id="cb131-4"><a href="#cb131-4"></a><span class="rm" style="color: #bf0303"><del>bool operator==(nullptr_t, const function&lt;R(ArgTypes…)&gt;&amp; f) noexcept;</del></span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>f</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb132"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb132-1"><a href="#cb132-1"></a>template&lt;class R, class... ArgTypes&gt;</span>
<span id="cb132-2"><a href="#cb132-2"></a>  bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp; f, nullptr_t) noexcept;</span>
<span id="cb132-3"><a href="#cb132-3"></a>template&lt;class R, class... ArgTypes&gt;</span>
<span id="cb132-4"><a href="#cb132-4"></a>  bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp; f) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">(</span><span class="dt">bool</span><span class="op">)</span>f</code>.</p>
</div>
</blockquote>
<p>Add a new row to 20.15.4.3 [meta.unary.prop], the “Type property predicates” table:</p>
<blockquote>
<table>
<tr>
<th>
Template
</th>
<th>
Condition
</th>
<th>
Preconditions
</th>
</tr>
<tr>
<td>
<div class="addu">
<div class="sourceCode" id="cb133"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb133-1"><a href="#cb133-1"></a>template&lt;class T&gt;</span>
<span id="cb133-2"><a href="#cb133-2"></a>struct has_strong_structural_equality;</span></code></pre></div>
</div>
</td>
<td>
<span class="addu">The type <code class="sourceCode cpp">T</code> has strong structural equality ([class.compare.default]).</span>
</td>
<td>
<span class="addu"><code class="sourceCode cpp">T</code> shall be a complete type, <em>cv</em> <code class="sourceCode cpp"><span class="dt">void</span></code>, or an array of unknown bound.</span>
</td>
</tr>
</table>
</blockquote>
<p>Change 20.15.7.6 [meta.trans.other] to add special rule for comparison categories:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> Note A: For the <code class="sourceCode cpp">common_type</code> trait applied to a template parameter pack <code class="sourceCode cpp">T</code> of types, the member <code class="sourceCode cpp">type</code> shall be either defined or not present as follows:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> If <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>T<span class="op">)</span></code> is zero, there shall be no member <code class="sourceCode cpp">type</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.2)</a></span> If <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>T<span class="op">)</span></code> is one, let <code class="sourceCode cpp">T0</code> denote the sole type constituting the pack <code class="sourceCode cpp">T</code>. The member typedef-name <code class="sourceCode cpp">type</code> shall denote the same type, if any, as <code class="sourceCode cpp">common_type_t<span class="op">&lt;</span>T0, T0<span class="op">&gt;</span></code>; otherwise there shall be no member <code class="sourceCode cpp">type</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3)</a></span> If <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>T<span class="op">)</span></code> is two, let the first and second types constituting <code class="sourceCode cpp">T</code> be denoted by <code class="sourceCode cpp">T1</code> and <code class="sourceCode cpp">T2</code>, respectively, and let <code class="sourceCode cpp">D1</code> and <code class="sourceCode cpp">D2</code> denote the same types as <code class="sourceCode cpp">decay_t<span class="op">&lt;</span>T1<span class="op">&gt;</span></code> and <code class="sourceCode cpp">decay_t<span class="op">&lt;</span>T2<span class="op">&gt;</span></code>, respectively.
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.3.1)</a></span> If <code class="sourceCode cpp">is_same_v<span class="op">&lt;</span>T1, D1<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">false</span></code> or <code class="sourceCode cpp">is_same_v<span class="op">&lt;</span>T2, D2<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">false</span></code>, let <code class="sourceCode cpp">C</code> denote the same type, if any, as <code class="sourceCode cpp">common_type_t<span class="op">&lt;</span>D1, D2<span class="op">&gt;</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3.2)</a></span> [<em>Note</em>: None of the following will apply if there is a specialization <code class="sourceCode cpp">common_type<span class="op">&lt;</span>D1, D2<span class="op">&gt;</span></code>. —<em>end note</em>]</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3.*)</a></span> <span class="addu">Otherwise, if both <code class="sourceCode cpp">D1</code> and <code class="sourceCode cpp">D2</code> denote comparison category types ([cmp.categories.pre]), let <code class="sourceCode cpp">C</code> denote the common comparison type ([class.spaceship]) of <code class="sourceCode cpp">D1</code> and <code class="sourceCode cpp">D2</code>.</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3.3)</a></span> Otherwise, if <code class="sourceCode cpp">decay_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">(</span><span class="kw">false</span> <span class="op">?</span> declval<span class="op">&lt;</span>D1<span class="op">&gt;()</span> <span class="op">:</span> declval<span class="op">&lt;</span>D2<span class="op">&gt;())&gt;</span></code> denotes a valid type, let <code class="sourceCode cpp">C</code> denote that type.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.3.4)</a></span> Otherwise, if <code class="sourceCode cpp">COND_RES<span class="op">(</span>CREF<span class="op">(</span>D1<span class="op">)</span>, CREF<span class="op">(</span>D2<span class="op">))</span></code> denotes a type, let <code class="sourceCode cpp">C</code> denote the type <code class="sourceCode cpp">decay_t<span class="op">&lt;</span>COND_RES<span class="op">(</span>CREF<span class="op">(</span>D1<span class="op">)</span>, CREF<span class="op">(</span>D2<span class="op">))&gt;</span></code>. In either case, the member typedef-name type shall denote the same type, if any, as <code class="sourceCode cpp">C</code>. Otherwise, there shall be no member <code class="sourceCode cpp">type</code>.</li>
</ul></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.4)</a></span> If <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>T<span class="op">)</span></code> is greater than two, let <code class="sourceCode cpp">T1</code>, <code class="sourceCode cpp">T2</code>, and <code class="sourceCode cpp">R</code>, respectively, denote the first, second, and (pack of) remaining types constituting <code class="sourceCode cpp">T</code>. Let <code class="sourceCode cpp">C</code> denote the same type, if any, as <code class="sourceCode cpp">common_type_t<span class="op">&lt;</span>T1, T2<span class="op">&gt;</span></code>. If there is such a type <code class="sourceCode cpp">C</code>, the member typedef-name <code class="sourceCode cpp">type</code> shall denote the same type, if any, as <code class="sourceCode cpp">common_type_t<span class="op">&lt;</span>C, R<span class="op">...&gt;</span></code>. Otherwise, there shall be no member <code class="sourceCode cpp">type</code>.</li>
</ul>
</blockquote>
<p>Change 20.17.2 [type.index.overview]. <span class="ednote" style="color: #0000ff">[ Editor&#39;s note: Note that the relational operators on <code class="sourceCode cpp">type_index</code> are based on <code class="sourceCode cpp">type_info<span class="op">::</span>before</code> (effectively <code class="sourceCode cpp"><span class="op">&lt;</span></code>). <code class="sourceCode cpp">type_info</code> <em>could</em> provide a three-way ordering function, but does not. Since an important motivation for the existence of <code class="sourceCode cpp">type_index</code> is to be used as a key in an associative container, we do not want to pessimize <code class="sourceCode cpp"><span class="op">&lt;</span></code> - but do want to provide <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>. ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb134"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb134-1"><a href="#cb134-1"></a>namespace std {</span>
<span id="cb134-2"><a href="#cb134-2"></a>  class type_index {</span>
<span id="cb134-3"><a href="#cb134-3"></a>  public:</span>
<span id="cb134-4"><a href="#cb134-4"></a>    type_index(const type_info&amp; rhs) noexcept;</span>
<span id="cb134-5"><a href="#cb134-5"></a>    bool operator==(const type_index&amp; rhs) const noexcept;</span>
<span id="cb134-6"><a href="#cb134-6"></a><span class="st">-   bool operator!=(const type_index&amp; rhs) const noexcept;</span></span>
<span id="cb134-7"><a href="#cb134-7"></a>    bool operator&lt; (const type_index&amp; rhs) const noexcept;</span>
<span id="cb134-8"><a href="#cb134-8"></a>    bool operator&gt; (const type_index&amp; rhs) const noexcept;</span>
<span id="cb134-9"><a href="#cb134-9"></a>    bool operator&lt;=(const type_index&amp; rhs) const noexcept;</span>
<span id="cb134-10"><a href="#cb134-10"></a>    bool operator&gt;=(const type_index&amp; rhs) const noexcept;</span>
<span id="cb134-11"><a href="#cb134-11"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const type_index&amp; rhs) const noexcept;</span></span>
<span id="cb134-12"><a href="#cb134-12"></a>    size_t hash_code() const noexcept;</span>
<span id="cb134-13"><a href="#cb134-13"></a>    const char* name() const noexcept;</span>
<span id="cb134-14"><a href="#cb134-14"></a></span>
<span id="cb134-15"><a href="#cb134-15"></a>  private:</span>
<span id="cb134-16"><a href="#cb134-16"></a>    const type_info* target;    // exposition only</span>
<span id="cb134-17"><a href="#cb134-17"></a>    // Note that the use of a pointer here, rather than a reference,</span>
<span id="cb134-18"><a href="#cb134-18"></a>    // means that the default copy/move constructor and assignment</span>
<span id="cb134-19"><a href="#cb134-19"></a>    // operators will be provided and work as expected.</span>
<span id="cb134-20"><a href="#cb134-20"></a>  };</span>
<span id="cb134-21"><a href="#cb134-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 20.17.3 [type.index.members]:</p>
<blockquote>
<div class="sourceCode" id="cb135"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb135-1"><a href="#cb135-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> type_index<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">*</span>target <span class="op">==</span> <span class="op">*</span>rhs<span class="op">.</span>target</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb136"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb136-1"><a href="#cb136-1"></a>bool operator!=(const type_index&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">*</span>target <span class="op">!=</span> <span class="op">*</span>rhs<span class="op">.</span>target</code>.</p>
</div>
<div class="sourceCode" id="cb137"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb137-1"><a href="#cb137-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;(</span><span class="kw">const</span> type_index<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">target<span class="op">-&gt;</span>before<span class="op">(*</span>rhs<span class="op">.</span>target<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb138"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb138-1"><a href="#cb138-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;(</span><span class="kw">const</span> type_index<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs<span class="op">.</span>target<span class="op">-&gt;</span>before<span class="op">(*</span>target<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb139"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb139-1"><a href="#cb139-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><span class="kw">const</span> type_index<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>rhs<span class="op">.</span>target<span class="op">-&gt;</span>before<span class="op">(*</span>target<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb140"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb140-1"><a href="#cb140-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> type_index<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>target<span class="op">-&gt;</span>before<span class="op">(*</span>rhs<span class="op">.</span>target<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb141"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb141-1"><a href="#cb141-1"></a>strong_ordering operator&lt;=&gt;(const type_index&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb142"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb142-1"><a href="#cb142-1"></a>if (*target == *rhs.target) return strong_ordering::equal;</span>
<span id="cb142-2"><a href="#cb142-2"></a>if (target-&gt;before(*rhs.target)) return strong_ordering::less;</span>
<span id="cb142-3"><a href="#cb142-3"></a>return strong_ordering::greater;</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<p>Change 20.19.1 [charconv.syn] (from <span class="citation" data-cites="P1191R0">[<a href="#ref-P1191R0" role="doc-biblioref">P1191R0</a>]</span>):</p>
<blockquote>
<div>
<div class="sourceCode" id="cb143"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb143-1"><a href="#cb143-1"></a>namespace std {</span>
<span id="cb143-2"><a href="#cb143-2"></a>  [...]</span>
<span id="cb143-3"><a href="#cb143-3"></a></span>
<span id="cb143-4"><a href="#cb143-4"></a>  // [charconv.to.chars], primitive numerical output conversion</span>
<span id="cb143-5"><a href="#cb143-5"></a>  struct to_chars_result {</span>
<span id="cb143-6"><a href="#cb143-6"></a>    char* ptr;</span>
<span id="cb143-7"><a href="#cb143-7"></a>    errc ec;</span>
<span id="cb143-8"><a href="#cb143-8"></a></span>
<span id="cb143-9"><a href="#cb143-9"></a><span class="va">+   friend bool operator==(const to_chars_result&amp;, const to_chars_result&amp;) = default;</span></span>
<span id="cb143-10"><a href="#cb143-10"></a>  };</span>
<span id="cb143-11"><a href="#cb143-11"></a></span>
<span id="cb143-12"><a href="#cb143-12"></a>  [...]</span>
<span id="cb143-13"><a href="#cb143-13"></a></span>
<span id="cb143-14"><a href="#cb143-14"></a>  // [charconv.from.chars], primitive numerical input conversion</span>
<span id="cb143-15"><a href="#cb143-15"></a>  struct from_chars_result {</span>
<span id="cb143-16"><a href="#cb143-16"></a>    const char* ptr;</span>
<span id="cb143-17"><a href="#cb143-17"></a>    errc ec;</span>
<span id="cb143-18"><a href="#cb143-18"></a></span>
<span id="cb143-19"><a href="#cb143-19"></a><span class="va">+   friend bool operator==(const from_chars_result&amp;, const from_chars_result&amp;) = default;</span></span>
<span id="cb143-20"><a href="#cb143-20"></a>  };</span>
<span id="cb143-21"><a href="#cb143-21"></a></span>
<span id="cb143-22"><a href="#cb143-22"></a>  [...]</span>
<span id="cb143-23"><a href="#cb143-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<h2 id="clause-21-strings-library"><span class="header-section-number">5.6</span> Clause 21: Strings library<a href="#clause-21-strings-library" class="self-link"></a></h2>
<p>Changing the operators for <code class="sourceCode cpp">basic_string</code> and <code class="sourceCode cpp">basic_string_view</code> and adding extra type alises to the <code class="sourceCode cpp">char_traits</code> specializations provided by the standard.</p>
<p>Change 21.2.3.1 [char.traits.specializations.char]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb144"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb144-1"><a href="#cb144-1"></a>namespace std {</span>
<span id="cb144-2"><a href="#cb144-2"></a>  template&lt;&gt; struct char_traits&lt;char&gt; {</span>
<span id="cb144-3"><a href="#cb144-3"></a>    using char_type  = char;</span>
<span id="cb144-4"><a href="#cb144-4"></a>    using int_type   = int;</span>
<span id="cb144-5"><a href="#cb144-5"></a>    using off_type   = streamoff;</span>
<span id="cb144-6"><a href="#cb144-6"></a>    using pos_type   = streampos;</span>
<span id="cb144-7"><a href="#cb144-7"></a>    using state_type = mbstate_t;</span>
<span id="cb144-8"><a href="#cb144-8"></a><span class="va">+   using comparison_category = strong_ordering;</span></span>
<span id="cb144-9"><a href="#cb144-9"></a>    [...]</span>
<span id="cb144-10"><a href="#cb144-10"></a>  };</span>
<span id="cb144-11"><a href="#cb144-11"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 21.2.3.2 [char.traits.specializations.char8.t]</p>
<blockquote>
<div>
<div class="sourceCode" id="cb145"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb145-1"><a href="#cb145-1"></a>namespace std {</span>
<span id="cb145-2"><a href="#cb145-2"></a>  template&lt;&gt; struct char_traits&lt;char8_t&gt; {</span>
<span id="cb145-3"><a href="#cb145-3"></a>    using char_type = char8_t;</span>
<span id="cb145-4"><a href="#cb145-4"></a>    using int_type = unsigned int;</span>
<span id="cb145-5"><a href="#cb145-5"></a>    using off_type = streamoff;</span>
<span id="cb145-6"><a href="#cb145-6"></a>    using pos_type = u8streampos;</span>
<span id="cb145-7"><a href="#cb145-7"></a>    using state_type = mbstate_t;</span>
<span id="cb145-8"><a href="#cb145-8"></a><span class="va">+   using comparison_category = strong_ordering;    </span></span>
<span id="cb145-9"><a href="#cb145-9"></a>    [...]</span>
<span id="cb145-10"><a href="#cb145-10"></a>  };</span>
<span id="cb145-11"><a href="#cb145-11"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 21.2.3.3 [char.traits.specializations.char16.t]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb146"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb146-1"><a href="#cb146-1"></a>namespace std {</span>
<span id="cb146-2"><a href="#cb146-2"></a>  template&lt;&gt; struct char_traits&lt;char16_t&gt; {</span>
<span id="cb146-3"><a href="#cb146-3"></a>    using char_type  = char16_t;</span>
<span id="cb146-4"><a href="#cb146-4"></a>    using int_type   = uint_least16_t;</span>
<span id="cb146-5"><a href="#cb146-5"></a>    using off_type   = streamoff;</span>
<span id="cb146-6"><a href="#cb146-6"></a>    using pos_type   = u16streampos;</span>
<span id="cb146-7"><a href="#cb146-7"></a>    using state_type = mbstate_t;</span>
<span id="cb146-8"><a href="#cb146-8"></a><span class="va">+   using comparison_category = strong_ordering;    </span></span>
<span id="cb146-9"><a href="#cb146-9"></a>    [...]</span>
<span id="cb146-10"><a href="#cb146-10"></a>  };</span>
<span id="cb146-11"><a href="#cb146-11"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 21.2.3.4 [char.traits.specializations.char32.t]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb147"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb147-1"><a href="#cb147-1"></a>namespace std {</span>
<span id="cb147-2"><a href="#cb147-2"></a>  template&lt;&gt; struct char_traits&lt;char32_t&gt; {</span>
<span id="cb147-3"><a href="#cb147-3"></a>    using char_type  = char32_t;</span>
<span id="cb147-4"><a href="#cb147-4"></a>    using int_type   = uint_least32_t;</span>
<span id="cb147-5"><a href="#cb147-5"></a>    using off_type   = streamoff;</span>
<span id="cb147-6"><a href="#cb147-6"></a>    using pos_type   = u32streampos;</span>
<span id="cb147-7"><a href="#cb147-7"></a>    using state_type = mbstate_t;</span>
<span id="cb147-8"><a href="#cb147-8"></a><span class="va">+   using comparison_category = strong_ordering;    </span></span>
<span id="cb147-9"><a href="#cb147-9"></a>    [...]</span>
<span id="cb147-10"><a href="#cb147-10"></a>  };</span>
<span id="cb147-11"><a href="#cb147-11"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 21.2.3.5 [char.traits.specializations.wchar.t]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb148"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb148-1"><a href="#cb148-1"></a>namespace std {</span>
<span id="cb148-2"><a href="#cb148-2"></a>  template&lt;&gt; struct char_traits&lt;wchar_t&gt; {</span>
<span id="cb148-3"><a href="#cb148-3"></a>    using char_type  = wchar_t;</span>
<span id="cb148-4"><a href="#cb148-4"></a>    using int_type   = wint_t;</span>
<span id="cb148-5"><a href="#cb148-5"></a>    using off_type   = streamoff;</span>
<span id="cb148-6"><a href="#cb148-6"></a>    using pos_type   = wstreampos;</span>
<span id="cb148-7"><a href="#cb148-7"></a>    using state_type = mbstate_t;</span>
<span id="cb148-8"><a href="#cb148-8"></a><span class="va">+   using comparison_category = strong_ordering;    </span></span>
<span id="cb148-9"><a href="#cb148-9"></a>    [...]</span>
<span id="cb148-10"><a href="#cb148-10"></a>  };</span>
<span id="cb148-11"><a href="#cb148-11"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 21.3.1 [string.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb149"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb149-1"><a href="#cb149-1"></a>namespace std {</span>
<span id="cb149-2"><a href="#cb149-2"></a>  // [char.traits], character traits</span>
<span id="cb149-3"><a href="#cb149-3"></a>  template&lt;class charT&gt; struct char_traits;</span>
<span id="cb149-4"><a href="#cb149-4"></a>  template&lt;&gt; struct char_traits&lt;char&gt;;</span>
<span id="cb149-5"><a href="#cb149-5"></a>  template&lt;&gt; struct char_traits&lt;char8_t&gt;;</span>
<span id="cb149-6"><a href="#cb149-6"></a>  template&lt;&gt; struct char_traits&lt;char16_t&gt;;</span>
<span id="cb149-7"><a href="#cb149-7"></a>  template&lt;&gt; struct char_traits&lt;char32_t&gt;;</span>
<span id="cb149-8"><a href="#cb149-8"></a>  template&lt;&gt; struct char_traits&lt;wchar_t&gt;;</span>
<span id="cb149-9"><a href="#cb149-9"></a></span>
<span id="cb149-10"><a href="#cb149-10"></a>  // [basic.string], basic_string</span>
<span id="cb149-11"><a href="#cb149-11"></a>  template&lt;class charT, class traits = char_traits&lt;charT&gt;, class Allocator = allocator&lt;charT&gt;&gt;</span>
<span id="cb149-12"><a href="#cb149-12"></a>    class basic_string;</span>
<span id="cb149-13"><a href="#cb149-13"></a>    </span>
<span id="cb149-14"><a href="#cb149-14"></a>  [...]</span>
<span id="cb149-15"><a href="#cb149-15"></a>  </span>
<span id="cb149-16"><a href="#cb149-16"></a>  template&lt;class charT, class traits, class Allocator&gt;</span>
<span id="cb149-17"><a href="#cb149-17"></a>    bool operator==(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span>
<span id="cb149-18"><a href="#cb149-18"></a>                    const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span>
<span id="cb149-19"><a href="#cb149-19"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-20"><a href="#cb149-20"></a><span class="st">-   bool operator==(const charT* lhs,</span></span>
<span id="cb149-21"><a href="#cb149-21"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb149-22"><a href="#cb149-22"></a>  template&lt;class charT, class traits, class Allocator&gt;</span>
<span id="cb149-23"><a href="#cb149-23"></a>    bool operator==(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span>
<span id="cb149-24"><a href="#cb149-24"></a>                    const charT* rhs);</span>
<span id="cb149-25"><a href="#cb149-25"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-26"><a href="#cb149-26"></a><span class="st">-   bool operator!=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-27"><a href="#cb149-27"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb149-28"><a href="#cb149-28"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-29"><a href="#cb149-29"></a><span class="st">-   bool operator!=(const charT* lhs,</span></span>
<span id="cb149-30"><a href="#cb149-30"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb149-31"><a href="#cb149-31"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-32"><a href="#cb149-32"></a><span class="st">-   bool operator!=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-33"><a href="#cb149-33"></a><span class="st">-                   const charT* rhs);</span></span>
<span id="cb149-34"><a href="#cb149-34"></a></span>
<span id="cb149-35"><a href="#cb149-35"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-36"><a href="#cb149-36"></a><span class="st">-   bool operator&lt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-37"><a href="#cb149-37"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb149-38"><a href="#cb149-38"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-39"><a href="#cb149-39"></a><span class="st">-   bool operator&lt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-40"><a href="#cb149-40"></a><span class="st">-                   const charT* rhs);</span></span>
<span id="cb149-41"><a href="#cb149-41"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-42"><a href="#cb149-42"></a><span class="st">-   bool operator&lt; (const charT* lhs,</span></span>
<span id="cb149-43"><a href="#cb149-43"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb149-44"><a href="#cb149-44"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-45"><a href="#cb149-45"></a><span class="st">-   bool operator&gt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-46"><a href="#cb149-46"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb149-47"><a href="#cb149-47"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-48"><a href="#cb149-48"></a><span class="st">-   bool operator&gt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-49"><a href="#cb149-49"></a><span class="st">-                   const charT* rhs);</span></span>
<span id="cb149-50"><a href="#cb149-50"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-51"><a href="#cb149-51"></a><span class="st">-   bool operator&gt; (const charT* lhs,</span></span>
<span id="cb149-52"><a href="#cb149-52"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb149-53"><a href="#cb149-53"></a></span>
<span id="cb149-54"><a href="#cb149-54"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-55"><a href="#cb149-55"></a><span class="st">-   bool operator&lt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-56"><a href="#cb149-56"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb149-57"><a href="#cb149-57"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-58"><a href="#cb149-58"></a><span class="st">-   bool operator&lt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-59"><a href="#cb149-59"></a><span class="st">-                   const charT* rhs);</span></span>
<span id="cb149-60"><a href="#cb149-60"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-61"><a href="#cb149-61"></a><span class="st">-   bool operator&lt;=(const charT* lhs,</span></span>
<span id="cb149-62"><a href="#cb149-62"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb149-63"><a href="#cb149-63"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-64"><a href="#cb149-64"></a><span class="st">-   bool operator&gt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-65"><a href="#cb149-65"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb149-66"><a href="#cb149-66"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-67"><a href="#cb149-67"></a><span class="st">-   bool operator&gt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-68"><a href="#cb149-68"></a><span class="st">-                   const charT* rhs);</span></span>
<span id="cb149-69"><a href="#cb149-69"></a><span class="st">- template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-70"><a href="#cb149-70"></a><span class="st">-   bool operator&gt;=(const charT* lhs,</span></span>
<span id="cb149-71"><a href="#cb149-71"></a><span class="st">-                   const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb149-72"><a href="#cb149-72"></a></span>
<span id="cb149-73"><a href="#cb149-73"></a><span class="va">+ template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-74"><a href="#cb149-74"></a><span class="va">+   <em>see below</em> operator&lt;=&gt;(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-75"><a href="#cb149-75"></a><span class="va">+                         const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb149-76"><a href="#cb149-76"></a><span class="va">+ template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb149-77"><a href="#cb149-77"></a><span class="va">+   <em>see below</em> operator&lt;=&gt;(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb149-78"><a href="#cb149-78"></a><span class="va">+                         const charT* rhs);</span></span>
<span id="cb149-79"><a href="#cb149-79"></a></span>
<span id="cb149-80"><a href="#cb149-80"></a></span>
<span id="cb149-81"><a href="#cb149-81"></a>  [...]</span>
<span id="cb149-82"><a href="#cb149-82"></a>}  </span></code></pre></div>
</div>
</blockquote>
<p>Change 21.3.3.2 [string.cmp]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb150"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb150-1"><a href="#cb150-1"></a>   template&lt;class charT, class traits, class Allocator&gt;</span>
<span id="cb150-2"><a href="#cb150-2"></a>     bool operator==(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span>
<span id="cb150-3"><a href="#cb150-3"></a>                     const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span>
<span id="cb150-4"><a href="#cb150-4"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-5"><a href="#cb150-5"></a><span class="st">-    bool operator==(const charT* lhs, const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb150-6"><a href="#cb150-6"></a>   template&lt;class charT, class traits, class Allocator&gt;</span>
<span id="cb150-7"><a href="#cb150-7"></a>     bool operator==(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs, const charT* rhs);</span>
<span id="cb150-8"><a href="#cb150-8"></a>   </span>
<span id="cb150-9"><a href="#cb150-9"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-10"><a href="#cb150-10"></a><span class="st">-    bool operator!=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-11"><a href="#cb150-11"></a><span class="st">-                    const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb150-12"><a href="#cb150-12"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-13"><a href="#cb150-13"></a><span class="st">-    bool operator!=(const charT* lhs, const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb150-14"><a href="#cb150-14"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-15"><a href="#cb150-15"></a><span class="st">-    bool operator!=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs, const charT* rhs);</span></span>
<span id="cb150-16"><a href="#cb150-16"></a>   </span>
<span id="cb150-17"><a href="#cb150-17"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-18"><a href="#cb150-18"></a><span class="st">-    bool operator&lt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-19"><a href="#cb150-19"></a><span class="st">-                    const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb150-20"><a href="#cb150-20"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-21"><a href="#cb150-21"></a><span class="st">-    bool operator&lt; (const charT* lhs, const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb150-22"><a href="#cb150-22"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-23"><a href="#cb150-23"></a><span class="st">-    bool operator&lt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs, const charT* rhs);</span></span>
<span id="cb150-24"><a href="#cb150-24"></a>   </span>
<span id="cb150-25"><a href="#cb150-25"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-26"><a href="#cb150-26"></a><span class="st">-    bool operator&gt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-27"><a href="#cb150-27"></a><span class="st">-                    const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb150-28"><a href="#cb150-28"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-29"><a href="#cb150-29"></a><span class="st">-    bool operator&gt; (const charT* lhs, const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb150-30"><a href="#cb150-30"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-31"><a href="#cb150-31"></a><span class="st">-    bool operator&gt; (const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs, const charT* rhs);</span></span>
<span id="cb150-32"><a href="#cb150-32"></a>   </span>
<span id="cb150-33"><a href="#cb150-33"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-34"><a href="#cb150-34"></a><span class="st">-    bool operator&lt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-35"><a href="#cb150-35"></a><span class="st">-                    const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb150-36"><a href="#cb150-36"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-37"><a href="#cb150-37"></a><span class="st">-    bool operator&lt;=(const charT* lhs, const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb150-38"><a href="#cb150-38"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-39"><a href="#cb150-39"></a><span class="st">-    bool operator&lt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs, const charT* rhs);</span></span>
<span id="cb150-40"><a href="#cb150-40"></a>   </span>
<span id="cb150-41"><a href="#cb150-41"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-42"><a href="#cb150-42"></a><span class="st">-    bool operator&gt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-43"><a href="#cb150-43"></a><span class="st">-                    const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb150-44"><a href="#cb150-44"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-45"><a href="#cb150-45"></a><span class="st">-    bool operator&gt;=(const charT* lhs, const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs);</span></span>
<span id="cb150-46"><a href="#cb150-46"></a><span class="st">-  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-47"><a href="#cb150-47"></a><span class="st">-    bool operator&gt;=(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs, const charT* rhs);</span></span>
<span id="cb150-48"><a href="#cb150-48"></a></span>
<span id="cb150-49"><a href="#cb150-49"></a><span class="va">+  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-50"><a href="#cb150-50"></a><span class="va">+    <em>see below</em> operator&lt;=&gt;(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-51"><a href="#cb150-51"></a><span class="va">+                          const basic_string&lt;charT, traits, Allocator&gt;&amp; rhs) noexcept;</span></span>
<span id="cb150-52"><a href="#cb150-52"></a><span class="va">+  template&lt;class charT, class traits, class Allocator&gt;</span></span>
<span id="cb150-53"><a href="#cb150-53"></a><span class="va">+    <em>see below</em> operator&lt;=&gt;(const basic_string&lt;charT, traits, Allocator&gt;&amp; lhs,</span></span>
<span id="cb150-54"><a href="#cb150-54"></a><span class="va">+                          const charT* rhs);</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Let <code class="sourceCode cpp">op</code> be the operator. Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb151"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb151-1"><a href="#cb151-1"></a><span class="cf">return</span> basic_string_view<span class="op">&lt;</span>charT, traits<span class="op">&gt;(</span>lhs<span class="op">)</span> <em>op</em> basic_string_view<span class="op">&lt;</span>charT, traits<span class="op">&gt;(</span>rhs<span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<p>Change 21.4.1 [string.view.synop]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb152"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb152-1"><a href="#cb152-1"></a>namespace std {</span>
<span id="cb152-2"><a href="#cb152-2"></a>  // [string.view.template], class template basic_string_view</span>
<span id="cb152-3"><a href="#cb152-3"></a>  template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;</span>
<span id="cb152-4"><a href="#cb152-4"></a>  class basic_string_view;</span>
<span id="cb152-5"><a href="#cb152-5"></a></span>
<span id="cb152-6"><a href="#cb152-6"></a>  // [string.view.comparison], non-member comparison functions</span>
<span id="cb152-7"><a href="#cb152-7"></a>  template&lt;class charT, class traits&gt;</span>
<span id="cb152-8"><a href="#cb152-8"></a>    constexpr bool operator==(basic_string_view&lt;charT, traits&gt; x,</span>
<span id="cb152-9"><a href="#cb152-9"></a>                              basic_string_view&lt;charT, traits&gt; y) noexcept;</span>
<span id="cb152-10"><a href="#cb152-10"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb152-11"><a href="#cb152-11"></a><span class="st">-   constexpr bool operator!=(basic_string_view&lt;charT, traits&gt; x,</span></span>
<span id="cb152-12"><a href="#cb152-12"></a><span class="st">-                             basic_string_view&lt;charT, traits&gt; y) noexcept;</span></span>
<span id="cb152-13"><a href="#cb152-13"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb152-14"><a href="#cb152-14"></a><span class="st">-   constexpr bool operator&lt; (basic_string_view&lt;charT, traits&gt; x,</span></span>
<span id="cb152-15"><a href="#cb152-15"></a><span class="st">-                             basic_string_view&lt;charT, traits&gt; y) noexcept;</span></span>
<span id="cb152-16"><a href="#cb152-16"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb152-17"><a href="#cb152-17"></a><span class="st">-   constexpr bool operator&gt; (basic_string_view&lt;charT, traits&gt; x,</span></span>
<span id="cb152-18"><a href="#cb152-18"></a><span class="st">-                             basic_string_view&lt;charT, traits&gt; y) noexcept;</span></span>
<span id="cb152-19"><a href="#cb152-19"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb152-20"><a href="#cb152-20"></a><span class="st">-   constexpr bool operator&lt;=(basic_string_view&lt;charT, traits&gt; x,</span></span>
<span id="cb152-21"><a href="#cb152-21"></a><span class="st">-                             basic_string_view&lt;charT, traits&gt; y) noexcept;</span></span>
<span id="cb152-22"><a href="#cb152-22"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb152-23"><a href="#cb152-23"></a><span class="st">-   constexpr bool operator&gt;=(basic_string_view&lt;charT, traits&gt; x,</span></span>
<span id="cb152-24"><a href="#cb152-24"></a><span class="st">-                             basic_string_view&lt;charT, traits&gt; y) noexcept;</span></span>
<span id="cb152-25"><a href="#cb152-25"></a><span class="va">+ template&lt;class charT, class traits&gt;</span></span>
<span id="cb152-26"><a href="#cb152-26"></a><span class="va">+   constexpr <em>see below</em> operator&lt;=&gt;(basic_string_view&lt;charT, traits&gt; x,</span></span>
<span id="cb152-27"><a href="#cb152-27"></a><span class="va">+                                   basic_string_view&lt;charT, traits&gt; y) noexcept;</span></span>
<span id="cb152-28"><a href="#cb152-28"></a></span>
<span id="cb152-29"><a href="#cb152-29"></a>  // see [string.view.comparison], sufficient additional overloads of comparison functions</span>
<span id="cb152-30"><a href="#cb152-30"></a></span>
<span id="cb152-31"><a href="#cb152-31"></a>  [...]</span>
<span id="cb152-32"><a href="#cb152-32"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to the table at the beginning of 21.4.3 [string.view.comparison]:</p>
<blockquote>
<table>
<tr>
<th>
Expression
</th>
<th>
Equivalent to
</th>
</tr>
<tr>
<td>
<code class="sourceCode cpp">t <span class="op">==</span> sv</code>
</td>
<td>
<code class="sourceCode cpp">S<span class="op">(</span>t<span class="op">)</span> <span class="op">==</span> sv</code>
</td>
</tr>
<tr>
<td>
[…]
</td>
<td>
[…]
</td>
</tr>
<tr>
<td>
<span class="addu"><code>t &lt;=&gt; sv</code></span>
</td>
<td>
<span class="addu"><code>S(t) &lt;=&gt; sv</code></span>
</td>
</tr>
<tr>
<td>
<span class="addu"><code>sv &lt;=&gt; t</code></span>
</td>
<td>
<span class="addu"><code>sv &lt;=&gt; S(t)</code></span>
</td>
</tr>
</table>
</blockquote>
<p>Remove the redundant <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> in the example in 21.4.3 [string.view.comparison]:</p>
<blockquote>
<p>[<em>Example</em>: A sample conforming implementation for <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> would be:</p>
<div>
<div class="sourceCode" id="cb153"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb153-1"><a href="#cb153-1"></a>  template&lt;class charT, class traits&gt;</span>
<span id="cb153-2"><a href="#cb153-2"></a>    constexpr bool operator==(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb153-3"><a href="#cb153-3"></a>                              basic_string_view&lt;charT, traits&gt; rhs) noexcept {</span>
<span id="cb153-4"><a href="#cb153-4"></a>      return lhs.compare(rhs) == 0;</span>
<span id="cb153-5"><a href="#cb153-5"></a>    }</span>
<span id="cb153-6"><a href="#cb153-6"></a>  template&lt;class charT, class traits&gt;</span>
<span id="cb153-7"><a href="#cb153-7"></a>    constexpr bool operator==(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb153-8"><a href="#cb153-8"></a>                              type_identity_t&lt;basic_string_view&lt;charT, traits&gt;&gt; rhs) noexcept {</span>
<span id="cb153-9"><a href="#cb153-9"></a>      return lhs.compare(rhs) == 0;</span>
<span id="cb153-10"><a href="#cb153-10"></a>    }</span>
<span id="cb153-11"><a href="#cb153-11"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb153-12"><a href="#cb153-12"></a><span class="st">-   constexpr bool operator==(type_identity_t&lt;basic_string_view&lt;charT, traits&gt;&gt; lhs,</span></span>
<span id="cb153-13"><a href="#cb153-13"></a><span class="st">-                             basic_string_view&lt;charT, traits&gt; rhs) noexcept {</span></span>
<span id="cb153-14"><a href="#cb153-14"></a><span class="st">-     return lhs.compare(rhs) == 0;</span></span>
<span id="cb153-15"><a href="#cb153-15"></a><span class="st">-   }</span></span></code></pre></div>
</div>
<p>—<em>end example</em>]</p>
</blockquote>
<p>Change the rest of 21.4.3 [string.view.comparison]:</p>
<blockquote>
<div class="sourceCode" id="cb154"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb154-1"><a href="#cb154-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> charT, <span class="kw">class</span> traits<span class="op">&gt;</span></span>
<span id="cb154-2"><a href="#cb154-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>basic_string_view<span class="op">&lt;</span>charT, traits<span class="op">&gt;</span> lhs,</span>
<span id="cb154-3"><a href="#cb154-3"></a>                            basic_string_view<span class="op">&lt;</span>charT, traits<span class="op">&gt;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb155"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb155-1"><a href="#cb155-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb155-2"><a href="#cb155-2"></a>  constexpr bool operator!=(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb155-3"><a href="#cb155-3"></a>                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">!=</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb156"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb156-1"><a href="#cb156-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb156-2"><a href="#cb156-2"></a>  constexpr bool operator&lt;(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb156-3"><a href="#cb156-3"></a>                           basic_string_view&lt;charT, traits&gt; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb157"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb157-1"><a href="#cb157-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb157-2"><a href="#cb157-2"></a>  constexpr bool operator&gt;(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb157-3"><a href="#cb157-3"></a>                           basic_string_view&lt;charT, traits&gt; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb158"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb158-1"><a href="#cb158-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb158-2"><a href="#cb158-2"></a>  constexpr bool operator&lt;=(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb158-3"><a href="#cb158-3"></a>                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;=</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb159"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb159-1"><a href="#cb159-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb159-2"><a href="#cb159-2"></a>  constexpr bool operator&gt;=(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb159-3"><a href="#cb159-3"></a>                            basic_string_view&lt;charT, traits&gt; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&gt;=</span> <span class="dv">0</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb160"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb160-1"><a href="#cb160-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb160-2"><a href="#cb160-2"></a>  constexpr <em>see below</em> operator&lt;=&gt;(basic_string_view&lt;charT, traits&gt; lhs,</span>
<span id="cb160-3"><a href="#cb160-3"></a>                                  basic_string_view&lt;charT, traits&gt; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> Let <code class="sourceCode cpp">R</code> denote the type <code class="sourceCode cpp">traits<span class="op">::</span>comparison_category</code> if it exists, otherwise <code class="sourceCode cpp">R</code> is <code class="sourceCode cpp">weak_ordering</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">static_cast</span><span class="op">&lt;</span>R<span class="op">&gt;(</span>lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dv">0</span><span class="op">)</span></code>.</p>
</div>
</blockquote>
<h2 id="clause-22-containers-library"><span class="header-section-number">5.7</span> Clause 22: Containers library<a href="#clause-22-containers-library" class="self-link"></a></h2>
<p><span class="ednote" style="color: #0000ff">[ Editor&#39;s note: <code class="sourceCode cpp">array</code>’s comparisons move to be hidden friends to allow for use as non-type template parameters. All the other containers drop <code class="sourceCode cpp"><span class="op">!=</span></code> and, if they have relational operators, those get replaced with a <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>. ]</span></p>
<p>Add to 22.2.1 [container.requirements.general]/4:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> In Tables 62, 63, and 64 <code class="sourceCode cpp">X</code> denotes a container class containing objects of type <code class="sourceCode cpp">T</code>, <code class="sourceCode cpp">a</code> and <code class="sourceCode cpp">b</code> denote values of type <code class="sourceCode cpp">X</code>, <span class="addu"><code class="sourceCode cpp">i</code> and <code class="sourceCode cpp">j</code> denote values of type (possibly-const) <code class="sourceCode cpp">X<span class="op">::</span>iterator</code></span>, <code class="sourceCode cpp">u</code> denotes an identifier, <code class="sourceCode cpp">r</code> denotes a non-const value of type <code class="sourceCode cpp">X</code>, and <code class="sourceCode cpp">rv</code> denotes a non-const rvalue of type <code class="sourceCode cpp">X</code>.</p>
</blockquote>
<p>Add a row to 22.2.1, Table 62 [container.req]:</p>
<blockquote>
<table>
<tr>
<th>
Expression
</th>
<th>
Return type
</th>
<th>
Operational<br />semantics
</th>
<th>
Assertion/note<br />pre-/post-condition
</th>
<th>
Complexity
</th>
</tr>
<tr>
<td>
<span class="addu"><code class="sourceCode cpp">i <span class="op">&lt;=&gt;</span> j</code></span>
</td>
<td>
<span class="addu"><code class="sourceCode cpp">strong_ordering</code> if <code class="sourceCode cpp">X<span class="op">::</span>iterator</code> meets the random access iterator requirements, otherwise <code class="sourceCode cpp">strong_equality</code></span>
</td>
<td>
</td>
<td>
</td>
<td>
<span class="addu">constant</span>
</td>
</tr>
</table>
</blockquote>
<p>Add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to the requirements in 22.2.1 [container.requirements.general]/7:</p>
<blockquote>
<p>In the expressions</p>
<div>
<div class="sourceCode" id="cb161"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb161-1"><a href="#cb161-1"></a>  i == j</span>
<span id="cb161-2"><a href="#cb161-2"></a>  i != j</span>
<span id="cb161-3"><a href="#cb161-3"></a>  i &lt; j</span>
<span id="cb161-4"><a href="#cb161-4"></a>  i &lt;= j</span>
<span id="cb161-5"><a href="#cb161-5"></a>  i &gt;= j</span>
<span id="cb161-6"><a href="#cb161-6"></a>  i &gt; j</span>
<span id="cb161-7"><a href="#cb161-7"></a><span class="va">+ i &lt;=&gt; j</span></span>
<span id="cb161-8"><a href="#cb161-8"></a>  i - j</span></code></pre></div>
</div>
<p>where <code class="sourceCode cpp">i</code> and <code class="sourceCode cpp">j</code> denote objects of a container’s iterator type, either or both may be replaced by an object of the container’s <code class="sourceCode cpp">const_iterator</code> type referring to the same element with no change in semantics.</p>
</blockquote>
<p>Replace 22.2.1 [container.requirements.general], Table 64 [container.opt] to refer to <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> using <em><code class="sourceCode default">synth-three-way</code></em> instead of <code class="sourceCode cpp"><span class="op">&lt;</span></code>.</p>
<blockquote>
<p>Table 64 lists operations that are provided for some types of containers but not others. Those containers for which the listed operations are provided shall implement the semantics described in Table 64 unless otherwise stated. If the iterators passed to <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">lexicographical_compare</code></span></del></span> <span class="addu"><code class="sourceCode cpp">lexicographical_compare_three_way</code></span> satisfy the constexpr iterator requirements ([iterator.requirements.general]) then the operations described in Table 64 are implemented by constexpr functions.</p>
<table>
<tr>
<th>
Expression
</th>
<th>
Return type
</th>
<th>
Operational<br />semantics
</th>
<th>
Assertion/note<br />pre-/post-condition
</th>
<th>
Complexity
</th>
</tr>
<tr>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">a <span class="op">&lt;</span> b</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>convertible to <span><code class="sourceCode default">bool</code></span></del></span>
</td>
<td>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb162"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb162-1"><a href="#cb162-1"></a>lexicographical_compare(</span>
<span id="cb162-2"><a href="#cb162-2"></a>    a.begin(), a.end(),</span>
<span id="cb162-3"><a href="#cb162-3"></a>    b.begin(), b.end())</span></code></pre></div>

</div>
</td>
<td>
<span class="rm" style="color: #bf0303"><del><em>Expects</em>: <span><code class="sourceCode cpp"><span class="op">&lt;</span></code></span> is defined for values of type (possibly const) <span><code class="sourceCode cpp">T</code></span>. <span><code class="sourceCode cpp"><span class="op">&lt;</span></code></span> is a total ordering relationship.</del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>linear</del></span>
</td>
</tr>
<tr>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">a <span class="op">&gt;</span> b</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>convertible to <span><code class="sourceCode default">bool</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">b <span class="op">&lt;</span> a</code></span></del></span>
</td>
<td>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>linear</del></span>
</td>
</tr>
<tr>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">a <span class="op">&lt;=</span> b</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>convertible to <span><code class="sourceCode default">bool</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">&gt;</span> b<span class="op">)</span></code></span></del></span>
</td>
<td>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>linear</del></span>
</td>
</tr>
<tr>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">a <span class="op">&gt;=</span> b</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>convertible to <span><code class="sourceCode default">bool</code></span></del></span>
</td>
<td>
<span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp"><span class="op">!(</span>a <span class="op">&lt;</span> b<span class="op">)</span></code></span></del></span>
</td>
<td>
</td>
<td>
<span class="rm" style="color: #bf0303"><del>linear</del></span>
</td>
</tr>
<tr>
<td>
<span class="addu"><code class="sourceCode cpp">a <span class="op">&lt;=&gt;</span> b</code></span>
</td>
<td>
<span class="addu"><em><code class="sourceCode default">synth-three-way-result</code></em><code class="sourceCode cpp"><span class="op">&lt;</span>value_type<span class="op">&gt;</span></code></span>
</td>
<td>
<div class="addu">
<div class="sourceCode" id="cb163"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb163-1"><a href="#cb163-1"></a>lexicographical_compare_three_way(</span>
<span id="cb163-2"><a href="#cb163-2"></a>    a.begin(), a.end(),</span>
<span id="cb163-3"><a href="#cb163-3"></a>    b.begin(), b.end(),</span>
<span id="cb163-4"><a href="#cb163-4"></a>    <em>synth-three-way</em>)</span></code></pre></div>
</div>
</td>
<td>
<span class="addu"><em>Expects</em>: Either <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> is defined for values of type (possibly const) <code class="sourceCode cpp">T</code>, or <code class="sourceCode cpp"><span class="op">&lt;</span></code> is defined for values of type (possibly const) <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp"><span class="op">&lt;</span></code> is a total ordering relationship.</span>
</td>
<td>
<span class="addu">linear</span>
</td>
</tr>
</table>
</blockquote>
<p>Change 22.3.2 [array.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb164"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb164-1"><a href="#cb164-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb164-2"><a href="#cb164-2"></a></span>
<span id="cb164-3"><a href="#cb164-3"></a>namespace std {</span>
<span id="cb164-4"><a href="#cb164-4"></a>  // [array], class template array</span>
<span id="cb164-5"><a href="#cb164-5"></a>  template&lt;class T, size_t N&gt; struct array;</span>
<span id="cb164-6"><a href="#cb164-6"></a></span>
<span id="cb164-7"><a href="#cb164-7"></a><span class="st">- template&lt;class T, size_t N&gt;</span></span>
<span id="cb164-8"><a href="#cb164-8"></a><span class="st">-   constexpr bool operator==(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);</span></span>
<span id="cb164-9"><a href="#cb164-9"></a><span class="st">- template&lt;class T, size_t N&gt;</span></span>
<span id="cb164-10"><a href="#cb164-10"></a><span class="st">-   constexpr bool operator!=(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);</span></span>
<span id="cb164-11"><a href="#cb164-11"></a><span class="st">- template&lt;class T, size_t N&gt;</span></span>
<span id="cb164-12"><a href="#cb164-12"></a><span class="st">-   constexpr bool operator&lt; (const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);</span></span>
<span id="cb164-13"><a href="#cb164-13"></a><span class="st">- template&lt;class T, size_t N&gt;</span></span>
<span id="cb164-14"><a href="#cb164-14"></a><span class="st">-   constexpr bool operator&gt; (const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);</span></span>
<span id="cb164-15"><a href="#cb164-15"></a><span class="st">- template&lt;class T, size_t N&gt;</span></span>
<span id="cb164-16"><a href="#cb164-16"></a><span class="st">-   constexpr bool operator&lt;=(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);</span></span>
<span id="cb164-17"><a href="#cb164-17"></a><span class="st">- template&lt;class T, size_t N&gt;</span></span>
<span id="cb164-18"><a href="#cb164-18"></a><span class="st">-   constexpr bool operator&gt;=(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);</span></span>
<span id="cb164-19"><a href="#cb164-19"></a>  template&lt;class T, size_t N&gt;</span>
<span id="cb164-20"><a href="#cb164-20"></a>    constexpr void swap(array&lt;T, N&gt;&amp; x, array&lt;T, N&gt;&amp; y) noexcept(noexcept(x.swap(y)));</span>
<span id="cb164-21"><a href="#cb164-21"></a>  [...]</span>
<span id="cb164-22"><a href="#cb164-22"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.3.3 [deque.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb165"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb165-1"><a href="#cb165-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb165-2"><a href="#cb165-2"></a></span>
<span id="cb165-3"><a href="#cb165-3"></a>namespace std {</span>
<span id="cb165-4"><a href="#cb165-4"></a>  // [deque], class template deque</span>
<span id="cb165-5"><a href="#cb165-5"></a>  template&lt;class T, class Allocator = allocator&lt;T&gt;&gt; class deque;</span>
<span id="cb165-6"><a href="#cb165-6"></a></span>
<span id="cb165-7"><a href="#cb165-7"></a>  template&lt;class T, class Allocator&gt;</span>
<span id="cb165-8"><a href="#cb165-8"></a>    bool operator==(const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span>
<span id="cb165-9"><a href="#cb165-9"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb165-10"><a href="#cb165-10"></a><span class="st">-   bool operator!=(const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb165-11"><a href="#cb165-11"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb165-12"><a href="#cb165-12"></a><span class="st">-   bool operator&lt; (const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb165-13"><a href="#cb165-13"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb165-14"><a href="#cb165-14"></a><span class="st">-   bool operator&gt; (const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb165-15"><a href="#cb165-15"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb165-16"><a href="#cb165-16"></a><span class="st">-   bool operator&lt;=(const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb165-17"><a href="#cb165-17"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb165-18"><a href="#cb165-18"></a><span class="st">-   bool operator&gt;=(const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb165-19"><a href="#cb165-19"></a><span class="va">+ template&lt;class T, class Allocator&gt;</span></span>
<span id="cb165-20"><a href="#cb165-20"></a><span class="va">+   <em>synth-three-way-result</em>&lt;T&gt; operator&lt;=&gt;(const deque&lt;T, Allocator&gt;&amp; x, const deque&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb165-21"><a href="#cb165-21"></a></span>
<span id="cb165-22"><a href="#cb165-22"></a>  [...]</span>
<span id="cb165-23"><a href="#cb165-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.3.4 [forward.list.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb166"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb166-1"><a href="#cb166-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb166-2"><a href="#cb166-2"></a></span>
<span id="cb166-3"><a href="#cb166-3"></a>namespace std {</span>
<span id="cb166-4"><a href="#cb166-4"></a>  // [forwardlist], class template forward_list</span>
<span id="cb166-5"><a href="#cb166-5"></a>  template&lt;class T, class Allocator = allocator&lt;T&gt;&gt; class forward_list;</span>
<span id="cb166-6"><a href="#cb166-6"></a></span>
<span id="cb166-7"><a href="#cb166-7"></a>  template&lt;class T, class Allocator&gt;</span>
<span id="cb166-8"><a href="#cb166-8"></a>    bool operator==(const forward_list&lt;T, Allocator&gt;&amp; x, const forward_list&lt;T, Allocator&gt;&amp; y);</span>
<span id="cb166-9"><a href="#cb166-9"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb166-10"><a href="#cb166-10"></a><span class="st">-   bool operator!=(const forward_list&lt;T, Allocator&gt;&amp; x, const forward_list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb166-11"><a href="#cb166-11"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb166-12"><a href="#cb166-12"></a><span class="st">-   bool operator&lt; (const forward_list&lt;T, Allocator&gt;&amp; x, const forward_list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb166-13"><a href="#cb166-13"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb166-14"><a href="#cb166-14"></a><span class="st">-   bool operator&gt; (const forward_list&lt;T, Allocator&gt;&amp; x, const forward_list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb166-15"><a href="#cb166-15"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb166-16"><a href="#cb166-16"></a><span class="st">-   bool operator&lt;=(const forward_list&lt;T, Allocator&gt;&amp; x, const forward_list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb166-17"><a href="#cb166-17"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb166-18"><a href="#cb166-18"></a><span class="st">-   bool operator&gt;=(const forward_list&lt;T, Allocator&gt;&amp; x, const forward_list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb166-19"><a href="#cb166-19"></a><span class="va">+ template&lt;class T, class Allocator&gt;</span></span>
<span id="cb166-20"><a href="#cb166-20"></a><span class="va">+   <em>synth-three-way-result</em>&lt;T&gt; operator&lt;=&gt;(const forward_list&lt;T, Allocator&gt;&amp; x,</span></span>
<span id="cb166-21"><a href="#cb166-21"></a><span class="va">+                                    const forward_list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb166-22"><a href="#cb166-22"></a></span>
<span id="cb166-23"><a href="#cb166-23"></a>  [...]</span>
<span id="cb166-24"><a href="#cb166-24"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.3.5 [list.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb167"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb167-1"><a href="#cb167-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb167-2"><a href="#cb167-2"></a></span>
<span id="cb167-3"><a href="#cb167-3"></a>namespace std {</span>
<span id="cb167-4"><a href="#cb167-4"></a>  // [list], class template list</span>
<span id="cb167-5"><a href="#cb167-5"></a>  template&lt;class T, class Allocator = allocator&lt;T&gt;&gt; class list;</span>
<span id="cb167-6"><a href="#cb167-6"></a></span>
<span id="cb167-7"><a href="#cb167-7"></a>  template&lt;class T, class Allocator&gt;</span>
<span id="cb167-8"><a href="#cb167-8"></a>    bool operator==(const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span>
<span id="cb167-9"><a href="#cb167-9"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb167-10"><a href="#cb167-10"></a><span class="st">-   bool operator!=(const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb167-11"><a href="#cb167-11"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb167-12"><a href="#cb167-12"></a><span class="st">-   bool operator&lt; (const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb167-13"><a href="#cb167-13"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb167-14"><a href="#cb167-14"></a><span class="st">-   bool operator&gt; (const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb167-15"><a href="#cb167-15"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb167-16"><a href="#cb167-16"></a><span class="st">-   bool operator&lt;=(const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb167-17"><a href="#cb167-17"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb167-18"><a href="#cb167-18"></a><span class="st">-   bool operator&gt;=(const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb167-19"><a href="#cb167-19"></a><span class="va">+ template&lt;class T, class Allocator&gt;</span></span>
<span id="cb167-20"><a href="#cb167-20"></a><span class="va">+   <em>synth-three-way-result</em>&lt;T&gt; operator&lt;=&gt;(const list&lt;T, Allocator&gt;&amp; x, const list&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb167-21"><a href="#cb167-21"></a>    </span>
<span id="cb167-22"><a href="#cb167-22"></a>  [...]</span>
<span id="cb167-23"><a href="#cb167-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.3.6 [vector.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb168"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb168-1"><a href="#cb168-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb168-2"><a href="#cb168-2"></a></span>
<span id="cb168-3"><a href="#cb168-3"></a>namespace std {</span>
<span id="cb168-4"><a href="#cb168-4"></a>  // [vector], class template vector</span>
<span id="cb168-5"><a href="#cb168-5"></a>  template&lt;class T, class Allocator = allocator&lt;T&gt;&gt; class vector;</span>
<span id="cb168-6"><a href="#cb168-6"></a></span>
<span id="cb168-7"><a href="#cb168-7"></a>  template&lt;class T, class Allocator&gt;</span>
<span id="cb168-8"><a href="#cb168-8"></a>    bool operator==(const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span>
<span id="cb168-9"><a href="#cb168-9"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb168-10"><a href="#cb168-10"></a><span class="st">-   bool operator!=(const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb168-11"><a href="#cb168-11"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb168-12"><a href="#cb168-12"></a><span class="st">-   bool operator&lt; (const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb168-13"><a href="#cb168-13"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb168-14"><a href="#cb168-14"></a><span class="st">-   bool operator&gt; (const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb168-15"><a href="#cb168-15"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb168-16"><a href="#cb168-16"></a><span class="st">-   bool operator&lt;=(const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb168-17"><a href="#cb168-17"></a><span class="st">- template&lt;class T, class Allocator&gt;</span></span>
<span id="cb168-18"><a href="#cb168-18"></a><span class="st">-   bool operator&gt;=(const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb168-19"><a href="#cb168-19"></a><span class="va">+ template&lt;class T, class Allocator&gt;</span></span>
<span id="cb168-20"><a href="#cb168-20"></a><span class="va">+   <em>synth-three-way-result</em>&lt;T&gt; operator&lt;=&gt;(const vector&lt;T, Allocator&gt;&amp; x, const vector&lt;T, Allocator&gt;&amp; y);</span></span>
<span id="cb168-21"><a href="#cb168-21"></a></span>
<span id="cb168-22"><a href="#cb168-22"></a>  [...]</span>
<span id="cb168-23"><a href="#cb168-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.3.7.1 [array.overview]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb169"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb169-1"><a href="#cb169-1"></a>namespace std {</span>
<span id="cb169-2"><a href="#cb169-2"></a>  template&lt;class T, size_t N&gt;</span>
<span id="cb169-3"><a href="#cb169-3"></a>  struct array {</span>
<span id="cb169-4"><a href="#cb169-4"></a>    [...]</span>
<span id="cb169-5"><a href="#cb169-5"></a></span>
<span id="cb169-6"><a href="#cb169-6"></a>    constexpr T *       data() noexcept;</span>
<span id="cb169-7"><a href="#cb169-7"></a>    constexpr const T * data() const noexcept;</span>
<span id="cb169-8"><a href="#cb169-8"></a>    </span>
<span id="cb169-9"><a href="#cb169-9"></a><span class="va">+   friend constexpr bool operator==(const array&amp;, const array&amp;) = default;</span></span>
<span id="cb169-10"><a href="#cb169-10"></a><span class="va">+   friend constexpr <em>synth-three-way-result</em>&lt;value_type&gt;</span></span>
<span id="cb169-11"><a href="#cb169-11"></a><span class="va">+     operator&lt;=&gt;(const array&amp;, const array&amp;);</span></span>
<span id="cb169-12"><a href="#cb169-12"></a>  };</span>
<span id="cb169-13"><a href="#cb169-13"></a></span>
<span id="cb169-14"><a href="#cb169-14"></a>  template&lt;class T, class... U&gt;</span>
<span id="cb169-15"><a href="#cb169-15"></a>    array(T, U...) -&gt; array&lt;T, 1 + sizeof...(U)&gt;;</span>
<span id="cb169-16"><a href="#cb169-16"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.4.2 [associative.map.syn].</p>
<blockquote>
<div>
<div class="sourceCode" id="cb170"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb170-1"><a href="#cb170-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb170-2"><a href="#cb170-2"></a></span>
<span id="cb170-3"><a href="#cb170-3"></a>namespace std {</span>
<span id="cb170-4"><a href="#cb170-4"></a>  // [map], class template map</span>
<span id="cb170-5"><a href="#cb170-5"></a>  template&lt;class Key, class T, class Compare = less&lt;Key&gt;,</span>
<span id="cb170-6"><a href="#cb170-6"></a>           class Allocator = allocator&lt;pair&lt;const Key, T&gt;&gt;&gt;</span>
<span id="cb170-7"><a href="#cb170-7"></a>    class map;</span>
<span id="cb170-8"><a href="#cb170-8"></a></span>
<span id="cb170-9"><a href="#cb170-9"></a>  template&lt;class Key, class T, class Compare, class Allocator&gt;</span>
<span id="cb170-10"><a href="#cb170-10"></a>    bool operator==(const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span>
<span id="cb170-11"><a href="#cb170-11"></a>                    const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span>
<span id="cb170-12"><a href="#cb170-12"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-13"><a href="#cb170-13"></a><span class="st">-   bool operator!=(const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-14"><a href="#cb170-14"></a><span class="st">-                   const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-15"><a href="#cb170-15"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-16"><a href="#cb170-16"></a><span class="st">-   bool operator&lt; (const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-17"><a href="#cb170-17"></a><span class="st">-                   const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-18"><a href="#cb170-18"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-19"><a href="#cb170-19"></a><span class="st">-   bool operator&gt; (const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-20"><a href="#cb170-20"></a><span class="st">-                   const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-21"><a href="#cb170-21"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-22"><a href="#cb170-22"></a><span class="st">-   bool operator&lt;=(const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-23"><a href="#cb170-23"></a><span class="st">-                   const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-24"><a href="#cb170-24"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-25"><a href="#cb170-25"></a><span class="st">-   bool operator&gt;=(const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-26"><a href="#cb170-26"></a><span class="st">-                   const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-27"><a href="#cb170-27"></a><span class="va">+ template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-28"><a href="#cb170-28"></a><span class="va">+   <em>synth-three-way-result</em>&lt;pair&lt;const Key, T&gt;&gt; operator&lt;=&gt;(const map&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-29"><a href="#cb170-29"></a><span class="va">+                                                     const map&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-30"><a href="#cb170-30"></a></span>
<span id="cb170-31"><a href="#cb170-31"></a>  [...]</span>
<span id="cb170-32"><a href="#cb170-32"></a>  </span>
<span id="cb170-33"><a href="#cb170-33"></a></span>
<span id="cb170-34"><a href="#cb170-34"></a>  // [multimap], class template multimap</span>
<span id="cb170-35"><a href="#cb170-35"></a>  template&lt;class Key, class T, class Compare = less&lt;Key&gt;,</span>
<span id="cb170-36"><a href="#cb170-36"></a>           class Allocator = allocator&lt;pair&lt;const Key, T&gt;&gt;&gt;</span>
<span id="cb170-37"><a href="#cb170-37"></a>    class multimap;</span>
<span id="cb170-38"><a href="#cb170-38"></a></span>
<span id="cb170-39"><a href="#cb170-39"></a>  template&lt;class Key, class T, class Compare, class Allocator&gt;</span>
<span id="cb170-40"><a href="#cb170-40"></a>    bool operator==(const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span>
<span id="cb170-41"><a href="#cb170-41"></a>                    const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);</span>
<span id="cb170-42"><a href="#cb170-42"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-43"><a href="#cb170-43"></a><span class="st">-   bool operator!=(const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-44"><a href="#cb170-44"></a><span class="st">-                   const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-45"><a href="#cb170-45"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-46"><a href="#cb170-46"></a><span class="st">-   bool operator&lt; (const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-47"><a href="#cb170-47"></a><span class="st">-                   const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-48"><a href="#cb170-48"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-49"><a href="#cb170-49"></a><span class="st">-   bool operator&gt; (const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-50"><a href="#cb170-50"></a><span class="st">-                   const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-51"><a href="#cb170-51"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-52"><a href="#cb170-52"></a><span class="st">-   bool operator&lt;=(const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-53"><a href="#cb170-53"></a><span class="st">-                   const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-54"><a href="#cb170-54"></a><span class="st">- template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-55"><a href="#cb170-55"></a><span class="st">-   bool operator&gt;=(const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-56"><a href="#cb170-56"></a><span class="st">-                   const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);  </span></span>
<span id="cb170-57"><a href="#cb170-57"></a><span class="va">+ template&lt;class Key, class T, class Compare, class Allocator&gt;</span></span>
<span id="cb170-58"><a href="#cb170-58"></a><span class="va">+   <em>synth-three-way-result</em>&lt;pair&lt;const Key, T&gt;&gt; operator&lt;=&gt;(const multimap&lt;Key, T, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb170-59"><a href="#cb170-59"></a><span class="va">+                                                     const multimap&lt;Key, T, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb170-60"><a href="#cb170-60"></a></span>
<span id="cb170-61"><a href="#cb170-61"></a>  [...]</span>
<span id="cb170-62"><a href="#cb170-62"></a>]</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.4.3 [associative.set.syn].</p>
<blockquote>
<div>
<div class="sourceCode" id="cb171"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb171-1"><a href="#cb171-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb171-2"><a href="#cb171-2"></a></span>
<span id="cb171-3"><a href="#cb171-3"></a>namespace std {</span>
<span id="cb171-4"><a href="#cb171-4"></a>  // [set], class template set</span>
<span id="cb171-5"><a href="#cb171-5"></a>  template&lt;class Key, class Compare = less&lt;Key&gt;, class Allocator = allocator&lt;Key&gt;&gt;</span>
<span id="cb171-6"><a href="#cb171-6"></a>    class set;</span>
<span id="cb171-7"><a href="#cb171-7"></a></span>
<span id="cb171-8"><a href="#cb171-8"></a>  template&lt;class Key, class Compare, class Allocator&gt;</span>
<span id="cb171-9"><a href="#cb171-9"></a>    bool operator==(const set&lt;Key, Compare, Allocator&gt;&amp; x,</span>
<span id="cb171-10"><a href="#cb171-10"></a>                    const set&lt;Key, Compare, Allocator&gt;&amp; y);</span>
<span id="cb171-11"><a href="#cb171-11"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-12"><a href="#cb171-12"></a><span class="st">-   bool operator!=(const set&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-13"><a href="#cb171-13"></a><span class="st">-                   const set&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-14"><a href="#cb171-14"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-15"><a href="#cb171-15"></a><span class="st">-   bool operator&lt; (const set&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-16"><a href="#cb171-16"></a><span class="st">-                   const set&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-17"><a href="#cb171-17"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-18"><a href="#cb171-18"></a><span class="st">-   bool operator&gt; (const set&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-19"><a href="#cb171-19"></a><span class="st">-                   const set&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-20"><a href="#cb171-20"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-21"><a href="#cb171-21"></a><span class="st">-   bool operator&lt;=(const set&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-22"><a href="#cb171-22"></a><span class="st">-                   const set&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-23"><a href="#cb171-23"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-24"><a href="#cb171-24"></a><span class="st">-   bool operator&gt;=(const set&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-25"><a href="#cb171-25"></a><span class="st">-                   const set&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-26"><a href="#cb171-26"></a><span class="va">+ template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-27"><a href="#cb171-27"></a><span class="va">+   <em>synth-three-way-result</em>&lt;Key&gt; operator&lt;=&gt;(const set&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-28"><a href="#cb171-28"></a><span class="va">+                                      const set&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-29"><a href="#cb171-29"></a>                    </span>
<span id="cb171-30"><a href="#cb171-30"></a>  [...]</span>
<span id="cb171-31"><a href="#cb171-31"></a>  </span>
<span id="cb171-32"><a href="#cb171-32"></a>  // [multiset], class template multiset</span>
<span id="cb171-33"><a href="#cb171-33"></a>  template&lt;class Key, class Compare = less&lt;Key&gt;, class Allocator = allocator&lt;Key&gt;&gt;</span>
<span id="cb171-34"><a href="#cb171-34"></a>    class multiset;</span>
<span id="cb171-35"><a href="#cb171-35"></a></span>
<span id="cb171-36"><a href="#cb171-36"></a>  template&lt;class Key, class Compare, class Allocator&gt;</span>
<span id="cb171-37"><a href="#cb171-37"></a>    bool operator==(const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span>
<span id="cb171-38"><a href="#cb171-38"></a>                    const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span>
<span id="cb171-39"><a href="#cb171-39"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-40"><a href="#cb171-40"></a><span class="st">-   bool operator!=(const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-41"><a href="#cb171-41"></a><span class="st">-                   const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-42"><a href="#cb171-42"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-43"><a href="#cb171-43"></a><span class="st">-   bool operator&lt; (const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-44"><a href="#cb171-44"></a><span class="st">-                   const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-45"><a href="#cb171-45"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-46"><a href="#cb171-46"></a><span class="st">-   bool operator&gt; (const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-47"><a href="#cb171-47"></a><span class="st">-                   const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-48"><a href="#cb171-48"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-49"><a href="#cb171-49"></a><span class="st">-   bool operator&lt;=(const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-50"><a href="#cb171-50"></a><span class="st">-                   const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-51"><a href="#cb171-51"></a><span class="st">- template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-52"><a href="#cb171-52"></a><span class="st">-   bool operator&gt;=(const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-53"><a href="#cb171-53"></a><span class="st">-                   const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-54"><a href="#cb171-54"></a><span class="va">+ template&lt;class Key, class Compare, class Allocator&gt;</span></span>
<span id="cb171-55"><a href="#cb171-55"></a><span class="va">+   <em>synth-three-way-result</em>&lt;Key&gt; operator&lt;=&gt;(const multiset&lt;Key, Compare, Allocator&gt;&amp; x,</span></span>
<span id="cb171-56"><a href="#cb171-56"></a><span class="va">+                                      const multiset&lt;Key, Compare, Allocator&gt;&amp; y);</span></span>
<span id="cb171-57"><a href="#cb171-57"></a></span>
<span id="cb171-58"><a href="#cb171-58"></a></span>
<span id="cb171-59"><a href="#cb171-59"></a>  [...]</span>
<span id="cb171-60"><a href="#cb171-60"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.5.2 [unord.map.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb172"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb172-1"><a href="#cb172-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb172-2"><a href="#cb172-2"></a></span>
<span id="cb172-3"><a href="#cb172-3"></a>namespace std {</span>
<span id="cb172-4"><a href="#cb172-4"></a>  // [unord.map], class template unordered_map</span>
<span id="cb172-5"><a href="#cb172-5"></a>  template&lt;class Key,</span>
<span id="cb172-6"><a href="#cb172-6"></a>           class T,</span>
<span id="cb172-7"><a href="#cb172-7"></a>           class Hash = hash&lt;Key&gt;,</span>
<span id="cb172-8"><a href="#cb172-8"></a>           class Pred = equal_to&lt;Key&gt;,</span>
<span id="cb172-9"><a href="#cb172-9"></a>           class Alloc = allocator&lt;pair&lt;const Key, T&gt;&gt;&gt;</span>
<span id="cb172-10"><a href="#cb172-10"></a>    class unordered_map;</span>
<span id="cb172-11"><a href="#cb172-11"></a></span>
<span id="cb172-12"><a href="#cb172-12"></a>  // [unord.multimap], class template unordered_multimap</span>
<span id="cb172-13"><a href="#cb172-13"></a>  template&lt;class Key,</span>
<span id="cb172-14"><a href="#cb172-14"></a>           class T,</span>
<span id="cb172-15"><a href="#cb172-15"></a>           class Hash = hash&lt;Key&gt;,</span>
<span id="cb172-16"><a href="#cb172-16"></a>           class Pred = equal_to&lt;Key&gt;,</span>
<span id="cb172-17"><a href="#cb172-17"></a>           class Alloc = allocator&lt;pair&lt;const Key, T&gt;&gt;&gt;</span>
<span id="cb172-18"><a href="#cb172-18"></a>    class unordered_multimap;</span>
<span id="cb172-19"><a href="#cb172-19"></a></span>
<span id="cb172-20"><a href="#cb172-20"></a>  template&lt;class Key, class T, class Hash, class Pred, class Alloc&gt;</span>
<span id="cb172-21"><a href="#cb172-21"></a>    bool operator==(const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,</span>
<span id="cb172-22"><a href="#cb172-22"></a>                    const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);</span>
<span id="cb172-23"><a href="#cb172-23"></a><span class="st">- template&lt;class Key, class T, class Hash, class Pred, class Alloc&gt;</span></span>
<span id="cb172-24"><a href="#cb172-24"></a><span class="st">-   bool operator!=(const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,</span></span>
<span id="cb172-25"><a href="#cb172-25"></a><span class="st">-                   const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);</span></span>
<span id="cb172-26"><a href="#cb172-26"></a></span>
<span id="cb172-27"><a href="#cb172-27"></a>  template&lt;class Key, class T, class Hash, class Pred, class Alloc&gt;</span>
<span id="cb172-28"><a href="#cb172-28"></a>    bool operator==(const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,</span>
<span id="cb172-29"><a href="#cb172-29"></a>                    const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);</span>
<span id="cb172-30"><a href="#cb172-30"></a><span class="st">- template&lt;class Key, class T, class Hash, class Pred, class Alloc&gt;</span></span>
<span id="cb172-31"><a href="#cb172-31"></a><span class="st">-   bool operator!=(const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,</span></span>
<span id="cb172-32"><a href="#cb172-32"></a><span class="st">-                   const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);</span></span>
<span id="cb172-33"><a href="#cb172-33"></a>                    </span>
<span id="cb172-34"><a href="#cb172-34"></a>  [...]</span>
<span id="cb172-35"><a href="#cb172-35"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.5.3 [unordered.set.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb173"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb173-1"><a href="#cb173-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb173-2"><a href="#cb173-2"></a></span>
<span id="cb173-3"><a href="#cb173-3"></a>namespace std {</span>
<span id="cb173-4"><a href="#cb173-4"></a>  // [unord.set], class template unordered_set</span>
<span id="cb173-5"><a href="#cb173-5"></a>  template&lt;class Key,</span>
<span id="cb173-6"><a href="#cb173-6"></a>           class Hash = hash&lt;Key&gt;,</span>
<span id="cb173-7"><a href="#cb173-7"></a>           class Pred = equal_to&lt;Key&gt;,</span>
<span id="cb173-8"><a href="#cb173-8"></a>           class Alloc = allocator&lt;Key&gt;&gt;</span>
<span id="cb173-9"><a href="#cb173-9"></a>    class unordered_set;</span>
<span id="cb173-10"><a href="#cb173-10"></a></span>
<span id="cb173-11"><a href="#cb173-11"></a>  // [unord.multiset], class template unordered_multiset</span>
<span id="cb173-12"><a href="#cb173-12"></a>  template&lt;class Key,</span>
<span id="cb173-13"><a href="#cb173-13"></a>           class Hash = hash&lt;Key&gt;,</span>
<span id="cb173-14"><a href="#cb173-14"></a>           class Pred = equal_to&lt;Key&gt;,</span>
<span id="cb173-15"><a href="#cb173-15"></a>           class Alloc = allocator&lt;Key&gt;&gt;</span>
<span id="cb173-16"><a href="#cb173-16"></a>    class unordered_multiset;</span>
<span id="cb173-17"><a href="#cb173-17"></a></span>
<span id="cb173-18"><a href="#cb173-18"></a>  template&lt;class Key, class Hash, class Pred, class Alloc&gt;</span>
<span id="cb173-19"><a href="#cb173-19"></a>    bool operator==(const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; a,</span>
<span id="cb173-20"><a href="#cb173-20"></a>                    const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; b);</span>
<span id="cb173-21"><a href="#cb173-21"></a><span class="st">- template&lt;class Key, class Hash, class Pred, class Alloc&gt;</span></span>
<span id="cb173-22"><a href="#cb173-22"></a><span class="st">-   bool operator!=(const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; a,</span></span>
<span id="cb173-23"><a href="#cb173-23"></a><span class="st">-                   const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; b);</span></span>
<span id="cb173-24"><a href="#cb173-24"></a></span>
<span id="cb173-25"><a href="#cb173-25"></a>  template&lt;class Key, class Hash, class Pred, class Alloc&gt;</span>
<span id="cb173-26"><a href="#cb173-26"></a>    bool operator==(const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; a,</span>
<span id="cb173-27"><a href="#cb173-27"></a>                    const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; b);</span>
<span id="cb173-28"><a href="#cb173-28"></a><span class="st">- template&lt;class Key, class Hash, class Pred, class Alloc&gt;</span></span>
<span id="cb173-29"><a href="#cb173-29"></a><span class="st">-   bool operator!=(const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; a,</span></span>
<span id="cb173-30"><a href="#cb173-30"></a><span class="st">-                   const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; b);</span></span>
<span id="cb173-31"><a href="#cb173-31"></a></span>
<span id="cb173-32"><a href="#cb173-32"></a>  [...]</span>
<span id="cb173-33"><a href="#cb173-33"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.6.2 [queue.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb174"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb174-1"><a href="#cb174-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb174-2"><a href="#cb174-2"></a></span>
<span id="cb174-3"><a href="#cb174-3"></a>namespace std {</span>
<span id="cb174-4"><a href="#cb174-4"></a>  template&lt;class T, class Container = deque&lt;T&gt;&gt; class queue;</span>
<span id="cb174-5"><a href="#cb174-5"></a></span>
<span id="cb174-6"><a href="#cb174-6"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb174-7"><a href="#cb174-7"></a>    bool operator==(const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span>
<span id="cb174-8"><a href="#cb174-8"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb174-9"><a href="#cb174-9"></a>    bool operator!=(const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span>
<span id="cb174-10"><a href="#cb174-10"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb174-11"><a href="#cb174-11"></a>    bool operator&lt; (const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span>
<span id="cb174-12"><a href="#cb174-12"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb174-13"><a href="#cb174-13"></a>    bool operator&gt; (const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span>
<span id="cb174-14"><a href="#cb174-14"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb174-15"><a href="#cb174-15"></a>    bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span>
<span id="cb174-16"><a href="#cb174-16"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb174-17"><a href="#cb174-17"></a>    bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span>
<span id="cb174-18"><a href="#cb174-18"></a><span class="va">+ template&lt;class T, ThreeWayComparable Container&gt;</span></span>
<span id="cb174-19"><a href="#cb174-19"></a><span class="va">+   compare_three_way_result_t&lt;Container&gt;</span></span>
<span id="cb174-20"><a href="#cb174-20"></a><span class="va">+     operator&lt;=&gt;(const queue&lt;T, Container&gt;&amp; x, const queue&lt;T, Container&gt;&amp; y);</span></span>
<span id="cb174-21"><a href="#cb174-21"></a></span>
<span id="cb174-22"><a href="#cb174-22"></a>  [...]</span>
<span id="cb174-23"><a href="#cb174-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 22.6.3 [stack.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb175"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb175-1"><a href="#cb175-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb175-2"><a href="#cb175-2"></a></span>
<span id="cb175-3"><a href="#cb175-3"></a>namespace std {</span>
<span id="cb175-4"><a href="#cb175-4"></a>  template&lt;class T, class Container = deque&lt;T&gt;&gt; class stack;</span>
<span id="cb175-5"><a href="#cb175-5"></a></span>
<span id="cb175-6"><a href="#cb175-6"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-7"><a href="#cb175-7"></a>    bool operator==(const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span>
<span id="cb175-8"><a href="#cb175-8"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-9"><a href="#cb175-9"></a>    bool operator!=(const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span>
<span id="cb175-10"><a href="#cb175-10"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-11"><a href="#cb175-11"></a>    bool operator&lt; (const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span>
<span id="cb175-12"><a href="#cb175-12"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-13"><a href="#cb175-13"></a>    bool operator&gt; (const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span>
<span id="cb175-14"><a href="#cb175-14"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-15"><a href="#cb175-15"></a>    bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span>
<span id="cb175-16"><a href="#cb175-16"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-17"><a href="#cb175-17"></a>    bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span>
<span id="cb175-18"><a href="#cb175-18"></a><span class="va">+ template&lt;class T, ThreeWayComparable Container&gt;</span></span>
<span id="cb175-19"><a href="#cb175-19"></a><span class="va">+   compare_three_way_result_t&lt;Container&gt;</span></span>
<span id="cb175-20"><a href="#cb175-20"></a><span class="va">+     operator&lt;=&gt;(const stack&lt;T, Container&gt;&amp; x, const stack&lt;T, Container&gt;&amp; y);</span></span>
<span id="cb175-21"><a href="#cb175-21"></a></span>
<span id="cb175-22"><a href="#cb175-22"></a>  template&lt;class T, class Container&gt;</span>
<span id="cb175-23"><a href="#cb175-23"></a>    void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y) noexcept(noexcept(x.swap(y)));</span>
<span id="cb175-24"><a href="#cb175-24"></a>  template&lt;class T, class Container, class Alloc&gt;</span>
<span id="cb175-25"><a href="#cb175-25"></a>    struct uses_allocator&lt;stack&lt;T, Container&gt;, Alloc&gt;;</span>
<span id="cb175-26"><a href="#cb175-26"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Add to 22.6.4.4 [queue.ops]:</p>
<blockquote>
<div class="sourceCode" id="cb176"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb176-1"><a href="#cb176-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> Container<span class="op">&gt;</span></span>
<span id="cb176-2"><a href="#cb176-2"></a>    <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> queue<span class="op">&lt;</span>T, Container<span class="op">&gt;&amp;</span> x,</span>
<span id="cb176-3"><a href="#cb176-3"></a>                    <span class="kw">const</span> queue<span class="op">&lt;</span>T, Container<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>c <span class="op">&gt;=</span> y<span class="op">.</span>c</code>.</p>
<div class="addu">
<div class="sourceCode" id="cb177"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb177-1"><a href="#cb177-1"></a>template&lt;class T, ThreeWayComparable Container&gt;</span>
<span id="cb177-2"><a href="#cb177-2"></a>  compare_three_way_result_t&lt;Container&gt;</span>
<span id="cb177-3"><a href="#cb177-3"></a>    operator&lt;=&gt;(const queue&lt;T, Container&gt;&amp; x,</span>
<span id="cb177-4"><a href="#cb177-4"></a>                const queue&lt;T, Container&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>c <span class="op">&lt;=&gt;</span> y<span class="op">.</span>c</code>.</p>
</div>
</blockquote>
<p>Add to 22.6.6.4 [stack.ops]:</p>
<blockquote>
<div class="sourceCode" id="cb178"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb178-1"><a href="#cb178-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> Container<span class="op">&gt;</span></span>
<span id="cb178-2"><a href="#cb178-2"></a>    <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> stack<span class="op">&lt;</span>T, Container<span class="op">&gt;&amp;</span> x,</span>
<span id="cb178-3"><a href="#cb178-3"></a>                    <span class="kw">const</span> stack<span class="op">&lt;</span>T, Container<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>c <span class="op">&gt;=</span> y<span class="op">.</span>c</code>.</p>
<div class="addu">
<div class="sourceCode" id="cb179"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb179-1"><a href="#cb179-1"></a>template&lt;class T, ThreeWayComparable Container&gt;</span>
<span id="cb179-2"><a href="#cb179-2"></a>  compare_three_way_result_t&lt;Container&gt;</span>
<span id="cb179-3"><a href="#cb179-3"></a>    operator&lt;=&gt;(const stack&lt;T, Container&gt;&amp; x,</span>
<span id="cb179-4"><a href="#cb179-4"></a>                const stack&lt;T, Container&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>c <span class="op">&lt;=&gt;</span> y<span class="op">.</span>c</code>.</p>
</div>
</blockquote>
<h2 id="clause-23-iterators-library"><span class="header-section-number">5.8</span> Clause 23: Iterators library<a href="#clause-23-iterators-library" class="self-link"></a></h2>
<p>Changing the operators for <code class="sourceCode cpp">reverse_iterator</code>, <code class="sourceCode cpp">move_iterator</code>, <code class="sourceCode cpp">istream_iterator</code>, <code class="sourceCode cpp">istreambuf_iterator</code>, <code class="sourceCode cpp">common_iterator</code>, <code class="sourceCode cpp">counted_iterator</code>, <code class="sourceCode cpp">unreachable_sentinel</code>.</p>
<p>We preserve existing comparison operators for <code class="sourceCode cpp">reverse_iterator</code> because <code class="sourceCode cpp"><span class="op">&gt;</span></code> actually forwards to the base <code class="sourceCode cpp"><span class="op">&gt;</span></code> rather than invoking the <code class="sourceCode cpp"><span class="op">&lt;</span></code> with the arguments reversed. So, like <code class="sourceCode cpp">optional</code>, we cannot synthesize a <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>.</p>
<p>We preserve existing comparison operators <code class="sourceCode cpp">move_iterator</code> because it seems pretty bad to try to synthesize a three-way comparison out of two operator calls instead of just making the one operator call.</p>
<p>Notably, we do <em>not</em> add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to any iterator requirements, although all standard library iterators that are ordered should provide <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>.</p>
<p>Change 23.2 [iterator.synopsis]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb180"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb180-1"><a href="#cb180-1"></a>#include &lt;concepts&gt;</span>
<span id="cb180-2"><a href="#cb180-2"></a></span>
<span id="cb180-3"><a href="#cb180-3"></a>namespace std {</span>
<span id="cb180-4"><a href="#cb180-4"></a>  [...]</span>
<span id="cb180-5"><a href="#cb180-5"></a>  </span>
<span id="cb180-6"><a href="#cb180-6"></a>  // [predef.iterators], predefined iterators and sentinels</span>
<span id="cb180-7"><a href="#cb180-7"></a>  // [reverse.iterators], reverse iterators</span>
<span id="cb180-8"><a href="#cb180-8"></a>  template&lt;class Iterator&gt; class reverse_iterator;</span>
<span id="cb180-9"><a href="#cb180-9"></a></span>
<span id="cb180-10"><a href="#cb180-10"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-11"><a href="#cb180-11"></a>    constexpr bool operator==(</span>
<span id="cb180-12"><a href="#cb180-12"></a>      const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb180-13"><a href="#cb180-13"></a>      const reverse_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-14"><a href="#cb180-14"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-15"><a href="#cb180-15"></a>    constexpr bool operator!=(</span>
<span id="cb180-16"><a href="#cb180-16"></a>      const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb180-17"><a href="#cb180-17"></a>      const reverse_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-18"><a href="#cb180-18"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-19"><a href="#cb180-19"></a>    constexpr bool operator&lt;(</span>
<span id="cb180-20"><a href="#cb180-20"></a>      const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb180-21"><a href="#cb180-21"></a>      const reverse_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-22"><a href="#cb180-22"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-23"><a href="#cb180-23"></a>    constexpr bool operator&gt;(</span>
<span id="cb180-24"><a href="#cb180-24"></a>      const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb180-25"><a href="#cb180-25"></a>      const reverse_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-26"><a href="#cb180-26"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-27"><a href="#cb180-27"></a>    constexpr bool operator&lt;=(</span>
<span id="cb180-28"><a href="#cb180-28"></a>      const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb180-29"><a href="#cb180-29"></a>      const reverse_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-30"><a href="#cb180-30"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-31"><a href="#cb180-31"></a>    constexpr bool operator&gt;=(</span>
<span id="cb180-32"><a href="#cb180-32"></a>      const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb180-33"><a href="#cb180-33"></a>      const reverse_iterator&lt;Iterator2&gt;&amp; y);  </span>
<span id="cb180-34"><a href="#cb180-34"></a><span class="va">+ template&lt;class Iterator1, ThreeWayComparableWith&lt;Iterator1, weak_equality&gt; Iterator2&gt;</span></span>
<span id="cb180-35"><a href="#cb180-35"></a><span class="va">+   constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span></span>
<span id="cb180-36"><a href="#cb180-36"></a><span class="va">+     operator&lt;=&gt;(const reverse_iterator&lt;Iterator1&gt;&amp; x,</span></span>
<span id="cb180-37"><a href="#cb180-37"></a><span class="va">+                 const reverse_iterator&lt;Iterator2&gt;&amp; y);      </span></span>
<span id="cb180-38"><a href="#cb180-38"></a></span>
<span id="cb180-39"><a href="#cb180-39"></a>  [...]</span>
<span id="cb180-40"><a href="#cb180-40"></a>  </span>
<span id="cb180-41"><a href="#cb180-41"></a>  // [move.iterators], move iterators and sentinels</span>
<span id="cb180-42"><a href="#cb180-42"></a>  template&lt;class Iterator&gt; class move_iterator;</span>
<span id="cb180-43"><a href="#cb180-43"></a></span>
<span id="cb180-44"><a href="#cb180-44"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-45"><a href="#cb180-45"></a>    constexpr bool operator==(</span>
<span id="cb180-46"><a href="#cb180-46"></a>      const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-47"><a href="#cb180-47"></a><span class="st">- template&lt;class Iterator1, class Iterator2&gt;</span></span>
<span id="cb180-48"><a href="#cb180-48"></a><span class="st">-   constexpr bool operator!=(</span></span>
<span id="cb180-49"><a href="#cb180-49"></a><span class="st">-     const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);</span></span>
<span id="cb180-50"><a href="#cb180-50"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-51"><a href="#cb180-51"></a>    constexpr bool operator&lt;(</span>
<span id="cb180-52"><a href="#cb180-52"></a>      const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-53"><a href="#cb180-53"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-54"><a href="#cb180-54"></a>    constexpr bool operator&gt;(</span>
<span id="cb180-55"><a href="#cb180-55"></a>      const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-56"><a href="#cb180-56"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-57"><a href="#cb180-57"></a>    constexpr bool operator&lt;=(</span>
<span id="cb180-58"><a href="#cb180-58"></a>      const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-59"><a href="#cb180-59"></a>  template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb180-60"><a href="#cb180-60"></a>    constexpr bool operator&gt;=(</span>
<span id="cb180-61"><a href="#cb180-61"></a>      const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb180-62"><a href="#cb180-62"></a><span class="va">+ template&lt;class Iterator1, ThreeWayComparableWith&lt;Iterator1, weak_equality&gt; Iterator2&gt;</span></span>
<span id="cb180-63"><a href="#cb180-63"></a><span class="va">+   constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span></span>
<span id="cb180-64"><a href="#cb180-64"></a><span class="va">+     operator&lt;=&gt;(const move_iterator&lt;Iterator1&gt;&amp; x,</span></span>
<span id="cb180-65"><a href="#cb180-65"></a><span class="va">+                 const move_iterator&lt;Iterator2&gt;&amp; y);</span></span>
<span id="cb180-66"><a href="#cb180-66"></a></span>
<span id="cb180-67"><a href="#cb180-67"></a>  [...]</span>
<span id="cb180-68"><a href="#cb180-68"></a>  </span>
<span id="cb180-69"><a href="#cb180-69"></a>  // [stream.iterators], stream iterators</span>
<span id="cb180-70"><a href="#cb180-70"></a>  template&lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,</span>
<span id="cb180-71"><a href="#cb180-71"></a>           class Distance = ptrdiff_t&gt;</span>
<span id="cb180-72"><a href="#cb180-72"></a>  class istream_iterator;</span>
<span id="cb180-73"><a href="#cb180-73"></a>  template&lt;class T, class charT, class traits, class Distance&gt;</span>
<span id="cb180-74"><a href="#cb180-74"></a>    bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,</span>
<span id="cb180-75"><a href="#cb180-75"></a>            const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);</span>
<span id="cb180-76"><a href="#cb180-76"></a><span class="st">- template&lt;class T, class charT, class traits, class Distance&gt;</span></span>
<span id="cb180-77"><a href="#cb180-77"></a><span class="st">-   bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,</span></span>
<span id="cb180-78"><a href="#cb180-78"></a><span class="st">-           const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);</span></span>
<span id="cb180-79"><a href="#cb180-79"></a></span>
<span id="cb180-80"><a href="#cb180-80"></a>  template&lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;&gt;</span>
<span id="cb180-81"><a href="#cb180-81"></a>      class ostream_iterator;</span>
<span id="cb180-82"><a href="#cb180-82"></a></span>
<span id="cb180-83"><a href="#cb180-83"></a>  template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;</span>
<span id="cb180-84"><a href="#cb180-84"></a>    class istreambuf_iterator;</span>
<span id="cb180-85"><a href="#cb180-85"></a>  template&lt;class charT, class traits&gt;</span>
<span id="cb180-86"><a href="#cb180-86"></a>    bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,</span>
<span id="cb180-87"><a href="#cb180-87"></a>            const istreambuf_iterator&lt;charT,traits&gt;&amp; b);</span>
<span id="cb180-88"><a href="#cb180-88"></a><span class="st">- template&lt;class charT, class traits&gt;</span></span>
<span id="cb180-89"><a href="#cb180-89"></a><span class="st">-   bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,</span></span>
<span id="cb180-90"><a href="#cb180-90"></a><span class="st">-           const istreambuf_iterator&lt;charT,traits&gt;&amp; b);</span></span>
<span id="cb180-91"><a href="#cb180-91"></a></span>
<span id="cb180-92"><a href="#cb180-92"></a>  [...]         </span>
<span id="cb180-93"><a href="#cb180-93"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to 23.5.1.7 [reverse.iter.cmp]:</p>
<blockquote>
<div class="sourceCode" id="cb181"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb181-1"><a href="#cb181-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Iterator1, <span class="kw">class</span> Iterator2<span class="op">&gt;</span></span>
<span id="cb181-2"><a href="#cb181-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span></span>
<span id="cb181-3"><a href="#cb181-3"></a>    <span class="kw">const</span> reverse_iterator<span class="op">&lt;</span>Iterator1<span class="op">&gt;&amp;</span> x,</span>
<span id="cb181-4"><a href="#cb181-4"></a>    <span class="kw">const</span> reverse_iterator<span class="op">&lt;</span>Iterator2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Constraints</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;=</span> y<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;=</span> y<span class="op">.</span>base<span class="op">()</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb182"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb182-1"><a href="#cb182-1"></a>template&lt;class Iterator1, ThreeWayComparableWith&lt;Iterator1, weak_equality&gt; Iterator2&gt;</span>
<span id="cb182-2"><a href="#cb182-2"></a>  constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span>
<span id="cb182-3"><a href="#cb182-3"></a>    operator&lt;=&gt;(const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb182-4"><a href="#cb182-4"></a>                const reverse_iterator&lt;Iterator2&gt;&amp; y);      </span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Returns</em>: <code class="sourceCode cpp">y<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;=&gt;</span> x<span class="op">.</span>base<span class="op">()</span></code>.</p>
<p>[<em>Note</em>: The argument order in the <em>Returns</em>: element is reversed because this is a reverse iterator. —<em>end note</em>]</p>
</div>
</blockquote>
<p>Change 23.5.3.1 [move.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb183"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb183-1"><a href="#cb183-1"></a>namespace std {</span>
<span id="cb183-2"><a href="#cb183-2"></a>  template&lt;class Iterator&gt;</span>
<span id="cb183-3"><a href="#cb183-3"></a>  class move_iterator {</span>
<span id="cb183-4"><a href="#cb183-4"></a>  public:</span>
<span id="cb183-5"><a href="#cb183-5"></a>    [...]</span>
<span id="cb183-6"><a href="#cb183-6"></a></span>
<span id="cb183-7"><a href="#cb183-7"></a>    template&lt;Sentinel&lt;Iterator&gt; S&gt;</span>
<span id="cb183-8"><a href="#cb183-8"></a>      friend constexpr bool</span>
<span id="cb183-9"><a href="#cb183-9"></a>        operator==(const move_iterator&amp; x, const move_sentinel&lt;S&gt;&amp; y);</span>
<span id="cb183-10"><a href="#cb183-10"></a><span class="st">-   template&lt;Sentinel&lt;Iterator&gt; S&gt;</span></span>
<span id="cb183-11"><a href="#cb183-11"></a><span class="st">-     friend constexpr bool</span></span>
<span id="cb183-12"><a href="#cb183-12"></a><span class="st">-       operator==(const move_sentinel&lt;S&gt;&amp; x, const move_iterator&amp; y);</span></span>
<span id="cb183-13"><a href="#cb183-13"></a><span class="st">-   template&lt;Sentinel&lt;Iterator&gt; S&gt;</span></span>
<span id="cb183-14"><a href="#cb183-14"></a><span class="st">-     friend constexpr bool</span></span>
<span id="cb183-15"><a href="#cb183-15"></a><span class="st">-       operator!=(const move_iterator&amp; x, const move_sentinel&lt;S&gt;&amp; y);</span></span>
<span id="cb183-16"><a href="#cb183-16"></a><span class="st">-   template&lt;Sentinel&lt;Iterator&gt; S&gt;</span></span>
<span id="cb183-17"><a href="#cb183-17"></a><span class="st">-     friend constexpr bool</span></span>
<span id="cb183-18"><a href="#cb183-18"></a><span class="st">-       operator!=(const move_sentinel&lt;S&gt;&amp; x, const move_iterator&amp; y);</span></span>
<span id="cb183-19"><a href="#cb183-19"></a>    template&lt;SizedSentinel&lt;Iterator&gt; S&gt;</span>
<span id="cb183-20"><a href="#cb183-20"></a>      friend constexpr iter_difference_t&lt;Iterator&gt;</span>
<span id="cb183-21"><a href="#cb183-21"></a>        operator-(const move_sentinel&lt;S&gt;&amp; x, const move_iterator&amp; y);</span>
<span id="cb183-22"><a href="#cb183-22"></a>        </span>
<span id="cb183-23"><a href="#cb183-23"></a>    [...]</span>
<span id="cb183-24"><a href="#cb183-24"></a>  };</span>
<span id="cb183-25"><a href="#cb183-25"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Remove <code class="sourceCode cpp"><span class="op">!=</span></code> and add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to 23.5.3.7 [move.iter.op.comp]:</p>
<blockquote>
<div class="sourceCode" id="cb184"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb184-1"><a href="#cb184-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Iterator1, <span class="kw">class</span> Iterator2<span class="op">&gt;</span></span>
<span id="cb184-2"><a href="#cb184-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator1<span class="op">&gt;&amp;</span> x,</span>
<span id="cb184-3"><a href="#cb184-3"></a>                            <span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span>
<span id="cb184-4"><a href="#cb184-4"></a><span class="kw">template</span><span class="op">&lt;</span>Sentinel<span class="op">&lt;</span>Iterator<span class="op">&gt;</span> S<span class="op">&gt;</span></span>
<span id="cb184-5"><a href="#cb184-5"></a>  <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> move_iterator<span class="op">&amp;</span> x,</span>
<span id="cb184-6"><a href="#cb184-6"></a>                                   <span class="kw">const</span> move_sentinel<span class="op">&lt;</span>S<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb185"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb185-1"><a href="#cb185-1"></a>template&lt;Sentinel&lt;Iterator&gt; S&gt;</span>
<span id="cb185-2"><a href="#cb185-2"></a>  friend constexpr bool operator==(const move_sentinel&lt;S&gt;&amp; x,</span>
<span id="cb185-3"><a href="#cb185-3"></a>                                   const move_iterator&amp; y);</span></code></pre></div>

</div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Constraints</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>base<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb186"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb186-1"><a href="#cb186-1"></a>template&lt;class Iterator1, class Iterator2&gt;</span>
<span id="cb186-2"><a href="#cb186-2"></a>  constexpr bool operator!=(const move_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb186-3"><a href="#cb186-3"></a>                            const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb186-4"><a href="#cb186-4"></a>template&lt;Sentinel&lt;Iterator&gt; S&gt;</span>
<span id="cb186-5"><a href="#cb186-5"></a>  friend constexpr bool operator!=(const move_iterator&amp; x,</span>
<span id="cb186-6"><a href="#cb186-6"></a>                                   const move_sentinel&lt;S&gt;&amp; y);</span>
<span id="cb186-7"><a href="#cb186-7"></a>template&lt;Sentinel&lt;Iterator&gt; S&gt;</span>
<span id="cb186-8"><a href="#cb186-8"></a>  friend constexpr bool operator!=(const move_sentinel&lt;S&gt;&amp; x,</span>
<span id="cb186-9"><a href="#cb186-9"></a>                                   const move_iterator&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Constraints</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb187"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb187-1"><a href="#cb187-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Iterator1, <span class="kw">class</span> Iterator2<span class="op">&gt;</span></span>
<span id="cb187-2"><a href="#cb187-2"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;(</span><span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator1<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Constraints</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>base<span class="op">()</span></code>.</p>
<div class="sourceCode" id="cb188"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb188-1"><a href="#cb188-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Iterator1, <span class="kw">class</span> Iterator2<span class="op">&gt;</span></span>
<span id="cb188-2"><a href="#cb188-2"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;(</span><span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator1<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Constraints</em>: <code class="sourceCode cpp">y<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;</span> x<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp">y <span class="op">&lt;</span> x</code>.</p>
<div class="sourceCode" id="cb189"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb189-1"><a href="#cb189-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Iterator1, <span class="kw">class</span> Iterator2<span class="op">&gt;</span></span>
<span id="cb189-2"><a href="#cb189-2"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator1<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Constraints</em>: <code class="sourceCode cpp">y<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;</span> x<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb190"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb190-1"><a href="#cb190-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Iterator1, <span class="kw">class</span> Iterator2<span class="op">&gt;</span></span>
<span id="cb190-2"><a href="#cb190-2"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator1<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> move_iterator<span class="op">&lt;</span>Iterator2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Constraints</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>base<span class="op">()</span></code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb191"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb191-1"><a href="#cb191-1"></a>template&lt;class Iterator1, ThreeWayComparableWith&lt;Iterator1, weak_equality&gt; Iterator2&gt;</span>
<span id="cb191-2"><a href="#cb191-2"></a>  constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span>
<span id="cb191-3"><a href="#cb191-3"></a>    operator&lt;=&gt;(const move_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb191-4"><a href="#cb191-4"></a>                const move_iterator&lt;Iterator2&gt;&amp; y);     </span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>base<span class="op">()</span> <span class="op">&lt;=&gt;</span> y<span class="op">.</span>base<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Remove <code class="sourceCode cpp"><span class="op">!=</span></code> from 23.5.4.1 [common.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb192"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb192-1"><a href="#cb192-1"></a>namespace std {</span>
<span id="cb192-2"><a href="#cb192-2"></a>  template&lt;Iterator I, Sentinel&lt;I&gt; S&gt;</span>
<span id="cb192-3"><a href="#cb192-3"></a>    requires (!Same&lt;I, S&gt;)</span>
<span id="cb192-4"><a href="#cb192-4"></a>  class common_iterator {</span>
<span id="cb192-5"><a href="#cb192-5"></a>  public:</span>
<span id="cb192-6"><a href="#cb192-6"></a>    [...]</span>
<span id="cb192-7"><a href="#cb192-7"></a>    </span>
<span id="cb192-8"><a href="#cb192-8"></a></span>
<span id="cb192-9"><a href="#cb192-9"></a>    template&lt;class I2, Sentinel&lt;I&gt; S2&gt;</span>
<span id="cb192-10"><a href="#cb192-10"></a>      requires Sentinel&lt;S, I2&gt;</span>
<span id="cb192-11"><a href="#cb192-11"></a>    friend bool operator==(</span>
<span id="cb192-12"><a href="#cb192-12"></a>      const common_iterator&amp; x, const common_iterator&lt;I2, S2&gt;&amp; y);</span>
<span id="cb192-13"><a href="#cb192-13"></a>    template&lt;class I2, Sentinel&lt;I&gt; S2&gt;</span>
<span id="cb192-14"><a href="#cb192-14"></a>      requires Sentinel&lt;S, I2&gt; &amp;&amp; EqualityComparableWith&lt;I, I2&gt;</span>
<span id="cb192-15"><a href="#cb192-15"></a>    friend bool operator==(</span>
<span id="cb192-16"><a href="#cb192-16"></a>      const common_iterator&amp; x, const common_iterator&lt;I2, S2&gt;&amp; y);</span>
<span id="cb192-17"><a href="#cb192-17"></a><span class="st">-   template&lt;class I2, Sentinel&lt;I&gt; S2&gt;</span></span>
<span id="cb192-18"><a href="#cb192-18"></a><span class="st">-     requires Sentinel&lt;S, I2&gt;</span></span>
<span id="cb192-19"><a href="#cb192-19"></a><span class="st">-   friend bool operator!=(</span></span>
<span id="cb192-20"><a href="#cb192-20"></a><span class="st">-     const common_iterator&amp; x, const common_iterator&lt;I2, S2&gt;&amp; y);</span></span>
<span id="cb192-21"><a href="#cb192-21"></a></span>
<span id="cb192-22"><a href="#cb192-22"></a>    [...]</span>
<span id="cb192-23"><a href="#cb192-23"></a>  };</span>
<span id="cb192-24"><a href="#cb192-24"></a>}  </span></code></pre></div>
</div>
</blockquote>
<p>Remove <code class="sourceCode cpp"><span class="op">!=</span></code> from 23.5.4.6 [common.iter.cmp]:</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb193"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb193-1"><a href="#cb193-1"></a>template&lt;class I2, Sentinel&lt;I&gt; S2&gt;</span>
<span id="cb193-2"><a href="#cb193-2"></a>  requires Sentinel&lt;S, I2&gt;</span>
<span id="cb193-3"><a href="#cb193-3"></a>friend bool operator!=(</span>
<span id="cb193-4"><a href="#cb193-4"></a>  const common_iterator&amp; x, const common_iterator&lt;I2, S2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 23.5.6.1 [counted.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb194"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb194-1"><a href="#cb194-1"></a>namespace std {</span>
<span id="cb194-2"><a href="#cb194-2"></a>  template&lt;Iterator I&gt;</span>
<span id="cb194-3"><a href="#cb194-3"></a>  class counted_iterator {</span>
<span id="cb194-4"><a href="#cb194-4"></a>  public:</span>
<span id="cb194-5"><a href="#cb194-5"></a>    [...]</span>
<span id="cb194-6"><a href="#cb194-6"></a></span>
<span id="cb194-7"><a href="#cb194-7"></a>    template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb194-8"><a href="#cb194-8"></a>      friend constexpr bool operator==(</span>
<span id="cb194-9"><a href="#cb194-9"></a>        const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span>
<span id="cb194-10"><a href="#cb194-10"></a>    friend constexpr bool operator==(</span>
<span id="cb194-11"><a href="#cb194-11"></a>      const counted_iterator&amp; x, default_sentinel_t);</span>
<span id="cb194-12"><a href="#cb194-12"></a><span class="st">-   friend constexpr bool operator==(</span></span>
<span id="cb194-13"><a href="#cb194-13"></a><span class="st">-     default_sentinel_t, const counted_iterator&amp; x);</span></span>
<span id="cb194-14"><a href="#cb194-14"></a></span>
<span id="cb194-15"><a href="#cb194-15"></a><span class="st">-   template&lt;Common&lt;I&gt; I2&gt;</span></span>
<span id="cb194-16"><a href="#cb194-16"></a><span class="st">-     friend constexpr bool operator!=(</span></span>
<span id="cb194-17"><a href="#cb194-17"></a><span class="st">-       const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></span>
<span id="cb194-18"><a href="#cb194-18"></a><span class="st">-   friend constexpr bool operator!=(</span></span>
<span id="cb194-19"><a href="#cb194-19"></a><span class="st">-     const counted_iterator&amp; x, default_sentinel_t y);</span></span>
<span id="cb194-20"><a href="#cb194-20"></a><span class="st">-   friend constexpr bool operator!=(</span></span>
<span id="cb194-21"><a href="#cb194-21"></a><span class="st">-     default_sentinel_t x, const counted_iterator&amp; y);</span></span>
<span id="cb194-22"><a href="#cb194-22"></a></span>
<span id="cb194-23"><a href="#cb194-23"></a><span class="st">-   template&lt;Common&lt;I&gt; I2&gt;</span></span>
<span id="cb194-24"><a href="#cb194-24"></a><span class="st">-     friend constexpr bool operator&lt;(</span></span>
<span id="cb194-25"><a href="#cb194-25"></a><span class="st">-       const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></span>
<span id="cb194-26"><a href="#cb194-26"></a><span class="st">-   template&lt;Common&lt;I&gt; I2&gt;</span></span>
<span id="cb194-27"><a href="#cb194-27"></a><span class="st">-     friend constexpr bool operator&gt;(</span></span>
<span id="cb194-28"><a href="#cb194-28"></a><span class="st">-       const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></span>
<span id="cb194-29"><a href="#cb194-29"></a><span class="st">-   template&lt;Common&lt;I&gt; I2&gt;</span></span>
<span id="cb194-30"><a href="#cb194-30"></a><span class="st">-     friend constexpr bool operator&lt;=(</span></span>
<span id="cb194-31"><a href="#cb194-31"></a><span class="st">-       const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></span>
<span id="cb194-32"><a href="#cb194-32"></a><span class="st">-   template&lt;Common&lt;I&gt; I2&gt;</span></span>
<span id="cb194-33"><a href="#cb194-33"></a><span class="st">-     friend constexpr bool operator&gt;=(</span></span>
<span id="cb194-34"><a href="#cb194-34"></a><span class="st">-       const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></span>
<span id="cb194-35"><a href="#cb194-35"></a><span class="va">+   template&lt;Common&lt;I&gt; I2&gt;</span></span>
<span id="cb194-36"><a href="#cb194-36"></a><span class="va">+     friend constexpr strong_ordering operator&lt;=&gt;(</span></span>
<span id="cb194-37"><a href="#cb194-37"></a><span class="va">+       const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></span>
<span id="cb194-38"><a href="#cb194-38"></a></span>
<span id="cb194-39"><a href="#cb194-39"></a>    [...]       </span>
<span id="cb194-40"><a href="#cb194-40"></a>  };</span>
<span id="cb194-41"><a href="#cb194-41"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Make the same changes to 23.5.6.6 [counted.iter.comp]:</p>
<blockquote>
<div class="sourceCode" id="cb195"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb195-1"><a href="#cb195-1"></a><span class="kw">template</span><span class="op">&lt;</span>Common<span class="op">&lt;</span>I<span class="op">&gt;</span> I2<span class="op">&gt;</span></span>
<span id="cb195-2"><a href="#cb195-2"></a>  <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span></span>
<span id="cb195-3"><a href="#cb195-3"></a>    <span class="kw">const</span> counted_iterator<span class="op">&amp;</span> x, <span class="kw">const</span> counted_iterator<span class="op">&lt;</span>I2<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Expects</em>: <code class="sourceCode cpp">x</code> and <code class="sourceCode cpp">y</code> refer to elements of the same sequence ([counted.iterator]).</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>length <span class="op">==</span> y<span class="op">.</span>length;</code></p>
<div class="sourceCode" id="cb196"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb196-1"><a href="#cb196-1"></a>  <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span></span>
<span id="cb196-2"><a href="#cb196-2"></a>    <span class="kw">const</span> counted_iterator<span class="op">&amp;</span> x, default_sentinel_t<span class="op">)</span>;</span></code></pre></div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb197"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb197-1"><a href="#cb197-1"></a>friend constexpr bool operator==(</span>
<span id="cb197-2"><a href="#cb197-2"></a>  default_sentinel_t, const counted_iterator&amp; x);</span></code></pre></div>

</div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>length <span class="op">==</span> <span class="dv">0</span>;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb198"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb198-1"><a href="#cb198-1"></a>template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb198-2"><a href="#cb198-2"></a>  friend constexpr bool operator!=(</span>
<span id="cb198-3"><a href="#cb198-3"></a>    const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span>
<span id="cb198-4"><a href="#cb198-4"></a>friend constexpr bool operator!=(</span>
<span id="cb198-5"><a href="#cb198-5"></a>  const counted_iterator&amp; x, default_sentinel_t y);</span>
<span id="cb198-6"><a href="#cb198-6"></a>friend constexpr bool operator!=(</span>
<span id="cb198-7"><a href="#cb198-7"></a>  default_sentinel_t x, const counted_iterator&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb199"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb199-1"><a href="#cb199-1"></a>template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb199-2"><a href="#cb199-2"></a>  friend constexpr bool operator&lt;(</span>
<span id="cb199-3"><a href="#cb199-3"></a>    const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Expects</em>: <code class="sourceCode cpp">x</code> and <code class="sourceCode cpp">y</code> refer to elements of the same sequence ([counted.iterator]).</p>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y<span class="op">.</span>length <span class="op">&lt;</span> x<span class="op">.</span>length;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> [<em>Note</em>: The argument order in the <em>Effects</em>: element is reversed because length counts down, not up. —<em>end note</em>]</p>
<div class="sourceCode" id="cb200"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb200-1"><a href="#cb200-1"></a>template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb200-2"><a href="#cb200-2"></a>  friend constexpr bool operator&gt;(</span>
<span id="cb200-3"><a href="#cb200-3"></a>    const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">&lt;</span> x;</code></p>
<div class="sourceCode" id="cb201"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb201-1"><a href="#cb201-1"></a>template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb201-2"><a href="#cb201-2"></a>  friend constexpr bool operator&lt;=(</span>
<span id="cb201-3"><a href="#cb201-3"></a>    const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb202"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb202-1"><a href="#cb202-1"></a>template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb202-2"><a href="#cb202-2"></a>  friend constexpr bool operator&gt;=(</span>
<span id="cb202-3"><a href="#cb202-3"></a>    const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span>;</code></p>
</div>
<div class="addu">
<div class="sourceCode" id="cb203"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb203-1"><a href="#cb203-1"></a>template&lt;Common&lt;I&gt; I2&gt;</span>
<span id="cb203-2"><a href="#cb203-2"></a>  friend constexpr strong_ordering operator&lt;=&gt;(</span>
<span id="cb203-3"><a href="#cb203-3"></a>    const counted_iterator&amp; x, const counted_iterator&lt;I2&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Expects</em>: <code class="sourceCode cpp">x</code> and <code class="sourceCode cpp">y</code> refer to elements of the same sequence ([counted.iterator]).</p>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y<span class="op">.</span>length <span class="op">&lt;=&gt;</span> x<span class="op">.</span>length;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> [<em>Note</em>: The argument order in the <em>Effects</em>: element is reversed because length counts down, not up. —<em>end note</em>]</p>
</div>
</blockquote>
<p>Change 23.5.7.1 [unreachable.sentinel] to just define what will become the single operator in the synopsis:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb204"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb204-1"><a href="#cb204-1"></a>  namespace std {</span>
<span id="cb204-2"><a href="#cb204-2"></a>    struct unreachable_sentinel_t {</span>
<span id="cb204-3"><a href="#cb204-3"></a>      template&lt;WeaklyIncrementable I&gt;</span>
<span id="cb204-4"><a href="#cb204-4"></a><span class="st">-       friend constexpr bool operator==(unreachable_sentinel_t, const I&amp;) noexcept<span class="diffdel">;</span></span></span>
<span id="cb204-5"><a href="#cb204-5"></a><span class="va">+       friend constexpr bool operator==(unreachable_sentinel_t, const I&amp;) noexcept</span></span>
<span id="cb204-6"><a href="#cb204-6"></a><span class="va">+         { return false; }</span></span>
<span id="cb204-7"><a href="#cb204-7"></a><span class="st">-       friend constexpr bool operator==(unreachable_sentinel_t, const I&amp;) noexcept;</span></span>
<span id="cb204-8"><a href="#cb204-8"></a><span class="st">-     template&lt;WeaklyIncrementable I&gt;</span></span>
<span id="cb204-9"><a href="#cb204-9"></a><span class="st">-       friend constexpr bool operator==(const I&amp;, unreachable_sentinel_t) noexcept;</span></span>
<span id="cb204-10"><a href="#cb204-10"></a><span class="st">-     template&lt;WeaklyIncrementable I&gt;</span></span>
<span id="cb204-11"><a href="#cb204-11"></a><span class="st">-       friend constexpr bool operator!=(unreachable_sentinel_t, const I&amp;) noexcept;</span></span>
<span id="cb204-12"><a href="#cb204-12"></a><span class="st">-     template&lt;WeaklyIncrementable I&gt;</span></span>
<span id="cb204-13"><a href="#cb204-13"></a><span class="st">-       friend constexpr bool operator!=(const I&amp;, unreachable_sentinel_t) noexcept;</span></span>
<span id="cb204-14"><a href="#cb204-14"></a>    };</span>
<span id="cb204-15"><a href="#cb204-15"></a>  }</span></code></pre></div>
</div>
</blockquote>
<p>Remove all of 23.5.7.2 [unreachable.sentinel.cmp] (which is just the definitions of <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code>)</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb205"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb205-1"><a href="#cb205-1"></a>template&lt;WeaklyIncrementable I&gt;</span>
<span id="cb205-2"><a href="#cb205-2"></a>  friend constexpr bool operator==(unreachable_sentinel_t, const I&amp;) noexcept;</span>
<span id="cb205-3"><a href="#cb205-3"></a>template&lt;WeaklyIncrementable I&gt;</span>
<span id="cb205-4"><a href="#cb205-4"></a>  friend constexpr bool operator==(const I&amp;, unreachable_sentinel_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
<div class="sourceCode" id="cb206"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb206-1"><a href="#cb206-1"></a>template&lt;WeaklyIncrementable I&gt;</span>
<span id="cb206-2"><a href="#cb206-2"></a>  friend constexpr bool operator!=(unreachable_sentinel_t, const I&amp;) noexcept;</span>
<span id="cb206-3"><a href="#cb206-3"></a>template&lt;WeaklyIncrementable I&gt;</span>
<span id="cb206-4"><a href="#cb206-4"></a>  friend constexpr bool operator!=(const I&amp;, unreachable_sentinel_t) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
</div>
</blockquote>
<p>Change 23.6.1 [istream.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb207"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb207-1"><a href="#cb207-1"></a>namespace std {</span>
<span id="cb207-2"><a href="#cb207-2"></a>  template&lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,</span>
<span id="cb207-3"><a href="#cb207-3"></a>           class Distance = ptrdiff_t&gt;</span>
<span id="cb207-4"><a href="#cb207-4"></a>  class istream_iterator {</span>
<span id="cb207-5"><a href="#cb207-5"></a>  public:</span>
<span id="cb207-6"><a href="#cb207-6"></a>    [...]</span>
<span id="cb207-7"><a href="#cb207-7"></a></span>
<span id="cb207-8"><a href="#cb207-8"></a>    friend bool operator==(const istream_iterator&amp; i, default_sentinel_t);</span>
<span id="cb207-9"><a href="#cb207-9"></a><span class="st">-   friend bool operator==(default_sentinel_t, const istream_iterator&amp; i);</span></span>
<span id="cb207-10"><a href="#cb207-10"></a><span class="st">-   friend bool operator!=(const istream_iterator&amp; x, default_sentinel_t y);</span></span>
<span id="cb207-11"><a href="#cb207-11"></a><span class="st">-   friend bool operator!=(default_sentinel_t x, const istream_iterator&amp; y);</span></span>
<span id="cb207-12"><a href="#cb207-12"></a></span>
<span id="cb207-13"><a href="#cb207-13"></a>    [...]</span>
<span id="cb207-14"><a href="#cb207-14"></a>  };</span>
<span id="cb207-15"><a href="#cb207-15"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 23.6.1.2 [istream.iterator.ops]:</p>
<blockquote>
<div class="sourceCode" id="cb208"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb208-1"><a href="#cb208-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> charT, <span class="kw">class</span> traits, <span class="kw">class</span> Distance<span class="op">&gt;</span></span>
<span id="cb208-2"><a href="#cb208-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> istream_iterator<span class="op">&lt;</span>T,charT,traits,Distance<span class="op">&gt;&amp;</span> x,</span>
<span id="cb208-3"><a href="#cb208-3"></a>                  <span class="kw">const</span> istream_iterator<span class="op">&lt;</span>T,charT,traits,Distance<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>in_stream <span class="op">==</span> y<span class="op">.</span>in_stream</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb209"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb209-1"><a href="#cb209-1"></a>friend bool operator==(default_sentinel_t, const istream_iterator&amp; i);</span></code></pre></div>

</div>
<div class="sourceCode" id="cb210"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb210-1"><a href="#cb210-1"></a><span class="kw">friend</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> istream_iterator<span class="op">&amp;</span> i, default_sentinel_t<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>i<span class="op">.</span>in_stream</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb211"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb211-1"><a href="#cb211-1"></a>template&lt;class T, class charT, class traits, class Distance&gt;</span>
<span id="cb211-2"><a href="#cb211-2"></a>  bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,</span>
<span id="cb211-3"><a href="#cb211-3"></a>                  const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);</span>
<span id="cb211-4"><a href="#cb211-4"></a>friend bool operator!=(default_sentinel_t x, const istream_iterator&amp; y);</span>
<span id="cb211-5"><a href="#cb211-5"></a>friend bool operator!=(const istream_iterator&amp; x, default_sentinel_t y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code></p>
</div>
</blockquote>
<p>Change 23.6.3 [istreambuf.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb212"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb212-1"><a href="#cb212-1"></a>namespace std {</span>
<span id="cb212-2"><a href="#cb212-2"></a>  template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;</span>
<span id="cb212-3"><a href="#cb212-3"></a>  class istreambuf_iterator {</span>
<span id="cb212-4"><a href="#cb212-4"></a>    [...]</span>
<span id="cb212-5"><a href="#cb212-5"></a>    </span>
<span id="cb212-6"><a href="#cb212-6"></a><span class="st">-   friend bool operator==(default_sentinel_t s, const istreambuf_iterator&amp; i);</span></span>
<span id="cb212-7"><a href="#cb212-7"></a>    friend bool operator==(const istreambuf_iterator&amp; i, default_sentinel_t s);</span>
<span id="cb212-8"><a href="#cb212-8"></a><span class="st">-   friend bool operator!=(default_sentinel_t a, const istreambuf_iterator&amp; b);</span></span>
<span id="cb212-9"><a href="#cb212-9"></a><span class="st">-   friend bool operator!=(const istreambuf_iterator&amp; a, default_sentinel_t b);</span></span>
<span id="cb212-10"><a href="#cb212-10"></a></span>
<span id="cb212-11"><a href="#cb212-11"></a>    [...]</span>
<span id="cb212-12"><a href="#cb212-12"></a>  };</span>
<span id="cb212-13"><a href="#cb212-13"></a>}   </span></code></pre></div>
</div>
</blockquote>
<p>Change 23.6.3.3 [istreambuf.iterator.ops]:</p>
<blockquote>
<div class="sourceCode" id="cb213"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb213-1"><a href="#cb213-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> charT, <span class="kw">class</span> traits<span class="op">&gt;</span></span>
<span id="cb213-2"><a href="#cb213-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> istreambuf_iterator<span class="op">&lt;</span>charT,traits<span class="op">&gt;&amp;</span> a,</span>
<span id="cb213-3"><a href="#cb213-3"></a>                  <span class="kw">const</span> istreambuf_iterator<span class="op">&lt;</span>charT,traits<span class="op">&gt;&amp;</span> b<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">a<span class="op">.</span>equal<span class="op">(</span>b<span class="op">)</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb214"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb214-1"><a href="#cb214-1"></a>friend bool operator==(default_sentinel_t s, const istreambuf_iterator&amp; i);</span></code></pre></div>

</div>
<div class="sourceCode" id="cb215"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb215-1"><a href="#cb215-1"></a><span class="kw">friend</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> istreambuf_iterator<span class="op">&amp;</span> i, default_sentinel_t s<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">i<span class="op">.</span>equal<span class="op">(</span>s<span class="op">)</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb216"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb216-1"><a href="#cb216-1"></a>template&lt;class charT, class traits&gt;</span>
<span id="cb216-2"><a href="#cb216-2"></a>  bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,</span>
<span id="cb216-3"><a href="#cb216-3"></a>                  const istreambuf_iterator&lt;charT,traits&gt;&amp; b);</span>
<span id="cb216-4"><a href="#cb216-4"></a>friend bool operator!=(default_sentinel_t a, const istreambuf_iterator&amp; b);</span>
<span id="cb216-5"><a href="#cb216-5"></a>friend bool operator!=(const istreambuf_iterator&amp; a, default_sentinel_t b);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!</span>a<span class="op">.</span>equal<span class="op">(</span>b<span class="op">)</span></code>.</p>
</div>
</blockquote>
<h2 id="clause-24-ranges-library"><span class="header-section-number">5.9</span> Clause 24: Ranges library<a href="#clause-24-ranges-library" class="self-link"></a></h2>
<p>Remove no-longer-needed <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code> operators from several iterators. Add a constrained <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to <code class="sourceCode cpp">iota_view<span class="op">::</span>iterator</code> and <code class="sourceCode cpp">transform_view<span class="op">::</span>iterator</code>.</p>
<p>Change 24.6.3.3 [range.iota.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb217"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb217-1"><a href="#cb217-1"></a>namespace std::ranges {</span>
<span id="cb217-2"><a href="#cb217-2"></a>  template&lt;class W, class Bound&gt;</span>
<span id="cb217-3"><a href="#cb217-3"></a>  struct iota_view&lt;W, Bound&gt;::iterator {</span>
<span id="cb217-4"><a href="#cb217-4"></a>    [...]</span>
<span id="cb217-5"><a href="#cb217-5"></a></span>
<span id="cb217-6"><a href="#cb217-6"></a>    friend constexpr bool operator==(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb217-7"><a href="#cb217-7"></a>      requires EqualityComparable&lt;W&gt;;</span>
<span id="cb217-8"><a href="#cb217-8"></a><span class="st">-   friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span></span>
<span id="cb217-9"><a href="#cb217-9"></a><span class="st">-     requires EqualityComparable&lt;W&gt;;</span></span>
<span id="cb217-10"><a href="#cb217-10"></a></span>
<span id="cb217-11"><a href="#cb217-11"></a>    friend constexpr bool operator&lt;(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb217-12"><a href="#cb217-12"></a>      requires StrictTotallyOrdered&lt;W&gt;;</span>
<span id="cb217-13"><a href="#cb217-13"></a>    friend constexpr bool operator&gt;(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb217-14"><a href="#cb217-14"></a>      requires StrictTotallyOrdered&lt;W&gt;;</span>
<span id="cb217-15"><a href="#cb217-15"></a>    friend constexpr bool operator&lt;=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb217-16"><a href="#cb217-16"></a>      requires StrictTotallyOrdered&lt;W&gt;;</span>
<span id="cb217-17"><a href="#cb217-17"></a>    friend constexpr bool operator&gt;=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb217-18"><a href="#cb217-18"></a>      requires StrictTotallyOrdered&lt;W&gt;;</span>
<span id="cb217-19"><a href="#cb217-19"></a><span class="va">+   friend constexpr compare_three_way_result_t&lt;W&gt; operator&lt;=&gt;(</span></span>
<span id="cb217-20"><a href="#cb217-20"></a><span class="va">+       const iterator&amp; x, const iterator&amp; y)</span></span>
<span id="cb217-21"><a href="#cb217-21"></a><span class="va">+     requires StrictTotallyOrdered&lt;W&gt; &amp;&amp; ThreeWayComparable&lt;W&gt;;</span></span>
<span id="cb217-22"><a href="#cb217-22"></a>    [...]</span>
<span id="cb217-23"><a href="#cb217-23"></a>  };</span>
<span id="cb217-24"><a href="#cb217-24"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb218"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb218-1"><a href="#cb218-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb218-2"><a href="#cb218-2"></a>  <span class="kw">requires</span> EqualityComparable<span class="op">&lt;</span>W<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>value_ <span class="op">==</span> y<span class="op">.</span>value_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb219"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb219-1"><a href="#cb219-1"></a>friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb219-2"><a href="#cb219-2"></a>  requires EqualityComparable&lt;W&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
<div class="sourceCode" id="cb220"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb220-1"><a href="#cb220-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb220-2"><a href="#cb220-2"></a>  <span class="kw">requires</span> StrictTotallyOrdered<span class="op">&lt;</span>W<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>value_ <span class="op">&lt;</span> y<span class="op">.</span>value_;</code></p>
<div class="sourceCode" id="cb221"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb221-1"><a href="#cb221-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb221-2"><a href="#cb221-2"></a>  <span class="kw">requires</span> StrictTotallyOrdered<span class="op">&lt;</span>W<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">&lt;</span> x;</code></p>
<div class="sourceCode" id="cb222"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb222-1"><a href="#cb222-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb222-2"><a href="#cb222-2"></a>  <span class="kw">requires</span> StrictTotallyOrdered<span class="op">&lt;</span>W<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb223"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb223-1"><a href="#cb223-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb223-2"><a href="#cb223-2"></a>  <span class="kw">requires</span> StrictTotallyOrdered<span class="op">&lt;</span>W<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span>;</code></p>
<div class="addu">
<div class="sourceCode" id="cb224"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb224-1"><a href="#cb224-1"></a>friend constexpr compare_three_way_result_t&lt;W&gt;</span>
<span id="cb224-2"><a href="#cb224-2"></a>  operator&lt;=&gt;(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb224-3"><a href="#cb224-3"></a>    requires StrictTotallyOrdered&lt;W&gt; &amp;&amp; ThreeWayComparable&lt;W&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>value_ <span class="op">&lt;=&gt;</span> y<span class="op">.</span>value_;</code></p>
</div>
</blockquote>
<p>Change 24.6.3.4 [range.iota.sentinel]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb225"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb225-1"><a href="#cb225-1"></a>namespace std::ranges {</span>
<span id="cb225-2"><a href="#cb225-2"></a>  template&lt;class W, class Bound&gt;</span>
<span id="cb225-3"><a href="#cb225-3"></a>  struct iota_view&lt;W, Bound&gt;::sentinel {</span>
<span id="cb225-4"><a href="#cb225-4"></a>    [...]</span>
<span id="cb225-5"><a href="#cb225-5"></a></span>
<span id="cb225-6"><a href="#cb225-6"></a>    friend constexpr bool operator==(const iterator&amp; x, const sentinel&amp; y);</span>
<span id="cb225-7"><a href="#cb225-7"></a><span class="st">-   friend constexpr bool operator==(const sentinel&amp; x, const iterator&amp; y);</span></span>
<span id="cb225-8"><a href="#cb225-8"></a><span class="st">-   friend constexpr bool operator!=(const iterator&amp; x, const sentinel&amp; y);</span></span>
<span id="cb225-9"><a href="#cb225-9"></a><span class="st">-   friend constexpr bool operator!=(const sentinel&amp; x, const iterator&amp; y);</span></span>
<span id="cb225-10"><a href="#cb225-10"></a>  };</span>
<span id="cb225-11"><a href="#cb225-11"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb226"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb226-1"><a href="#cb226-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> sentinel<span class="op">(</span>Bound bound<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp">bound_</code> with <code class="sourceCode cpp">bound</code>.</p>
<div class="sourceCode" id="cb227"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb227-1"><a href="#cb227-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> sentinel<span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>value_ <span class="op">==</span> y<span class="op">.</span>bound_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb228"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb228-1"><a href="#cb228-1"></a>friend constexpr bool operator==(const sentinel&amp; x, const iterator&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">==</span> x;</code></p>
<div class="sourceCode" id="cb229"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb229-1"><a href="#cb229-1"></a>friend constexpr bool operator!=(const iterator&amp; x, const sentinel&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb230"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb230-1"><a href="#cb230-1"></a>friend constexpr bool operator!=(const sentinel&amp; x, const iterator&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">==</span> x<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Remove <code class="sourceCode cpp"><span class="op">!=</span></code> from 24.7.4.3 [range.filter.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb231"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb231-1"><a href="#cb231-1"></a>namespace std::ranges {</span>
<span id="cb231-2"><a href="#cb231-2"></a>  template&lt;class V, class Pred&gt;</span>
<span id="cb231-3"><a href="#cb231-3"></a>  class filter_view&lt;V, Pred&gt;::iterator {</span>
<span id="cb231-4"><a href="#cb231-4"></a>    [...]</span>
<span id="cb231-5"><a href="#cb231-5"></a></span>
<span id="cb231-6"><a href="#cb231-6"></a>    friend constexpr bool operator==(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb231-7"><a href="#cb231-7"></a>      requires EqualityComparable&lt;iterator_t&lt;V&gt;&gt;;</span>
<span id="cb231-8"><a href="#cb231-8"></a><span class="st">-   friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span></span>
<span id="cb231-9"><a href="#cb231-9"></a><span class="st">-     requires EqualityComparable&lt;iterator_t&lt;V&gt;&gt;;</span></span>
<span id="cb231-10"><a href="#cb231-10"></a></span>
<span id="cb231-11"><a href="#cb231-11"></a>    [...]</span>
<span id="cb231-12"><a href="#cb231-12"></a>  };</span>
<span id="cb231-13"><a href="#cb231-13"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb232"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb232-1"><a href="#cb232-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb232-2"><a href="#cb232-2"></a>  <span class="kw">requires</span> EqualityComparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>V<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">==</span> y<span class="op">.</span>current_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb233"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb233-1"><a href="#cb233-1"></a>friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb233-2"><a href="#cb233-2"></a>  requires EqualityComparable&lt;iterator_t&lt;V&gt;&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.4.4 [range.filter.sentinel]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb234"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb234-1"><a href="#cb234-1"></a>namespace std::ranges {</span>
<span id="cb234-2"><a href="#cb234-2"></a>  template&lt;class V, class Pred&gt;</span>
<span id="cb234-3"><a href="#cb234-3"></a>  class filter_view&lt;V, Pred&gt;::sentinel {</span>
<span id="cb234-4"><a href="#cb234-4"></a>    [...]</span>
<span id="cb234-5"><a href="#cb234-5"></a></span>
<span id="cb234-6"><a href="#cb234-6"></a>    friend constexpr bool operator==(const iterator&amp; x, const sentinel&amp; y);</span>
<span id="cb234-7"><a href="#cb234-7"></a><span class="st">-   friend constexpr bool operator==(const sentinel&amp; x, const iterator&amp; y);</span></span>
<span id="cb234-8"><a href="#cb234-8"></a><span class="st">-   friend constexpr bool operator!=(const iterator&amp; x, const sentinel&amp; y);</span></span>
<span id="cb234-9"><a href="#cb234-9"></a><span class="st">-   friend constexpr bool operator!=(const sentinel&amp; x, const iterator&amp; y);</span></span>
<span id="cb234-10"><a href="#cb234-10"></a>  };</span>
<span id="cb234-11"><a href="#cb234-11"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb235"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb235-1"><a href="#cb235-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> sentinel<span class="op">(</span>filter_view<span class="op">&amp;</span> parent<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp">end_</code> with <code class="sourceCode cpp">ranges<span class="op">::</span>end<span class="op">(</span>parent<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb236"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb236-1"><a href="#cb236-1"></a><span class="kw">constexpr</span> sentinel_t<span class="op">&lt;</span>V<span class="op">&gt;</span> base<span class="op">()</span> <span class="kw">const</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> end_;</code></p>
<div class="sourceCode" id="cb237"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb237-1"><a href="#cb237-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> sentinel<span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">==</span> y<span class="op">.</span>end_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb238"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb238-1"><a href="#cb238-1"></a>friend constexpr bool operator==(const sentinel&amp; x, const iterator&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">==</span> x;</code></p>
<div class="sourceCode" id="cb239"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb239-1"><a href="#cb239-1"></a>friend constexpr bool operator!=(const iterator&amp; x, const sentinel&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb240"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb240-1"><a href="#cb240-1"></a>friend constexpr bool operator!=(const sentinel&amp; x, const iterator&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">==</span> x<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.5.3 [range.transform.iterator].</p>
<blockquote>
<div>
<div class="sourceCode" id="cb241"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb241-1"><a href="#cb241-1"></a>namespace std::ranges {</span>
<span id="cb241-2"><a href="#cb241-2"></a>  template&lt;class V, class F&gt;</span>
<span id="cb241-3"><a href="#cb241-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb241-4"><a href="#cb241-4"></a>  class transform_view&lt;V, F&gt;::iterator {</span>
<span id="cb241-5"><a href="#cb241-5"></a>    [...]</span>
<span id="cb241-6"><a href="#cb241-6"></a>    </span>
<span id="cb241-7"><a href="#cb241-7"></a></span>
<span id="cb241-8"><a href="#cb241-8"></a>    friend constexpr bool operator==(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb241-9"><a href="#cb241-9"></a>      requires EqualityComparable&lt;iterator_t&lt;Base&gt;&gt;;</span>
<span id="cb241-10"><a href="#cb241-10"></a><span class="st">-   friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span></span>
<span id="cb241-11"><a href="#cb241-11"></a><span class="st">-     requires EqualityComparable&lt;iterator_t&lt;Base&gt;&gt;;</span></span>
<span id="cb241-12"><a href="#cb241-12"></a></span>
<span id="cb241-13"><a href="#cb241-13"></a>    friend constexpr bool operator&lt;(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb241-14"><a href="#cb241-14"></a>      requires RandomAccessRange&lt;Base&gt;;</span>
<span id="cb241-15"><a href="#cb241-15"></a>    friend constexpr bool operator&gt;(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb241-16"><a href="#cb241-16"></a>      requires RandomAccessRange&lt;Base&gt;;</span>
<span id="cb241-17"><a href="#cb241-17"></a>    friend constexpr bool operator&lt;=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb241-18"><a href="#cb241-18"></a>      requires RandomAccessRange&lt;Base&gt;;</span>
<span id="cb241-19"><a href="#cb241-19"></a>    friend constexpr bool operator&gt;=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb241-20"><a href="#cb241-20"></a>      requires RandomAccessRange&lt;Base&gt;;</span>
<span id="cb241-21"><a href="#cb241-21"></a><span class="va">+   friend constexpr compare_three_way_result_t&lt;iterator_t&lt;Base&gt;&gt;</span></span>
<span id="cb241-22"><a href="#cb241-22"></a><span class="va">+     operator&lt;=&gt;(const iterator&amp; x, const iterator&amp; y)</span></span>
<span id="cb241-23"><a href="#cb241-23"></a><span class="va">+       requires RandomAccessRange&lt;Base&gt; &amp;&amp; ThreeWayComparable&lt;iterator_t&lt;Base&gt;&gt;;</span></span>
<span id="cb241-24"><a href="#cb241-24"></a></span>
<span id="cb241-25"><a href="#cb241-25"></a>    [...]</span>
<span id="cb241-26"><a href="#cb241-26"></a>  };</span>
<span id="cb241-27"><a href="#cb241-27"></a>}  </span></code></pre></div>
</div>
<div class="sourceCode" id="cb242"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb242-1"><a href="#cb242-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb242-2"><a href="#cb242-2"></a>  <span class="kw">requires</span> EqualityComparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>Base<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">==</span> y<span class="op">.</span>current_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb243"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb243-1"><a href="#cb243-1"></a>friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb243-2"><a href="#cb243-2"></a>  requires EqualityComparable&lt;iterator_t&lt;Base&gt;&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
<div class="sourceCode" id="cb244"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb244-1"><a href="#cb244-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb244-2"><a href="#cb244-2"></a>  <span class="kw">requires</span> RandomAccessRange<span class="op">&lt;</span>Base<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">&lt;</span> y<span class="op">.</span>current_;</code></p>
<div class="sourceCode" id="cb245"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb245-1"><a href="#cb245-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb245-2"><a href="#cb245-2"></a>  <span class="kw">requires</span> RandomAccessRange<span class="op">&lt;</span>Base<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">&lt;</span> x;</code></p>
<div class="sourceCode" id="cb246"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb246-1"><a href="#cb246-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb246-2"><a href="#cb246-2"></a>  <span class="kw">requires</span> RandomAccessRange<span class="op">&lt;</span>Base<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb247"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb247-1"><a href="#cb247-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> iterator<span class="op">&amp;</span> x, <span class="kw">const</span> iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb247-2"><a href="#cb247-2"></a>  <span class="kw">requires</span> RandomAccessRange<span class="op">&lt;</span>Base<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span>;</code></p>
<div class="addu">
<div class="sourceCode" id="cb248"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb248-1"><a href="#cb248-1"></a>friend constexpr compare_three_way_result_t&lt;iterator_t&lt;Base&gt;&gt;</span>
<span id="cb248-2"><a href="#cb248-2"></a>  operator&lt;=&gt;(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb248-3"><a href="#cb248-3"></a>    requires RandomAccessRange&lt;Base&gt; &amp;&amp; ThreeWayComparable&lt;iterator_t&lt;Base&gt;&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Effects</em>: Equivalent to <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">&lt;=&gt;</span> y<span class="op">.</span>current_;</code></p>
</div>
</blockquote>
<p>Change 24.7.5.4 [range.transform.sentinel]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb249"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb249-1"><a href="#cb249-1"></a>namespace std::ranges {</span>
<span id="cb249-2"><a href="#cb249-2"></a>  template&lt;class V, class F&gt;</span>
<span id="cb249-3"><a href="#cb249-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb249-4"><a href="#cb249-4"></a>  class transform_view&lt;V, F&gt;::sentinel {</span>
<span id="cb249-5"><a href="#cb249-5"></a>    [...]</span>
<span id="cb249-6"><a href="#cb249-6"></a>    </span>
<span id="cb249-7"><a href="#cb249-7"></a>    friend constexpr bool operator==(const iterator&lt;Const&gt;&amp; x, const sentinel&amp; y);</span>
<span id="cb249-8"><a href="#cb249-8"></a><span class="st">-   friend constexpr bool operator==(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></span>
<span id="cb249-9"><a href="#cb249-9"></a><span class="st">-   friend constexpr bool operator!=(const iterator&lt;Const&gt;&amp; x, const sentinel&amp; y);</span></span>
<span id="cb249-10"><a href="#cb249-10"></a><span class="st">-   friend constexpr bool operator!=(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></span>
<span id="cb249-11"><a href="#cb249-11"></a></span>
<span id="cb249-12"><a href="#cb249-12"></a>    [...]   </span>
<span id="cb249-13"><a href="#cb249-13"></a>  };</span>
<span id="cb249-14"><a href="#cb249-14"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb250"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb250-1"><a href="#cb250-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&lt;</span>Const<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> sentinel<span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">==</span> y<span class="op">.</span>end_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb251"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb251-1"><a href="#cb251-1"></a>friend constexpr bool operator==(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">==</span> x;</code></p>
<div class="sourceCode" id="cb252"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb252-1"><a href="#cb252-1"></a>friend constexpr bool operator!=(const iterator&lt;Const&gt;&amp; x, const sentinel&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb253"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb253-1"><a href="#cb253-1"></a>friend constexpr bool operator!=(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">==</span> x<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.6.3 [range.take.sentinel]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb254"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb254-1"><a href="#cb254-1"></a>namespace std::ranges {</span>
<span id="cb254-2"><a href="#cb254-2"></a>  template&lt;class V&gt;</span>
<span id="cb254-3"><a href="#cb254-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb254-4"><a href="#cb254-4"></a>  class take_view&lt;V&gt;::sentinel {</span>
<span id="cb254-5"><a href="#cb254-5"></a>    [...]</span>
<span id="cb254-6"><a href="#cb254-6"></a></span>
<span id="cb254-7"><a href="#cb254-7"></a><span class="st">-   friend constexpr bool operator==(const sentinel&amp; x, const CI&amp; y);</span></span>
<span id="cb254-8"><a href="#cb254-8"></a>    friend constexpr bool operator==(const CI&amp; y, const sentinel&amp; x);</span>
<span id="cb254-9"><a href="#cb254-9"></a><span class="st">-   friend constexpr bool operator!=(const sentinel&amp; x, const CI&amp; y);</span></span>
<span id="cb254-10"><a href="#cb254-10"></a><span class="st">-   friend constexpr bool operator!=(const CI&amp; y, const sentinel&amp; x);</span></span>
<span id="cb254-11"><a href="#cb254-11"></a>  };</span>
<span id="cb254-12"><a href="#cb254-12"></a>}</span></code></pre></div>
</div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb255"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb255-1"><a href="#cb255-1"></a>friend constexpr bool operator==(const sentinel&amp; x, const CI&amp; y);</span></code></pre></div>

</div>
<div class="sourceCode" id="cb256"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb256-1"><a href="#cb256-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> CI<span class="op">&amp;</span> y, <span class="kw">const</span> sentinel<span class="op">&amp;</span> x<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y<span class="op">.</span>count<span class="op">()</span> <span class="op">==</span> <span class="dv">0</span> <span class="op">||</span> y<span class="op">.</span>base<span class="op">()</span> <span class="op">==</span> x<span class="op">.</span>end_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb257"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb257-1"><a href="#cb257-1"></a>friend constexpr bool operator!=(const sentinel&amp; x, const CI&amp; y);</span>
<span id="cb257-2"><a href="#cb257-2"></a>friend constexpr bool operator!=(const CI&amp; y, const sentinel&amp; x);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.7.3 [range.join.iterator]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb258"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb258-1"><a href="#cb258-1"></a>namespace std::ranges {</span>
<span id="cb258-2"><a href="#cb258-2"></a>template&lt;class V&gt;</span>
<span id="cb258-3"><a href="#cb258-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb258-4"><a href="#cb258-4"></a>  struct join_view&lt;V&gt;::iterator {</span>
<span id="cb258-5"><a href="#cb258-5"></a>    [...]</span>
<span id="cb258-6"><a href="#cb258-6"></a></span>
<span id="cb258-7"><a href="#cb258-7"></a>    friend constexpr bool operator==(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb258-8"><a href="#cb258-8"></a>      requires ref_is_glvalue &amp;&amp; EqualityComparable&lt;iterator_t&lt;Base&gt;&gt; &amp;&amp;</span>
<span id="cb258-9"><a href="#cb258-9"></a>               EqualityComparable&lt;iterator_t&lt;iter_reference_t&lt;iterator_t&lt;Base&gt;&gt;&gt;&gt;;</span>
<span id="cb258-10"><a href="#cb258-10"></a></span>
<span id="cb258-11"><a href="#cb258-11"></a><span class="st">-   friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span></span>
<span id="cb258-12"><a href="#cb258-12"></a><span class="st">-     requires ref_is_glvalue &amp;&amp; EqualityComparable&lt;iterator_t&lt;Base&gt;&gt; &amp;&amp;</span></span>
<span id="cb258-13"><a href="#cb258-13"></a><span class="st">-              EqualityComparable&lt;iterator_t&lt;iter_reference_t&lt;iterator_t&lt;Base&gt;&gt;&gt;&gt;;</span></span>
<span id="cb258-14"><a href="#cb258-14"></a></span>
<span id="cb258-15"><a href="#cb258-15"></a>    [...]              </span>
<span id="cb258-16"><a href="#cb258-16"></a>  };</span>
<span id="cb258-17"><a href="#cb258-17"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb259"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb259-1"><a href="#cb259-1"></a>friend constexpr bool operator==(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb259-2"><a href="#cb259-2"></a>  requires ref_is_glvalue &amp;&amp; EqualityComparable&lt;iterator_t&lt;Base&gt;&gt; &amp;&amp;</span>
<span id="cb259-3"><a href="#cb259-3"></a>           EqualityComparable&lt;iterator_t&lt;iter_reference_t&lt;iterator_t&lt;Base&gt;&gt;&gt;&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>outer_ <span class="op">==</span> y<span class="op">.</span>outer_ <span class="op">&amp;&amp;</span> x<span class="op">.</span>inner_ <span class="op">==</span> y<span class="op">.</span>inner_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb260"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb260-1"><a href="#cb260-1"></a>friend constexpr bool operator!=(const iterator&amp; x, const iterator&amp; y)</span>
<span id="cb260-2"><a href="#cb260-2"></a>  requires ref_is_glvalue &amp;&amp; EqualityComparable&lt;iterator_t&lt;Base&gt;&gt; &amp;&amp;</span>
<span id="cb260-3"><a href="#cb260-3"></a>           EqualityComparable&lt;iterator_t&lt;iter_reference_t&lt;iterator_t&lt;Base&gt;&gt;&gt;&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.7.4 [range.join.sentinel]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb261"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb261-1"><a href="#cb261-1"></a>namespace std::ranges {</span>
<span id="cb261-2"><a href="#cb261-2"></a>  template&lt;class V&gt;</span>
<span id="cb261-3"><a href="#cb261-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb261-4"><a href="#cb261-4"></a>  struct join_view&lt;V&gt;::sentinel {</span>
<span id="cb261-5"><a href="#cb261-5"></a>    [...]</span>
<span id="cb261-6"><a href="#cb261-6"></a></span>
<span id="cb261-7"><a href="#cb261-7"></a>    friend constexpr bool operator==(const iterator&lt;Const&gt;&amp; x, const sentinel&amp; y);</span>
<span id="cb261-8"><a href="#cb261-8"></a><span class="st">-   friend constexpr bool operator==(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></span>
<span id="cb261-9"><a href="#cb261-9"></a><span class="st">-   friend constexpr bool operator!=(const iterator&lt;Const&gt;&amp; x, const sentinel&amp; y);</span></span>
<span id="cb261-10"><a href="#cb261-10"></a><span class="st">-   friend constexpr bool operator!=(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></span>
<span id="cb261-11"><a href="#cb261-11"></a>  };</span>
<span id="cb261-12"><a href="#cb261-12"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb262"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb262-1"><a href="#cb262-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> iterator<span class="op">&lt;</span>Const<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> sentinel<span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>outer_ <span class="op">==</span> y<span class="op">.</span>end_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb263"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb263-1"><a href="#cb263-1"></a>friend constexpr bool operator==(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> y <span class="op">==</span> x;</code></p>
<div class="sourceCode" id="cb264"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb264-1"><a href="#cb264-1"></a>friend constexpr bool operator!=(const iterator&lt;Const&gt;&amp; x, const sentinel&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
<div class="sourceCode" id="cb265"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb265-1"><a href="#cb265-1"></a>friend constexpr bool operator!=(const sentinel&amp; x, const iterator&lt;Const&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>y <span class="op">==</span> x<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.8.3 [range.split.outer]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb266"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb266-1"><a href="#cb266-1"></a>namespace std::ranges {</span>
<span id="cb266-2"><a href="#cb266-2"></a>  template&lt;class V, class Pattern&gt;</span>
<span id="cb266-3"><a href="#cb266-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb266-4"><a href="#cb266-4"></a>  struct split_view&lt;V, Pattern&gt;::outer_iterator {</span>
<span id="cb266-5"><a href="#cb266-5"></a>    [...]</span>
<span id="cb266-6"><a href="#cb266-6"></a>    </span>
<span id="cb266-7"><a href="#cb266-7"></a>    friend constexpr bool operator==(const outer_iterator&amp; x, const outer_iterator&amp; y)</span>
<span id="cb266-8"><a href="#cb266-8"></a>      requires ForwardRange&lt;Base&gt;;</span>
<span id="cb266-9"><a href="#cb266-9"></a><span class="st">-   friend constexpr bool operator!=(const outer_iterator&amp; x, const outer_iterator&amp; y)</span></span>
<span id="cb266-10"><a href="#cb266-10"></a><span class="st">-     requires ForwardRange&lt;Base&gt;;</span></span>
<span id="cb266-11"><a href="#cb266-11"></a></span>
<span id="cb266-12"><a href="#cb266-12"></a>    friend constexpr bool operator==(const outer_iterator&amp; x, default_sentinel_t);</span>
<span id="cb266-13"><a href="#cb266-13"></a><span class="st">-   friend constexpr bool operator==(default_sentinel_t, const outer_iterator&amp; x);</span></span>
<span id="cb266-14"><a href="#cb266-14"></a><span class="st">-   friend constexpr bool operator!=(const outer_iterator&amp; x, default_sentinel_t y);</span></span>
<span id="cb266-15"><a href="#cb266-15"></a><span class="st">-   friend constexpr bool operator!=(default_sentinel_t y, const outer_iterator&amp; x);</span></span>
<span id="cb266-16"><a href="#cb266-16"></a>  };</span>
<span id="cb266-17"><a href="#cb266-17"></a>}</span></code></pre></div>
</div>
<div class="sourceCode" id="cb267"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb267-1"><a href="#cb267-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> outer_iterator<span class="op">&amp;</span> x, <span class="kw">const</span> outer_iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb267-2"><a href="#cb267-2"></a>  <span class="kw">requires</span> ForwardRange<span class="op">&lt;</span>Base<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current_ <span class="op">==</span> y<span class="op">.</span>current_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb268"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb268-1"><a href="#cb268-1"></a>friend constexpr bool operator!=(const outer_iterator&amp; x, const outer_iterator&amp; y)</span>
<span id="cb268-2"><a href="#cb268-2"></a>  requires ForwardRange&lt;Base&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
<div class="sourceCode" id="cb269"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb269-1"><a href="#cb269-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> outer_iterator<span class="op">&amp;</span> x, default_sentinel_t<span class="op">)</span>;</span></code></pre></div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb270"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb270-1"><a href="#cb270-1"></a>friend constexpr bool operator==(default_sentinel_t, const outer_iterator&amp; x);</span></code></pre></div>

</div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>current <span class="op">==</span> ranges<span class="op">::</span>end<span class="op">(</span>x<span class="op">.</span>parent_<span class="op">-&gt;</span>base_<span class="op">)</span>;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb271"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb271-1"><a href="#cb271-1"></a>friend constexpr bool operator!=(const outer_iterator&amp; x, default_sentinel_t y);</span>
<span id="cb271-2"><a href="#cb271-2"></a>friend constexpr bool operator!=(default_sentinel_t y, const outer_iterator&amp; x);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
</blockquote>
<p>Change 24.7.8.5 [range.split.inner]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb272"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb272-1"><a href="#cb272-1"></a>namespace std::ranges {</span>
<span id="cb272-2"><a href="#cb272-2"></a>  template&lt;class V, class Pattern&gt;</span>
<span id="cb272-3"><a href="#cb272-3"></a>  template&lt;bool Const&gt;</span>
<span id="cb272-4"><a href="#cb272-4"></a>  struct split_view&lt;V, Pattern&gt;::inner_iterator {</span>
<span id="cb272-5"><a href="#cb272-5"></a>    [...]</span>
<span id="cb272-6"><a href="#cb272-6"></a>    </span>
<span id="cb272-7"><a href="#cb272-7"></a>    friend constexpr bool operator==(const inner_iterator&amp; x, const inner_iterator&amp; y)</span>
<span id="cb272-8"><a href="#cb272-8"></a>      requires ForwardRange&lt;Base&gt;;</span>
<span id="cb272-9"><a href="#cb272-9"></a><span class="st">-   friend constexpr bool operator!=(const inner_iterator&amp; x, const inner_iterator&amp; y)</span></span>
<span id="cb272-10"><a href="#cb272-10"></a><span class="st">-     requires ForwardRange&lt;Base&gt;;</span></span>
<span id="cb272-11"><a href="#cb272-11"></a></span>
<span id="cb272-12"><a href="#cb272-12"></a>    friend constexpr bool operator==(const inner_iterator&amp; x, default_sentinel_t);</span>
<span id="cb272-13"><a href="#cb272-13"></a><span class="st">-   friend constexpr bool operator==(default_sentinel_t, const inner_iterator&amp; x);</span></span>
<span id="cb272-14"><a href="#cb272-14"></a><span class="st">-   friend constexpr bool operator!=(const inner_iterator&amp; x, default_sentinel_t y);</span></span>
<span id="cb272-15"><a href="#cb272-15"></a><span class="st">-   friend constexpr bool operator!=(default_sentinel_t y, const inner_iterator&amp; x);</span></span>
<span id="cb272-16"><a href="#cb272-16"></a></span>
<span id="cb272-17"><a href="#cb272-17"></a>    [...]</span>
<span id="cb272-18"><a href="#cb272-18"></a>  };</span>
<span id="cb272-19"><a href="#cb272-19"></a>}  </span></code></pre></div>
</div>
<div class="sourceCode" id="cb273"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb273-1"><a href="#cb273-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> inner_iterator<span class="op">&amp;</span> x, <span class="kw">const</span> inner_iterator<span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb273-2"><a href="#cb273-2"></a>  <span class="kw">requires</span> ForwardRange<span class="op">&lt;</span>Base<span class="op">&gt;</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span>i_<span class="op">.</span>current_ <span class="op">==</span> y<span class="op">.</span>i_<span class="op">.</span>current_;</code></p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb274"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb274-1"><a href="#cb274-1"></a>friend constexpr bool operator!=(const inner_iterator&amp; x, const inner_iterator&amp; y)</span>
<span id="cb274-2"><a href="#cb274-2"></a>  requires ForwardRange&lt;Base&gt;;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
<div class="sourceCode" id="cb275"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb275-1"><a href="#cb275-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> inner_iterator<span class="op">&amp;</span> x, default_sentinel_t<span class="op">)</span>;</span></code></pre></div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb276"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb276-1"><a href="#cb276-1"></a>friend constexpr bool operator==(default_sentinel_t, const inner_iterator&amp; x);</span></code></pre></div>

</div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb277"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb277-1"><a href="#cb277-1"></a><span class="kw">auto</span> cur <span class="op">=</span> x<span class="op">.</span>i_<span class="op">.</span>current;</span>
<span id="cb277-2"><a href="#cb277-2"></a><span class="kw">auto</span> end <span class="op">=</span> ranges<span class="op">::</span>end<span class="op">(</span>x<span class="op">.</span>i_<span class="op">.</span>parent_<span class="op">-&gt;</span>base_<span class="op">)</span>;</span>
<span id="cb277-3"><a href="#cb277-3"></a><span class="cf">if</span> <span class="op">(</span>cur <span class="op">==</span> end<span class="op">)</span> <span class="cf">return</span> <span class="kw">true</span>;</span>
<span id="cb277-4"><a href="#cb277-4"></a><span class="kw">auto</span> <span class="op">[</span>pcur, pend<span class="op">]</span> <span class="op">=</span> subrange<span class="op">{</span>x<span class="op">.</span>i_<span class="op">.</span>parent_<span class="op">-&gt;</span>pattern_<span class="op">}</span>;</span>
<span id="cb277-5"><a href="#cb277-5"></a><span class="cf">if</span> <span class="op">(</span>pcur <span class="op">==</span> pend<span class="op">)</span> <span class="cf">return</span> x<span class="op">.</span>incremented_;</span>
<span id="cb277-6"><a href="#cb277-6"></a><span class="cf">do</span> <span class="op">{</span></span>
<span id="cb277-7"><a href="#cb277-7"></a>  <span class="cf">if</span> <span class="op">(*</span>cur <span class="op">!=</span> <span class="op">*</span>pcur<span class="op">)</span> <span class="cf">return</span> <span class="kw">false</span>;</span>
<span id="cb277-8"><a href="#cb277-8"></a>  <span class="cf">if</span> <span class="op">(++</span>pcur <span class="op">==</span> pend<span class="op">)</span> <span class="cf">return</span> <span class="kw">true</span>;</span>
<span id="cb277-9"><a href="#cb277-9"></a><span class="op">}</span> <span class="cf">while</span> <span class="op">(++</span>cur <span class="op">!=</span> end<span class="op">)</span>;</span>
<span id="cb277-10"><a href="#cb277-10"></a><span class="cf">return</span> <span class="kw">false</span>;</span></code></pre></div>
</blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb278"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb278-1"><a href="#cb278-1"></a>friend constexpr bool operator!=(const inner_iterator&amp; x, default_sentinel_t y);</span>
<span id="cb278-2"><a href="#cb278-2"></a>friend constexpr bool operator!=(default_sentinel_t y, const inner_iterator&amp; x);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span>;</code></p>
</div>
</blockquote>
<h2 id="clause-25-algorithms-library"><span class="header-section-number">5.10</span> Clause 25: Algorithms library<a href="#clause-25-algorithms-library" class="self-link"></a></h2>
<p><span class="ednote" style="color: #0000ff">[ Editor&#39;s note: Remove <code class="sourceCode cpp">compare_3way</code> and rename <code class="sourceCode cpp">lexicographical_compare_3way</code>. At the discretion of the editors, change the name of the clause alg.3way to alg.threeway or alg.three.way. ]</span></p>
<p>Change 25.4 [algorithm.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb279"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb279-1"><a href="#cb279-1"></a>namespace std {</span>
<span id="cb279-2"><a href="#cb279-2"></a>   [...]</span>
<span id="cb279-3"><a href="#cb279-3"></a></span>
<span id="cb279-4"><a href="#cb279-4"></a>  // [alg.3way], three-way comparison algorithms</span>
<span id="cb279-5"><a href="#cb279-5"></a><span class="st">- template&lt;class T, class U&gt;</span></span>
<span id="cb279-6"><a href="#cb279-6"></a><span class="st">-   constexpr auto compare_3way(const T&amp; a, const U&amp; b);</span></span>
<span id="cb279-7"><a href="#cb279-7"></a>  template&lt;class InputIterator1, class InputIterator2, class Cmp&gt;</span>
<span id="cb279-8"><a href="#cb279-8"></a>    constexpr auto</span>
<span id="cb279-9"><a href="#cb279-9"></a><span class="st">-     lexicographical_compare_3way(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb279-10"><a href="#cb279-10"></a><span class="va">+     <span class="diffins">lexicographical_compare_three_way</span>(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb279-11"><a href="#cb279-11"></a>                                   InputIterator2 b2, InputIterator2 e2,</span>
<span id="cb279-12"><a href="#cb279-12"></a>                                   Cmp comp)</span>
<span id="cb279-13"><a href="#cb279-13"></a>        -&gt; common_comparison_category_t&lt;decltype(comp(*b1, *b2)), strong_ordering&gt;;</span>
<span id="cb279-14"><a href="#cb279-14"></a>  template&lt;class InputIterator1, class InputIterator2&gt;</span>
<span id="cb279-15"><a href="#cb279-15"></a>    constexpr auto</span>
<span id="cb279-16"><a href="#cb279-16"></a><span class="st">-     lexicographical_compare_3way(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb279-17"><a href="#cb279-17"></a><span class="va">+     <span class="diffins">lexicographical_compare_three_way</span>(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb279-18"><a href="#cb279-18"></a>                                   InputIterator2 b2, InputIterator2 e2);</span>
<span id="cb279-19"><a href="#cb279-19"></a>   </span>
<span id="cb279-20"><a href="#cb279-20"></a>   [...]</span>
<span id="cb279-21"><a href="#cb279-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 25.7.11 [alg.3way]:</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb280"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb280-1"><a href="#cb280-1"></a>template&lt;class T, class U&gt; constexpr auto compare_3way(const T&amp; a, const U&amp; b);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Compares two values and produces a result of the strongest applicable comparison category type:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> Returns <code class="sourceCode cpp">a <span class="op">&lt;=&gt;</span> b</code> if that expression is well-formed.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> Otherwise, if the expressions <code class="sourceCode cpp">a <span class="op">==</span> b</code> and <code class="sourceCode cpp">a <span class="op">&lt;</span> b</code> are each well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>, returns <code class="sourceCode cpp">strong_ordering<span class="op">::</span>equal</code> when <code class="sourceCode cpp">a <span class="op">==</span> b</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, otherwise returns <code class="sourceCode cpp">strong_ordering<span class="op">::</span>less</code> when <code class="sourceCode cpp">a <span class="op">&lt;</span> b</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, and otherwise returns <code class="sourceCode cpp">strong_ordering<span class="op">::</span>greater</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.3)</a></span> Otherwise, if the expression <code class="sourceCode cpp">a <span class="op">==</span> b</code> is well-formed and convertible to <code class="sourceCode cpp"><span class="dt">bool</span></code>, returns <code class="sourceCode cpp">strong_equality<span class="op">::</span>equal</code> when <code class="sourceCode cpp">a <span class="op">==</span> b</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, and otherwise returns <code class="sourceCode cpp">strong_equality<span class="op">::</span>nonequal</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.4)</a></span> Otherwise, the function is defined as deleted.</li>
</ul>

</div>
<div>
<div class="sourceCode" id="cb281"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb281-1"><a href="#cb281-1"></a>  template&lt;class InputIterator1, class InputIterator2, class Cmp&gt;</span>
<span id="cb281-2"><a href="#cb281-2"></a>    constexpr auto</span>
<span id="cb281-3"><a href="#cb281-3"></a><span class="st">-     lexicographical_compare_3way(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb281-4"><a href="#cb281-4"></a><span class="va">+     <span class="diffins">lexicographical_compare_three_way</span>(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb281-5"><a href="#cb281-5"></a>                                   InputIterator2 b2, InputIterator2 e2,</span>
<span id="cb281-6"><a href="#cb281-6"></a>                                   Cmp comp)</span>
<span id="cb281-7"><a href="#cb281-7"></a>        -&gt; common_comparison_category_t&lt;decltype(comp(*b1, *b2)), strong_ordering&gt;;</span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Requires</em>: <code class="sourceCode cpp">Cmp</code> shall be a function object type whose return type is a comparison category type.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Lexicographically compares two ranges and produces a result of the strongest applicable comparison category type. Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb282"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb282-1"><a href="#cb282-1"></a><span class="cf">for</span> <span class="op">(</span> ; b1 <span class="op">!=</span> e1 <span class="op">&amp;&amp;</span> b2 <span class="op">!=</span> e2; <span class="dt">void</span><span class="op">(++</span>b1<span class="op">)</span>, <span class="dt">void</span><span class="op">(++</span>b2<span class="op">)</span> <span class="op">)</span></span>
<span id="cb282-2"><a href="#cb282-2"></a>  <span class="cf">if</span> <span class="op">(</span><span class="kw">auto</span> cmp <span class="op">=</span> comp<span class="op">(*</span>b1,<span class="op">*</span>b2<span class="op">)</span>; cmp <span class="op">!=</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb282-3"><a href="#cb282-3"></a>    <span class="cf">return</span> cmp;</span>
<span id="cb282-4"><a href="#cb282-4"></a><span class="cf">return</span> b1 <span class="op">!=</span> e1 <span class="op">?</span> strong_ordering<span class="op">::</span>greater <span class="op">:</span></span>
<span id="cb282-5"><a href="#cb282-5"></a>       b2 <span class="op">!=</span> e2 <span class="op">?</span> strong_ordering<span class="op">::</span>less <span class="op">:</span></span>
<span id="cb282-6"><a href="#cb282-6"></a>                  strong_ordering<span class="op">::</span>equal;</span></code></pre></div>
</blockquote>
<div>
<div class="sourceCode" id="cb283"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb283-1"><a href="#cb283-1"></a>  template&lt;class InputIterator1, class InputIterator2&gt;</span>
<span id="cb283-2"><a href="#cb283-2"></a>    constexpr auto</span>
<span id="cb283-3"><a href="#cb283-3"></a><span class="st">-     lexicographical_compare_3way(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb283-4"><a href="#cb283-4"></a><span class="va">+     <span class="diffins">lexicographical_compare_three_way</span>(InputIterator1 b1, InputIterator1 e1,</span></span>
<span id="cb283-5"><a href="#cb283-5"></a>                                   InputIterator2 b2, InputIterator2 e2);</span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb284"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb284-1"><a href="#cb284-1"></a><span class="st">- return lexicographical_compare_3way(b1, e1, b2, e2,</span></span>
<span id="cb284-2"><a href="#cb284-2"></a><span class="st">-                                     [](const auto&amp; t, const auto&amp; u) {</span></span>
<span id="cb284-3"><a href="#cb284-3"></a><span class="st">-                                       return compare_3way(t, u);</span></span>
<span id="cb284-4"><a href="#cb284-4"></a><span class="st">-                                     });</span></span>
<span id="cb284-5"><a href="#cb284-5"></a><span class="va">+  return lexicographical_compare_three_way(b1, e1, b2, e2,</span></span>
<span id="cb284-6"><a href="#cb284-6"></a><span class="va">+                                           compare_three_way());</span></span></code></pre></div>
</div>
</blockquote>
</blockquote>
<h2 id="clause-26-numerics-library"><span class="header-section-number">5.11</span> Clause 26: Numerics library<a href="#clause-26-numerics-library" class="self-link"></a></h2>
<p>Remove obsolete <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">!=</span></code> operators from <code class="sourceCode cpp">complex</code>, add a new <code class="sourceCode cpp"><span class="op">==</span></code> to <code class="sourceCode cpp">slice</code>.</p>
<p>Change 26.4.1 [complex.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb285"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb285-1"><a href="#cb285-1"></a>namespace std {</span>
<span id="cb285-2"><a href="#cb285-2"></a>  // [complex], class template complex</span>
<span id="cb285-3"><a href="#cb285-3"></a>  template&lt;class T&gt; class complex;</span>
<span id="cb285-4"><a href="#cb285-4"></a></span>
<span id="cb285-5"><a href="#cb285-5"></a>  // [complex.special], specializations</span>
<span id="cb285-6"><a href="#cb285-6"></a>  template&lt;&gt; class complex&lt;float&gt;;</span>
<span id="cb285-7"><a href="#cb285-7"></a>  template&lt;&gt; class complex&lt;double&gt;;</span>
<span id="cb285-8"><a href="#cb285-8"></a>  template&lt;&gt; class complex&lt;long double&gt;;</span>
<span id="cb285-9"><a href="#cb285-9"></a>  </span>
<span id="cb285-10"><a href="#cb285-10"></a>  [...]</span>
<span id="cb285-11"><a href="#cb285-11"></a>  </span>
<span id="cb285-12"><a href="#cb285-12"></a>  template&lt;class T&gt; constexpr bool operator==(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);</span>
<span id="cb285-13"><a href="#cb285-13"></a>  template&lt;class T&gt; constexpr bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);</span>
<span id="cb285-14"><a href="#cb285-14"></a><span class="st">- template&lt;class T&gt; constexpr bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);</span></span>
<span id="cb285-15"><a href="#cb285-15"></a></span>
<span id="cb285-16"><a href="#cb285-16"></a><span class="st">- template&lt;class T&gt; constexpr bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);</span></span>
<span id="cb285-17"><a href="#cb285-17"></a><span class="st">- template&lt;class T&gt; constexpr bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);</span></span>
<span id="cb285-18"><a href="#cb285-18"></a><span class="st">- template&lt;class T&gt; constexpr bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);</span></span>
<span id="cb285-19"><a href="#cb285-19"></a></span>
<span id="cb285-20"><a href="#cb285-20"></a>  [...]</span>
<span id="cb285-21"><a href="#cb285-21"></a>}  </span></code></pre></div>
</div>
</blockquote>
<p>Change 26.4.6 [complex.ops]:</p>
<blockquote>
<div class="sourceCode" id="cb286"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb286-1"><a href="#cb286-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> complex<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> lhs, <span class="kw">const</span> complex<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span>
<span id="cb286-2"><a href="#cb286-2"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> complex<span class="op">&lt;</span>T<span class="op">&gt;&amp;</span> lhs, <span class="kw">const</span> T<span class="op">&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb287"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb287-1"><a href="#cb287-1"></a>template&lt;class T&gt; constexpr bool operator==(const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);</span></code></pre></div>

</div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>real<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>real<span class="op">()</span> <span class="op">&amp;&amp;</span> lhs<span class="op">.</span>imag<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>imag<span class="op">()</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Remarks</em>: The imaginary part is assumed to be <code class="sourceCode cpp">T<span class="op">()</span></code>, or <code class="sourceCode cpp"><span class="fl">0.0</span></code>, for the <code class="sourceCode cpp">T</code> arguments.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb288"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb288-1"><a href="#cb288-1"></a>template&lt;class T&gt; constexpr bool operator!=(const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);</span>
<span id="cb288-2"><a href="#cb288-2"></a>template&lt;class T&gt; constexpr bool operator!=(const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);</span>
<span id="cb288-3"><a href="#cb288-3"></a>template&lt;class T&gt; constexpr bool operator!=(const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <code class="sourceCode cpp">Returns</code>: <code class="sourceCode cpp">rhs<span class="op">.</span>real<span class="op">()</span> <span class="op">!=</span> lhs<span class="op">.</span>real<span class="op">()</span> <span class="op">||</span> rhs<span class="op">.</span>imag<span class="op">()</span> <span class="op">!=</span> lhs<span class="op">.</span>imag<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Change 26.7.4.1 [class.slice.overview]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb289"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb289-1"><a href="#cb289-1"></a>namespace std {</span>
<span id="cb289-2"><a href="#cb289-2"></a>  class slice {</span>
<span id="cb289-3"><a href="#cb289-3"></a>  public:</span>
<span id="cb289-4"><a href="#cb289-4"></a>    slice();</span>
<span id="cb289-5"><a href="#cb289-5"></a>    slice(size_t, size_t, size_t);</span>
<span id="cb289-6"><a href="#cb289-6"></a></span>
<span id="cb289-7"><a href="#cb289-7"></a>    size_t start() const;</span>
<span id="cb289-8"><a href="#cb289-8"></a>    size_t size() const;</span>
<span id="cb289-9"><a href="#cb289-9"></a>    size_t stride() const;</span>
<span id="cb289-10"><a href="#cb289-10"></a>    </span>
<span id="cb289-11"><a href="#cb289-11"></a><span class="va">+   friend bool operator==(const slice&amp; x, const slice&amp; y);</span></span>
<span id="cb289-12"><a href="#cb289-12"></a>  };</span>
<span id="cb289-13"><a href="#cb289-13"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Add a new subclause 26.7.4.4 “Operators” [slice.ops]:</p>
<blockquote>
<div class="addu">
<div class="sourceCode" id="cb290"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb290-1"><a href="#cb290-1"></a>friend bool operator==(const slice&amp; x, const slice&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb291"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb291-1"><a href="#cb291-1"></a>return x.start() == y.start() &amp;&amp;</span>
<span id="cb291-2"><a href="#cb291-2"></a>  x.size() == y.size() &amp;&amp;</span>
<span id="cb291-3"><a href="#cb291-3"></a>  x.stride() == y.stride();</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<h2 id="clause-27-time-library"><span class="header-section-number">5.12</span> Clause 27: Time library<a href="#clause-27-time-library" class="self-link"></a></h2>
<p>Add <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to all the chrono types where possible, in some cases added as a new constrained function template, in most cases replacing the relational operators. Also removing no-longer-necessary <code class="sourceCode cpp"><span class="op">!=</span></code> operators.</p>
<p>Change 27.2 [time.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb292"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb292-1"><a href="#cb292-1"></a>namespace std {</span>
<span id="cb292-2"><a href="#cb292-2"></a>  namespace chrono {</span>
<span id="cb292-3"><a href="#cb292-3"></a>    [...]</span>
<span id="cb292-4"><a href="#cb292-4"></a>    </span>
<span id="cb292-5"><a href="#cb292-5"></a>    // [time.duration.comparisons], duration comparisons</span>
<span id="cb292-6"><a href="#cb292-6"></a>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb292-7"><a href="#cb292-7"></a>      constexpr bool operator==(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb292-8"><a href="#cb292-8"></a>                                const duration&lt;Rep2, Period2&gt;&amp; rhs);</span>
<span id="cb292-9"><a href="#cb292-9"></a><span class="st">-   template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span></span>
<span id="cb292-10"><a href="#cb292-10"></a><span class="st">-     constexpr bool operator!=(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span></span>
<span id="cb292-11"><a href="#cb292-11"></a><span class="st">-                               const duration&lt;Rep2, Period2&gt;&amp; rhs);</span></span>
<span id="cb292-12"><a href="#cb292-12"></a>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb292-13"><a href="#cb292-13"></a>      constexpr bool operator&lt; (const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb292-14"><a href="#cb292-14"></a>                                const duration&lt;Rep2, Period2&gt;&amp; rhs);</span>
<span id="cb292-15"><a href="#cb292-15"></a>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb292-16"><a href="#cb292-16"></a>      constexpr bool operator&gt; (const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb292-17"><a href="#cb292-17"></a>                                const duration&lt;Rep2, Period2&gt;&amp; rhs);</span>
<span id="cb292-18"><a href="#cb292-18"></a>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb292-19"><a href="#cb292-19"></a>      constexpr bool operator&lt;=(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb292-20"><a href="#cb292-20"></a>                                const duration&lt;Rep2, Period2&gt;&amp; rhs);</span>
<span id="cb292-21"><a href="#cb292-21"></a>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb292-22"><a href="#cb292-22"></a>      constexpr bool operator&gt;=(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb292-23"><a href="#cb292-23"></a>                                const duration&lt;Rep2, Period2&gt;&amp; rhs);</span>
<span id="cb292-24"><a href="#cb292-24"></a><span class="va">+   template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span></span>
<span id="cb292-25"><a href="#cb292-25"></a><span class="va">+       requires <em>see below</em></span></span>
<span id="cb292-26"><a href="#cb292-26"></a><span class="va">+     constexpr auto operator&lt;=&gt;(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span></span>
<span id="cb292-27"><a href="#cb292-27"></a><span class="va">+                                const duration&lt;Rep2, Period2&gt;&amp; rhs);</span></span>
<span id="cb292-28"><a href="#cb292-28"></a></span>
<span id="cb292-29"><a href="#cb292-29"></a>    [...]</span>
<span id="cb292-30"><a href="#cb292-30"></a>    </span>
<span id="cb292-31"><a href="#cb292-31"></a>    // [time.point.comparisons], time_point comparisons</span>
<span id="cb292-32"><a href="#cb292-32"></a>    template&lt;class Clock, class Duration1, class Duration2&gt;</span>
<span id="cb292-33"><a href="#cb292-33"></a>       constexpr bool operator==(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb292-34"><a href="#cb292-34"></a>                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span>
<span id="cb292-35"><a href="#cb292-35"></a><span class="st">-   template&lt;class Clock, class Duration1, class Duration2&gt;</span></span>
<span id="cb292-36"><a href="#cb292-36"></a><span class="st">-      constexpr bool operator!=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span></span>
<span id="cb292-37"><a href="#cb292-37"></a><span class="st">-                                const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span></span>
<span id="cb292-38"><a href="#cb292-38"></a>    template&lt;class Clock, class Duration1, class Duration2&gt;</span>
<span id="cb292-39"><a href="#cb292-39"></a>       constexpr bool operator&lt; (const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb292-40"><a href="#cb292-40"></a>                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span>
<span id="cb292-41"><a href="#cb292-41"></a>    template&lt;class Clock, class Duration1, class Duration2&gt;</span>
<span id="cb292-42"><a href="#cb292-42"></a>       constexpr bool operator&gt; (const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb292-43"><a href="#cb292-43"></a>                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span>
<span id="cb292-44"><a href="#cb292-44"></a>    template&lt;class Clock, class Duration1, class Duration2&gt;</span>
<span id="cb292-45"><a href="#cb292-45"></a>       constexpr bool operator&lt;=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb292-46"><a href="#cb292-46"></a>                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span>
<span id="cb292-47"><a href="#cb292-47"></a>    template&lt;class Clock, class Duration1, class Duration2&gt;</span>
<span id="cb292-48"><a href="#cb292-48"></a>       constexpr bool operator&gt;=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb292-49"><a href="#cb292-49"></a>                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);  </span>
<span id="cb292-50"><a href="#cb292-50"></a><span class="va">+   template&lt;class Clock, class Duration1, ThreeWayComparableWith&lt;Duration1&gt; Duration2&gt;</span></span>
<span id="cb292-51"><a href="#cb292-51"></a><span class="va">+      constexpr auto operator&lt;=&gt;(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span></span>
<span id="cb292-52"><a href="#cb292-52"></a><span class="va">+                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs); </span></span>
<span id="cb292-53"><a href="#cb292-53"></a></span>
<span id="cb292-54"><a href="#cb292-54"></a>    [...]</span>
<span id="cb292-55"><a href="#cb292-55"></a>    </span>
<span id="cb292-56"><a href="#cb292-56"></a>    // [time.cal.day], class day</span>
<span id="cb292-57"><a href="#cb292-57"></a>    class day;</span>
<span id="cb292-58"><a href="#cb292-58"></a></span>
<span id="cb292-59"><a href="#cb292-59"></a>    constexpr bool operator==(const day&amp; x, const day&amp; y) noexcept;</span>
<span id="cb292-60"><a href="#cb292-60"></a><span class="st">-   constexpr bool operator!=(const day&amp; x, const day&amp; y) noexcept;</span></span>
<span id="cb292-61"><a href="#cb292-61"></a><span class="st">-   constexpr bool operator&lt; (const day&amp; x, const day&amp; y) noexcept;</span></span>
<span id="cb292-62"><a href="#cb292-62"></a><span class="st">-   constexpr bool operator&gt; (const day&amp; x, const day&amp; y) noexcept;</span></span>
<span id="cb292-63"><a href="#cb292-63"></a><span class="st">-   constexpr bool operator&lt;=(const day&amp; x, const day&amp; y) noexcept;</span></span>
<span id="cb292-64"><a href="#cb292-64"></a><span class="st">-   constexpr bool operator&gt;=(const day&amp; x, const day&amp; y) noexcept;</span></span>
<span id="cb292-65"><a href="#cb292-65"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const day&amp; x, const day&amp; y) noexcept;</span></span>
<span id="cb292-66"><a href="#cb292-66"></a>    </span>
<span id="cb292-67"><a href="#cb292-67"></a>    [...]</span>
<span id="cb292-68"><a href="#cb292-68"></a>    </span>
<span id="cb292-69"><a href="#cb292-69"></a>    // [time.cal.month], class month</span>
<span id="cb292-70"><a href="#cb292-70"></a>    class month;</span>
<span id="cb292-71"><a href="#cb292-71"></a></span>
<span id="cb292-72"><a href="#cb292-72"></a>    constexpr bool operator==(const month&amp; x, const month&amp; y) noexcept;</span>
<span id="cb292-73"><a href="#cb292-73"></a><span class="st">-   constexpr bool operator!=(const month&amp; x, const month&amp; y) noexcept;</span></span>
<span id="cb292-74"><a href="#cb292-74"></a><span class="st">-   constexpr bool operator&lt; (const month&amp; x, const month&amp; y) noexcept;</span></span>
<span id="cb292-75"><a href="#cb292-75"></a><span class="st">-   constexpr bool operator&gt; (const month&amp; x, const month&amp; y) noexcept;</span></span>
<span id="cb292-76"><a href="#cb292-76"></a><span class="st">-   constexpr bool operator&lt;=(const month&amp; x, const month&amp; y) noexcept;</span></span>
<span id="cb292-77"><a href="#cb292-77"></a><span class="st">-   constexpr bool operator&gt;=(const month&amp; x, const month&amp; y) noexcept; </span></span>
<span id="cb292-78"><a href="#cb292-78"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const month&amp; x, const month&amp; y) noexcept;</span></span>
<span id="cb292-79"><a href="#cb292-79"></a></span>
<span id="cb292-80"><a href="#cb292-80"></a>    [...]</span>
<span id="cb292-81"><a href="#cb292-81"></a>    </span>
<span id="cb292-82"><a href="#cb292-82"></a></span>
<span id="cb292-83"><a href="#cb292-83"></a>    // [time.cal.year], class year</span>
<span id="cb292-84"><a href="#cb292-84"></a>    class year;</span>
<span id="cb292-85"><a href="#cb292-85"></a></span>
<span id="cb292-86"><a href="#cb292-86"></a>    constexpr bool operator==(const year&amp; x, const year&amp; y) noexcept;</span>
<span id="cb292-87"><a href="#cb292-87"></a><span class="st">-   constexpr bool operator!=(const year&amp; x, const year&amp; y) noexcept;</span></span>
<span id="cb292-88"><a href="#cb292-88"></a><span class="st">-   constexpr bool operator&lt; (const year&amp; x, const year&amp; y) noexcept;</span></span>
<span id="cb292-89"><a href="#cb292-89"></a><span class="st">-   constexpr bool operator&gt; (const year&amp; x, const year&amp; y) noexcept;</span></span>
<span id="cb292-90"><a href="#cb292-90"></a><span class="st">-   constexpr bool operator&lt;=(const year&amp; x, const year&amp; y) noexcept;</span></span>
<span id="cb292-91"><a href="#cb292-91"></a><span class="st">-   constexpr bool operator&gt;=(const year&amp; x, const year&amp; y) noexcept;   </span></span>
<span id="cb292-92"><a href="#cb292-92"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const year&amp; x, const year&amp; y) noexcept;</span></span>
<span id="cb292-93"><a href="#cb292-93"></a></span>
<span id="cb292-94"><a href="#cb292-94"></a>    [...]</span>
<span id="cb292-95"><a href="#cb292-95"></a></span>
<span id="cb292-96"><a href="#cb292-96"></a>    // [time.cal.wd], class weekday</span>
<span id="cb292-97"><a href="#cb292-97"></a>    class weekday;</span>
<span id="cb292-98"><a href="#cb292-98"></a></span>
<span id="cb292-99"><a href="#cb292-99"></a>    constexpr bool operator==(const weekday&amp; x, const weekday&amp; y) noexcept;</span>
<span id="cb292-100"><a href="#cb292-100"></a><span class="st">-   constexpr bool operator!=(const weekday&amp; x, const weekday&amp; y) noexcept;</span></span>
<span id="cb292-101"><a href="#cb292-101"></a></span>
<span id="cb292-102"><a href="#cb292-102"></a>    [...]</span>
<span id="cb292-103"><a href="#cb292-103"></a>    </span>
<span id="cb292-104"><a href="#cb292-104"></a>    // [time.cal.wdidx], class weekday_indexed</span>
<span id="cb292-105"><a href="#cb292-105"></a>    class weekday_indexed;</span>
<span id="cb292-106"><a href="#cb292-106"></a></span>
<span id="cb292-107"><a href="#cb292-107"></a>    constexpr bool operator==(const weekday_indexed&amp; x, const weekday_indexed&amp; y) noexcept;</span>
<span id="cb292-108"><a href="#cb292-108"></a><span class="st">-   constexpr bool operator!=(const weekday_indexed&amp; x, const weekday_indexed&amp; y) noexcept;</span></span>
<span id="cb292-109"><a href="#cb292-109"></a>    </span>
<span id="cb292-110"><a href="#cb292-110"></a>    [...]</span>
<span id="cb292-111"><a href="#cb292-111"></a>    </span>
<span id="cb292-112"><a href="#cb292-112"></a>    // [time.cal.wdlast], class weekday_last</span>
<span id="cb292-113"><a href="#cb292-113"></a>    class weekday_last;</span>
<span id="cb292-114"><a href="#cb292-114"></a></span>
<span id="cb292-115"><a href="#cb292-115"></a>    constexpr bool operator==(const weekday_last&amp; x, const weekday_last&amp; y) noexcept;</span>
<span id="cb292-116"><a href="#cb292-116"></a><span class="st">-   constexpr bool operator!=(const weekday_last&amp; x, const weekday_last&amp; y) noexcept;</span></span>
<span id="cb292-117"><a href="#cb292-117"></a></span>
<span id="cb292-118"><a href="#cb292-118"></a>    [...]</span>
<span id="cb292-119"><a href="#cb292-119"></a></span>
<span id="cb292-120"><a href="#cb292-120"></a>    // [time.cal.md], class month_day</span>
<span id="cb292-121"><a href="#cb292-121"></a>    class month_day;</span>
<span id="cb292-122"><a href="#cb292-122"></a></span>
<span id="cb292-123"><a href="#cb292-123"></a>    constexpr bool operator==(const month_day&amp; x, const month_day&amp; y) noexcept;</span>
<span id="cb292-124"><a href="#cb292-124"></a><span class="st">-   constexpr bool operator!=(const month_day&amp; x, const month_day&amp; y) noexcept;</span></span>
<span id="cb292-125"><a href="#cb292-125"></a><span class="st">-   constexpr bool operator&lt; (const month_day&amp; x, const month_day&amp; y) noexcept;</span></span>
<span id="cb292-126"><a href="#cb292-126"></a><span class="st">-   constexpr bool operator&gt; (const month_day&amp; x, const month_day&amp; y) noexcept;</span></span>
<span id="cb292-127"><a href="#cb292-127"></a><span class="st">-   constexpr bool operator&lt;=(const month_day&amp; x, const month_day&amp; y) noexcept;</span></span>
<span id="cb292-128"><a href="#cb292-128"></a><span class="st">-   constexpr bool operator&gt;=(const month_day&amp; x, const month_day&amp; y) noexcept;</span></span>
<span id="cb292-129"><a href="#cb292-129"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const month_day&amp; x, const month_day&amp; y) noexcept;</span></span>
<span id="cb292-130"><a href="#cb292-130"></a>    </span>
<span id="cb292-131"><a href="#cb292-131"></a>    [...]</span>
<span id="cb292-132"><a href="#cb292-132"></a>    </span>
<span id="cb292-133"><a href="#cb292-133"></a></span>
<span id="cb292-134"><a href="#cb292-134"></a>    // [time.cal.mdlast], class month_day_last</span>
<span id="cb292-135"><a href="#cb292-135"></a>    class month_day_last;</span>
<span id="cb292-136"><a href="#cb292-136"></a></span>
<span id="cb292-137"><a href="#cb292-137"></a>    constexpr bool operator==(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span>
<span id="cb292-138"><a href="#cb292-138"></a><span class="st">-   constexpr bool operator!=(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-139"><a href="#cb292-139"></a><span class="st">-   constexpr bool operator&lt; (const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-140"><a href="#cb292-140"></a><span class="st">-   constexpr bool operator&gt; (const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-141"><a href="#cb292-141"></a><span class="st">-   constexpr bool operator&lt;=(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-142"><a href="#cb292-142"></a><span class="st">-   constexpr bool operator&gt;=(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-143"><a href="#cb292-143"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-144"><a href="#cb292-144"></a></span>
<span id="cb292-145"><a href="#cb292-145"></a>    template&lt;class charT, class traits&gt;</span>
<span id="cb292-146"><a href="#cb292-146"></a>      basic_ostream&lt;charT, traits&gt;&amp;</span>
<span id="cb292-147"><a href="#cb292-147"></a>        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const month_day_last&amp; mdl);</span>
<span id="cb292-148"><a href="#cb292-148"></a></span>
<span id="cb292-149"><a href="#cb292-149"></a>    // [time.cal.mwd], class month_weekday</span>
<span id="cb292-150"><a href="#cb292-150"></a>    class month_weekday;</span>
<span id="cb292-151"><a href="#cb292-151"></a></span>
<span id="cb292-152"><a href="#cb292-152"></a>    constexpr bool operator==(const month_weekday&amp; x, const month_weekday&amp; y) noexcept;</span>
<span id="cb292-153"><a href="#cb292-153"></a><span class="st">-   constexpr bool operator!=(const month_weekday&amp; x, const month_weekday&amp; y) noexcept;</span></span>
<span id="cb292-154"><a href="#cb292-154"></a></span>
<span id="cb292-155"><a href="#cb292-155"></a>    template&lt;class charT, class traits&gt;</span>
<span id="cb292-156"><a href="#cb292-156"></a>      basic_ostream&lt;charT, traits&gt;&amp;</span>
<span id="cb292-157"><a href="#cb292-157"></a>        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const month_weekday&amp; mwd);</span>
<span id="cb292-158"><a href="#cb292-158"></a></span>
<span id="cb292-159"><a href="#cb292-159"></a>    // [time.cal.mwdlast], class month_weekday_last</span>
<span id="cb292-160"><a href="#cb292-160"></a>    class month_weekday_last;</span>
<span id="cb292-161"><a href="#cb292-161"></a></span>
<span id="cb292-162"><a href="#cb292-162"></a>    constexpr bool operator==(const month_weekday_last&amp; x, const month_weekday_last&amp; y) noexcept;</span>
<span id="cb292-163"><a href="#cb292-163"></a><span class="st">-   constexpr bool operator!=(const month_weekday_last&amp; x, const month_weekday_last&amp; y) noexcept;</span></span>
<span id="cb292-164"><a href="#cb292-164"></a></span>
<span id="cb292-165"><a href="#cb292-165"></a>    template&lt;class charT, class traits&gt;</span>
<span id="cb292-166"><a href="#cb292-166"></a>      basic_ostream&lt;charT, traits&gt;&amp;</span>
<span id="cb292-167"><a href="#cb292-167"></a>        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const month_weekday_last&amp; mwdl);</span>
<span id="cb292-168"><a href="#cb292-168"></a></span>
<span id="cb292-169"><a href="#cb292-169"></a>    // [time.cal.ym], class year_month</span>
<span id="cb292-170"><a href="#cb292-170"></a>    class year_month;</span>
<span id="cb292-171"><a href="#cb292-171"></a></span>
<span id="cb292-172"><a href="#cb292-172"></a>    constexpr bool operator==(const year_month&amp; x, const year_month&amp; y) noexcept;</span>
<span id="cb292-173"><a href="#cb292-173"></a><span class="st">-   constexpr bool operator!=(const year_month&amp; x, const year_month&amp; y) noexcept;</span></span>
<span id="cb292-174"><a href="#cb292-174"></a><span class="st">-   constexpr bool operator&lt; (const year_month&amp; x, const year_month&amp; y) noexcept;</span></span>
<span id="cb292-175"><a href="#cb292-175"></a><span class="st">-   constexpr bool operator&gt; (const year_month&amp; x, const year_month&amp; y) noexcept;</span></span>
<span id="cb292-176"><a href="#cb292-176"></a><span class="st">-   constexpr bool operator&lt;=(const year_month&amp; x, const year_month&amp; y) noexcept;</span></span>
<span id="cb292-177"><a href="#cb292-177"></a><span class="st">-   constexpr bool operator&gt;=(const year_month&amp; x, const year_month&amp; y) noexcept;</span></span>
<span id="cb292-178"><a href="#cb292-178"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const year_month&amp; x, const year_month&amp; y) noexcept;</span></span>
<span id="cb292-179"><a href="#cb292-179"></a></span>
<span id="cb292-180"><a href="#cb292-180"></a>    [...]</span>
<span id="cb292-181"><a href="#cb292-181"></a></span>
<span id="cb292-182"><a href="#cb292-182"></a>    // [time.cal.ymd], class year_month_day</span>
<span id="cb292-183"><a href="#cb292-183"></a>    class year_month_day;</span>
<span id="cb292-184"><a href="#cb292-184"></a></span>
<span id="cb292-185"><a href="#cb292-185"></a>    constexpr bool operator==(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span>
<span id="cb292-186"><a href="#cb292-186"></a><span class="st">-   constexpr bool operator!=(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></span>
<span id="cb292-187"><a href="#cb292-187"></a><span class="st">-   constexpr bool operator&lt; (const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></span>
<span id="cb292-188"><a href="#cb292-188"></a><span class="st">-   constexpr bool operator&gt; (const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></span>
<span id="cb292-189"><a href="#cb292-189"></a><span class="st">-   constexpr bool operator&lt;=(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></span>
<span id="cb292-190"><a href="#cb292-190"></a><span class="st">-   constexpr bool operator&gt;=(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></span>
<span id="cb292-191"><a href="#cb292-191"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></span>
<span id="cb292-192"><a href="#cb292-192"></a></span>
<span id="cb292-193"><a href="#cb292-193"></a>    [...]</span>
<span id="cb292-194"><a href="#cb292-194"></a>    </span>
<span id="cb292-195"><a href="#cb292-195"></a>    // [time.cal.ymdlast], class year_month_day_last</span>
<span id="cb292-196"><a href="#cb292-196"></a>    class year_month_day_last;</span>
<span id="cb292-197"><a href="#cb292-197"></a></span>
<span id="cb292-198"><a href="#cb292-198"></a>    constexpr bool operator==(const year_month_day_last&amp; x,</span>
<span id="cb292-199"><a href="#cb292-199"></a>                              const year_month_day_last&amp; y) noexcept;</span>
<span id="cb292-200"><a href="#cb292-200"></a><span class="st">-   constexpr bool operator!=(const year_month_day_last&amp; x,</span></span>
<span id="cb292-201"><a href="#cb292-201"></a><span class="st">-                             const year_month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-202"><a href="#cb292-202"></a><span class="st">-   constexpr bool operator&lt; (const year_month_day_last&amp; x,</span></span>
<span id="cb292-203"><a href="#cb292-203"></a><span class="st">-                             const year_month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-204"><a href="#cb292-204"></a><span class="st">-   constexpr bool operator&gt; (const year_month_day_last&amp; x,</span></span>
<span id="cb292-205"><a href="#cb292-205"></a><span class="st">-                             const year_month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-206"><a href="#cb292-206"></a><span class="st">-   constexpr bool operator&lt;=(const year_month_day_last&amp; x,</span></span>
<span id="cb292-207"><a href="#cb292-207"></a><span class="st">-                             const year_month_day_last&amp; y) noexcept;</span></span>
<span id="cb292-208"><a href="#cb292-208"></a><span class="st">-   constexpr bool operator&gt;=(const year_month_day_last&amp; x,</span></span>
<span id="cb292-209"><a href="#cb292-209"></a><span class="st">-                             const year_month_day_last&amp; y) noexcept;   </span></span>
<span id="cb292-210"><a href="#cb292-210"></a><span class="va">+   constexpr strong_ordering operator&lt;=&gt;(const year_month_day_last&amp; x,</span></span>
<span id="cb292-211"><a href="#cb292-211"></a><span class="va">+                                         const year_month_day_last&amp; y) noexcept;   </span></span>
<span id="cb292-212"><a href="#cb292-212"></a>    </span>
<span id="cb292-213"><a href="#cb292-213"></a>    [...]</span>
<span id="cb292-214"><a href="#cb292-214"></a>    </span>
<span id="cb292-215"><a href="#cb292-215"></a></span>
<span id="cb292-216"><a href="#cb292-216"></a>    // [time.cal.ymwd], class year_month_weekday</span>
<span id="cb292-217"><a href="#cb292-217"></a>    class year_month_weekday;</span>
<span id="cb292-218"><a href="#cb292-218"></a></span>
<span id="cb292-219"><a href="#cb292-219"></a>    constexpr bool operator==(const year_month_weekday&amp; x,</span>
<span id="cb292-220"><a href="#cb292-220"></a>                              const year_month_weekday&amp; y) noexcept;</span>
<span id="cb292-221"><a href="#cb292-221"></a><span class="st">-   constexpr bool operator!=(const year_month_weekday&amp; x,</span></span>
<span id="cb292-222"><a href="#cb292-222"></a><span class="st">-                             const year_month_weekday&amp; y) noexcept;</span></span>
<span id="cb292-223"><a href="#cb292-223"></a></span>
<span id="cb292-224"><a href="#cb292-224"></a>    [...]</span>
<span id="cb292-225"><a href="#cb292-225"></a></span>
<span id="cb292-226"><a href="#cb292-226"></a>    // [time.cal.ymwdlast], class year_month_weekday_last</span>
<span id="cb292-227"><a href="#cb292-227"></a>    class year_month_weekday_last;</span>
<span id="cb292-228"><a href="#cb292-228"></a></span>
<span id="cb292-229"><a href="#cb292-229"></a>    constexpr bool operator==(const year_month_weekday_last&amp; x,</span>
<span id="cb292-230"><a href="#cb292-230"></a>                              const year_month_weekday_last&amp; y) noexcept;</span>
<span id="cb292-231"><a href="#cb292-231"></a><span class="st">-   constexpr bool operator!=(const year_month_weekday_last&amp; x,</span></span>
<span id="cb292-232"><a href="#cb292-232"></a><span class="st">-                             const year_month_weekday_last&amp; y) noexcept;   </span></span>
<span id="cb292-233"><a href="#cb292-233"></a></span>
<span id="cb292-234"><a href="#cb292-234"></a>    [...]</span>
<span id="cb292-235"><a href="#cb292-235"></a>    </span>
<span id="cb292-236"><a href="#cb292-236"></a>    // [time.zone.timezone], class time_zone</span>
<span id="cb292-237"><a href="#cb292-237"></a>    enum class choose {earliest, latest};</span>
<span id="cb292-238"><a href="#cb292-238"></a>    class time_zone;</span>
<span id="cb292-239"><a href="#cb292-239"></a></span>
<span id="cb292-240"><a href="#cb292-240"></a>    bool operator==(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span>
<span id="cb292-241"><a href="#cb292-241"></a><span class="st">-   bool operator!=(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></span>
<span id="cb292-242"><a href="#cb292-242"></a></span>
<span id="cb292-243"><a href="#cb292-243"></a><span class="st">-   bool operator&lt;(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></span>
<span id="cb292-244"><a href="#cb292-244"></a><span class="st">-   bool operator&gt;(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></span>
<span id="cb292-245"><a href="#cb292-245"></a><span class="st">-   bool operator&lt;=(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></span>
<span id="cb292-246"><a href="#cb292-246"></a><span class="st">-   bool operator&gt;=(const time_zone&amp; x, const time_zone&amp; y) noexcept;   </span></span>
<span id="cb292-247"><a href="#cb292-247"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></span>
<span id="cb292-248"><a href="#cb292-248"></a></span>
<span id="cb292-249"><a href="#cb292-249"></a>    // [time.zone.zonedtraits], class template zoned_traits</span>
<span id="cb292-250"><a href="#cb292-250"></a>    template&lt;class T&gt; struct zoned_traits;</span>
<span id="cb292-251"><a href="#cb292-251"></a></span>
<span id="cb292-252"><a href="#cb292-252"></a>    // [time.zone.zonedtime], class template zoned_time</span>
<span id="cb292-253"><a href="#cb292-253"></a>    template&lt;class Duration, class TimeZonePtr = const time_zone*&gt; class zoned_time;</span>
<span id="cb292-254"><a href="#cb292-254"></a></span>
<span id="cb292-255"><a href="#cb292-255"></a>    using zoned_seconds = zoned_time&lt;seconds&gt;;</span>
<span id="cb292-256"><a href="#cb292-256"></a></span>
<span id="cb292-257"><a href="#cb292-257"></a>    template&lt;class Duration1, class Duration2, class TimeZonePtr&gt;</span>
<span id="cb292-258"><a href="#cb292-258"></a>      bool operator==(const zoned_time&lt;Duration1, TimeZonePtr&gt;&amp; x,</span>
<span id="cb292-259"><a href="#cb292-259"></a>                      const zoned_time&lt;Duration2, TimeZonePtr&gt;&amp; y);</span>
<span id="cb292-260"><a href="#cb292-260"></a></span>
<span id="cb292-261"><a href="#cb292-261"></a><span class="st">-   template&lt;class Duration1, class Duration2, class TimeZonePtr&gt;</span></span>
<span id="cb292-262"><a href="#cb292-262"></a><span class="st">-     bool operator!=(const zoned_time&lt;Duration1, TimeZonePtr&gt;&amp; x,</span></span>
<span id="cb292-263"><a href="#cb292-263"></a><span class="st">-                     const zoned_time&lt;Duration2, TimeZonePtr&gt;&amp; y);</span></span>
<span id="cb292-264"><a href="#cb292-264"></a></span>
<span id="cb292-265"><a href="#cb292-265"></a>    [...]</span>
<span id="cb292-266"><a href="#cb292-266"></a>    </span>
<span id="cb292-267"><a href="#cb292-267"></a>    // [time.zone.leap], leap second support</span>
<span id="cb292-268"><a href="#cb292-268"></a>    class leap;</span>
<span id="cb292-269"><a href="#cb292-269"></a></span>
<span id="cb292-270"><a href="#cb292-270"></a>    bool operator==(const leap&amp; x, const leap&amp; y);</span>
<span id="cb292-271"><a href="#cb292-271"></a><span class="st">-   bool operator!=(const leap&amp; x, const leap&amp; y);</span></span>
<span id="cb292-272"><a href="#cb292-272"></a><span class="st">-   bool operator&lt; (const leap&amp; x, const leap&amp; y);</span></span>
<span id="cb292-273"><a href="#cb292-273"></a><span class="st">-   bool operator&gt; (const leap&amp; x, const leap&amp; y);</span></span>
<span id="cb292-274"><a href="#cb292-274"></a><span class="st">-   bool operator&lt;=(const leap&amp; x, const leap&amp; y);</span></span>
<span id="cb292-275"><a href="#cb292-275"></a><span class="st">-   bool operator&gt;=(const leap&amp; x, const leap&amp; y);  </span></span>
<span id="cb292-276"><a href="#cb292-276"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const leap&amp; x, const leap&amp; y);</span></span>
<span id="cb292-277"><a href="#cb292-277"></a></span>
<span id="cb292-278"><a href="#cb292-278"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-279"><a href="#cb292-279"></a>      bool operator==(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span>
<span id="cb292-280"><a href="#cb292-280"></a><span class="st">-   template&lt;class Duration&gt;</span></span>
<span id="cb292-281"><a href="#cb292-281"></a><span class="st">-     bool operator==(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y);</span></span>
<span id="cb292-282"><a href="#cb292-282"></a><span class="st">-   template&lt;class Duration&gt;</span></span>
<span id="cb292-283"><a href="#cb292-283"></a><span class="st">-     bool operator!=(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span></span>
<span id="cb292-284"><a href="#cb292-284"></a><span class="st">-   template&lt;class Duration&gt;</span></span>
<span id="cb292-285"><a href="#cb292-285"></a><span class="st">-     bool operator!=(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y);</span></span>
<span id="cb292-286"><a href="#cb292-286"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-287"><a href="#cb292-287"></a>      bool operator&lt; (const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span>
<span id="cb292-288"><a href="#cb292-288"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-289"><a href="#cb292-289"></a>      bool operator&lt; (const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y);</span>
<span id="cb292-290"><a href="#cb292-290"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-291"><a href="#cb292-291"></a>      bool operator&gt; (const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span>
<span id="cb292-292"><a href="#cb292-292"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-293"><a href="#cb292-293"></a>      bool operator&gt; (const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y);</span>
<span id="cb292-294"><a href="#cb292-294"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-295"><a href="#cb292-295"></a>      bool operator&lt;=(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span>
<span id="cb292-296"><a href="#cb292-296"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-297"><a href="#cb292-297"></a>      bool operator&lt;=(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y);</span>
<span id="cb292-298"><a href="#cb292-298"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-299"><a href="#cb292-299"></a>      bool operator&gt;=(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span>
<span id="cb292-300"><a href="#cb292-300"></a>    template&lt;class Duration&gt;</span>
<span id="cb292-301"><a href="#cb292-301"></a>      bool operator&gt;=(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y);</span>
<span id="cb292-302"><a href="#cb292-302"></a><span class="va">+   template&lt;ThreeWayComparableWith&lt;sys_seconds&gt; Duration&gt;</span></span>
<span id="cb292-303"><a href="#cb292-303"></a><span class="va">+     auto operator&lt;=&gt;(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y);</span></span>
<span id="cb292-304"><a href="#cb292-304"></a></span>
<span id="cb292-305"><a href="#cb292-305"></a></span>
<span id="cb292-306"><a href="#cb292-306"></a>    // [time.zone.link], class link</span>
<span id="cb292-307"><a href="#cb292-307"></a>    class link;</span>
<span id="cb292-308"><a href="#cb292-308"></a></span>
<span id="cb292-309"><a href="#cb292-309"></a>    bool operator==(const link&amp; x, const link&amp; y);</span>
<span id="cb292-310"><a href="#cb292-310"></a><span class="st">-   bool operator!=(const link&amp; x, const link&amp; y);</span></span>
<span id="cb292-311"><a href="#cb292-311"></a><span class="st">-   bool operator&lt; (const link&amp; x, const link&amp; y);</span></span>
<span id="cb292-312"><a href="#cb292-312"></a><span class="st">-   bool operator&gt; (const link&amp; x, const link&amp; y);</span></span>
<span id="cb292-313"><a href="#cb292-313"></a><span class="st">-   bool operator&lt;=(const link&amp; x, const link&amp; y);</span></span>
<span id="cb292-314"><a href="#cb292-314"></a><span class="st">-   bool operator&gt;=(const link&amp; x, const link&amp; y);</span></span>
<span id="cb292-315"><a href="#cb292-315"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const link&amp; x, const link&amp; y);</span></span>
<span id="cb292-316"><a href="#cb292-316"></a></span>
<span id="cb292-317"><a href="#cb292-317"></a>    [...]</span>
<span id="cb292-318"><a href="#cb292-318"></a>  }</span>
<span id="cb292-319"><a href="#cb292-319"></a>}  </span></code></pre></div>
</div>
</blockquote>
<p>Change 27.5.6 [time.duration.comparisons]:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> In the function descriptions that follow, <code class="sourceCode cpp">CT</code> represents <code class="sourceCode cpp">common_type_t<span class="op">&lt;</span>A, B<span class="op">&gt;</span></code>, where <code class="sourceCode cpp">A</code> and <code class="sourceCode cpp">B</code> are the types of the two arguments to the function.</p>
<div class="sourceCode" id="cb293"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb293-1"><a href="#cb293-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Rep1, <span class="kw">class</span> Period1, <span class="kw">class</span> Rep2, <span class="kw">class</span> Period2<span class="op">&gt;</span></span>
<span id="cb293-2"><a href="#cb293-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> duration<span class="op">&lt;</span>Rep1, Period1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb293-3"><a href="#cb293-3"></a>                            <span class="kw">const</span> duration<span class="op">&lt;</span>Rep2, Period2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">CT<span class="op">(</span>lhs<span class="op">).</span>count<span class="op">()</span> <span class="op">==</span> CT<span class="op">(</span>rhs<span class="op">).</span>count<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb294"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb294-1"><a href="#cb294-1"></a>template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb294-2"><a href="#cb294-2"></a>  constexpr bool operator!=(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb294-3"><a href="#cb294-3"></a>                            const duration&lt;Rep2, Period2&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb295"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb295-1"><a href="#cb295-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Rep1, <span class="kw">class</span> Period1, <span class="kw">class</span> Rep2, <span class="kw">class</span> Period2<span class="op">&gt;</span></span>
<span id="cb295-2"><a href="#cb295-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;(</span><span class="kw">const</span> duration<span class="op">&lt;</span>Rep1, Period1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb295-3"><a href="#cb295-3"></a>                           <span class="kw">const</span> duration<span class="op">&lt;</span>Rep2, Period2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">CT<span class="op">(</span>lhs<span class="op">).</span>count<span class="op">()</span> <span class="op">&lt;</span> CT<span class="op">(</span>rhs<span class="op">).</span>count<span class="op">()</span></code>.</p>
<div class="sourceCode" id="cb296"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb296-1"><a href="#cb296-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Rep1, <span class="kw">class</span> Period1, <span class="kw">class</span> Rep2, <span class="kw">class</span> Period2<span class="op">&gt;</span></span>
<span id="cb296-2"><a href="#cb296-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;(</span><span class="kw">const</span> duration<span class="op">&lt;</span>Rep1, Period1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb296-3"><a href="#cb296-3"></a>                           <span class="kw">const</span> duration<span class="op">&lt;</span>Rep2, Period2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb297"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb297-1"><a href="#cb297-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Rep1, <span class="kw">class</span> Period1, <span class="kw">class</span> Rep2, <span class="kw">class</span> Period2<span class="op">&gt;</span></span>
<span id="cb297-2"><a href="#cb297-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><span class="kw">const</span> duration<span class="op">&lt;</span>Rep1, Period1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb297-3"><a href="#cb297-3"></a>                            <span class="kw">const</span> duration<span class="op">&lt;</span>Rep2, Period2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb298"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb298-1"><a href="#cb298-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Rep1, <span class="kw">class</span> Period1, <span class="kw">class</span> Rep2, <span class="kw">class</span> Period2<span class="op">&gt;</span></span>
<span id="cb298-2"><a href="#cb298-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> duration<span class="op">&lt;</span>Rep1, Period1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb298-3"><a href="#cb298-3"></a>                            <span class="kw">const</span> duration<span class="op">&lt;</span>Rep2, Period2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb299"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb299-1"><a href="#cb299-1"></a>template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;</span>
<span id="cb299-2"><a href="#cb299-2"></a>    requires ThreeWayComparable&lt;typename CT::rep&gt;</span>
<span id="cb299-3"><a href="#cb299-3"></a>  constexpr auto operator&lt;=&gt;(const duration&lt;Rep1, Period1&gt;&amp; lhs,</span>
<span id="cb299-4"><a href="#cb299-4"></a>                             const duration&lt;Rep2, Period2&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">CT<span class="op">(</span>lhs<span class="op">).</span>count<span class="op">()</span> <span class="op">&lt;=&gt;</span> CT<span class="op">(</span>rhs<span class="op">).</span>count<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Change 27.6.6 [time.point.comparisons]:</p>
<blockquote>
<div class="sourceCode" id="cb300"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb300-1"><a href="#cb300-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Clock, <span class="kw">class</span> Duration1, <span class="kw">class</span> Duration2<span class="op">&gt;</span></span>
<span id="cb300-2"><a href="#cb300-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb300-3"><a href="#cb300-3"></a>                            <span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>time_since_epoch<span class="op">()</span> <span class="op">==</span> rhs<span class="op">.</span>time_since_epoch<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb301"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb301-1"><a href="#cb301-1"></a>template&lt;class Clock, class Duration1, class Duration2&gt;</span>
<span id="cb301-2"><a href="#cb301-2"></a>  constexpr bool operator!=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb301-3"><a href="#cb301-3"></a>                            const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb302"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb302-1"><a href="#cb302-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Clock, <span class="kw">class</span> Duration1, <span class="kw">class</span> Duration2<span class="op">&gt;</span></span>
<span id="cb302-2"><a href="#cb302-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;(</span><span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb302-3"><a href="#cb302-3"></a>                           <span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>time_since_epoch<span class="op">()</span> <span class="op">&lt;</span> rhs<span class="op">.</span>time_since_epoch<span class="op">()</span></code>.</p>
<div class="sourceCode" id="cb303"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb303-1"><a href="#cb303-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Clock, <span class="kw">class</span> Duration1, <span class="kw">class</span> Duration2<span class="op">&gt;</span></span>
<span id="cb303-2"><a href="#cb303-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;(</span><span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb303-3"><a href="#cb303-3"></a>                           <span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb304"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb304-1"><a href="#cb304-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Clock, <span class="kw">class</span> Duration1, <span class="kw">class</span> Duration2<span class="op">&gt;</span></span>
<span id="cb304-2"><a href="#cb304-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&lt;=(</span><span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb304-3"><a href="#cb304-3"></a>                            <span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb305"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb305-1"><a href="#cb305-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Clock, <span class="kw">class</span> Duration1, <span class="kw">class</span> Duration2<span class="op">&gt;</span></span>
<span id="cb305-2"><a href="#cb305-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">&gt;=(</span><span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration1<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb305-3"><a href="#cb305-3"></a>                            <span class="kw">const</span> time_point<span class="op">&lt;</span>Clock, Duration2<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb306"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb306-1"><a href="#cb306-1"></a>template&lt;class Clock, class Duration1,</span>
<span id="cb306-2"><a href="#cb306-2"></a>         ThreeWayComparableWith&lt;Duration1&gt; Duration2&gt;</span>
<span id="cb306-3"><a href="#cb306-3"></a>  constexpr auto operator&lt;=&gt;(const time_point&lt;Clock, Duration1&gt;&amp; lhs,</span>
<span id="cb306-4"><a href="#cb306-4"></a>                             const time_point&lt;Clock, Duration2&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>time_since_epoch<span class="op">()</span> <span class="op">&lt;=&gt;</span> rhs<span class="op">.</span>time_since_epoch<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Change 27.8.3.3 [time.cal.day.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb307"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb307-1"><a href="#cb307-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> day<span class="op">&amp;</span> x, <span class="kw">const</span> day<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">unsigned</span><span class="op">{</span>x<span class="op">}</span> <span class="op">==</span> <span class="dt">unsigned</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb308"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb308-1"><a href="#cb308-1"></a>constexpr bool operator&lt;(const day&amp; x, const day&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">unsigned</span><span class="op">{</span>x<span class="op">}</span> <span class="op">&lt;</span> <span class="dt">unsigned</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb309"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb309-1"><a href="#cb309-1"></a>constexpr strong_ordering operator&lt;=&gt;(const day&amp; x, const day&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">unsigned</span><span class="op">{</span>x<span class="op">}</span> <span class="op">&lt;=&gt;</span> <span class="dt">unsigned</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
</div>
</blockquote>
<p>Change 27.8.4.3 [time.cal.month.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb310"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb310-1"><a href="#cb310-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> month<span class="op">&amp;</span> x, <span class="kw">const</span> month<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">unsigned</span><span class="op">{</span>x<span class="op">}</span> <span class="op">==</span> <span class="dt">unsigned</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb311"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb311-1"><a href="#cb311-1"></a>constexpr bool operator&lt;(const month&amp; x, const month&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">unsigned</span><span class="op">{</span>x<span class="op">}</span> <span class="op">&lt;</span> <span class="dt">unsigned</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb312"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb312-1"><a href="#cb312-1"></a>constexpr strong_ordering operator&lt;=&gt;(const month&amp; x, const month&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">unsigned</span><span class="op">{</span>x<span class="op">}</span> <span class="op">&lt;=&gt;</span> <span class="dt">unsigned</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
</div>
</blockquote>
<p>Change 27.8.5.3 [time.cal.year.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb313"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb313-1"><a href="#cb313-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> year<span class="op">&amp;</span> x, <span class="kw">const</span> year<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">int</span><span class="op">{</span>x<span class="op">}</span> <span class="op">==</span> <span class="dt">int</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb314"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb314-1"><a href="#cb314-1"></a>constexpr bool operator&lt;(const year&amp; x, const year&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">int</span><span class="op">{</span>x<span class="op">}</span> <span class="op">&lt;</span> <span class="dt">int</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb315"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb315-1"><a href="#cb315-1"></a>constexpr strong_ordering operator&lt;=&gt;(const year&amp; x, const year&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="dt">int</span><span class="op">{</span>x<span class="op">}</span> <span class="op">&lt;=&gt;</span> <span class="dt">int</span><span class="op">{</span>y<span class="op">}</span></code>.</p>
</div>
</blockquote>
<p>Change 27.8.9.3 [time.cal.md.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb316"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb316-1"><a href="#cb316-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> month_day<span class="op">&amp;</span> x, <span class="kw">const</span> month_day<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>month<span class="op">()</span> <span class="op">&amp;&amp;</span> x<span class="op">.</span>day<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>day<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb317"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb317-1"><a href="#cb317-1"></a>constexpr bool operator&lt;(const month_day&amp; x, const month_day&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: If <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>month<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, if <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&gt;</span> y<span class="op">.</span>month<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">false</span></code>. Otherwise, returns <code class="sourceCode cpp">x<span class="op">.</span>day<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>day<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb318"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb318-1"><a href="#cb318-1"></a>constexpr strong_ordering operator&lt;=&gt;(const month_day&amp; x, const month_day&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb319"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb319-1"><a href="#cb319-1"></a>if (auto c = x.month() &lt;=&gt; y.month(); c != 0) return c;</span>
<span id="cb319-2"><a href="#cb319-2"></a>return x.day() &lt;=&gt; y.day();</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<p>Change 27.8.10 [time.cal.mdlast]:</p>
<blockquote>
<div class="sourceCode" id="cb320"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb320-1"><a href="#cb320-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> month_day_last<span class="op">&amp;</span> x, <span class="kw">const</span> month_day_last<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>month<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb321"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb321-1"><a href="#cb321-1"></a>constexpr bool operator&lt;(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>month<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb322"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb322-1"><a href="#cb322-1"></a>constexpr strong_ordering operator&lt;=&gt;(const month_day_last&amp; x, const month_day_last&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&lt;=&gt;</span> y<span class="op">.</span>month<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Change 27.8.13.3 [time.cal.ym.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb323"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb323-1"><a href="#cb323-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> year_month<span class="op">&amp;</span> x, <span class="kw">const</span> year_month<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>year<span class="op">()</span> <span class="op">&amp;&amp;</span> x<span class="op">.</span>month<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>month<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb324"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb324-1"><a href="#cb324-1"></a>constexpr bool operator&lt;(const year_month&amp; x, const year_month&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: If <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>year<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, if <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">&gt;</span> y<span class="op">.</span>year<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">false</span></code>. Otherwise, returns <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>month<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb325"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb325-1"><a href="#cb325-1"></a>constexpr strong_ordering operator&lt;=&gt;(const year_month&amp; x, const year_month&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb326"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb326-1"><a href="#cb326-1"></a>if (auto c = x.year() &lt;=&gt; y.year(); c != 0) return c;</span>
<span id="cb326-2"><a href="#cb326-2"></a>return x.month() &lt;=&gt; y.month();</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<p>Change 27.8.14.3 [time.cal.md.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb327"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb327-1"><a href="#cb327-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> year_month_day<span class="op">&amp;</span> x, <span class="kw">const</span> year_month_day<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>year<span class="op">()</span> <span class="op">&amp;&amp;</span> x<span class="op">.</span>month<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>month<span class="op">()</span> <span class="op">&amp;&amp;</span> x<span class="op">.</span>day<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>day<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb328"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb328-1"><a href="#cb328-1"></a>constexpr bool operator&lt;(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: If <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>year<span class="op">()</span></code>, returns <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, if <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">&gt;</span> y<span class="op">.</span>year<span class="op">()</span></code>, returns <code class="sourceCode cpp"><span class="kw">false</span></code>. Otherwise, if <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>month<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, if <code class="sourceCode cpp">x<span class="op">.</span>month<span class="op">()</span> <span class="op">&gt;</span> y<span class="op">.</span>month<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">false</span></code>. Otherwise, returns <code class="sourceCode cpp">x<span class="op">.</span>day<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>day<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb329"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb329-1"><a href="#cb329-1"></a>constexpr strong_ordering operator&lt;=&gt;(const year_month_day&amp; x, const year_month_day&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb330"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb330-1"><a href="#cb330-1"></a>if (auto c = x.year() &lt;=&gt; y.year(); c != 0) return c;</span>
<span id="cb330-2"><a href="#cb330-2"></a>if (auto c = x.month() &lt;=&gt; y.month(); c != 0) return c;</span>
<span id="cb330-3"><a href="#cb330-3"></a>return x.day() &lt;=&gt; y.day();</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<p>Change 27.8.15.3 [time.cal.ymdlast.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb331"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb331-1"><a href="#cb331-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> year_month_day_last<span class="op">&amp;</span> x, <span class="kw">const</span> year_month_day_last<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>year<span class="op">()</span> <span class="op">&amp;&amp;</span> x<span class="op">.</span>month_day_last<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>month_day_last<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb332"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb332-1"><a href="#cb332-1"></a>constexpr bool operator&lt;(const year_month_day_last&amp; x, const year_month_day_last&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: If <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>year<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, if <code class="sourceCode cpp">x<span class="op">.</span>year<span class="op">()</span> <span class="op">&gt;</span> y<span class="op">.</span>year<span class="op">()</span></code> returns <code class="sourceCode cpp"><span class="kw">false</span></code>. Otherwise, returns <code class="sourceCode cpp">x<span class="op">.</span>month_day_last<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>month_day_last<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb333"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb333-1"><a href="#cb333-1"></a>constexpr strong_ordering operator&lt;=&gt;(const year_month_day_last&amp; x, const year_month_day_last&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb334"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb334-1"><a href="#cb334-1"></a>if (auto c = x.year() &lt;=&gt; y.year(); c != 0) return c;</span>
<span id="cb334-2"><a href="#cb334-2"></a>return x.month_day_last() &lt;=&gt; y.month_day_last();</span></code></pre></div>
</blockquote>
</div>
</blockquote>
<p>Change 27.10.5.3 [time.zone.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb335"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb335-1"><a href="#cb335-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> time_zone<span class="op">&amp;</span> x, <span class="kw">const</span> time_zone<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>name<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>name<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb336"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb336-1"><a href="#cb336-1"></a>constexpr bool operator&lt;(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>name<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>name<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb337"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb337-1"><a href="#cb337-1"></a>constexpr strong_ordering operator&lt;=&gt;(const time_zone&amp; x, const time_zone&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>name<span class="op">()</span> <span class="op">&lt;=&gt;</span> y<span class="op">.</span>name<span class="op">()</span></code>.</p>
</div>
</blockquote>
<p>Change 27.10.7.4 [time.zone.zonedtime.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb338"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb338-1"><a href="#cb338-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Duration1, <span class="kw">class</span> Duration2, <span class="kw">class</span> TimeZonePtr<span class="op">&gt;</span></span>
<span id="cb338-2"><a href="#cb338-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> zoned_time<span class="op">&lt;</span>Duration1, TimeZonePtr<span class="op">&gt;&amp;</span> x,</span>
<span id="cb338-3"><a href="#cb338-3"></a>                  <span class="kw">const</span> zoned_time<span class="op">&lt;</span>Duration2, TimeZonePtr<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>zone_ <span class="op">==</span> y<span class="op">.</span>zone_ <span class="op">&amp;&amp;</span> x<span class="op">.</span>tp_ <span class="op">==</span> y<span class="op">.</span>tp_</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb339"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb339-1"><a href="#cb339-1"></a>template&lt;class Duration1, class Duration2, class TimeZonePtr&gt;</span>
<span id="cb339-2"><a href="#cb339-2"></a>  bool operator!=(const zoned_time&lt;Duration1, TimeZonePtr&gt;&amp; x,</span>
<span id="cb339-3"><a href="#cb339-3"></a>                  const zoned_time&lt;Duration2, TimeZonePtr&gt;&amp; y);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 27.10.8.3 [time.zone.leap.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb340"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb340-1"><a href="#cb340-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> leap<span class="op">&amp;</span> x, <span class="kw">const</span> leap<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>date<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>date<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb341"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb341-1"><a href="#cb341-1"></a>constexpr bool operator&lt;(const leap&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>date<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>date<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb342"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb342-1"><a href="#cb342-1"></a>constexpr strong_ordering operator&lt;=&gt;(const leap&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2a</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>date<span class="op">()</span> <span class="op">&lt;=&gt;</span> y<span class="op">.</span>date<span class="op">()</span></code>.</p>
</div>
<div class="sourceCode" id="cb343"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb343-1"><a href="#cb343-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Duration<span class="op">&gt;</span></span>
<span id="cb343-2"><a href="#cb343-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> leap<span class="op">&amp;</span> x, <span class="kw">const</span> sys_time<span class="op">&lt;</span>Duration<span class="op">&gt;&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>date<span class="op">()</span> <span class="op">==</span> y</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb344"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb344-1"><a href="#cb344-1"></a>template&lt;class Duration&gt;</span>
<span id="cb344-2"><a href="#cb344-2"></a>  constexpr bool operator==(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">y <span class="op">==</span> x</code>.</p>
<div class="sourceCode" id="cb345"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb345-1"><a href="#cb345-1"></a>template&lt;class Duration&gt;</span>
<span id="cb345-2"><a href="#cb345-2"></a>  constexpr bool operator!=(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb346"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb346-1"><a href="#cb346-1"></a>template&lt;class Duration&gt;</span>
<span id="cb346-2"><a href="#cb346-2"></a>  constexpr bool operator!=(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb347"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb347-1"><a href="#cb347-1"></a>template&lt;class Duration&gt;</span>
<span id="cb347-2"><a href="#cb347-2"></a>  constexpr bool operator&lt;(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>date<span class="op">()</span> <span class="op">&lt;</span> y</code>.</p>
<div class="sourceCode" id="cb348"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb348-1"><a href="#cb348-1"></a>template&lt;class Duration&gt;</span>
<span id="cb348-2"><a href="#cb348-2"></a>  constexpr bool operator&lt;(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp">x <span class="op">&lt;</span> y<span class="op">.</span>date<span class="op">()</span></code>.</p>
<div class="sourceCode" id="cb349"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb349-1"><a href="#cb349-1"></a>template&lt;class Duration&gt;</span>
<span id="cb349-2"><a href="#cb349-2"></a>  constexpr bool operator&gt;(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp">y <span class="op">&lt;</span> x</code>.</p>
<div class="sourceCode" id="cb350"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb350-1"><a href="#cb350-1"></a>template&lt;class Duration&gt;</span>
<span id="cb350-2"><a href="#cb350-2"></a>  constexpr bool operator&gt;(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp">y <span class="op">&lt;</span> x</code>.</p>
<div class="sourceCode" id="cb351"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb351-1"><a href="#cb351-1"></a>template&lt;class Duration&gt;</span>
<span id="cb351-2"><a href="#cb351-2"></a>  constexpr bool operator&lt;=(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb352"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb352-1"><a href="#cb352-1"></a>template&lt;class Duration&gt;</span>
<span id="cb352-2"><a href="#cb352-2"></a>  constexpr bool operator&lt;=(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb353"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb353-1"><a href="#cb353-1"></a>template&lt;class Duration&gt;</span>
<span id="cb353-2"><a href="#cb353-2"></a>  constexpr bool operator&gt;=(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb354"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb354-1"><a href="#cb354-1"></a>template&lt;class Duration&gt;</span>
<span id="cb354-2"><a href="#cb354-2"></a>  constexpr bool operator&gt;=(const sys_time&lt;Duration&gt;&amp; x, const leap&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span></code>.</p>
<div class="addu">
<div class="sourceCode" id="cb355"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb355-1"><a href="#cb355-1"></a>template&lt;ThreeWayComparableWith&lt;sys_seconds&gt; Duration&gt;</span>
<span id="cb355-2"><a href="#cb355-2"></a>  constexpr auto operator&lt;=&gt;(const leap&amp; x, const sys_time&lt;Duration&gt;&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>date<span class="op">()</span> <span class="op">&lt;=&gt;</span> y</code>.</p>
</div>
</blockquote>
<p>Change 27.10.9.3 [time.zone.link.nonmembers]:</p>
<blockquote>
<div class="sourceCode" id="cb356"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb356-1"><a href="#cb356-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> link<span class="op">&amp;</span> x, <span class="kw">const</span> link<span class="op">&amp;</span> y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>name<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span>name<span class="op">()</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb357"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb357-1"><a href="#cb357-1"></a>constexpr bool operator&lt;(const link&amp; x, const link&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>name<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span>name<span class="op">()</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb358"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb358-1"><a href="#cb358-1"></a>constexpr strong_ordering operator&lt;=&gt;(const link&amp; x, const link&amp; y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">x<span class="op">.</span>name<span class="op">()</span> <span class="op">&lt;=&gt;</span> y<span class="op">.</span>name<span class="op">()</span></code>.</p>
</div>
</blockquote>
<h2 id="clause-28-localization-library"><span class="header-section-number">5.13</span> Clause 28: Localization library<a href="#clause-28-localization-library" class="self-link"></a></h2>
<p>Remove the <code class="sourceCode cpp"><span class="op">!=</span></code> from <code class="sourceCode cpp">locale</code>.</p>
<p>Change 28.3.1 [locale]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb359"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb359-1"><a href="#cb359-1"></a>namespace std {</span>
<span id="cb359-2"><a href="#cb359-2"></a>  class locale {</span>
<span id="cb359-3"><a href="#cb359-3"></a>    [...]</span>
<span id="cb359-4"><a href="#cb359-4"></a>    </span>
<span id="cb359-5"><a href="#cb359-5"></a>    bool operator==(const locale&amp; other) const;</span>
<span id="cb359-6"><a href="#cb359-6"></a><span class="st">-   bool operator!=(const locale&amp; other) const; </span></span>
<span id="cb359-7"><a href="#cb359-7"></a>    </span>
<span id="cb359-8"><a href="#cb359-8"></a>    [...]</span>
<span id="cb359-9"><a href="#cb359-9"></a>  };</span>
<span id="cb359-10"><a href="#cb359-10"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 28.3.1.4 [locale.operators]:</p>
<blockquote>
<div class="sourceCode" id="cb360"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb360-1"><a href="#cb360-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> locale<span class="op">&amp;</span> other<span class="op">)</span> <span class="kw">const</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if both arguments are the same locale, or one is a copy of the other, or each has a name and the names are identical; <code class="sourceCode cpp"><span class="kw">false</span></code> otherwise.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb361"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb361-1"><a href="#cb361-1"></a>bool operator!=(const locale&amp; other) const;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> other<span class="op">)</span></code>.</p>
</div>
</blockquote>
<h2 id="clause-29-inputoutput-library"><span class="header-section-number">5.14</span> Clause 29: Input/output library<a href="#clause-29-inputoutput-library" class="self-link"></a></h2>
<p>Add <code class="sourceCode cpp"><span class="op">==</span></code> to <code class="sourceCode cpp">space_info</code> and <code class="sourceCode cpp">file_status</code>, replace the relational operators with <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> for <code class="sourceCode cpp">path</code> and <code class="sourceCode cpp">directory_entry</code>.</p>
<p>Change 29.11.5 [fs.filesystem.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb362"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb362-1"><a href="#cb362-1"></a>namespace std::filesystem {</span>
<span id="cb362-2"><a href="#cb362-2"></a>  [...]</span>
<span id="cb362-3"><a href="#cb362-3"></a>  </span>
<span id="cb362-4"><a href="#cb362-4"></a>  struct space_info {</span>
<span id="cb362-5"><a href="#cb362-5"></a>    uintmax_t capacity;</span>
<span id="cb362-6"><a href="#cb362-6"></a>    uintmax_t free;</span>
<span id="cb362-7"><a href="#cb362-7"></a>    uintmax_t available;</span>
<span id="cb362-8"><a href="#cb362-8"></a></span>
<span id="cb362-9"><a href="#cb362-9"></a><span class="va">+   friend bool operator==(const space_info&amp;, const space_info&amp;) = default;</span></span>
<span id="cb362-10"><a href="#cb362-10"></a>  };  </span>
<span id="cb362-11"><a href="#cb362-11"></a>  </span>
<span id="cb362-12"><a href="#cb362-12"></a>  [...]</span>
<span id="cb362-13"><a href="#cb362-13"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 29.11.7 [fs.class.path]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb363"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb363-1"><a href="#cb363-1"></a>namespace std::filesystem {</span>
<span id="cb363-2"><a href="#cb363-2"></a>  class path {</span>
<span id="cb363-3"><a href="#cb363-3"></a>    [...]</span>
<span id="cb363-4"><a href="#cb363-4"></a>    </span>
<span id="cb363-5"><a href="#cb363-5"></a>    // [fs.path.nonmember], non-member operators</span>
<span id="cb363-6"><a href="#cb363-6"></a>    friend bool operator==(const path&amp; lhs, const path&amp; rhs) noexcept;</span>
<span id="cb363-7"><a href="#cb363-7"></a><span class="st">-   friend bool operator!=(const path&amp; lhs, const path&amp; rhs) noexcept;</span></span>
<span id="cb363-8"><a href="#cb363-8"></a><span class="st">-   friend bool operator&lt; (const path&amp; lhs, const path&amp; rhs) noexcept;</span></span>
<span id="cb363-9"><a href="#cb363-9"></a><span class="st">-   friend bool operator&lt;=(const path&amp; lhs, const path&amp; rhs) noexcept;</span></span>
<span id="cb363-10"><a href="#cb363-10"></a><span class="st">-   friend bool operator&gt; (const path&amp; lhs, const path&amp; rhs) noexcept;</span></span>
<span id="cb363-11"><a href="#cb363-11"></a><span class="st">-   friend bool operator&gt;=(const path&amp; lhs, const path&amp; rhs) noexcept;  </span></span>
<span id="cb363-12"><a href="#cb363-12"></a><span class="va">+   friend strong_ordering operator&lt;=&gt;(const path&amp; lhs, const path&amp; rhs) noexcept;  </span></span>
<span id="cb363-13"><a href="#cb363-13"></a>    </span>
<span id="cb363-14"><a href="#cb363-14"></a>    [...]</span>
<span id="cb363-15"><a href="#cb363-15"></a>  };</span>
<span id="cb363-16"><a href="#cb363-16"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 29.11.7.7 [fs.path.nonmember]:</p>
<blockquote>
<div class="sourceCode" id="cb364"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb364-1"><a href="#cb364-1"></a><span class="kw">friend</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> path<span class="op">&amp;</span> lhs, <span class="kw">const</span> path<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">!(lhs &lt; rhs) &amp;&amp; !(rhs &lt; lhs)</code></span></del></span> <span class="addu"><code class="sourceCode default">lhs.compare(rhs) == 0</code></span>.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> [<em>Note</em>: Path equality and path equivalence have different semantics.</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> Equality is determined by the path non-member <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code>, which considers the two paths’ lexical representations only. [<em>Example: <code class="sourceCode cpp">path<span class="op">(</span><span class="st">&quot;foo&quot;</span><span class="op">)</span> <span class="op">==</span> <span class="st">&quot;bar&quot;</span></code> is never <code class="sourceCode cpp"><span class="kw">true</span></code>. —</em>end example*]</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> Equivalence is determined by the <code class="sourceCode cpp">equivalent<span class="op">()</span></code> non-member function, which determines if two paths resolve ([fs.class.path]) to the same file system entity. [<em>Example</em>: <code class="sourceCode cpp">equivalent<span class="op">(</span><span class="st">&quot;foo&quot;</span>, <span class="st">&quot;bar&quot;</span><span class="op">)</span></code> will be true when both paths resolve to the same file. —<em>end example</em>]</li>
</ul>
<p>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. —<em>end note</em>]</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb365"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb365-1"><a href="#cb365-1"></a>friend bool operator!=(const path&amp; lhs, const path&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb366"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb366-1"><a href="#cb366-1"></a>friend bool operator&lt; (const path&amp; lhs, const path&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb367"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb367-1"><a href="#cb367-1"></a>friend bool operator&lt;=(const path&amp; lhs, const path&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb368"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb368-1"><a href="#cb368-1"></a>friend bool operator&gt; (const path&amp; lhs, const path&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb369"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb369-1"><a href="#cb369-1"></a>friend bool operator&gt;=(const path&amp; lhs, const path&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb370"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb370-1"><a href="#cb370-1"></a>friend strong_ordering operator&lt;=&gt;(const path&amp; lhs, const path&amp; rhs) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dv">0</span></code>.</p>
</div>
</blockquote>
<p>Change 29.11.10 [fs.class.file.status]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb371"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb371-1"><a href="#cb371-1"></a>namespace std::filesystem {</span>
<span id="cb371-2"><a href="#cb371-2"></a>  class file_status {</span>
<span id="cb371-3"><a href="#cb371-3"></a>    [...]</span>
<span id="cb371-4"><a href="#cb371-4"></a>    </span>
<span id="cb371-5"><a href="#cb371-5"></a><span class="va">+   friend bool operator==(const file_status&amp; lhs, const file_status&amp; rhs) noexcept</span></span>
<span id="cb371-6"><a href="#cb371-6"></a><span class="va">+     { return lhs.type() == rhs.type() &amp;&amp; lhs.permissions() == rhs.permissions(); }</span></span>
<span id="cb371-7"><a href="#cb371-7"></a>  };</span>
<span id="cb371-8"><a href="#cb371-8"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 29.11.11 [fs.class.directory.entry]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb372"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb372-1"><a href="#cb372-1"></a>namespace std::filesystem {</span>
<span id="cb372-2"><a href="#cb372-2"></a>  class directory_entry {</span>
<span id="cb372-3"><a href="#cb372-3"></a>    [...]</span>
<span id="cb372-4"><a href="#cb372-4"></a></span>
<span id="cb372-5"><a href="#cb372-5"></a>    bool operator==(const directory_entry&amp; rhs) const noexcept;</span>
<span id="cb372-6"><a href="#cb372-6"></a><span class="st">-   bool operator!=(const directory_entry&amp; rhs) const noexcept;</span></span>
<span id="cb372-7"><a href="#cb372-7"></a><span class="st">-   bool operator&lt; (const directory_entry&amp; rhs) const noexcept;</span></span>
<span id="cb372-8"><a href="#cb372-8"></a><span class="st">-   bool operator&gt; (const directory_entry&amp; rhs) const noexcept;</span></span>
<span id="cb372-9"><a href="#cb372-9"></a><span class="st">-   bool operator&lt;=(const directory_entry&amp; rhs) const noexcept;</span></span>
<span id="cb372-10"><a href="#cb372-10"></a><span class="st">-   bool operator&gt;=(const directory_entry&amp; rhs) const noexcept; </span></span>
<span id="cb372-11"><a href="#cb372-11"></a><span class="va">+   strong_ordering operator&lt;=&gt;(const directory_entry&amp; rhs) const noexcept; </span></span>
<span id="cb372-12"><a href="#cb372-12"></a></span>
<span id="cb372-13"><a href="#cb372-13"></a>    [...]</span>
<span id="cb372-14"><a href="#cb372-14"></a>  };</span>
<span id="cb372-15"><a href="#cb372-15"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 29.11.11.3 [fs.dir.entry.obs]:</p>
<blockquote>
<div class="sourceCode" id="cb373"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb373-1"><a href="#cb373-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> directory_entry<span class="op">&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">31</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">==</span> rhs<span class="op">.</span>pathobject</code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb374"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb374-1"><a href="#cb374-1"></a>bool operator!=(const directory_entry&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">32</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">!=</span> rhs<span class="op">.</span>pathobject</code>.</p>
<div class="sourceCode" id="cb375"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb375-1"><a href="#cb375-1"></a>bool operator&lt; (const directory_entry&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">33</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">&lt;</span> rhs<span class="op">.</span>pathobject</code>.</p>
<div class="sourceCode" id="cb376"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb376-1"><a href="#cb376-1"></a>bool operator&gt; (const directory_entry&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">34</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">&gt;</span> rhs<span class="op">.</span>pathobject</code>.</p>
<div class="sourceCode" id="cb377"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb377-1"><a href="#cb377-1"></a>bool operator&lt;=(const directory_entry&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">35</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">&lt;=</span> rhs<span class="op">.</span>pathobject</code>.</p>
<div class="sourceCode" id="cb378"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb378-1"><a href="#cb378-1"></a>bool operator&gt;=(const directory_entry&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">36</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">&gt;=</span> rhs<span class="op">.</span>pathobject</code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb379"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb379-1"><a href="#cb379-1"></a>strong_ordering operator&lt;=&gt;(const directory_entry&amp; rhs) const noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">37</a></span> <em>Returns</em>: <code class="sourceCode cpp">pathobject <span class="op">&lt;=&gt;</span> rhs<span class="op">.</span>pathobject</code>.</p>
</div>
</blockquote>
<h2 id="clause-30-regular-expressions-library"><span class="header-section-number">5.15</span> Clause 30: Regular expressions library<a href="#clause-30-regular-expressions-library" class="self-link"></a></h2>
<p>Reduce all the <code class="sourceCode cpp">sub_match</code> operators to just <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>, and remove <code class="sourceCode cpp"><span class="op">!=</span></code> from <code class="sourceCode cpp">match_results</code>.</p>
<p>Change 30.4 [re.syn]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb380"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb380-1"><a href="#cb380-1"></a>#include &lt;initializer_list&gt;</span>
<span id="cb380-2"><a href="#cb380-2"></a></span>
<span id="cb380-3"><a href="#cb380-3"></a>namespace std {</span>
<span id="cb380-4"><a href="#cb380-4"></a>  [...]</span>
<span id="cb380-5"><a href="#cb380-5"></a></span>
<span id="cb380-6"><a href="#cb380-6"></a>  // [re.submatch], class template sub_match</span>
<span id="cb380-7"><a href="#cb380-7"></a>  template&lt;class BidirectionalIterator&gt;</span>
<span id="cb380-8"><a href="#cb380-8"></a>    class sub_match;</span>
<span id="cb380-9"><a href="#cb380-9"></a></span>
<span id="cb380-10"><a href="#cb380-10"></a>  using csub_match  = sub_match&lt;const char*&gt;;</span>
<span id="cb380-11"><a href="#cb380-11"></a>  using wcsub_match = sub_match&lt;const wchar_t*&gt;;</span>
<span id="cb380-12"><a href="#cb380-12"></a>  using ssub_match  = sub_match&lt;string::const_iterator&gt;;</span>
<span id="cb380-13"><a href="#cb380-13"></a>  using wssub_match = sub_match&lt;wstring::const_iterator&gt;;</span>
<span id="cb380-14"><a href="#cb380-14"></a></span>
<span id="cb380-15"><a href="#cb380-15"></a>  // [re.submatch.op], sub_match non-member operators</span>
<span id="cb380-16"><a href="#cb380-16"></a>  template&lt;class BiIter&gt;</span>
<span id="cb380-17"><a href="#cb380-17"></a>    bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span>
<span id="cb380-18"><a href="#cb380-18"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-19"><a href="#cb380-19"></a><span class="st">-   bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-20"><a href="#cb380-20"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-21"><a href="#cb380-21"></a><span class="st">-   bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-22"><a href="#cb380-22"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-23"><a href="#cb380-23"></a><span class="st">-   bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-24"><a href="#cb380-24"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-25"><a href="#cb380-25"></a><span class="st">-   bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-26"><a href="#cb380-26"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-27"><a href="#cb380-27"></a><span class="st">-   bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-28"><a href="#cb380-28"></a><span class="va">+ template&lt;class BiIter&gt;</span></span>
<span id="cb380-29"><a href="#cb380-29"></a><span class="va">+   constexpr auto operator&lt;=&gt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-30"><a href="#cb380-30"></a></span>
<span id="cb380-31"><a href="#cb380-31"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-32"><a href="#cb380-32"></a><span class="st">-   bool operator==(</span></span>
<span id="cb380-33"><a href="#cb380-33"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span></span>
<span id="cb380-34"><a href="#cb380-34"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-35"><a href="#cb380-35"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-36"><a href="#cb380-36"></a><span class="st">-   bool operator!=(</span></span>
<span id="cb380-37"><a href="#cb380-37"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span></span>
<span id="cb380-38"><a href="#cb380-38"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-39"><a href="#cb380-39"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-40"><a href="#cb380-40"></a><span class="st">-   bool operator&lt;(</span></span>
<span id="cb380-41"><a href="#cb380-41"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span></span>
<span id="cb380-42"><a href="#cb380-42"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-43"><a href="#cb380-43"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-44"><a href="#cb380-44"></a><span class="st">-   bool operator&gt;(</span></span>
<span id="cb380-45"><a href="#cb380-45"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span></span>
<span id="cb380-46"><a href="#cb380-46"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-47"><a href="#cb380-47"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-48"><a href="#cb380-48"></a><span class="st">-   bool operator&lt;=(</span></span>
<span id="cb380-49"><a href="#cb380-49"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span></span>
<span id="cb380-50"><a href="#cb380-50"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-51"><a href="#cb380-51"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-52"><a href="#cb380-52"></a><span class="st">-   bool operator&gt;=(</span></span>
<span id="cb380-53"><a href="#cb380-53"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span></span>
<span id="cb380-54"><a href="#cb380-54"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-55"><a href="#cb380-55"></a></span>
<span id="cb380-56"><a href="#cb380-56"></a>  template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb380-57"><a href="#cb380-57"></a>    bool operator==(</span>
<span id="cb380-58"><a href="#cb380-58"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb380-59"><a href="#cb380-59"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span>
<span id="cb380-60"><a href="#cb380-60"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-61"><a href="#cb380-61"></a><span class="st">-   bool operator!=(</span></span>
<span id="cb380-62"><a href="#cb380-62"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-63"><a href="#cb380-63"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></span>
<span id="cb380-64"><a href="#cb380-64"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-65"><a href="#cb380-65"></a><span class="st">-   bool operator&lt;(</span></span>
<span id="cb380-66"><a href="#cb380-66"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-67"><a href="#cb380-67"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></span>
<span id="cb380-68"><a href="#cb380-68"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-69"><a href="#cb380-69"></a><span class="st">-   bool operator&gt;(</span></span>
<span id="cb380-70"><a href="#cb380-70"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-71"><a href="#cb380-71"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></span>
<span id="cb380-72"><a href="#cb380-72"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-73"><a href="#cb380-73"></a><span class="st">-   bool operator&lt;=(</span></span>
<span id="cb380-74"><a href="#cb380-74"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-75"><a href="#cb380-75"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></span>
<span id="cb380-76"><a href="#cb380-76"></a><span class="st">- template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-77"><a href="#cb380-77"></a><span class="st">-   bool operator&gt;=(</span></span>
<span id="cb380-78"><a href="#cb380-78"></a><span class="st">-     const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-79"><a href="#cb380-79"></a><span class="st">-     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></span>
<span id="cb380-80"><a href="#cb380-80"></a><span class="va">+ template&lt;class BiIter, class ST, class SA&gt;</span></span>
<span id="cb380-81"><a href="#cb380-81"></a><span class="va">+   auto operator&lt;=&gt;(</span></span>
<span id="cb380-82"><a href="#cb380-82"></a><span class="va">+     const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-83"><a href="#cb380-83"></a><span class="va">+     const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></span>
<span id="cb380-84"><a href="#cb380-84"></a></span>
<span id="cb380-85"><a href="#cb380-85"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-86"><a href="#cb380-86"></a><span class="st">-   bool operator==(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span></span>
<span id="cb380-87"><a href="#cb380-87"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-88"><a href="#cb380-88"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-89"><a href="#cb380-89"></a><span class="st">-   bool operator!=(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span></span>
<span id="cb380-90"><a href="#cb380-90"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-91"><a href="#cb380-91"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-92"><a href="#cb380-92"></a><span class="st">-   bool operator&lt;(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span></span>
<span id="cb380-93"><a href="#cb380-93"></a><span class="st">-                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-94"><a href="#cb380-94"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-95"><a href="#cb380-95"></a><span class="st">-   bool operator&gt;(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span></span>
<span id="cb380-96"><a href="#cb380-96"></a><span class="st">-                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-97"><a href="#cb380-97"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-98"><a href="#cb380-98"></a><span class="st">-   bool operator&lt;=(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span></span>
<span id="cb380-99"><a href="#cb380-99"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-100"><a href="#cb380-100"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-101"><a href="#cb380-101"></a><span class="st">-   bool operator&gt;=(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span></span>
<span id="cb380-102"><a href="#cb380-102"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-103"><a href="#cb380-103"></a></span>
<span id="cb380-104"><a href="#cb380-104"></a>  template&lt;class BiIter&gt;</span>
<span id="cb380-105"><a href="#cb380-105"></a>    bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb380-106"><a href="#cb380-106"></a>                    const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span>
<span id="cb380-107"><a href="#cb380-107"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-108"><a href="#cb380-108"></a><span class="st">-   bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-109"><a href="#cb380-109"></a><span class="st">-                   const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></span>
<span id="cb380-110"><a href="#cb380-110"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-111"><a href="#cb380-111"></a><span class="st">-   bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-112"><a href="#cb380-112"></a><span class="st">-                  const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></span>
<span id="cb380-113"><a href="#cb380-113"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-114"><a href="#cb380-114"></a><span class="st">-   bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-115"><a href="#cb380-115"></a><span class="st">-                  const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></span>
<span id="cb380-116"><a href="#cb380-116"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-117"><a href="#cb380-117"></a><span class="st">-   bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-118"><a href="#cb380-118"></a><span class="st">-                   const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></span>
<span id="cb380-119"><a href="#cb380-119"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-120"><a href="#cb380-120"></a><span class="st">-   bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-121"><a href="#cb380-121"></a><span class="st">-                   const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></span>
<span id="cb380-122"><a href="#cb380-122"></a><span class="va">+ template&lt;class BiIter&gt;</span></span>
<span id="cb380-123"><a href="#cb380-123"></a><span class="va">+   auto operator&lt;=&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-124"><a href="#cb380-124"></a><span class="va">+                    const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></span>
<span id="cb380-125"><a href="#cb380-125"></a></span>
<span id="cb380-126"><a href="#cb380-126"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-127"><a href="#cb380-127"></a><span class="st">-   bool operator==(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span></span>
<span id="cb380-128"><a href="#cb380-128"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-129"><a href="#cb380-129"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-130"><a href="#cb380-130"></a><span class="st">-   bool operator!=(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span></span>
<span id="cb380-131"><a href="#cb380-131"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-132"><a href="#cb380-132"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-133"><a href="#cb380-133"></a><span class="st">-   bool operator&lt;(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span></span>
<span id="cb380-134"><a href="#cb380-134"></a><span class="st">-                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-135"><a href="#cb380-135"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-136"><a href="#cb380-136"></a><span class="st">-   bool operator&gt;(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span></span>
<span id="cb380-137"><a href="#cb380-137"></a><span class="st">-                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-138"><a href="#cb380-138"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-139"><a href="#cb380-139"></a><span class="st">-   bool operator&lt;=(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span></span>
<span id="cb380-140"><a href="#cb380-140"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-141"><a href="#cb380-141"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-142"><a href="#cb380-142"></a><span class="st">-   bool operator&gt;=(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span></span>
<span id="cb380-143"><a href="#cb380-143"></a><span class="st">-                   const sub_match&lt;BiIter&gt;&amp; rhs);</span></span>
<span id="cb380-144"><a href="#cb380-144"></a></span>
<span id="cb380-145"><a href="#cb380-145"></a>  template&lt;class BiIter&gt;</span>
<span id="cb380-146"><a href="#cb380-146"></a>    bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb380-147"><a href="#cb380-147"></a>                    const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span>
<span id="cb380-148"><a href="#cb380-148"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-149"><a href="#cb380-149"></a><span class="st">-   bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-150"><a href="#cb380-150"></a><span class="st">-                   const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></span>
<span id="cb380-151"><a href="#cb380-151"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-152"><a href="#cb380-152"></a><span class="st">-   bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-153"><a href="#cb380-153"></a><span class="st">-                  const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></span>
<span id="cb380-154"><a href="#cb380-154"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-155"><a href="#cb380-155"></a><span class="st">-   bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-156"><a href="#cb380-156"></a><span class="st">-                  const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></span>
<span id="cb380-157"><a href="#cb380-157"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-158"><a href="#cb380-158"></a><span class="st">-   bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-159"><a href="#cb380-159"></a><span class="st">-                   const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></span>
<span id="cb380-160"><a href="#cb380-160"></a><span class="st">- template&lt;class BiIter&gt;</span></span>
<span id="cb380-161"><a href="#cb380-161"></a><span class="st">-   bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-162"><a href="#cb380-162"></a><span class="st">-                   const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></span>
<span id="cb380-163"><a href="#cb380-163"></a><span class="va">+ template&lt;class BiIter&gt;</span></span>
<span id="cb380-164"><a href="#cb380-164"></a><span class="va">+   auto operator&lt;=&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span></span>
<span id="cb380-165"><a href="#cb380-165"></a><span class="va">+                    const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></span>
<span id="cb380-166"><a href="#cb380-166"></a></span>
<span id="cb380-167"><a href="#cb380-167"></a>  template&lt;class charT, class ST, class BiIter&gt;</span>
<span id="cb380-168"><a href="#cb380-168"></a>    basic_ostream&lt;charT, ST&gt;&amp;</span>
<span id="cb380-169"><a href="#cb380-169"></a>      operator&lt;&lt;(basic_ostream&lt;charT, ST&gt;&amp; os, const sub_match&lt;BiIter&gt;&amp; m);</span>
<span id="cb380-170"><a href="#cb380-170"></a></span>
<span id="cb380-171"><a href="#cb380-171"></a>  // [re.results], class template match_results</span>
<span id="cb380-172"><a href="#cb380-172"></a>  template&lt;class BidirectionalIterator,</span>
<span id="cb380-173"><a href="#cb380-173"></a>           class Allocator = allocator&lt;sub_match&lt;BidirectionalIterator&gt;&gt;&gt;</span>
<span id="cb380-174"><a href="#cb380-174"></a>    class match_results;</span>
<span id="cb380-175"><a href="#cb380-175"></a></span>
<span id="cb380-176"><a href="#cb380-176"></a>  using cmatch  = match_results&lt;const char*&gt;;</span>
<span id="cb380-177"><a href="#cb380-177"></a>  using wcmatch = match_results&lt;const wchar_t*&gt;;</span>
<span id="cb380-178"><a href="#cb380-178"></a>  using smatch  = match_results&lt;string::const_iterator&gt;;</span>
<span id="cb380-179"><a href="#cb380-179"></a>  using wsmatch = match_results&lt;wstring::const_iterator&gt;;</span>
<span id="cb380-180"><a href="#cb380-180"></a></span>
<span id="cb380-181"><a href="#cb380-181"></a>  // match_results comparisons</span>
<span id="cb380-182"><a href="#cb380-182"></a>  template&lt;class BidirectionalIterator, class Allocator&gt;</span>
<span id="cb380-183"><a href="#cb380-183"></a>    bool operator==(const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,</span>
<span id="cb380-184"><a href="#cb380-184"></a>                    const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);</span>
<span id="cb380-185"><a href="#cb380-185"></a><span class="st">- template&lt;class BidirectionalIterator, class Allocator&gt;</span></span>
<span id="cb380-186"><a href="#cb380-186"></a><span class="st">-   bool operator!=(const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,</span></span>
<span id="cb380-187"><a href="#cb380-187"></a><span class="st">-                   const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);</span></span>
<span id="cb380-188"><a href="#cb380-188"></a></span>
<span id="cb380-189"><a href="#cb380-189"></a>  [...]</span>
<span id="cb380-190"><a href="#cb380-190"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change 30.9.2 [re.submatch.op]. <span class="ednote" style="color: #0000ff">[ Editor&#39;s note: As a result, there should be nine functions left here: four <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code>s, four <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code>s, and the <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;&lt;</span></code>. ]</span></p>
<blockquote>
<div class="addu">
<p><span class="marginalizedparent"><a class="marginalized">0</a></span> Let <em><code class="sourceCode default">SM_CAT</code></em><code class="sourceCode cpp"><span class="op">(</span>I<span class="op">)</span></code> be <code class="sourceCode cpp">compare_three_way_result_t<span class="op">&lt;</span>basic_string<span class="op">&lt;</span><span class="kw">typename</span> iterator_traits<span class="op">&lt;</span>I<span class="op">&gt;::</span>value_type<span class="op">&gt;&gt;</span></code>.</p>
</div>
<div class="sourceCode" id="cb381"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb381-1"><a href="#cb381-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> BiIter<span class="op">&gt;</span></span>
<span id="cb381-2"><a href="#cb381-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;&amp;</span> lhs, <span class="kw">const</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb382"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb382-1"><a href="#cb382-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb382-2"><a href="#cb382-2"></a>  bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">!=</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb383"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb383-1"><a href="#cb383-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb383-2"><a href="#cb383-2"></a>  bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb384"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb384-1"><a href="#cb384-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb384-2"><a href="#cb384-2"></a>  bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb385"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb385-1"><a href="#cb385-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb385-2"><a href="#cb385-2"></a>  bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;=</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb386"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb386-1"><a href="#cb386-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb386-2"><a href="#cb386-2"></a>  bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&gt;=</span> <span class="dv">0</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb387"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb387-1"><a href="#cb387-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb387-2"><a href="#cb387-2"></a>  auto operator&lt;=&gt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">a</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">static_cast</span><span class="op">&lt;</span></code><em><code class="sourceCode cpp">SM_CAT</code></em><code class="sourceCode cpp"><span class="op">(</span>BiIter<span class="op">)&gt;(</span>lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dv">0</span><span class="op">)</span></code>.</p>
</div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb388"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb388-1"><a href="#cb388-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb388-2"><a href="#cb388-2"></a>  bool operator==(</span>
<span id="cb388-3"><a href="#cb388-3"></a>    const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span>
<span id="cb388-4"><a href="#cb388-4"></a>    const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>:</p>
<blockquote>
<div class="sourceCode" id="cb389"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb389-1"><a href="#cb389-1"></a>rhs.compare(typename sub_match&lt;BiIter&gt;::string_type(lhs.data(), lhs.size())) == 0</span></code></pre></div>
</blockquote>
<div class="sourceCode" id="cb390"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb390-1"><a href="#cb390-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb390-2"><a href="#cb390-2"></a>  bool operator!=(</span>
<span id="cb390-3"><a href="#cb390-3"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span>
<span id="cb390-4"><a href="#cb390-4"></a>      const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb391"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb391-1"><a href="#cb391-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb391-2"><a href="#cb391-2"></a>  bool operator&lt;(</span>
<span id="cb391-3"><a href="#cb391-3"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span>
<span id="cb391-4"><a href="#cb391-4"></a>      const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>:</p>
<blockquote>
<div class="sourceCode" id="cb392"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb392-1"><a href="#cb392-1"></a>rhs.compare(typename sub_match&lt;BiIter&gt;::string_type(lhs.data(), lhs.size())) &gt; 0</span></code></pre></div>
</blockquote>
<div class="sourceCode" id="cb393"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb393-1"><a href="#cb393-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb393-2"><a href="#cb393-2"></a>  bool operator&gt;(</span>
<span id="cb393-3"><a href="#cb393-3"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span>
<span id="cb393-4"><a href="#cb393-4"></a>      const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb394"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb394-1"><a href="#cb394-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb394-2"><a href="#cb394-2"></a>  bool operator&lt;=(</span>
<span id="cb394-3"><a href="#cb394-3"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span>
<span id="cb394-4"><a href="#cb394-4"></a>      const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb395"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb395-1"><a href="#cb395-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb395-2"><a href="#cb395-2"></a>  bool operator&gt;=(</span>
<span id="cb395-3"><a href="#cb395-3"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,</span>
<span id="cb395-4"><a href="#cb395-4"></a>      const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb396"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb396-1"><a href="#cb396-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> BiIter, <span class="kw">class</span> ST, <span class="kw">class</span> SA<span class="op">&gt;</span></span>
<span id="cb396-2"><a href="#cb396-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span></span>
<span id="cb396-3"><a href="#cb396-3"></a>      <span class="kw">const</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb396-4"><a href="#cb396-4"></a>      <span class="kw">const</span> basic_string<span class="op">&lt;</span><span class="kw">typename</span> iterator_traits<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>value_type, ST, SA<span class="op">&gt;&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Returns</em>:</p>
<blockquote>
<div class="sourceCode" id="cb397"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb397-1"><a href="#cb397-1"></a>lhs<span class="op">.</span>compare<span class="op">(</span><span class="kw">typename</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>string_type<span class="op">(</span>rhs<span class="op">.</span>data<span class="op">()</span>, rhs<span class="op">.</span>size<span class="op">()))</span> <span class="op">==</span> <span class="dv">0</span></span></code></pre></div>
</blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb398"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb398-1"><a href="#cb398-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb398-2"><a href="#cb398-2"></a>  bool operator!=(</span>
<span id="cb398-3"><a href="#cb398-3"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb398-4"><a href="#cb398-4"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb399"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb399-1"><a href="#cb399-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb399-2"><a href="#cb399-2"></a>  bool operator&lt;(</span>
<span id="cb399-3"><a href="#cb399-3"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb399-4"><a href="#cb399-4"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Returns</em>:</p>
<blockquote>
<div class="sourceCode" id="cb400"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb400-1"><a href="#cb400-1"></a>lhs.compare(typename sub_match&lt;BiIter&gt;::string_type(rhs.data(), rhs.size())) &lt; 0</span></code></pre></div>
</blockquote>
<div class="sourceCode" id="cb401"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb401-1"><a href="#cb401-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb401-2"><a href="#cb401-2"></a>  bool operator&gt;(</span>
<span id="cb401-3"><a href="#cb401-3"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb401-4"><a href="#cb401-4"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb402"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb402-1"><a href="#cb402-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb402-2"><a href="#cb402-2"></a>  bool operator&lt;=(</span>
<span id="cb402-3"><a href="#cb402-3"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb402-4"><a href="#cb402-4"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb403"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb403-1"><a href="#cb403-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb403-2"><a href="#cb403-2"></a>  bool operator&gt;=(</span>
<span id="cb403-3"><a href="#cb403-3"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb403-4"><a href="#cb403-4"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb404"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb404-1"><a href="#cb404-1"></a>template&lt;class BiIter, class ST, class SA&gt;</span>
<span id="cb404-2"><a href="#cb404-2"></a>  auto operator&lt;=&gt;(</span>
<span id="cb404-3"><a href="#cb404-3"></a>      const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb404-4"><a href="#cb404-4"></a>      const basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">b</a></span> <em>Returns</em>:</p>
<blockquote>
<div class="sourceCode" id="cb405"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb405-1"><a href="#cb405-1"></a>static_cast&lt;<em>SM_CAT</em>(BiIter)&gt;(lhs.compare(</span>
<span id="cb405-2"><a href="#cb405-2"></a>    typename sub_match&lt;BiIter&gt;::string_type(rhs.data(), rhs.size()))</span>
<span id="cb405-3"><a href="#cb405-3"></a>      &lt;=&gt; 0</span>
<span id="cb405-4"><a href="#cb405-4"></a>    )</span></code></pre></div>
</blockquote>
</div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb406"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb406-1"><a href="#cb406-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb406-2"><a href="#cb406-2"></a>  bool operator==(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span>
<span id="cb406-3"><a href="#cb406-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs<span class="op">.</span>compare<span class="op">(</span>lhs<span class="op">)</span> <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb407"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb407-1"><a href="#cb407-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb407-2"><a href="#cb407-2"></a>  bool operator!=(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span>
<span id="cb407-3"><a href="#cb407-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">20</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb408"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb408-1"><a href="#cb408-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb408-2"><a href="#cb408-2"></a>  bool operator&lt;(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span>
<span id="cb408-3"><a href="#cb408-3"></a>                 const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">21</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs<span class="op">.</span>compare<span class="op">(</span>lhs<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb409"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb409-1"><a href="#cb409-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb409-2"><a href="#cb409-2"></a>  bool operator&gt;(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span>
<span id="cb409-3"><a href="#cb409-3"></a>                 const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">22</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb410"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb410-1"><a href="#cb410-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb410-2"><a href="#cb410-2"></a>  bool operator&lt;=(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span>
<span id="cb410-3"><a href="#cb410-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">23</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb411"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb411-1"><a href="#cb411-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb411-2"><a href="#cb411-2"></a>  bool operator&gt;=(const typename iterator_traits&lt;BiIter&gt;::value_type* lhs,</span>
<span id="cb411-3"><a href="#cb411-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">24</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb412"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb412-1"><a href="#cb412-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> BiIter<span class="op">&gt;</span></span>
<span id="cb412-2"><a href="#cb412-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb412-3"><a href="#cb412-3"></a>                  <span class="kw">const</span> <span class="kw">typename</span> iterator_traits<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>value_type<span class="op">*</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb413"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb413-1"><a href="#cb413-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb413-2"><a href="#cb413-2"></a>  bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb413-3"><a href="#cb413-3"></a>                  const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb414"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb414-1"><a href="#cb414-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb414-2"><a href="#cb414-2"></a>  bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb414-3"><a href="#cb414-3"></a>                 const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">27</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb415"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb415-1"><a href="#cb415-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb415-2"><a href="#cb415-2"></a>  bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb415-3"><a href="#cb415-3"></a>                 const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">28</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb416"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb416-1"><a href="#cb416-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb416-2"><a href="#cb416-2"></a>  bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb416-3"><a href="#cb416-3"></a>                  const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">29</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb417"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb417-1"><a href="#cb417-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb417-2"><a href="#cb417-2"></a>  bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb417-3"><a href="#cb417-3"></a>                  const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">30</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb418"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb418-1"><a href="#cb418-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb418-2"><a href="#cb418-2"></a>  auto operator&lt;=&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb418-3"><a href="#cb418-3"></a>                   const typename iterator_traits&lt;BiIter&gt;::value_type* rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">c</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">static_cast</span><span class="op">&lt;</span></code><em><code class="sourceCode cpp">SM_CAT</code></em><code class="sourceCode cpp"><span class="op">(</span>BiIter<span class="op">)&gt;(</span>lhs<span class="op">.</span>compare<span class="op">(</span>rhs<span class="op">)</span> <span class="op">&lt;=&gt;</span> <span class="dv">0</span><span class="op">)</span></code>.</p>
</div>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb419"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb419-1"><a href="#cb419-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb419-2"><a href="#cb419-2"></a>  bool operator==(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span>
<span id="cb419-3"><a href="#cb419-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">31</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs<span class="op">.</span>compare<span class="op">(</span><span class="kw">typename</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>string_type<span class="op">(</span><span class="dv">1</span>, lhs<span class="op">))</span> <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb420"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb420-1"><a href="#cb420-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb420-2"><a href="#cb420-2"></a>  bool operator!=(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span>
<span id="cb420-3"><a href="#cb420-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">32</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb421"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb421-1"><a href="#cb421-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb421-2"><a href="#cb421-2"></a>  bool operator&lt;(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span>
<span id="cb421-3"><a href="#cb421-3"></a>                 const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">33</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs<span class="op">.</span>compare<span class="op">(</span><span class="kw">typename</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>string_type<span class="op">(</span><span class="dv">1</span>, lhs<span class="op">))</span> <span class="op">&gt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb422"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb422-1"><a href="#cb422-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb422-2"><a href="#cb422-2"></a>  bool operator&gt;(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span>
<span id="cb422-3"><a href="#cb422-3"></a>                 const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">34</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb423"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb423-1"><a href="#cb423-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb423-2"><a href="#cb423-2"></a>  bool operator&lt;=(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span>
<span id="cb423-3"><a href="#cb423-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">35</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb424"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb424-1"><a href="#cb424-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb424-2"><a href="#cb424-2"></a>  bool operator&gt;=(const typename iterator_traits&lt;BiIter&gt;::value_type&amp; lhs,</span>
<span id="cb424-3"><a href="#cb424-3"></a>                  const sub_match&lt;BiIter&gt;&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">36</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="sourceCode" id="cb425"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb425-1"><a href="#cb425-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> BiIter<span class="op">&gt;</span></span>
<span id="cb425-2"><a href="#cb425-2"></a>  <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;&amp;</span> lhs,</span>
<span id="cb425-3"><a href="#cb425-3"></a>                  <span class="kw">const</span> <span class="kw">typename</span> iterator_traits<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>value_type<span class="op">&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">37</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span><span class="kw">typename</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>string_type<span class="op">(</span><span class="dv">1</span>, rhs<span class="op">))</span> <span class="op">==</span> <span class="dv">0</span></code>.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb426"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb426-1"><a href="#cb426-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb426-2"><a href="#cb426-2"></a>  bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb426-3"><a href="#cb426-3"></a>                  const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">38</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb427"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb427-1"><a href="#cb427-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb427-2"><a href="#cb427-2"></a>  bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb427-3"><a href="#cb427-3"></a>                 const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">39</a></span> <em>Returns</em>: <code class="sourceCode cpp">lhs<span class="op">.</span>compare<span class="op">(</span><span class="kw">typename</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;::</span>string_type<span class="op">(</span><span class="dv">1</span>, rhs<span class="op">))</span> <span class="op">&lt;</span> <span class="dv">0</span></code>.</p>
<div class="sourceCode" id="cb428"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb428-1"><a href="#cb428-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb428-2"><a href="#cb428-2"></a>  bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb428-3"><a href="#cb428-3"></a>                 const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">40</a></span> <em>Returns</em>: <code class="sourceCode cpp">rhs <span class="op">&lt;</span> lhs</code>.</p>
<div class="sourceCode" id="cb429"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb429-1"><a href="#cb429-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb429-2"><a href="#cb429-2"></a>  bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb429-3"><a href="#cb429-3"></a>                  const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">41</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>rhs <span class="op">&lt;</span> lhs<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb430"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb430-1"><a href="#cb430-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb430-2"><a href="#cb430-2"></a>  bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb430-3"><a href="#cb430-3"></a>                  const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">42</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>lhs <span class="op">&lt;</span> rhs<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb431"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb431-1"><a href="#cb431-1"></a>template&lt;class BiIter&gt;</span>
<span id="cb431-2"><a href="#cb431-2"></a>  auto operator&lt;=&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,</span>
<span id="cb431-3"><a href="#cb431-3"></a>                   const typename iterator_traits&lt;BiIter&gt;::value_type&amp; rhs);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">d</a></span> <em>Returns</em>:</p>
<blockquote>
<div class="sourceCode" id="cb432"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb432-1"><a href="#cb432-1"></a>static_cast&lt;<em>SM_CAT</em>(BiIter)&gt;(lhs.compare(</span>
<span id="cb432-2"><a href="#cb432-2"></a>    typename sub_match&lt;BiIter&gt;::string_type(1, rhs))</span>
<span id="cb432-3"><a href="#cb432-3"></a>      &lt;=&gt; 0</span>
<span id="cb432-4"><a href="#cb432-4"></a>    )</span></code></pre></div>
</blockquote>
</div>
<div class="sourceCode" id="cb433"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb433-1"><a href="#cb433-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> charT, <span class="kw">class</span> ST, <span class="kw">class</span> BiIter<span class="op">&gt;</span></span>
<span id="cb433-2"><a href="#cb433-2"></a>  basic_ostream<span class="op">&lt;</span>charT, ST<span class="op">&gt;&amp;</span></span>
<span id="cb433-3"><a href="#cb433-3"></a>    <span class="kw">operator</span><span class="op">&lt;&lt;(</span>basic_ostream<span class="op">&lt;</span>charT, ST<span class="op">&gt;&amp;</span> os, <span class="kw">const</span> sub_match<span class="op">&lt;</span>BiIter<span class="op">&gt;&amp;</span> m<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">43</a></span> <em>Returns</em>: <code class="sourceCode cpp">os <span class="op">&lt;&lt;</span> m<span class="op">.</span>str<span class="op">()</span></code>.</p>
</blockquote>
<p>Remove the <code class="sourceCode cpp"><span class="op">!=</span></code> from 30.10.8 [re.results.nonmember]:</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb434"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb434-1"><a href="#cb434-1"></a>template&lt;class BidirectionalIterator, class Allocator&gt;</span>
<span id="cb434-2"><a href="#cb434-2"></a>bool operator!=(const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,</span>
<span id="cb434-3"><a href="#cb434-3"></a>                const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>m1 <span class="op">==</span> m2<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 30.12.1 [re.regiter]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb435"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb435-1"><a href="#cb435-1"></a>namespace std {</span>
<span id="cb435-2"><a href="#cb435-2"></a>  template&lt;class BidirectionalIterator,</span>
<span id="cb435-3"><a href="#cb435-3"></a>            class charT = typename iterator_traits&lt;BidirectionalIterator&gt;::value_type,</span>
<span id="cb435-4"><a href="#cb435-4"></a>            class traits = regex_traits&lt;charT&gt;&gt;</span>
<span id="cb435-5"><a href="#cb435-5"></a>    class regex_iterator {</span>
<span id="cb435-6"><a href="#cb435-6"></a>      [...]</span>
<span id="cb435-7"><a href="#cb435-7"></a>      regex_iterator&amp; operator=(const regex_iterator&amp;);</span>
<span id="cb435-8"><a href="#cb435-8"></a>      bool operator==(const regex_iterator&amp;) const;</span>
<span id="cb435-9"><a href="#cb435-9"></a><span class="st">-     bool operator!=(const regex_iterator&amp;) const;</span></span>
<span id="cb435-10"><a href="#cb435-10"></a>      const value_type&amp; operator*() const;</span>
<span id="cb435-11"><a href="#cb435-11"></a>      [...]</span>
<span id="cb435-12"><a href="#cb435-12"></a>    };</span>
<span id="cb435-13"><a href="#cb435-13"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Remove the <code class="sourceCode cpp"><span class="op">!=</span></code> from 30.12.1.2 [re.regiter.comp]:</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb436"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb436-1"><a href="#cb436-1"></a>bool operator!=(const regex_iterator&amp; right) const;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> right<span class="op">)</span></code>.</p>
</div>
</blockquote>
<p>Change 30.12.2 [re.tokiter]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb437"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb437-1"><a href="#cb437-1"></a>namespace std {</span>
<span id="cb437-2"><a href="#cb437-2"></a>  template&lt;class BidirectionalIterator,</span>
<span id="cb437-3"><a href="#cb437-3"></a>            class charT = typename iterator_traits&lt;BidirectionalIterator&gt;::value_type,</span>
<span id="cb437-4"><a href="#cb437-4"></a>            class traits = regex_traits&lt;charT&gt;&gt;</span>
<span id="cb437-5"><a href="#cb437-5"></a>    class regex_token_iterator {</span>
<span id="cb437-6"><a href="#cb437-6"></a>      [...]</span>
<span id="cb437-7"><a href="#cb437-7"></a>      bool operator==(const regex_token_iterator&amp;) const;</span>
<span id="cb437-8"><a href="#cb437-8"></a><span class="st">-     bool operator!=(const regex_token_iterator&amp;) const;</span></span>
<span id="cb437-9"><a href="#cb437-9"></a>      [...]</span>
<span id="cb437-10"><a href="#cb437-10"></a>    };</span>
<span id="cb437-11"><a href="#cb437-11"></a>}   </span></code></pre></div>
</div>
</blockquote>
<p>Remove the <code class="sourceCode cpp"><span class="op">!=</span></code> from 30.12.2.2 [re.tokiter.comp]:</p>
<blockquote>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb438"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb438-1"><a href="#cb438-1"></a>bool operator!=(const regex_token_iterator&amp; right) const;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> right<span class="op">)</span></code>.</p>
</div>
</blockquote>
<h2 id="clause-31-atomic-operations-library"><span class="header-section-number">5.16</span> Clause 31: Atomic operations library<a href="#clause-31-atomic-operations-library" class="self-link"></a></h2>
<p>No changes necessary.</p>
<h2 id="clause-32-thread-support-library"><span class="header-section-number">5.17</span> Clause 32: Thread support library<a href="#clause-32-thread-support-library" class="self-link"></a></h2>
<p><span class="ednote" style="color: #0000ff">[ Editor&#39;s note: Replace <code class="sourceCode cpp">thread<span class="op">::</span>id</code>s operators with just <code class="sourceCode cpp"><span class="op">==</span></code> and <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>. ]</span></p>
<p>Change 32.3.2.1 [thread.thread.id]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb439"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb439-1"><a href="#cb439-1"></a>namespace std {</span>
<span id="cb439-2"><a href="#cb439-2"></a>  class thread::id {</span>
<span id="cb439-3"><a href="#cb439-3"></a>  public:</span>
<span id="cb439-4"><a href="#cb439-4"></a>    id() noexcept;</span>
<span id="cb439-5"><a href="#cb439-5"></a>  };</span>
<span id="cb439-6"><a href="#cb439-6"></a></span>
<span id="cb439-7"><a href="#cb439-7"></a>  bool operator==(thread::id x, thread::id y) noexcept;</span>
<span id="cb439-8"><a href="#cb439-8"></a><span class="st">- bool operator!=(thread::id x, thread::id y) noexcept;</span></span>
<span id="cb439-9"><a href="#cb439-9"></a><span class="st">- bool operator&lt;(thread::id x, thread::id y) noexcept;</span></span>
<span id="cb439-10"><a href="#cb439-10"></a><span class="st">- bool operator&gt;(thread::id x, thread::id y) noexcept;</span></span>
<span id="cb439-11"><a href="#cb439-11"></a><span class="st">- bool operator&lt;=(thread::id x, thread::id y) noexcept;</span></span>
<span id="cb439-12"><a href="#cb439-12"></a><span class="st">- bool operator&gt;=(thread::id x, thread::id y) noexcept;</span></span>
<span id="cb439-13"><a href="#cb439-13"></a><span class="va">+ strong_ordering operator&lt;=&gt;(thread::id x, thread::id y) noexcept;</span></span>
<span id="cb439-14"><a href="#cb439-14"></a></span>
<span id="cb439-15"><a href="#cb439-15"></a>  template&lt;class charT, class traits&gt;</span>
<span id="cb439-16"><a href="#cb439-16"></a>    basic_ostream&lt;charT, traits&gt;&amp;</span>
<span id="cb439-17"><a href="#cb439-17"></a>      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; out, thread::id id);</span>
<span id="cb439-18"><a href="#cb439-18"></a></span>
<span id="cb439-19"><a href="#cb439-19"></a>  // hash support</span>
<span id="cb439-20"><a href="#cb439-20"></a>  template&lt;class T&gt; struct hash;</span>
<span id="cb439-21"><a href="#cb439-21"></a>  template&lt;&gt; struct hash&lt;thread::id&gt;;</span>
<span id="cb439-22"><a href="#cb439-22"></a>}</span></code></pre></div>
</div>
</blockquote>
<blockquote>
<div class="sourceCode" id="cb440"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb440-1"><a href="#cb440-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>thread<span class="op">::</span>id x, thread<span class="op">::</span>id y<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> only if <code class="sourceCode cpp">x</code> and <code class="sourceCode cpp">y</code> represent the same thread of execution or neither x nor y represents a thread of execution.</p>
<div class="rm" style="color: #bf0303">

<div class="sourceCode" id="cb441"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb441-1"><a href="#cb441-1"></a>bool operator!=(thread::id x, thread::id y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">==</span> y<span class="op">)</span></code></p>
<div class="sourceCode" id="cb442"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb442-1"><a href="#cb442-1"></a>bool operator&lt;(thread::id x, thread::id y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Returns</em>: A value such that <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;</span></code> is a total ordering as described in [alg.sorting].</p>
<div class="sourceCode" id="cb443"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb443-1"><a href="#cb443-1"></a>bool operator&gt;(thread::id x, thread::id y) noexcept; </span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns</em>: <code class="sourceCode cpp">y <span class="op">&lt;</span> x</code>.</p>
<div class="sourceCode" id="cb444"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb444-1"><a href="#cb444-1"></a>bool operator&lt;=(thread::id x, thread::id y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>y <span class="op">&lt;</span> x<span class="op">)</span></code>.</p>
<div class="sourceCode" id="cb445"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb445-1"><a href="#cb445-1"></a>bool operator&gt;=(thread::id x, thread::id y) noexcept;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="op">!(</span>x <span class="op">&lt;</span> y<span class="op">)</span></code>.</p>
</div>
<div class="addu">
<div class="sourceCode" id="cb446"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb446-1"><a href="#cb446-1"></a>strong_ordering operator&lt;=&gt;(thread::id x, thread::id y) noexcept;</span></code></pre></div>
<p>Let <code><i>P</i>(x, y)</code> be an unspecified total ordering over <code class="sourceCode cpp">thread<span class="op">::</span>id</code> as described in [alg.sorting].</p>
<p><span class="marginalizedparent"><a class="marginalized">a</a></span> <em>Returns</em>: <code class="sourceCode cpp">strong_ordering<span class="op">::</span>less</code> if <code><i>P</i>(x, y)</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, <code class="sourceCode cpp">strong_ordering<span class="op">::</span>greater</code> if <code><i>P</i>(y, x)</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, <code class="sourceCode cpp">strong_ordering<span class="op">::</span>equal</code>.</p>
</div>
</blockquote>
<h1 id="references" style="border-bottom:1px solid #cccccc"><span class="header-section-number">6</span> References<a href="#references" class="self-link"></a></h1>

<div id="refs" role="doc-bibliography">
<div id="ref-P0732R2">
<p>[P0732R2] Jeff Snyder, Louis Dionne. 2018. Class Types in Non-Type Template Parameters. <br />
<a href="https://wg21.link/p0732r2">https://wg21.link/p0732r2</a></p>
</div>
<div id="ref-P0790R2">
<p>[P0790R2] David Stone. 2019. Effect of operator&lt;=&gt; on the C++ Standard Library. <br />
<a href="https://wg21.link/p0790r2">https://wg21.link/p0790r2</a></p>
</div>
<div id="ref-P0891R2">
<p>[P0891R2] Gašper Ažman, Jeff Snyder. 2019. Make <code class="sourceCode cpp">strong_order</code> a Customization Point! <br />
<a href="https://wg21.link/p0891r2">https://wg21.link/p0891r2</a></p>
</div>
<div id="ref-P1154R1">
<p>[P1154R1] Arthur O’Dwyer, Jeff Snyder. 2019. Type traits for structural comparison. <br />
<a href="https://wg21.link/p1154r1">https://wg21.link/p1154r1</a></p>
</div>
<div id="ref-P1185R2">
<p>[P1185R2] Barry Revzin. 2019. <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span> <span class="op">!=</span> <span class="op">==</span></code>. <br />
<a href="https://wg21.link/p1185r2">https://wg21.link/p1185r2</a></p>
</div>
<div id="ref-P1186R1">
<p>[P1186R1] Barry Revzin. 2019. When do you actually use <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>? <br />
<a href="https://wg21.link/p1186r1">https://wg21.link/p1186r1</a></p>
</div>
<div id="ref-P1186R2">
<p>[P1186R2] Barry Revzin. 2019. When do you actually use <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>? <br />
<a href="https://wg21.link/p1186r2">https://wg21.link/p1186r2</a></p>
</div>
<div id="ref-P1188R0">
<p>[P1188R0] Barry Revzin. 2019. Library utilities for <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>. <br />
<a href="https://wg21.link/p1188r0">https://wg21.link/p1188r0</a></p>
</div>
<div id="ref-P1189R0">
<p>[P1189R0] Barry Revzin. 2019. Adding <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to library. <br />
<a href="https://wg21.link/p1189r0">https://wg21.link/p1189r0</a></p>
</div>
<div id="ref-P1191R0">
<p>[P1191R0] David Stone. 2018. Adding <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code> to types that are not currently comparable. <br />
<a href="https://wg21.link/p1191r0">https://wg21.link/p1191r0</a></p>
</div>
<div id="ref-P1201R0">
<p>[P1201R0] Oleg Fatkhiev, Antony Polukhin. 2018. Variant direct comparisons. <br />
<a href="https://wg21.link/p1201r0">https://wg21.link/p1201r0</a></p>
</div>
<div id="ref-P1295R0">
<p>[P1295R0] Tomasz Kamiński. 2018. Spaceship library update. <br />
<a href="https://wg21.link/p1295r0">https://wg21.link/p1295r0</a></p>
</div>
<div id="ref-P1380R1">
<p>[P1380R1] Lawrence Crowl. 2019. Ambiguity and Insecurities with Three-Way Comparison. <br />
<a href="https://wg21.link/p1380r1">https://wg21.link/p1380r1</a></p>
</div>
<div id="ref-P1614R0">
<p>[P1614R0] Barry Revzin. 2019. The Mothership Has Landed: Adding <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> to the Library. <br />
<a href="https://wg21.link/p1614r0">https://wg21.link/p1614r0</a></p>
</div>
</div>
</div>
</div>
</body>
</html>
