<!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-11-07" />
  <title>Remove std::weak_equality and std::strong_equality</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;
text-align: center;
}
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">Remove <code class="sourceCode cpp">std<span class="op">::</span>weak_equality</code> and <code class="sourceCode cpp">std<span class="op">::</span>strong_equality</code></h1>

<table style="border:none;float:right">
  <tr>
    <td>Document #: </td>
    <td>P1959R0</td>
  </tr>
  <tr>
    <td>Date: </td>
    <td>2019-11-07</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project: </td>
    <td>Programming Language C++<br>
      EWG, LEWG<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">
<h1 id="introduction" style="border-bottom:1px solid #cccccc"><span class="header-section-number">1</span> Introduction<a href="#introduction" class="self-link"></a></h1>
<p>This paper resolves NB comments <a href="https://github.com/cplusplus/nbballot/issues/168">US 170</a>:</p>
<blockquote>
<p>The <code class="sourceCode cpp">strong_equality</code> and <code class="sourceCode cpp">weak_equality</code> comparison categories don’t make sense now that we split equality from ordering. It doesn’t make sense to declare an <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code> that returns one of these – they just add needless complexity.</p>
</blockquote>
<p>and <a href="https://github.com/cplusplus/nbballot/issues/171">CA 173</a>:</p>
<blockquote>
<p>With the separation of <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> and <code class="sourceCode cpp"><span class="op">==</span></code>, <code class="sourceCode cpp">weak_equality</code> has lost its primary use (of being a potential return type of <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code>). Currently weak_equality serves no useful purpose in the standard (i.e., nothing in std acts on it), and just causes confusion (what’s the difference between weak and strong, when should I use which?) The difference between the two is ill-defined (involving substitutability and “salient” properties, which are also vaguely defined). The best definition of equality for a type is the type’s own <code class="sourceCode cpp"><span class="op">==</span></code> operator. We should not try to sub-divide the concept of equality.</p>
</blockquote>
<p>The first of these comments subsumes the other, and this paper provides the wording for that change.</p>
<h1 id="wording" style="border-bottom:1px solid #cccccc"><span class="header-section-number">2</span> Wording<a href="#wording" class="self-link"></a></h1>
<p>Change 7.6.8 [expr.spaceship], paragraph 7, to remove the ability to call <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> on function pointers, pointers to members, and <code class="sourceCode cpp">nullptr_t</code>.</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <span class="rm" style="color: #bf0303"><del>If the composite pointer type is a function pointer type, a pointer-to-member type, or <span><code class="sourceCode cpp">std​<span class="op">::</span>​nullptr_t</code></span>, the result is of type <span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality</code></span>; the result is <span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality​<span class="op">::</span>​equal</code></span> if the (possibly converted) operands compare equal ([expr.eq]) and <span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality​<span class="op">::</span>​nonequal</code></span> if they compare unequal, otherwise the result of the operator is unspecified.</del></span></p>
</blockquote>
<p>Change 7.6.8 [expr.spaceship], paragraph 10:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> The <span class="rm" style="color: #bf0303"><del>five</del></span> <span class="addu">three</span> comparison category types (the types <code class="sourceCode cpp">std​<span class="op">::</span>​strong_ordering</code>, <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality</code></span>,</del></span> <code class="sourceCode cpp">std​<span class="op">::</span>​weak_ordering</code>, <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">std​<span class="op">::</span>​weak_equality</code></span>,</del></span> and <code class="sourceCode cpp">std​<span class="op">::</span>​partial_ordering</code>) are not predefined; […]</p>
</blockquote>
<p>Change 11.11.1 [class.compare.default], paragraph 4:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> A type <code class="sourceCode cpp">C</code> has <em>strong structural equality</em> if, given a glvalue <code class="sourceCode cpp">x</code> of type <code class="sourceCode cpp"><span class="kw">const</span> C</code>, either:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <code class="sourceCode cpp">C</code> is a non-class type and <code class="sourceCode cpp">x <span class="op">&lt;=&gt;</span> x</code> is a valid expression of type <code class="sourceCode cpp">std<span class="op">::</span>strong_ordering</code> <span class="rm" style="color: #bf0303"><del>or <span><code class="sourceCode cpp">std<span class="op">::</span>strong_equality</code></span></del></span>, or</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <code class="sourceCode cpp">C</code> is a class type where all of the following hold: […]</li>
</ul>
</blockquote>
<p>Remove the <code class="sourceCode cpp">XXX_equality</code> cases from 11.11.3 [class.spaceship], paragraph 1:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The <em>synthesized three-way comparison</em> for comparison category type <code class="sourceCode cpp">R</code> ([cmp.categories]) of glvalues <code class="sourceCode cpp">a</code> and <code class="sourceCode cpp">b</code> of the same type is defined as follows:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> […]</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.5)</a></span> Otherwise, if <code class="sourceCode cpp">R</code> is <code class="sourceCode cpp">partial_ordering</code>, then</p>
<blockquote>
<div class="sourceCode" id="cb1"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb1-1"><a href="#cb1-1"></a>a == b ? partial_ordering::equivalent : </span>
<span id="cb1-2"><a href="#cb1-2"></a>a &lt; b  ? partial_ordering::less :</span>
<span id="cb1-3"><a href="#cb1-3"></a>b &lt; a  ? partial_ordering::greater :</span>
<span id="cb1-4"><a href="#cb1-4"></a>         partial_ordering::unordered</span></code></pre></div>
</blockquote></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.6)</a></span> <span class="rm" style="color: #bf0303"><del>Otherwise, if <span><code class="sourceCode cpp">R</code></span> is <span><code class="sourceCode cpp">strong_equality</code></span>, then <span><code class="sourceCode cpp">a <span class="op">==</span> b <span class="op">?</span> strong_equality<span class="op">::</span>equal <span class="op">:</span> strong_equality<span class="op">::</span>nonequal</code></span>;</del></span></p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.7)</a></span> <span class="rm" style="color: #bf0303"><del>Otherwise, if <span><code class="sourceCode cpp">R</code></span> is <span><code class="sourceCode cpp">weak_equality</code></span>, then <span><code class="sourceCode cpp">a <span class="op">==</span> b <span class="op">?</span> weak_equality<span class="op">::</span>equivalent <span class="op">:</span> weak_equality<span class="op">::</span>nonequivalent</code></span>;</del></span></p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.8)</a></span> Otherwise, the synthesized three-way comparison is not defined.</p></li>
</ul>
</blockquote>
<p>Remove the <code class="sourceCode cpp">XXX_equality</code> cases from 11.11.3 [class.spaceship], paragraph 3:</p>
<blockquote>
<p>The <em>common comparison type</em> <code class="sourceCode cpp">U</code> of a possibly-empty list of <code class="sourceCode cpp">n</code> types <code class="sourceCode cpp">T0</code>, <code class="sourceCode cpp">T1</code>, …, <code class="sourceCode cpp">Tn−<span class="dv">1</span></code> is defined as follows:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> If any <code class="sourceCode cpp">Ti</code> is not a comparison category type ([cmp.categories]), <code class="sourceCode cpp">U</code> is void.</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <span class="rm" style="color: #bf0303"><del>Otherwise, if at least one <span><code class="sourceCode cpp">Ti</code></span> is <span><code class="sourceCode cpp">std​<span class="op">::</span>​weak_equality</code></span>, or at least one <span><code class="sourceCode cpp">Ti</code></span> is <span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality</code></span> and at least one <span><code class="sourceCode cpp">Tj</code></span> is <span><code class="sourceCode cpp">std​<span class="op">::</span>​partial_ordering</code></span> or <span><code class="sourceCode cpp">std​<span class="op">::</span>​weak_ordering</code></span>, <span><code class="sourceCode cpp">U</code></span> is <span><code class="sourceCode cpp">std​<span class="op">::</span>​weak_equality</code></span> ([cmp.weakeq]).</del></span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.3)</a></span> <span class="rm" style="color: #bf0303"><del>Otherwise, if at least one <span><code class="sourceCode cpp">Ti</code></span> is <span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality</code></span>, <span><code class="sourceCode cpp">U</code></span> is <span><code class="sourceCode cpp">std​<span class="op">::</span>​strong_equality</code></span> ([cmp.strongeq]).</del></span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.4)</a></span> Otherwise, if at least one <code class="sourceCode cpp">Ti</code> is <code class="sourceCode cpp">std​<span class="op">::</span>​partial_ordering</code>, <code class="sourceCode cpp">U</code> is <code class="sourceCode cpp">std​<span class="op">::</span>​partial_ordering</code> ([cmp.partialord]).</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.5)</a></span> Otherwise, if at least one <code class="sourceCode cpp">Ti</code> is <code class="sourceCode cpp">std​<span class="op">::</span>​weak_ordering</code>, <code class="sourceCode cpp">U</code> is <code class="sourceCode cpp">std​<span class="op">::</span>​weak_ordering</code> ([cmp.weakord]).</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.6)</a></span> Otherwise, <code class="sourceCode cpp">U</code> is <code class="sourceCode cpp">std​<span class="op">::</span>​strong_ordering</code> ([cmp.strongord]).</li>
</ul>
</blockquote>
<p>Change the example in 11.11.4 [class.rel], paragraph 3, to use a different type that has no <code class="sourceCode cpp"><span class="op">&lt;</span></code>:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb2"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb2-1"><a href="#cb2-1"></a><span class="va">+ struct HasNoLessThan { };</span></span>
<span id="cb2-2"><a href="#cb2-2"></a></span>
<span id="cb2-3"><a href="#cb2-3"></a>  struct C {</span>
<span id="cb2-4"><a href="#cb2-4"></a><span class="st">-   friend std::strong_equality operator&lt;=&gt;(const C&amp;, const C&amp;);</span></span>
<span id="cb2-5"><a href="#cb2-5"></a><span class="va">+   friend HasNoLessThan operator&lt;=&gt;(const C&amp;, const C&amp;);</span></span>
<span id="cb2-6"><a href="#cb2-6"></a>    bool operator&lt;(const C&amp;) const = default;             // OK, function is deleted</span>
<span id="cb2-7"><a href="#cb2-7"></a>  };</span></code></pre></div>
</div>
</blockquote>
<p>Remove <code class="sourceCode cpp"><span class="op">&lt;=&gt;</span></code> from 12.7 [over.built], paragraph 19:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> For every <code class="sourceCode cpp">T</code>, where <code class="sourceCode cpp">T</code> is a pointer-to-member type or <code class="sourceCode cpp">std​<span class="op">::</span>​nullptr_t</code>, there exist candidate operator functions of the form:</p>
<div>
<div class="sourceCode" id="cb3"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb3-1"><a href="#cb3-1"></a>  bool                 operator==(T, T);</span>
<span id="cb3-2"><a href="#cb3-2"></a>  bool                 operator!=(T, T);</span>
<span id="cb3-3"><a href="#cb3-3"></a><span class="st">- std::strong_equality operator&lt;=&gt;(T, T);</span></span></code></pre></div>
</div>
</blockquote>
<p>Change 13.2 [temp.param]/4 to add back the bullets that <span class="citation" data-cites="P0732R2">[<a href="#ref-P0732R2" role="doc-biblioref">P0732R2</a>]</span> removed, now that these other types no longer have strong structural equality:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> A non-type template-parameter shall have one of the following (optionally cv-qualified) types:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> a literal type that has strong structural equality ([class.compare.default]),</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> an lvalue reference type,</li>
<li><span class="marginalizedparent"><a class="marginalized">(4.3)</a></span> a type that contains a placeholder type ([dcl.spec.auto]), <span class="rm" style="color: #bf0303"><del>or</del></span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.4)</a></span> a placeholder for a deduced class type ([dcl.type.class.deduct])<span class="rm" style="color: #bf0303"><del>.</del></span> <span class="addu">,</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.5)</a></span> <span class="addu">pointer to object or pointer to function,</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.6)</a></span> <span class="addu">pointer to member, or</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.7)</a></span> <span class="addu"><code class="sourceCode cpp">std<span class="op">::</span>nullptr_t</code>.</span></li>
</ul>
</blockquote>
<p>Remove the <code class="sourceCode cpp">XXX_equality</code> types from the compare synopsis in 17.11.1 [compare.syn]:</p>
<div>
<div class="sourceCode" id="cb4"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb4-1"><a href="#cb4-1"></a>namespace std {</span>
<span id="cb4-2"><a href="#cb4-2"></a>  // [cmp.categories], comparison category types</span>
<span id="cb4-3"><a href="#cb4-3"></a><span class="st">- class weak_equality;</span></span>
<span id="cb4-4"><a href="#cb4-4"></a><span class="st">- class strong_equality;</span></span>
<span id="cb4-5"><a href="#cb4-5"></a>  class partial_ordering;</span>
<span id="cb4-6"><a href="#cb4-6"></a>  class weak_ordering;</span>
<span id="cb4-7"><a href="#cb4-7"></a>  class strong_ordering;</span>
<span id="cb4-8"><a href="#cb4-8"></a></span>
<span id="cb4-9"><a href="#cb4-9"></a>  // named comparison functions</span>
<span id="cb4-10"><a href="#cb4-10"></a><span class="st">- constexpr bool is_eq  (weak_equality cmp) noexcept    { return cmp == 0; }</span></span>
<span id="cb4-11"><a href="#cb4-11"></a><span class="st">- constexpr bool is_neq (weak_equality cmp) noexcept    { return cmp != 0; }</span></span>
<span id="cb4-12"><a href="#cb4-12"></a><span class="va">+ constexpr bool is_eq  (partial_ordering cmp) noexcept { return cmp == 0; }</span></span>
<span id="cb4-13"><a href="#cb4-13"></a><span class="va">+ constexpr bool is_neq (partial_ordering cmp) noexcept { return cmp != 0; }</span></span>
<span id="cb4-14"><a href="#cb4-14"></a>  constexpr bool is_lt  (partial_ordering cmp) noexcept { return cmp &lt; 0; }</span>
<span id="cb4-15"><a href="#cb4-15"></a>  constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp &lt;= 0; }</span>
<span id="cb4-16"><a href="#cb4-16"></a>  constexpr bool is_gt  (partial_ordering cmp) noexcept { return cmp &gt; 0; }</span>
<span id="cb4-17"><a href="#cb4-17"></a>  constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp &gt;= 0; }</span>
<span id="cb4-18"><a href="#cb4-18"></a>}</span></code></pre></div>
</div>
<p>Change 17.11.2.1 [cmp.categories.pre], paragraphs 1-2:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The types <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode cpp">weak_equality</code></span>, <span><code class="sourceCode cpp">strong_equality</code></span>,</del></span> <code class="sourceCode cpp">partial_ordering</code>, <code class="sourceCode cpp">weak_ordering</code>, and <code class="sourceCode cpp">strong_ordering</code> are collectively termed the comparison category types. Each is specified in terms of an exposition-only data member named value whose value typically corresponds to that of an enumerator from one of the following exposition-only enumerations:</p>
<div class="sourceCode" id="cb5"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb5-1"><a href="#cb5-1"></a>enum class eq { equal = 0, equivalent = equal,</span>
<span id="cb5-2"><a href="#cb5-2"></a>                nonequal = 1, nonequivalent = nonequal };   // exposition only</span>
<span id="cb5-3"><a href="#cb5-3"></a>enum class ord { less = -1, greater = 1 };                  // exposition only</span>
<span id="cb5-4"><a href="#cb5-4"></a>enum class ncmp { unordered = -127 };                       // exposition only</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> [ Note: The type<span class="rm" style="color: #bf0303"><del>s</del></span> <code class="sourceCode cpp">strong_ordering</code> <span class="rm" style="color: #bf0303"><del>and weak_equality</del></span> correspond<span class="addu">s</span><span class="rm" style="color: #bf0303"><del>, respectively,</del></span> to the term<span class="rm" style="color: #bf0303"><del>s</del></span> total ordering <span class="rm" style="color: #bf0303"><del>and equivalence</del></span> in mathematics. — end note ]</p>
</blockquote>
<p>Remove 17.11.2.2 [cmp.weakeq] (the subclause that defines <code class="sourceCode cpp">std<span class="op">::</span>weak_equality</code>).</p>
<p>Remove 17.11.2.3 [cmp.strongeq] (the subclause that defines <code class="sourceCode cpp">std<span class="op">::</span>strong_equality</code>).</p>
<p>Remove the conversion operator to <code class="sourceCode cpp">weak_equality</code> from 17.11.2.4 [cmp.partialord]:</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 partial_ordering {</span>
<span id="cb6-3"><a href="#cb6-3"></a>    [...] </span>
<span id="cb6-4"><a href="#cb6-4"></a> </span>
<span id="cb6-5"><a href="#cb6-5"></a><span class="st">-   // conversion</span></span>
<span id="cb6-6"><a href="#cb6-6"></a><span class="st">-   constexpr operator weak_equality() const noexcept;  </span></span>
<span id="cb6-7"><a href="#cb6-7"></a>  </span>
<span id="cb6-8"><a href="#cb6-8"></a>    [...]</span>
<span id="cb6-9"><a href="#cb6-9"></a>  };</span>
<span id="cb6-10"><a href="#cb6-10"></a>}</span></code></pre></div>
</div>
<div class="rm" style="color: #bf0303">
<p><code class="sourceCode cpp"><span class="kw">constexpr</span> <span class="kw">operator</span> weak_equality<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">value <span class="op">==</span> <span class="dv">0</span> <span class="op">?</span> weak_equality​<span class="op">::</span>​equivalent <span class="op">:</span> weak_equality​<span class="op">::</span>​nonequivalent</code>. [ Note: The result is independent of the <code class="sourceCode cpp">is_ordered</code> member. — end note ]</p>
</div>
</blockquote>
<p>Remove the conversion operator to <code class="sourceCode cpp">weak_equality</code> from 17.11.2.5 [cmp.weakord]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb7"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb7-1"><a href="#cb7-1"></a>namespace std {</span>
<span id="cb7-2"><a href="#cb7-2"></a>  class weak_ordering  {</span>
<span id="cb7-3"><a href="#cb7-3"></a>    [...] </span>
<span id="cb7-4"><a href="#cb7-4"></a> </span>
<span id="cb7-5"><a href="#cb7-5"></a>    // conversion</span>
<span id="cb7-6"><a href="#cb7-6"></a><span class="st">-   constexpr operator weak_equality() const noexcept; </span></span>
<span id="cb7-7"><a href="#cb7-7"></a>    constexpr operator partial_ordering() const noexcept; </span>
<span id="cb7-8"><a href="#cb7-8"></a>  </span>
<span id="cb7-9"><a href="#cb7-9"></a>    [...]</span>
<span id="cb7-10"><a href="#cb7-10"></a>  };</span>
<span id="cb7-11"><a href="#cb7-11"></a>}</span></code></pre></div>
</div>
<div class="rm" style="color: #bf0303">
<p><code class="sourceCode cpp"><span class="kw">constexpr</span> <span class="kw">operator</span> weak_equality<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">value <span class="op">==</span> <span class="dv">0</span> <span class="op">?</span> weak_equality​<span class="op">::</span>​equivalent <span class="op">:</span> weak_equality​<span class="op">::</span>​nonequivalent</code>.</p>
</div>
</blockquote>
<p>Remove the conversion operators to <code class="sourceCode cpp">XXX_equality</code> from 17.11.2.6 [cmp.strongord]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb8"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb8-1"><a href="#cb8-1"></a>namespace std {</span>
<span id="cb8-2"><a href="#cb8-2"></a>  class strong_ordering   {</span>
<span id="cb8-3"><a href="#cb8-3"></a>    [...] </span>
<span id="cb8-4"><a href="#cb8-4"></a> </span>
<span id="cb8-5"><a href="#cb8-5"></a>    // conversions</span>
<span id="cb8-6"><a href="#cb8-6"></a><span class="st">-   constexpr operator weak_equality() const noexcept;</span></span>
<span id="cb8-7"><a href="#cb8-7"></a><span class="st">-   constexpr operator strong_equality() const noexcept;</span></span>
<span id="cb8-8"><a href="#cb8-8"></a>    constexpr operator partial_ordering() const noexcept;</span>
<span id="cb8-9"><a href="#cb8-9"></a>    constexpr operator weak_ordering() const noexcept;</span>
<span id="cb8-10"><a href="#cb8-10"></a>  </span>
<span id="cb8-11"><a href="#cb8-11"></a>    [...]</span>
<span id="cb8-12"><a href="#cb8-12"></a>  };</span>
<span id="cb8-13"><a href="#cb8-13"></a>}</span></code></pre></div>
</div>
<div class="rm" style="color: #bf0303">
<p><code class="sourceCode cpp"><span class="kw">constexpr</span> <span class="kw">operator</span> weak_equality<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns</em>: <code class="sourceCode cpp">value <span class="op">==</span> <span class="dv">0</span> <span class="op">?</span> weak_equality​<span class="op">::</span>​equivalent <span class="op">:</span> weak_equality​<span class="op">::</span>​nonequivalent</code>.</p>
<p><code class="sourceCode cpp"><span class="kw">constexpr</span> <span class="kw">operator</span> strong_equality<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp">value <span class="op">==</span> <span class="dv">0</span> <span class="op">?</span> strong_equality​<span class="op">::</span>​equal <span class="op">:</span> strong_equality​<span class="op">::</span>nonequal</code>.</p>
</div>
</blockquote>
<p>Simplify the three-way comparable concepts in 17.11.4 [cmp.concept]:</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>template &lt;typename T, typename Cat = partial_ordering&gt;</span>
<span id="cb9-2"><a href="#cb9-2"></a>  concept three_way_comparable  =</span>
<span id="cb9-3"><a href="#cb9-3"></a>    <em>weakly-equality-comparable-with</em>&lt;T, T&gt; &amp;&amp;</span>
<span id="cb9-4"><a href="#cb9-4"></a><span class="st">-   (!convertible_to&lt;Cat, partial_ordering&gt; || <em>partially-ordered-with</em>&lt;T, T&gt;) &amp;&amp;</span></span>
<span id="cb9-5"><a href="#cb9-5"></a><span class="va">+   <em>partially-ordered-with</em>&lt;T, T&gt; &amp;&amp;</span></span>
<span id="cb9-6"><a href="#cb9-6"></a>    requires(const remove_reference_t&lt;T&gt;&amp; a,</span>
<span id="cb9-7"><a href="#cb9-7"></a>             const remove_reference_t&lt;T&gt;&amp; b) {</span>
<span id="cb9-8"><a href="#cb9-8"></a>      { a &lt;=&gt; b } -&gt; <em>compares-as</em>&lt;Cat&gt;;</span>
<span id="cb9-9"><a href="#cb9-9"></a>    };</span></code></pre></div>
</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">three_way_comparable<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> <span class="rm" style="color: #bf0303"><del>If <span><code class="sourceCode cpp">Cat</code></span> is convertible to <span><code class="sourceCode cpp">strong_equality</code></span>, <span><code class="sourceCode cpp">T</code></span> models <span><code class="sourceCode cpp">equality_comparable_with</code></span> ([concept.equalitycomparable]).</del></span></li>
<li><span class="marginalizedparent"><a class="marginalized">(2.5)</a></span> <span class="rm" style="color: #bf0303"><del>If <span><code class="sourceCode cpp">Cat</code></span> is convertible to <span><code class="sourceCode cpp">partial_ordering</code></span>:</del></span> <span class="ednote" style="color: #0000ff">[ Editor&#39;s note: Make the following subbullets into normal bullets ]</span>
<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">totally_ordered</code> ([concept.totallyordered]).</li>
</ul>
<div>
<div class="sourceCode" id="cb10"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb10-1"><a href="#cb10-1"></a>template &lt;typename T, typename U,</span>
<span id="cb10-2"><a href="#cb10-2"></a>          typename Cat = partial_ordering&gt;</span>
<span id="cb10-3"><a href="#cb10-3"></a>  concept three_way_comparable_with = </span>
<span id="cb10-4"><a href="#cb10-4"></a>    <em>weakly-equality-comparable-with</em>&lt;T, U&gt; &amp;&amp;</span>
<span id="cb10-5"><a href="#cb10-5"></a><span class="st">-   (!convertible_to&lt;Cat, partial_ordering&gt; || <em>partially-ordered-with</em>&lt;T, U&gt;) &amp;&amp;</span></span>
<span id="cb10-6"><a href="#cb10-6"></a><span class="va">+   <em>partially-ordered-with</em>&lt;T, U&gt; &amp;&amp;</span></span>
<span id="cb10-7"><a href="#cb10-7"></a>    three_way_comparable&lt;T, Cat&gt; &amp;&amp;</span>
<span id="cb10-8"><a href="#cb10-8"></a>    three_way_comparable&lt;U, Cat&gt; &amp;&amp;</span>
<span id="cb10-9"><a href="#cb10-9"></a>    common_reference_with&lt;const remove_reference_t&lt;T&gt;&amp;, const remove_reference_t&lt;U&gt;&amp;&gt; &amp;&amp;</span>
<span id="cb10-10"><a href="#cb10-10"></a>    three_way_comparable&lt;</span>
<span id="cb10-11"><a href="#cb10-11"></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="cb10-12"><a href="#cb10-12"></a>      Cat&gt; &amp;&amp;</span>
<span id="cb10-13"><a href="#cb10-13"></a>    requires(const remove_reference_t&lt;T&gt;&amp; t,</span>
<span id="cb10-14"><a href="#cb10-14"></a>             const remove_reference_t&lt;U&gt;&amp; u) {</span>
<span id="cb10-15"><a href="#cb10-15"></a>      { t &lt;=&gt; u } -&gt; <em>compares-as</em>&lt;Cat&gt;;</span>
<span id="cb10-16"><a href="#cb10-16"></a>      { u &lt;=&gt; t } -&gt; <em>compares-as</em>&lt;Cat&gt;;</span>
<span id="cb10-17"><a href="#cb10-17"></a>    };</span></code></pre></div>
</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> <span class="rm" style="color: #bf0303"><del>If <span><code class="sourceCode cpp">Cat</code></span> is convertible to <span><code class="sourceCode cpp">strong_equality</code></span>, <span><code class="sourceCode cpp">T</code></span> and <span><code class="sourceCode cpp">U</code></span> model <span><code class="sourceCode cpp">equality_comparable_with<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code></span> ([concepts.equalitycomparable]).</del></span></li>
<li><span class="marginalizedparent"><a class="marginalized">(3.7)</a></span> <span class="rm" style="color: #bf0303"><del>If <span><code class="sourceCode cpp">Cat</code></span> is convertible to <span><code class="sourceCode cpp">partial_ordering</code></span>:</del></span> <span class="ednote" style="color: #0000ff">[ Editor&#39;s note: Make the following subbullets into normal bullets ]</span>
<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">totally_ordered_with<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code> ([concepts.totallyordered]).</li>
</ul>
</blockquote>
<p>Change the root comparison category in some of the iterator <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">&lt;=&gt;</span></code>s from <code class="sourceCode cpp">weak_equality</code> to <code class="sourceCode cpp">partial_ordering</code> (that is, just remove the provided argument) in 23.2 [iterator.synopsis]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb11"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb11-1"><a href="#cb11-1"></a>#include &lt;concepts&gt;</span>
<span id="cb11-2"><a href="#cb11-2"></a></span>
<span id="cb11-3"><a href="#cb11-3"></a>namespace std {</span>
<span id="cb11-4"><a href="#cb11-4"></a>  [...]</span>
<span id="cb11-5"><a href="#cb11-5"></a>  </span>
<span id="cb11-6"><a href="#cb11-6"></a><span class="st">- template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1<span class="diffdel">, weak_equality</span>&gt; Iterator2&gt;</span></span>
<span id="cb11-7"><a href="#cb11-7"></a><span class="va">+ template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1&gt; Iterator2&gt;</span></span>
<span id="cb11-8"><a href="#cb11-8"></a>    constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span>
<span id="cb11-9"><a href="#cb11-9"></a>      operator&lt;=&gt;(const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb11-10"><a href="#cb11-10"></a>                  const reverse_iterator&lt;Iterator2&gt;&amp; y);  </span>
<span id="cb11-11"><a href="#cb11-11"></a>                  </span>
<span id="cb11-12"><a href="#cb11-12"></a>  [...]</span>
<span id="cb11-13"><a href="#cb11-13"></a>                  </span>
<span id="cb11-14"><a href="#cb11-14"></a><span class="st">- template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1<span class="diffdel">, weak_equality</span>&gt; Iterator2&gt;</span></span>
<span id="cb11-15"><a href="#cb11-15"></a><span class="va">+ template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1&gt; Iterator2&gt;</span></span>
<span id="cb11-16"><a href="#cb11-16"></a>    constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span>
<span id="cb11-17"><a href="#cb11-17"></a>      operator&lt;=&gt;(const move_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb11-18"><a href="#cb11-18"></a>                  const move_iterator&lt;Iterator2&gt;&amp; y);</span>
<span id="cb11-19"><a href="#cb11-19"></a>                  </span>
<span id="cb11-20"><a href="#cb11-20"></a>  [...]</span>
<span id="cb11-21"><a href="#cb11-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>And the same in 23.5.1.7 [reverse.iter.cmp]:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb12"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb12-1"><a href="#cb12-1"></a><span class="st">- template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1<span class="diffdel">, weak_equality</span>&gt; Iterator2&gt;</span></span>
<span id="cb12-2"><a href="#cb12-2"></a><span class="va">+ template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1&gt; Iterator2&gt;</span></span>
<span id="cb12-3"><a href="#cb12-3"></a>    constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span>
<span id="cb12-4"><a href="#cb12-4"></a>      operator&lt;=&gt;(const reverse_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb12-5"><a href="#cb12-5"></a>                  const reverse_iterator&lt;Iterator2&gt;&amp; y);    </span></code></pre></div>
</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>
</blockquote>
<p>And the same in 23.5.3.7 [move.iter.pop.cmp]:</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><span class="st">- template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1<span class="diffdel">, weak_equality</span>&gt; Iterator2&gt;</span></span>
<span id="cb13-2"><a href="#cb13-2"></a><span class="va">+ template&lt;class Iterator1, three_way_comparable_with&lt;Iterator1&gt; Iterator2&gt;</span></span>
<span id="cb13-3"><a href="#cb13-3"></a>    constexpr compare_three_way_result_t&lt;Iterator1, Iterator2&gt;</span>
<span id="cb13-4"><a href="#cb13-4"></a>      operator&lt;=&gt;(const move_iterator&lt;Iterator1&gt;&amp; x,</span>
<span id="cb13-5"><a href="#cb13-5"></a>                  const move_iterator&lt;Iterator2&gt;&amp; y);</span></code></pre></div>
</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>
</blockquote>
<h1 id="references" style="border-bottom:1px solid #cccccc"><span class="header-section-number">3</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>
</div>
</div>
</body>
</html>
