<!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="2021-04-11" />
  <title>zip</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%;}
      div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
      ul.task-list{list-style: none;}
      pre > code.sourceCode { white-space: pre; position: relative; }
      pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
      pre > code.sourceCode > span:empty { height: 1.2em; }
      code.sourceCode > span { color: inherit; text-decoration: inherit; }
      div.sourceCode { margin: 1em 0; }
      pre.sourceCode { margin: 0; }
      @media screen {
      div.sourceCode { overflow: auto; }
      }
      @media print {
      pre > code.sourceCode { white-space: pre-wrap; }
      pre > 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 {
      pre > 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; }
</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, div.add blockquote { 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); }
blockquote { background-color: #f6f8fa; }
</style>
  <link href="data:image/x-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"><code class="sourceCode cpp">zip</code></h1>

<table style="border:none;float:right">
  <tr>
    <td>Document #:</td>
    <td>P2321R1</td>
  </tr>
  <tr>
    <td>Date:</td>
    <td>2021-04-11</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project:</td>
    <td>Programming Language C++</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Audience:</td>
    <td>
      LEWG<br>
      LWG<br>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to:</td>
    <td>
      Tim Song<br>&lt;<a href="mailto:t.canens.cpp@gmail.com" class="email">t.canens.cpp@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="#abstract"><span class="toc-section-number">1</span> Abstract<span></span></a></li>
<li><a href="#revision-history"><span class="toc-section-number">2</span> Revision history<span></span></a></li>
<li><a href="#examples"><span class="toc-section-number">3</span> Examples<span></span></a></li>
<li><a href="#discussion"><span class="toc-section-number">4</span> Discussion<span></span></a>
<ul>
<li><a href="#proxy-reference-changes"><span class="toc-section-number">4.1</span> Proxy reference changes<span></span></a></li>
<li><a href="#zip-and-zip_transform"><span class="toc-section-number">4.2</span> <code class="sourceCode cpp">zip</code> and <code class="sourceCode cpp">zip_transform</code><span></span></a>
<ul>
<li><a href="#no-common-exposition-only-base-view"><span class="toc-section-number">4.2.1</span> No common exposition-only base view<span></span></a></li>
<li><a href="#tuple-or-pair"><span class="toc-section-number">4.2.2</span> <code class="sourceCode cpp">tuple</code> or <code class="sourceCode cpp">pair</code>?<span></span></a></li>
<li><a href="#zipping-nothing"><span class="toc-section-number">4.2.3</span> Zipping nothing?<span></span></a></li>
<li><a href="#when-is-zip_view-a-common_range"><span class="toc-section-number">4.2.4</span> When is <code class="sourceCode cpp">zip_view</code> a <code class="sourceCode cpp">common_range</code>?<span></span></a></li>
</ul></li>
<li><a href="#adjacent-and-adjacent_transform"><span class="toc-section-number">4.3</span> <code class="sourceCode cpp">adjacent</code> and <code class="sourceCode cpp">adjacent_transform</code><span></span></a>
<ul>
<li><a href="#naming"><span class="toc-section-number">4.3.1</span> Naming<span></span></a></li>
<li><a href="#value-type"><span class="toc-section-number">4.3.2</span> Value type<span></span></a></li>
<li><a href="#common_range"><span class="toc-section-number">4.3.3</span> <code class="sourceCode cpp">common_range</code><span></span></a></li>
<li><a href="#no-input-ranges"><span class="toc-section-number">4.3.4</span> No input ranges<span></span></a></li>
<li><a href="#iter_swap"><span class="toc-section-number">4.3.5</span> <code class="sourceCode cpp">iter_swap</code><span></span></a></li>
</ul></li>
</ul></li>
<li><a href="#wording"><span class="toc-section-number">5</span> Wording<span></span></a>
<ul>
<li><a href="#tuple"><span class="toc-section-number">5.1</span> <code class="sourceCode cpp">tuple</code><span></span></a></li>
<li><a href="#pair"><span class="toc-section-number">5.2</span> <code class="sourceCode cpp">pair</code><span></span></a></li>
<li><a href="#vectorboolreference"><span class="toc-section-number">5.3</span> <code class="sourceCode cpp">vector<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;::</span>reference</code><span></span></a></li>
<li><a href="#addition-to-ranges"><span class="toc-section-number">5.4</span> Addition to <code class="sourceCode cpp"><span class="op">&lt;</span>ranges<span class="op">&gt;</span></code><span></span></a></li>
<li><a href="#zip"><span class="toc-section-number">5.5</span> <code class="sourceCode cpp">zip</code><span></span></a>
<ul>
<li><a href="#zip-view-range.zip">24.7.? Zip view [range.zip]<span></span></a></li>
</ul></li>
<li><a href="#zip_transform"><span class="toc-section-number">5.6</span> <code class="sourceCode cpp">zip_transform</code><span></span></a>
<ul>
<li><a href="#zip-transform-view-range.zip.transform">24.7.? Zip transform view [range.zip.transform]<span></span></a></li>
</ul></li>
<li><a href="#adjacent"><span class="toc-section-number">5.7</span> <code class="sourceCode cpp">adjacent</code><span></span></a>
<ul>
<li><a href="#adjacent-view-range.adjacent">24.7.? Adjacent view [range.adjacent]<span></span></a></li>
</ul></li>
<li><a href="#adjacent_transform"><span class="toc-section-number">5.8</span> <code class="sourceCode cpp">adjacent_transform</code><span></span></a>
<ul>
<li><a href="#adjacent-transform-view-range.adjacent.transform">24.7.? Adjacent transform view [range.adjacent.transform]<span></span></a></li>
</ul></li>
<li><a href="#feature-test-macro"><span class="toc-section-number">5.9</span> Feature-test macro<span></span></a></li>
</ul></li>
<li><a href="#acknowledgements"><span class="toc-section-number">6</span> Acknowledgements<span></span></a></li>
<li><a href="#bibliography"><span class="toc-section-number">7</span> References<span></span></a></li>
</ul>
</div>
<h1 data-number="1" style="border-bottom:1px solid #cccccc" id="abstract"><span class="header-section-number">1</span> Abstract<a href="#abstract" class="self-link"></a></h1>
<p>This paper proposes</p>
<ul>
<li>four views, <code class="sourceCode cpp">zip</code>, <code class="sourceCode cpp">zip_transform</code>, <code class="sourceCode cpp">adjacent</code>, and <code class="sourceCode cpp">adjacent_transform</code>,</li>
<li>changes to <code class="sourceCode cpp">tuple</code> and <code class="sourceCode cpp">pair</code> necessary to make them usable as proxy references (necessary for <code class="sourceCode cpp">zip</code> and <code class="sourceCode cpp">adjacent</code>), and</li>
<li>changes to <code class="sourceCode cpp">vector<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;::</span>reference</code> to make it usable as a proxy reference for writing,</li>
</ul>
<p>all as described in section 3.2 of <span class="citation" data-cites="P2214R0">[<a href="#ref-P2214R0" role="doc-biblioref">P2214R0</a>]</span>.</p>
<h1 data-number="2" style="border-bottom:1px solid #cccccc" id="revision-history"><span class="header-section-number">2</span> Revision history<a href="#revision-history" class="self-link"></a></h1>
<ul>
<li>R1: Added feature test macro. Expanded discussion regarding 1) <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">==</span></code> for forward-or-weaker <code class="sourceCode cpp">zip</code> iterators and 2) <code class="sourceCode cpp">adjacent</code> on input ranges. Miscellaneous wording fixes (thanks to Barry Revzin and Tomasz Kamiński). Added a short example.</li>
</ul>
<h1 data-number="3" style="border-bottom:1px solid #cccccc" id="examples"><span class="header-section-number">3</span> Examples<a href="#examples" class="self-link"></a></h1>
<div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1"></a>std<span class="op">::</span>vector v1 <span class="op">=</span> <span class="op">{</span><span class="dv">1</span>, <span class="dv">2</span><span class="op">}</span>;</span>
<span id="cb1-2"><a href="#cb1-2"></a>std<span class="op">::</span>vector v2 <span class="op">=</span> <span class="op">{</span><span class="ch">&#39;a&#39;</span>, <span class="ch">&#39;b&#39;</span>, <span class="ch">&#39;c&#39;</span><span class="op">}</span>;</span>
<span id="cb1-3"><a href="#cb1-3"></a>std<span class="op">::</span>vector v3 <span class="op">=</span> <span class="op">{</span><span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span><span class="op">}</span>;</span>
<span id="cb1-4"><a href="#cb1-4"></a></span>
<span id="cb1-5"><a href="#cb1-5"></a>fmt<span class="op">::</span>print<span class="op">(</span><span class="st">&quot;{}</span><span class="sc">\n</span><span class="st">&quot;</span>, std<span class="op">::</span>views<span class="op">::</span>zip<span class="op">(</span>v1, v2<span class="op">))</span>;                               <span class="co">// {(1, &#39;a&#39;), (2, &#39;b&#39;)}</span></span>
<span id="cb1-6"><a href="#cb1-6"></a>fmt<span class="op">::</span>print<span class="op">(</span><span class="st">&quot;{}</span><span class="sc">\n</span><span class="st">&quot;</span>, std<span class="op">::</span>views<span class="op">::</span>zip_transform<span class="op">(</span>std<span class="op">::</span>multiplies<span class="op">()</span>, v1, v3<span class="op">))</span>;  <span class="co">// {3, 8}</span></span>
<span id="cb1-7"><a href="#cb1-7"></a>fmt<span class="op">::</span>print<span class="op">(</span><span class="st">&quot;{}</span><span class="sc">\n</span><span class="st">&quot;</span>, v2 <span class="op">|</span> std<span class="op">::</span>views<span class="op">::</span>pairwise<span class="op">)</span>;                             <span class="co">// {(&#39;a&#39;, &#39;b&#39;), (&#39;b&#39;, &#39;c&#39;)}</span></span>
<span id="cb1-8"><a href="#cb1-8"></a>fmt<span class="op">::</span>print<span class="op">(</span><span class="st">&quot;{}</span><span class="sc">\n</span><span class="st">&quot;</span>, v3 <span class="op">|</span> std<span class="op">::</span>views<span class="op">::</span>pairwise_transform<span class="op">(</span>std<span class="op">::</span>plus<span class="op">()))</span>;      <span class="co">// {7, 9}</span></span></code></pre></div>
<h1 data-number="4" style="border-bottom:1px solid #cccccc" id="discussion"><span class="header-section-number">4</span> Discussion<a href="#discussion" class="self-link"></a></h1>
<p>The proposed wording below generally follows the design described in section 3.2 of <span class="citation" data-cites="P2214R0">[<a href="#ref-P2214R0" role="doc-biblioref">P2214R0</a>]</span>, and the discussion in this paper assumes familiarity with that paper. This section focuses on deviations from and additions to that paper, as well as certain details in the design of the views that should be called out.</p>
<h2 data-number="4.1" id="proxy-reference-changes"><span class="header-section-number">4.1</span> Proxy reference changes<a href="#proxy-reference-changes" class="self-link"></a></h2>
<p>The basic rationale for changes to <code class="sourceCode cpp">tuple</code> and <code class="sourceCode cpp">pair</code> are described in exhaustive detail in <span class="citation" data-cites="P2214R0">[<a href="#ref-P2214R0" role="doc-biblioref">P2214R0</a>]</span> sections 3.2.1 and 3.2.2 and will not be repeated here. Several additions are worth noting:</p>
<ul>
<li><p><code class="sourceCode cpp">common_type</code> and <code class="sourceCode cpp">basic_common_reference</code> specializations are added for <code class="sourceCode cpp">tuple</code> and <code class="sourceCode cpp">pair</code>. These are also required for <code class="sourceCode cpp">tuple</code> and <code class="sourceCode cpp">pair</code> to be usable as proxy references.</p></li>
<li><p><code class="sourceCode cpp">swap</code> for <code class="sourceCode cpp"><span class="kw">const</span> tuple</code> and <code class="sourceCode cpp"><span class="kw">const</span> pair</code>. Once tuples of references are made const-assignable, the default <code class="sourceCode cpp">std<span class="op">::</span>swap</code> can be called for const tuples of references. However, that triple-move <code class="sourceCode cpp">swap</code> does the wrong thing:</p>
<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">int</span> i <span class="op">=</span> <span class="dv">1</span>, j <span class="op">=</span> <span class="dv">2</span>;</span>
<span id="cb2-2"><a href="#cb2-2"></a>  <span class="kw">const</span> <span class="kw">auto</span> t1 <span class="op">=</span> std<span class="op">::</span>tie<span class="op">(</span>i<span class="op">)</span>, t2 <span class="op">=</span> std<span class="op">::</span>tie<span class="op">(</span>j<span class="op">)</span>;</span>
<span id="cb2-3"><a href="#cb2-3"></a></span>
<span id="cb2-4"><a href="#cb2-4"></a>  <span class="co">// If std::swap(t1, t2); called the default triple-move std::swap then</span></span>
<span id="cb2-5"><a href="#cb2-5"></a>  <span class="co">// this would do</span></span>
<span id="cb2-6"><a href="#cb2-6"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> std<span class="op">::</span>move<span class="op">(</span>t1<span class="op">)</span>;</span>
<span id="cb2-7"><a href="#cb2-7"></a>  t1 <span class="op">=</span> std<span class="op">::</span>move<span class="op">(</span>t2<span class="op">)</span>;</span>
<span id="cb2-8"><a href="#cb2-8"></a>  t2 <span class="op">=</span> std<span class="op">::</span>move<span class="op">(</span>tmp<span class="op">)</span>;</span>
<span id="cb2-9"><a href="#cb2-9"></a></span>
<span id="cb2-10"><a href="#cb2-10"></a>  <span class="co">// i == 2, j == 2</span></span></code></pre></div>
<p>This paper therefore proposes adding overloads of <code class="sourceCode cpp">swap</code> for <code class="sourceCode cpp"><span class="kw">const</span></code> tuples and pairs to correctly perform element-wise swap.</p></li>
<li><p>Consistent with the scoped allocator protocol, allocator-extended constructors that correspond to the new <code class="sourceCode cpp">tuple</code> constructors have been added to <code class="sourceCode cpp">tuple</code>, and new overloads of <code class="sourceCode cpp">uses_allocator_construction_args</code> corresponding to the new <code class="sourceCode cpp">pair</code> constructors have been added as well.</p></li>
</ul>
<h2 data-number="4.2" id="zip-and-zip_transform"><span class="header-section-number">4.2</span> <code class="sourceCode cpp">zip</code> and <code class="sourceCode cpp">zip_transform</code><a href="#zip-and-zip_transform" class="self-link"></a></h2>
<h3 data-number="4.2.1" id="no-common-exposition-only-base-view"><span class="header-section-number">4.2.1</span> No common exposition-only base view<a href="#no-common-exposition-only-base-view" class="self-link"></a></h3>
<p><span class="citation" data-cites="P2214R0">[<a href="#ref-P2214R0" role="doc-biblioref">P2214R0</a>]</span> proposes implementing <code class="sourceCode cpp">zip</code> and <code class="sourceCode cpp">zip_transform</code> to produce specializations of an exposition-only <em><code class="sourceCode cpp">iter<span class="op">-</span>zip<span class="op">-</span>transform<span class="op">-</span>view</code></em>, which is roughly how they are implemented in range-v3. In the process of writing wording for these views, however, it has become apparent that the two views have enough differences that a common underlying view would need to have additional knobs to control the behavior (beyond the <code class="sourceCode cpp">value_type</code> issue already noted in the paper). The extra complexity required would likely negate any potential benefit from having a single underlying view.</p>
<p>Instead, the wording below specifies <code class="sourceCode cpp">zip_transform</code> largely in terms of <code class="sourceCode cpp">zip</code>. This significantly reduces specification duplication without sacrificing efficiency.</p>
<h3 data-number="4.2.2" id="tuple-or-pair"><span class="header-section-number">4.2.2</span> <code class="sourceCode cpp">tuple</code> or <code class="sourceCode cpp">pair</code>?<a href="#tuple-or-pair" class="self-link"></a></h3>
<p>In range-v3, zipping two views produced a range of <code class="sourceCode cpp">pair</code>s, while zipping any other number of ranges produce a range of <code class="sourceCode cpp">tuple</code>s. This paper maintains that design for several reasons:</p>
<ul>
<li>Since <code class="sourceCode cpp">pair</code> is tuple-like, most common uses of the result (<code class="sourceCode cpp">get</code>, <code class="sourceCode cpp">apply</code>, structured bindings, etc.) would work just as well.</li>
<li>Certain parts of the standard library, notably <code class="sourceCode cpp">map</code> and friends, are dependent on <code class="sourceCode cpp">pair</code>.</li>
<li><code class="sourceCode cpp">pair</code> implicitly converts to <code class="sourceCode cpp">tuple</code> if one is really needed, whereas constructing a <code class="sourceCode cpp">pair</code> from a <code class="sourceCode cpp">tuple</code> is more difficult.</li>
</ul>
<h3 data-number="4.2.3" id="zipping-nothing"><span class="header-section-number">4.2.3</span> Zipping nothing?<a href="#zipping-nothing" class="self-link"></a></h3>
<p>As in range-v3, zipping nothing produces an <code class="sourceCode cpp">empty_view</code> of the appropriate type.</p>
<h3 data-number="4.2.4" id="when-is-zip_view-a-common_range"><span class="header-section-number">4.2.4</span> When is <code class="sourceCode cpp">zip_view</code> a <code class="sourceCode cpp">common_range</code>?<a href="#when-is-zip_view-a-common_range" class="self-link"></a></h3>
<p>A <code class="sourceCode cpp">common_range</code> is a range whose iterator and sentinel types are the same.</p>
<p>Obviously, when zipping a single range, the <code class="sourceCode cpp">zip_view</code> can be a <code class="sourceCode cpp">common_range</code> if the underlying range is.</p>
<p>When the <code class="sourceCode cpp">zip_view</code> is not bidirectional, it can be a <code class="sourceCode cpp">common_range</code> when every underlying view is a <code class="sourceCode cpp">common_range</code>. To handle differently-sized ranges, iterator <code class="sourceCode cpp"><span class="op">==</span></code> is a logical OR: two iterators compare equal if one of the sub-iterators compare equal. Note that the domain of <code class="sourceCode cpp"><span class="op">==</span></code> only extends to iterators over the same underlying sequence; the use of logical OR is valid within that domain because the only valid operands to <code class="sourceCode cpp"><span class="op">==</span></code> are iterators obtained from incrementing <code class="sourceCode cpp">begin<span class="op">()</span></code> zero or more times and the iterator returned by <code class="sourceCode cpp">end<span class="op">()</span></code>.</p>
<p>When the <code class="sourceCode cpp">zip_view</code> is bidirectional (or stronger), however, it is now possible to iterate backwards from the end iterator (if it is indeed an iterator). As a result, we cannot simply construct the end iterator out of the end iterators of the views: if the views are different in size, iterating backwards from the end will give us elements that are not in the view at all (see <span class="citation" data-cites="range-v3.1592">[<a href="#ref-range-v3.1592" role="doc-biblioref">range-v3.1592</a>]</span>). Instead, we need to produce a “proper” end iterator by advancing from <code class="sourceCode cpp">begin</code>; to be able compute <code class="sourceCode cpp">end</code> in constant time, we need all views to be random access and sized.</p>
<p>As <code class="sourceCode cpp">end</code> is only required to be amortized constant time, it is in theory possible to do a linear time traversal and cache the result. The additional benefit from such a design appears remote, and it has significant costs.</p>
<h4 data-number="4.2.4.1" id="does-that-mean-viewsenumeratea_std_list-isnt-a-common_range"><span class="header-section-number">4.2.4.1</span> Does that mean <code class="sourceCode cpp">views<span class="op">::</span>enumerate<span class="op">(</span>a_std_list<span class="op">)</span></code> isn’t a <code class="sourceCode cpp">common_range</code>?<a href="#does-that-mean-viewsenumeratea_std_list-isnt-a-common_range" class="self-link"></a></h4>
<p>It’s still an open question whether <code class="sourceCode cpp">enumerate</code> should be implemented in terms of <code class="sourceCode cpp">zip_view</code> or not. If it is specified in terms of <code class="sourceCode cpp">zip_view</code> (and produces a <code class="sourceCode cpp">pair</code>), as proposed in <span class="citation" data-cites="P2214R0">[<a href="#ref-P2214R0" role="doc-biblioref">P2214R0</a>]</span>, it is easy to specify an separate <code class="sourceCode cpp">enumerate_view</code> that is implemented with <code class="sourceCode cpp">zip_view</code> but still produces a common range for this case.</p>
<h4 data-number="4.2.4.2" id="what-about-infinite-ranges-in-general"><span class="header-section-number">4.2.4.2</span> What about infinite ranges in general?<a href="#what-about-infinite-ranges-in-general" class="self-link"></a></h4>
<p>If <code class="sourceCode cpp">zip_view</code> can recognize when a range is infinite, then it is theoretically possible for it to be a <code class="sourceCode cpp">common_range</code> in the following two cases:</p>
<ul>
<li>Every range but one is an infinite random-access range, while the one finite range is a sized and common range (of any iterator strength). This is the general case of <code class="sourceCode cpp">enumerate</code> above.</li>
<li>Every range is either random-access and sized, or random-access and infinite, and at least one range is sized.</li>
</ul>
<p>The standard, however, generally does not recognize infinite ranges (despite providing <code class="sourceCode cpp">unreachable_sentinel</code>). It goes without saying that a complete design for infinite ranges support is outside the scope of this paper.</p>
<h2 data-number="4.3" id="adjacent-and-adjacent_transform"><span class="header-section-number">4.3</span> <code class="sourceCode cpp">adjacent</code> and <code class="sourceCode cpp">adjacent_transform</code><a href="#adjacent-and-adjacent_transform" class="self-link"></a></h2>
<p>As <code class="sourceCode cpp">adjacent</code> is a specialized version of <code class="sourceCode cpp">zip</code>, most of the discussion in above applies, <em>mutatis mutandis</em>, to <code class="sourceCode cpp">adjacent</code> as well, and will not be repeated here.</p>
<h3 data-number="4.3.1" id="naming"><span class="header-section-number">4.3.1</span> Naming<a href="#naming" class="self-link"></a></h3>
<p>The wording below tentatively uses <code class="sourceCode cpp">adjacent</code> for the general functionality, and <code class="sourceCode cpp">pairwise</code> for the <code class="sourceCode cpp">N <span class="op">==</span> <span class="dv">2</span></code> case. <span class="citation" data-cites="P2214R0">[<a href="#ref-P2214R0" role="doc-biblioref">P2214R0</a>]</span> section 3.2.5 suggests an alternative (<code class="sourceCode cpp">slide_as_tuple</code> for the general functionality and <code class="sourceCode cpp">adjacent</code> for the <code class="sourceCode cpp">N <span class="op">==</span> <span class="dv">2</span></code> case). The author has a mild preference for the current names due to the somewhat unwieldiness of the name <code class="sourceCode cpp">slide_as_tuple</code>.</p>
<h3 data-number="4.3.2" id="value-type"><span class="header-section-number">4.3.2</span> Value type<a href="#value-type" class="self-link"></a></h3>
<p>The value type of <code class="sourceCode cpp">adjacent_view</code> is a homogeneous <code class="sourceCode cpp">tuple</code> or <code class="sourceCode cpp">pair</code>. Since <code class="sourceCode cpp">array</code> cannot hold references and is defined to be an aggregate, using it as the value type poses significant usability issues (even if we somehow get the <code class="sourceCode cpp">common_reference_with</code> requirements in <code class="sourceCode cpp">indirectly_readable</code> to work with even more <code class="sourceCode cpp">tuple</code>/<code class="sourceCode cpp">pair</code> changes).</p>
<h3 data-number="4.3.3" id="common_range"><span class="header-section-number">4.3.3</span> <code class="sourceCode cpp">common_range</code><a href="#common_range" class="self-link"></a></h3>
<p>One notable difference from <code class="sourceCode cpp">zip</code> is that since <code class="sourceCode cpp">adjacent</code> comes from a single underlying view, it can be a <code class="sourceCode cpp">common_range</code> whenever its underlying view is.</p>
<h3 data-number="4.3.4" id="no-input-ranges"><span class="header-section-number">4.3.4</span> No input ranges<a href="#no-input-ranges" class="self-link"></a></h3>
<p>Because <code class="sourceCode cpp">adjacent</code> by definition holds multiple iterators to the same view, it requires forward ranges. It is true that the <code class="sourceCode cpp">N <span class="op">==</span> <span class="dv">1</span></code> case could theoretically support input ranges, but that adds extra complexity and seems entirely pointless. Besides, someone desperate to wrap their input range in a single element <code class="sourceCode cpp">tuple</code> can just use <code class="sourceCode cpp">zip</code> instead.</p>
<p>During LEWG review of R0 of this paper it was suggested that <code class="sourceCode cpp">adjacent<span class="op">&lt;</span>N<span class="op">&gt;</span></code> could support input views by caching the elements referred to by the last <code class="sourceCode cpp">N</code> iterators. Such a view would have significant differences from what is being proposed in this paper. For instance, because the reference obtained from an input iterator is invalidated on increment, the range will have to cache by value type, and so the reference type will have to be something like <code class="sourceCode cpp">tuple<span class="op">&lt;</span>range_value_t<span class="op">&lt;</span>V<span class="op">&gt;&amp;...&gt;</span></code> (or perhaps even <code class="sourceCode cpp">tuple<span class="op">&lt;</span>range_value_t<span class="op">&lt;</span>V<span class="op">&gt;...&gt;&amp;</span></code>?) instead of <code class="sourceCode cpp">tuple<span class="op">&lt;</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;...&gt;</span></code>. To be able to construct and update the cached values, the view would have to require underlying range’s value type to be constructible and assignable from its reference type. And because we don’t know what elements the user may desire to access, iterating through the view necessarily requires copying every element of the underlying view into the cache, which can be wasteful if not all elements need to be accessed. By comparison, iterating through the proposed <code class="sourceCode cpp">adjacent</code> copies exactly zero of the underlying range’s elements.</p>
<p>Additionally, because input views provide much fewer operations and guarantees, they can often be implemented more efficiently than forward views. There has been an open range-v3 issue <span class="citation" data-cites="range-v3.704">[<a href="#ref-range-v3.704" role="doc-biblioref">range-v3.704</a>]</span> since 2017 (see also <a href="https://old.reddit.com/r/cpp/comments/8ytrnb/what_i_dont_like_about_ranges/e82rk5a/">this comment</a> from Eric Niebler on /r/cpp) to provide an API that downgrades a forward-or-stronger range to input for efficiency when the forward range’s guarantees are not needed. Having a view adaptor that is significantly more expensive when given an input range would significantly damage the usability and teachability of such a design.</p>
<p>The author believes that the behavioral and performance characteristics of such a view is different enough from the <code class="sourceCode cpp">adjacent</code> proposed in this paper that it would be inappropriate to put them under the same name. It can be proposed separately if desired.</p>
<h3 data-number="4.3.5" id="iter_swap"><span class="header-section-number">4.3.5</span> <code class="sourceCode cpp">iter_swap</code><a href="#iter_swap" class="self-link"></a></h3>
<p>Since the iterators of <code class="sourceCode cpp">adjacent_view</code> refer to potentially overlapping elements of the underlying view, <code class="sourceCode cpp">iter_swap</code> cannot really “exchange the values” of the range elements when the iterators overlap. However, it does not appear to be possible to disable <code class="sourceCode cpp">ranges<span class="op">::</span>iter_swap</code> (deleting or not providing <code class="sourceCode cpp">iter_swap</code> will simply fallback to the default implementation), and swapping non-overlapping iterators is still useful functionality. Thus, the wording below retains <code class="sourceCode cpp">iter_swap</code> but gives it a precondition that there is no overlap.</p>
<h1 data-number="5" style="border-bottom:1px solid #cccccc" id="wording"><span class="header-section-number">5</span> Wording<a href="#wording" class="self-link"></a></h1>
<p>This wording is relative to <span class="citation" data-cites="N4878">[<a href="#ref-N4878" role="doc-biblioref">N4878</a>]</span>.</p>
<h2 data-number="5.1" id="tuple"><span class="header-section-number">5.1</span> <code class="sourceCode cpp">tuple</code><a href="#tuple" class="self-link"></a></h2>
<div>
<ol type="1">
<li>Edit <span>20.5.2 <a href="https://wg21.link/tuple.syn">[tuple.syn]</a></span>, header <code class="sourceCode cpp"><span class="op">&lt;</span>tuple<span class="op">&gt;</span></code> synopsis, as indicated:</li>
</ol>
<blockquote>
<div>
<div class="sourceCode" id="cb3"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb3-1"><a href="#cb3-1"></a></span>
<span id="cb3-2"><a href="#cb3-2"></a> #include &lt;compare&gt;              // see [compare.syn]</span>
<span id="cb3-3"><a href="#cb3-3"></a></span>
<span id="cb3-4"><a href="#cb3-4"></a> namespace std {</span>
<span id="cb3-5"><a href="#cb3-5"></a>   // [tuple.tuple], class template tuple</span>
<span id="cb3-6"><a href="#cb3-6"></a>   template&lt;class... Types&gt;</span>
<span id="cb3-7"><a href="#cb3-7"></a>     class tuple;</span>
<span id="cb3-8"><a href="#cb3-8"></a></span>
<span id="cb3-9"><a href="#cb3-9"></a><span class="va">+  template&lt;class... TTypes, class... UTypes, template&lt;class&gt; class TQual, template&lt;class&gt; class UQual&gt;</span></span>
<span id="cb3-10"><a href="#cb3-10"></a><span class="va">+    requires requires { typename tuple&lt;common_reference_t&lt;TQual&lt;TTypes&gt;, UQual&lt;UTypes&gt;&gt;...&gt;; }</span></span>
<span id="cb3-11"><a href="#cb3-11"></a><span class="va">+  struct basic_common_reference&lt;tuple&lt;TTypes...&gt;, tuple&lt;UTypes...&gt;, TQual, UQual&gt; {</span></span>
<span id="cb3-12"><a href="#cb3-12"></a><span class="va">+    using type = tuple&lt;common_reference_t&lt;TQual&lt;TTypes&gt;, UQual&lt;UTypes&gt;&gt;...&gt;;</span></span>
<span id="cb3-13"><a href="#cb3-13"></a><span class="va">+  };</span></span>
<span id="cb3-14"><a href="#cb3-14"></a><span class="va">+</span></span>
<span id="cb3-15"><a href="#cb3-15"></a><span class="va">+  template&lt;class... TTypes, class... UTypes&gt;</span></span>
<span id="cb3-16"><a href="#cb3-16"></a><span class="va">+    requires requires { typename tuple&lt;common_type_t&lt;TTypes, UTypes&gt;...&gt;; }</span></span>
<span id="cb3-17"><a href="#cb3-17"></a><span class="va">+  struct common_type&lt;tuple&lt;TTypes...&gt;, tuple&lt;UTypes...&gt;&gt; {</span></span>
<span id="cb3-18"><a href="#cb3-18"></a><span class="va">+    using type = tuple&lt;common_type_t&lt;TTypes, UTypes&gt;...&gt;;</span></span>
<span id="cb3-19"><a href="#cb3-19"></a><span class="va">+  };</span></span>
<span id="cb3-20"><a href="#cb3-20"></a></span>
<span id="cb3-21"><a href="#cb3-21"></a></span>
<span id="cb3-22"><a href="#cb3-22"></a>   // [...]</span>
<span id="cb3-23"><a href="#cb3-23"></a></span>
<span id="cb3-24"><a href="#cb3-24"></a>   // [tuple.special], specialized algorithms</span>
<span id="cb3-25"><a href="#cb3-25"></a>   template&lt;class... Types&gt;</span>
<span id="cb3-26"><a href="#cb3-26"></a>     constexpr void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y) noexcept(<em>see below</em>);</span>
<span id="cb3-27"><a href="#cb3-27"></a><span class="va">+  template&lt;class... Types&gt;</span></span>
<span id="cb3-28"><a href="#cb3-28"></a><span class="va">+    constexpr void swap(const tuple&lt;Types...&gt;&amp; x, const tuple&lt;Types...&gt;&amp; y) noexcept(<em>see below</em>);</span></span>
<span id="cb3-29"><a href="#cb3-29"></a> }</span></code></pre></div>
</div>
</blockquote>
<ol start="2" type="1">
<li>Edit <span>20.5.3 <a href="https://wg21.link/tuple.tuple">[tuple.tuple]</a></span>, class template <code class="sourceCode cpp">tuple</code> synopsis, as indicated:</li>
</ol>
<blockquote>
<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>   template&lt;class... Types&gt;</span>
<span id="cb4-3"><a href="#cb4-3"></a>   class tuple {</span>
<span id="cb4-4"><a href="#cb4-4"></a>   public:</span>
<span id="cb4-5"><a href="#cb4-5"></a>     // [tuple.cnstr], tuple construction</span>
<span id="cb4-6"><a href="#cb4-6"></a>     constexpr explicit(<em>see below</em>) tuple();</span>
<span id="cb4-7"><a href="#cb4-7"></a>     constexpr explicit(<em>see below</em>) tuple(const Types&amp;...);         // only if sizeof...(Types) &gt;= 1</span>
<span id="cb4-8"><a href="#cb4-8"></a>     template&lt;class... UTypes&gt;</span>
<span id="cb4-9"><a href="#cb4-9"></a>       constexpr explicit(<em>see below</em>) tuple(UTypes&amp;&amp;...);           // only if sizeof...(Types) &gt;= 1</span>
<span id="cb4-10"><a href="#cb4-10"></a></span>
<span id="cb4-11"><a href="#cb4-11"></a>     tuple(const tuple&amp;) = default;</span>
<span id="cb4-12"><a href="#cb4-12"></a>     tuple(tuple&amp;&amp;) = default;</span>
<span id="cb4-13"><a href="#cb4-13"></a></span>
<span id="cb4-14"><a href="#cb4-14"></a><span class="va">+    template&lt;class... UTypes&gt;</span></span>
<span id="cb4-15"><a href="#cb4-15"></a><span class="va">+      constexpr explicit(<em>see below</em>) tuple(tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb4-16"><a href="#cb4-16"></a>     template&lt;class... UTypes&gt;</span>
<span id="cb4-17"><a href="#cb4-17"></a>       constexpr explicit(<em>see below</em>) tuple(const tuple&lt;UTypes...&gt;&amp;);</span>
<span id="cb4-18"><a href="#cb4-18"></a>     template&lt;class... UTypes&gt;</span>
<span id="cb4-19"><a href="#cb4-19"></a>       constexpr explicit(<em>see below</em>) tuple(tuple&lt;UTypes...&gt;&amp;&amp;);</span>
<span id="cb4-20"><a href="#cb4-20"></a><span class="va">+    template&lt;class... UTypes&gt;</span></span>
<span id="cb4-21"><a href="#cb4-21"></a><span class="va">+      constexpr explicit(<em>see below</em>) tuple(const tuple&lt;UTypes...&gt;&amp;&amp;);</span></span>
<span id="cb4-22"><a href="#cb4-22"></a></span>
<span id="cb4-23"><a href="#cb4-23"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb4-24"><a href="#cb4-24"></a><span class="va">+      constexpr explicit(<em>see below</em>) tuple(pair&lt;U1, U2&gt;&amp;);         // only if sizeof...(Types) == 2</span></span>
<span id="cb4-25"><a href="#cb4-25"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb4-26"><a href="#cb4-26"></a>       constexpr explicit(<em>see below</em>) tuple(const pair&lt;U1, U2&gt;&amp;);   // only if sizeof...(Types) == 2</span>
<span id="cb4-27"><a href="#cb4-27"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb4-28"><a href="#cb4-28"></a>       constexpr explicit(<em>see below</em>) tuple(pair&lt;U1, U2&gt;&amp;&amp;);        // only if sizeof...(Types) == 2</span>
<span id="cb4-29"><a href="#cb4-29"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb4-30"><a href="#cb4-30"></a><span class="va">+      constexpr explicit(<em>see below</em>) tuple(const pair&lt;U1, U2&gt;&amp;&amp;);  // only if sizeof...(Types) == 2</span></span>
<span id="cb4-31"><a href="#cb4-31"></a></span>
<span id="cb4-32"><a href="#cb4-32"></a>     // allocator-extended constructors</span>
<span id="cb4-33"><a href="#cb4-33"></a>     template&lt;class Alloc&gt;</span>
<span id="cb4-34"><a href="#cb4-34"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-35"><a href="#cb4-35"></a>         tuple(allocator_arg_t, const Alloc&amp; a);</span>
<span id="cb4-36"><a href="#cb4-36"></a>     template&lt;class Alloc&gt;</span>
<span id="cb4-37"><a href="#cb4-37"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-38"><a href="#cb4-38"></a>         tuple(allocator_arg_t, const Alloc&amp; a, const Types&amp;...);</span>
<span id="cb4-39"><a href="#cb4-39"></a>     template&lt;class Alloc, class... UTypes&gt;</span>
<span id="cb4-40"><a href="#cb4-40"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-41"><a href="#cb4-41"></a>         tuple(allocator_arg_t, const Alloc&amp; a, UTypes&amp;&amp;...);</span>
<span id="cb4-42"><a href="#cb4-42"></a>     template&lt;class Alloc&gt;</span>
<span id="cb4-43"><a href="#cb4-43"></a>       constexpr tuple(allocator_arg_t, const Alloc&amp; a, const tuple&amp;);</span>
<span id="cb4-44"><a href="#cb4-44"></a>     template&lt;class Alloc&gt;</span>
<span id="cb4-45"><a href="#cb4-45"></a>       constexpr tuple(allocator_arg_t, const Alloc&amp; a, tuple&amp;&amp;);</span>
<span id="cb4-46"><a href="#cb4-46"></a><span class="va">+    template&lt;class Alloc, class... UTypes&gt;</span></span>
<span id="cb4-47"><a href="#cb4-47"></a><span class="va">+      constexpr explicit(<em>see below</em>)</span></span>
<span id="cb4-48"><a href="#cb4-48"></a><span class="va">+        tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb4-49"><a href="#cb4-49"></a>     template&lt;class Alloc, class... UTypes&gt;</span>
<span id="cb4-50"><a href="#cb4-50"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-51"><a href="#cb4-51"></a>         tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;);</span>
<span id="cb4-52"><a href="#cb4-52"></a>     template&lt;class Alloc, class... UTypes&gt;</span>
<span id="cb4-53"><a href="#cb4-53"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-54"><a href="#cb4-54"></a>         tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;&amp;);</span>
<span id="cb4-55"><a href="#cb4-55"></a><span class="va">+    template&lt;class Alloc, class... UTypes&gt;</span></span>
<span id="cb4-56"><a href="#cb4-56"></a><span class="va">+      constexpr explicit(<em>see below</em>)</span></span>
<span id="cb4-57"><a href="#cb4-57"></a><span class="va">+        tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;&amp;);</span></span>
<span id="cb4-58"><a href="#cb4-58"></a><span class="va">+    template&lt;class Alloc, class U1, class U2&gt;</span></span>
<span id="cb4-59"><a href="#cb4-59"></a><span class="va">+      constexpr explicit(<em>see below</em>)</span></span>
<span id="cb4-60"><a href="#cb4-60"></a><span class="va">+        tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;);</span></span>
<span id="cb4-61"><a href="#cb4-61"></a>     template&lt;class Alloc, class U1, class U2&gt;</span>
<span id="cb4-62"><a href="#cb4-62"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-63"><a href="#cb4-63"></a>         tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;);</span>
<span id="cb4-64"><a href="#cb4-64"></a>     template&lt;class Alloc, class U1, class U2&gt;</span>
<span id="cb4-65"><a href="#cb4-65"></a>       constexpr explicit(<em>see below</em>)</span>
<span id="cb4-66"><a href="#cb4-66"></a>         tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;&amp;);</span>
<span id="cb4-67"><a href="#cb4-67"></a><span class="va">+    template&lt;class Alloc, class U1, class U2&gt;</span></span>
<span id="cb4-68"><a href="#cb4-68"></a><span class="va">+      constexpr explicit(<em>see below</em>)</span></span>
<span id="cb4-69"><a href="#cb4-69"></a><span class="va">+        tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;&amp;);</span></span>
<span id="cb4-70"><a href="#cb4-70"></a></span>
<span id="cb4-71"><a href="#cb4-71"></a>     // [tuple.assign], tuple assignment</span>
<span id="cb4-72"><a href="#cb4-72"></a>     constexpr tuple&amp; operator=(const tuple&amp;);</span>
<span id="cb4-73"><a href="#cb4-73"></a><span class="va">+    constexpr const tuple&amp; operator=(const tuple&amp;) const;</span></span>
<span id="cb4-74"><a href="#cb4-74"></a>     constexpr tuple&amp; operator=(tuple&amp;&amp;) noexcept(<em>see below</em>);</span>
<span id="cb4-75"><a href="#cb4-75"></a><span class="va">+    constexpr const tuple&amp; operator=(tuple&amp;&amp;) const;</span></span>
<span id="cb4-76"><a href="#cb4-76"></a></span>
<span id="cb4-77"><a href="#cb4-77"></a>     template&lt;class... UTypes&gt;</span>
<span id="cb4-78"><a href="#cb4-78"></a>       constexpr tuple&amp; operator=(const tuple&lt;UTypes...&gt;&amp;);</span>
<span id="cb4-79"><a href="#cb4-79"></a><span class="va">+    template&lt;class... UTypes&gt;</span></span>
<span id="cb4-80"><a href="#cb4-80"></a><span class="va">+      constexpr const tuple&amp; operator=(const tuple&lt;UTypes...&gt;&amp;) const;</span></span>
<span id="cb4-81"><a href="#cb4-81"></a>     template&lt;class... UTypes&gt;</span>
<span id="cb4-82"><a href="#cb4-82"></a>       constexpr tuple&amp; operator=(tuple&lt;UTypes...&gt;&amp;&amp;);</span>
<span id="cb4-83"><a href="#cb4-83"></a><span class="va">+    template&lt;class... UTypes&gt;</span></span>
<span id="cb4-84"><a href="#cb4-84"></a><span class="va">+      constexpr const tuple&amp; operator=(tuple&lt;UTypes...&gt;&amp;&amp;) const;</span></span>
<span id="cb4-85"><a href="#cb4-85"></a></span>
<span id="cb4-86"><a href="#cb4-86"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb4-87"><a href="#cb4-87"></a>       constexpr tuple&amp; operator=(const pair&lt;U1, U2&gt;&amp;);          // only if sizeof...(Types) == 2</span>
<span id="cb4-88"><a href="#cb4-88"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb4-89"><a href="#cb4-89"></a><span class="va">+      constexpr const tuple&amp; operator=(const pair&lt;U1, U2&gt;&amp;) const;    // only if sizeof...(Types) == 2</span></span>
<span id="cb4-90"><a href="#cb4-90"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb4-91"><a href="#cb4-91"></a>       constexpr tuple&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp;);               // only if sizeof...(Types) == 2</span>
<span id="cb4-92"><a href="#cb4-92"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb4-93"><a href="#cb4-93"></a><span class="va">+      constexpr const tuple&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp;) const;         // only if sizeof...(Types) == 2</span></span>
<span id="cb4-94"><a href="#cb4-94"></a></span>
<span id="cb4-95"><a href="#cb4-95"></a>     // [tuple.swap], tuple swap</span>
<span id="cb4-96"><a href="#cb4-96"></a>     constexpr void swap(tuple&amp;) noexcept(<em>see below</em>);</span>
<span id="cb4-97"><a href="#cb4-97"></a><span class="va">+    constexpr void swap(const tuple&amp;) const noexcept(<em>see below</em>);</span></span>
<span id="cb4-98"><a href="#cb4-98"></a>   };</span>
<span id="cb4-99"><a href="#cb4-99"></a></span>
<span id="cb4-100"><a href="#cb4-100"></a>   // [...]</span>
<span id="cb4-101"><a href="#cb4-101"></a> }</span></code></pre></div>
</div>
</blockquote>
<ol start="3" type="1">
<li>Edit <span>20.5.3.1 <a href="https://wg21.link/tuple.cnstr">[tuple.cnstr]</a></span> as indicated:</li>
</ol>
<blockquote>
<div class="add" style="color: #006e28">

<div>
<div class="sourceCode" id="cb5"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb5-1"><a href="#cb5-1"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(tuple&lt;UTypes...&gt;&amp; u);</span>
<span id="cb5-2"><a href="#cb5-2"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(const tuple&lt;UTypes...&gt;&amp; u);</span>
<span id="cb5-3"><a href="#cb5-3"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);</span>
<span id="cb5-4"><a href="#cb5-4"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(const tuple&lt;UTypes...&gt;&amp;&amp; u);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> Let <code class="sourceCode default">I</code> be the pack <code class="sourceCode default">0, 1, ..., (sizeof...(Types) - 1)</code>. Let <code class="sourceCode default">FWD(u)</code> be <code class="sourceCode default">static_cast&lt;decltype(u)&gt;(u)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> equals <code class="sourceCode default">sizeof...(UTypes)</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">(is_constructible_v&lt;Types, decltype(get&lt;I&gt;(FWD(u)))&gt; &amp;&amp; ...)</code> is <code class="sourceCode default">true</code>, and</li>
<li>either <code class="sourceCode default">sizeof...(Types)</code> is not <code class="sourceCode default">1</code>, or (when <code class="sourceCode default">Types...</code> expands to <code class="sourceCode default">T</code> and <code class="sourceCode default">UTypes...</code> expands to <code class="sourceCode default">U</code>) <code class="sourceCode default">is_convertible_v&lt;decltype(u), T&gt;</code>, <code class="sourceCode default">is_constructible_v&lt;T, decltype(u)&gt;</code>, and <code class="sourceCode default">is_same_v&lt;T, U&gt;</code> are all false.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> For all <em>i</em>, initializes the <em>i</em><sup>th</sup> element of <code class="sourceCode default">*this</code> with <code class="sourceCode default">get&lt;<em>i</em>&gt;(FWD(u))</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!conjunction_v&lt;is_convertible&lt;decltype(get&lt;I&gt;(FWD(u))), Types&gt;...&gt;</code></p>
</blockquote>
<div class="sourceCode" id="cb6"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb6-1"><a href="#cb6-1"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(pair&lt;U1, U2&gt;&amp; u);</span>
<span id="cb6-2"><a href="#cb6-2"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(const pair&lt;U1, U2&gt;&amp; u);</span>
<span id="cb6-3"><a href="#cb6-3"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(pair&lt;U1, U2&gt;&amp;&amp; u);</span>
<span id="cb6-4"><a href="#cb6-4"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(const pair&lt;U1, U2&gt;&amp;&amp; u);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> Let <code class="sourceCode default">FWD(u)</code> be <code class="sourceCode default">static_cast&lt;decltype(u)&gt;(u)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> is 2 and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;T<sub>0</sub>, decltype(get&lt;0&gt;(FWD(u)))&gt;</code> is <code class="sourceCode default">true</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;T<sub>1</sub>, decltype(get&lt;1&gt;(FWD(u)))&gt;</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> Initializes the first element with <code class="sourceCode default">get&lt;0&gt;(FWD(u))</code> and the second element with <code class="sourceCode default">get&lt;1&gt;(FWD(u))</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!is_convertible_v&lt;decltype(get&lt;0&gt;(FWD(u))), T<sub>0</sub>&gt; || !is_convertible_v&lt;decltype(get&lt;1&gt;(FWD(u))), T<sub>1</sub>&gt;</code></p>
</blockquote>
</div>

</div>
<div class="rm" style="color: #bf0303">

<div>
<div class="sourceCode" id="cb7"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb7-1"><a href="#cb7-1"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(const tuple&lt;UTypes...&gt;&amp; u);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(18.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> equals <code class="sourceCode default">sizeof...(UTypes</code>)<span class="diffins">,</span> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(18.2)</a></span><code class="sourceCode default">is_constructible_v&lt;T<em><sub>i</sub></em>, const U<em><sub>i</sub></em>&amp;&gt;</code> is <code class="sourceCode default">true</code> for all <em>i</em>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(18.3)</a></span> either <code class="sourceCode default">sizeof...(Types)</code> is not 1, or (when <code class="sourceCode default">Types...</code> expands to <code class="sourceCode default">T</code> and <code class="sourceCode default">UTypes...</code> expands to <code class="sourceCode default">U</code>) <code class="sourceCode default">is_convertible_v&lt;const tuple&lt;U&gt;&amp;, T&gt;</code>, <code class="sourceCode default">is_constructible_v&lt;T, const tuple&lt;U&gt;&amp;&gt;</code>, and <code class="sourceCode default">is_same_v&lt;T, U&gt;</code> are all <code class="sourceCode default">false</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Effects:</em> Initializes each element of <code class="sourceCode default">*this</code> with the corresponding element of <code class="sourceCode default">u</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">20</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!conjunction_v&lt;is_convertible&lt;const UTypes&amp;, Types&gt;...&gt;</code></p>
</blockquote>
<div class="sourceCode" id="cb8"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb8-1"><a href="#cb8-1"></a>template&lt;class... UTypes&gt; constexpr explicit(<em>see below</em>) tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">21</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(21.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> equals <code class="sourceCode default">sizeof...(UTypes</code>), and</li>
<li><span class="marginalizedparent"><a class="marginalized">(21.2)</a></span><code class="sourceCode default">is_constructible_v&lt;T<em><sub>i</sub></em>, U<em><sub>i</sub></em>&gt;</code> is <code class="sourceCode default">true</code> for all <em>i</em>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(21.3)</a></span> either <code class="sourceCode default">sizeof...(Types)</code> is not 1, or (when <code class="sourceCode default">Types...</code> expands to <code class="sourceCode default">T</code> and <code class="sourceCode default">UTypes...</code> expands to <code class="sourceCode default">U</code>) <code class="sourceCode default">is_convertible_v&lt;tuple&lt;U&gt;, T&gt;</code>, <code class="sourceCode default">is_constructible_v&lt;T, tuple&lt;U&gt;&gt;</code>, and <code class="sourceCode default">is_same_v&lt;T, U&gt;</code> are all <code class="sourceCode default">false</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">22</a></span> <em>Effects:</em> For all <em>i</em>, initializes the <em>i</em><sup>th</sup> element of <code class="sourceCode default">*this</code> with <code class="sourceCode default">std::forward&lt;U<em><sub>i</sub></em>&gt;(get&lt;<em>i</em>&gt;(u))</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">23</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!conjunction_v&lt;is_convertible&lt;UTypes, Types&gt;...&gt;</code></p>
</blockquote>
<div class="sourceCode" id="cb9"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb9-1"><a href="#cb9-1"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) tuple(const pair&lt;U1, U2&gt;&amp; u);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">24</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(24.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> is 2,</li>
<li><span class="marginalizedparent"><a class="marginalized">(24.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;T<sub>0</sub>, const U1&amp;&gt;</code> is <code class="sourceCode default">true</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(24.3)</a></span> <code class="sourceCode default">is_constructible_v&lt;T<sub>1</sub>, const U2&amp;&gt;</code> is <code class="sourceCode default">true</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span> <em>Effects:</em> Initializes the first element with <code class="sourceCode default">u.first</code> and the second element with <code class="sourceCode default">u.second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!is_convertible_v&lt;const U1&amp;, T<sub>0</sub>&gt; || !is_convertible_v&lt;const U2&amp;, T<sub>1</sub>&gt;</code></p>
</blockquote>
<div class="sourceCode" id="cb10"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb10-1"><a href="#cb10-1"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) tuple(pair&lt;U1, U2&gt;&amp;&amp; u);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">27</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(27.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> is 2,</li>
<li><span class="marginalizedparent"><a class="marginalized">(27.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;T<sub>0</sub>, U1&gt;</code> is <code class="sourceCode default">true</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(27.3)</a></span> <code class="sourceCode default">is_constructible_v&lt;T<sub>1</sub>, U2&gt;</code> is <code class="sourceCode default">true</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">28</a></span> <em>Effects:</em> Initializes the first element with <code class="sourceCode default">std::forward&lt;U1&gt;(u.first)</code> and the second element with <code class="sourceCode default">std::forward&lt;U2&gt;(u.second)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">29</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!is_convertible_v&lt;U1, T<sub>0</sub>&gt; || !is_convertible_v&lt;U2, T<sub>1</sub>&gt;</code></p>
</blockquote>
</div>

</div>
<div>
<blockquote>
<div>
<div class="sourceCode" id="cb11"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb11-1"><a href="#cb11-1"></a>  template&lt;class Alloc&gt;</span>
<span id="cb11-2"><a href="#cb11-2"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-3"><a href="#cb11-3"></a>      tuple(allocator_arg_t, const Alloc&amp; a);</span>
<span id="cb11-4"><a href="#cb11-4"></a>  template&lt;class Alloc&gt;</span>
<span id="cb11-5"><a href="#cb11-5"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-6"><a href="#cb11-6"></a>      tuple(allocator_arg_t, const Alloc&amp; a, const Types&amp;...);</span>
<span id="cb11-7"><a href="#cb11-7"></a>  template&lt;class Alloc, class... UTypes&gt;</span>
<span id="cb11-8"><a href="#cb11-8"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-9"><a href="#cb11-9"></a>      tuple(allocator_arg_t, const Alloc&amp; a, UTypes&amp;&amp;...);</span>
<span id="cb11-10"><a href="#cb11-10"></a>  template&lt;class Alloc&gt;</span>
<span id="cb11-11"><a href="#cb11-11"></a>    constexpr tuple(allocator_arg_t, const Alloc&amp; a, const tuple&amp;);</span>
<span id="cb11-12"><a href="#cb11-12"></a>  template&lt;class Alloc&gt;</span>
<span id="cb11-13"><a href="#cb11-13"></a>    constexpr tuple(allocator_arg_t, const Alloc&amp; a, tuple&amp;&amp;);</span>
<span id="cb11-14"><a href="#cb11-14"></a><span class="va">+ template&lt;class Alloc, class... UTypes&gt;</span></span>
<span id="cb11-15"><a href="#cb11-15"></a><span class="va">+   constexpr explicit(<em>see below</em>)</span></span>
<span id="cb11-16"><a href="#cb11-16"></a><span class="va">+     tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;);</span></span>
<span id="cb11-17"><a href="#cb11-17"></a>  template&lt;class Alloc, class... UTypes&gt;</span>
<span id="cb11-18"><a href="#cb11-18"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-19"><a href="#cb11-19"></a>      tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;);</span>
<span id="cb11-20"><a href="#cb11-20"></a>  template&lt;class Alloc, class... UTypes&gt;</span>
<span id="cb11-21"><a href="#cb11-21"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-22"><a href="#cb11-22"></a>      tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;&amp;);</span>
<span id="cb11-23"><a href="#cb11-23"></a><span class="va">+ template&lt;class Alloc, class... UTypes&gt;</span></span>
<span id="cb11-24"><a href="#cb11-24"></a><span class="va">+   constexpr explicit(<em>see below</em>)</span></span>
<span id="cb11-25"><a href="#cb11-25"></a><span class="va">+     tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;&amp;);</span></span>
<span id="cb11-26"><a href="#cb11-26"></a><span class="va">+ template&lt;class Alloc, class U1, class U2&gt;</span></span>
<span id="cb11-27"><a href="#cb11-27"></a><span class="va">+   constexpr explicit(<em>see below</em>)</span></span>
<span id="cb11-28"><a href="#cb11-28"></a><span class="va">+     tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;);</span></span>
<span id="cb11-29"><a href="#cb11-29"></a>  template&lt;class Alloc, class U1, class U2&gt;</span>
<span id="cb11-30"><a href="#cb11-30"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-31"><a href="#cb11-31"></a>      tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;);</span>
<span id="cb11-32"><a href="#cb11-32"></a>  template&lt;class Alloc, class U1, class U2&gt;</span>
<span id="cb11-33"><a href="#cb11-33"></a>    constexpr explicit(<em>see below</em>)</span>
<span id="cb11-34"><a href="#cb11-34"></a>      tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;&amp;);</span>
<span id="cb11-35"><a href="#cb11-35"></a><span class="va">+ template&lt;class Alloc, class U1, class U2&gt;</span></span>
<span id="cb11-36"><a href="#cb11-36"></a><span class="va">+   constexpr explicit(<em>see below</em>)</span></span>
<span id="cb11-37"><a href="#cb11-37"></a><span class="va">+     tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;&amp;);</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">31</a></span> <em>Preconditions:</em> <code class="sourceCode cpp">Alloc</code> meets the <em>Cpp17Allocator</em> requirements (Table 38).</p>
<p><span class="marginalizedparent"><a class="marginalized">32</a></span> <em>Effects</em>: Equivalent to the preceding constructors except that each element is constructed with uses-allocator construction.</p>
</blockquote>
</div>
</blockquote>
<ol start="4" type="1">
<li>Add the following to <span>20.5.3.2 <a href="https://wg21.link/tuple.assign">[tuple.assign]</a></span>:</li>
</ol>
<blockquote>
<div class="add" style="color: #006e28">

<div>
<div class="sourceCode" id="cb12"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb12-1"><a href="#cb12-1"></a>constexpr const tuple&amp; operator=(const tuple&amp; u) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>: <code class="sourceCode default">(is_copy_assignable_v&lt;const Types&gt; &amp;&amp; ...)</code> is <code class="sourceCode default">true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects</em>: Assigns each element of <code class="sourceCode default">u</code> to the corresponding element of <code class="sourceCode default">*this</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb13"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb13-1"><a href="#cb13-1"></a>constexpr const tuple&amp; operator=(tuple&amp;&amp; u) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>: <code class="sourceCode default">(is_assignable_v&lt;const Types&amp;, Types&gt; &amp;&amp; ...)</code> is <code class="sourceCode default">true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects</em>: For all <em>i</em>, assigns <code class="sourceCode default">std::forward&lt;T<em><sub>i</sub></em>&gt;(get&lt;<em>i</em>&gt;(u))</code> to <code class="sourceCode default">get&lt;<em>i</em>&gt;(*this)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb14"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb14-1"><a href="#cb14-1"></a>template&lt;class... UTypes&gt; constexpr const tuple&amp; operator=(const tuple&lt;UTypes...&gt;&amp; u) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> Constraints:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> equals <code class="sourceCode default">sizeof...(UTypes)</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">(is_assignable_v&lt;const Types&amp;, const UTypes&amp;&gt; &amp;&amp; ...)</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects</em>: Assigns each element of <code class="sourceCode default">u</code> to the corresponding element of <code class="sourceCode default">*this</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb15"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb15-1"><a href="#cb15-1"></a>template&lt;class... UTypes&gt; constexpr const tuple&amp; operator=(tuple&lt;UTypes...&gt;&amp;&amp; u) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> Constraints:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> equals <code class="sourceCode default">sizeof...(UTypes)</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">(is_assignable_v&lt;const Types&amp;, UTypes&gt; &amp;&amp; ...)</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects</em>: For all <em>i</em>, assigns <code class="sourceCode default">std::forward&lt;U<em><sub>i</sub></em>&gt;(get&lt;<em>i</em>&gt;(u))</code> to <code class="sourceCode default">get&lt;<em>i</em>&gt;(*this)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb16"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb16-1"><a href="#cb16-1"></a>template&lt;class U1, class U2&gt; constexpr const tuple&amp; operator=(const pair&lt;U1, U2&gt;&amp; u) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> is 2,</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_assignable_v&lt;const T<sub>0</sub>&amp;, const U1&amp;&gt;</code> is <code class="sourceCode default">true</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.3)</a></span> <code class="sourceCode default">is_assignable_v&lt;const T<sub>1</sub>&amp;, const U2&amp;&gt;</code> is <code class="sourceCode default">true</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> Assigns <code class="sourceCode default">u.first</code> to the first element and <code class="sourceCode default">u.second</code> to the second element.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb17"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb17-1"><a href="#cb17-1"></a>template&lt;class U1, class U2&gt; constexpr const tuple&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp; u) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">sizeof...(Types)</code> is 2,</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_assignable_v&lt;const T<sub>0</sub>&amp;, U1&gt;</code> is <code class="sourceCode default">true</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.3)</a></span> <code class="sourceCode default">is_assignable_v&lt;const T<sub>1</sub>&amp;, U2&gt;</code> is <code class="sourceCode default">true</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> Assigns <code class="sourceCode default">std::forward&lt;U1&gt;(u.first)</code> to the first element and <code class="sourceCode default">std::forward&lt;U2&gt;(u.second)</code> to the second element.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
</div>

</div>
</blockquote>
<ol start="5" type="1">
<li>Edit <span>20.5.3.3 <a href="https://wg21.link/tuple.swap">[tuple.swap]</a></span> as indicated:</li>
</ol>
<blockquote>
<div>
<blockquote>
<div>
<div class="sourceCode" id="cb18"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb18-1"><a href="#cb18-1"></a>  constexpr void swap(tuple&amp; rhs) noexcept(<em>see below</em>);</span>
<span id="cb18-2"><a href="#cb18-2"></a><span class="va">+ constexpr void swap(const tuple&amp; rhs) const noexcept(<em>see below</em>);</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Preconditions</em>: Each element in <code class="sourceCode cpp"><span class="op">*</span><span class="kw">this</span></code> is swappable with (<span>16.4.4.3 <a href="https://wg21.link/swappable.requirements">[swappable.requirements]</a></span>) the corresponding element in <code class="sourceCode cpp">rhs</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Calls <code class="sourceCode cpp">swap</code> for each element in <code class="sourceCode cpp"><span class="op">*</span><span class="kw">this</span></code> and its corresponding element in <code class="sourceCode cpp">rhs</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Throws</em>: Nothing unless one of the element-wise <code class="sourceCode cpp">swap</code> calls throws an exception.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Remarks</em>: The expression inside <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to <span class="diffdel">the logical AND of the following expressions: <code class="sourceCode cpp">is_nothrow_swappable_v<span class="op">&lt;</span>T<em><sub>i</sub></em><span class="op">&gt;</span></code>, where <code class="sourceCode cpp">T<em><sub>i</sub></em><span class="op">&gt;</span></code> is the <em>i</em><sup>th</sup> type in <code class="sourceCode cpp">Types</code>.</span></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <span class="diffins"><code class="sourceCode cpp"><span class="op">(</span>is_nothrow_swappable_v<span class="op">&lt;</span>Types<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> for the first overload.</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <span class="diffins"><code class="sourceCode cpp"><span class="op">(</span>is_nothrow_swappable_v<span class="op">&lt;</span><span class="kw">const</span> Types<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> for the second overload.</span></li>
</ul>
</blockquote>
</div>
</blockquote>
<ol start="6" type="1">
<li>Edit <span>20.5.10 <a href="https://wg21.link/tuple.special">[tuple.special]</a></span> as indicated:</li>
</ol>
<blockquote>
<div>
<blockquote>
<div>
<div class="sourceCode" id="cb19"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb19-1"><a href="#cb19-1"></a>  template&lt;class... Types&gt;</span>
<span id="cb19-2"><a href="#cb19-2"></a>    constexpr void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y) noexcept(<em>see below</em>);</span>
<span id="cb19-3"><a href="#cb19-3"></a><span class="va">+ template&lt;class... Types&gt;</span></span>
<span id="cb19-4"><a href="#cb19-4"></a><span class="va">+   constexpr void swap(const tuple&lt;Types...&gt;&amp; x, const tuple&lt;Types...&gt;&amp; y) noexcept(<em>see below</em>);</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Constraints</em>: <span class="diffdel"><code class="sourceCode cpp">is_swappable_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code> is true for every type <code class="sourceCode cpp">T</code> in <code class="sourceCode cpp">Types</code>.</span></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> <span class="diffins">For the first overload, <code class="sourceCode cpp"><span class="op">(</span>is_swappable_v<span class="op">&lt;</span>Types<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> <span class="diffins">For the second overload, <code class="sourceCode cpp"><span class="op">(</span>is_swappable_v<span class="op">&lt;</span><span class="kw">const</span> Types<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</span></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: As if by <code class="sourceCode cpp">x<span class="op">.</span>swap<span class="op">(</span>y<span class="op">)</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Remarks</em>: The expression inside <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to: <code class="sourceCode cpp"><span class="kw">noexcept</span><span class="op">(</span>x<span class="op">.</span>swap<span class="op">(</span>y<span class="op">))</span></code>.</p>
</blockquote>
</div>
</blockquote>
</div>
<h2 data-number="5.2" id="pair"><span class="header-section-number">5.2</span> <code class="sourceCode cpp">pair</code><a href="#pair" class="self-link"></a></h2>
<div>
<ol type="1">
<li>Edit <span>20.2.1 <a href="https://wg21.link/utility.syn">[utility.syn]</a></span>, header <code class="sourceCode cpp"><span class="op">&lt;</span>utility<span class="op">&gt;</span></code> synopsis, as indicated:</li>
</ol>
<blockquote>
<div>
<div class="sourceCode" id="cb20"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb20-1"><a href="#cb20-1"></a></span>
<span id="cb20-2"><a href="#cb20-2"></a> #include &lt;compare&gt;              // see [compare.syn]</span>
<span id="cb20-3"><a href="#cb20-3"></a> #include &lt;initializer_list&gt;     // see [initializer.list.syn]</span>
<span id="cb20-4"><a href="#cb20-4"></a></span>
<span id="cb20-5"><a href="#cb20-5"></a> namespace std {</span>
<span id="cb20-6"><a href="#cb20-6"></a>   // [...]</span>
<span id="cb20-7"><a href="#cb20-7"></a></span>
<span id="cb20-8"><a href="#cb20-8"></a>   // [pairs], class template pair</span>
<span id="cb20-9"><a href="#cb20-9"></a>   template&lt;class T1, class T2&gt;</span>
<span id="cb20-10"><a href="#cb20-10"></a>     struct pair;</span>
<span id="cb20-11"><a href="#cb20-11"></a></span>
<span id="cb20-12"><a href="#cb20-12"></a><span class="va">+  template&lt;class T1, class T2, class U1, class U2, template&lt;class&gt; class TQual, template&lt;class&gt; class UQual&gt;</span></span>
<span id="cb20-13"><a href="#cb20-13"></a><span class="va">+    requires requires { typename pair&lt;common_reference_t&lt;TQual&lt;T1&gt;, UQual&lt;U1&gt;&gt;,</span></span>
<span id="cb20-14"><a href="#cb20-14"></a><span class="va">+                                      common_reference_t&lt;TQual&lt;T2&gt;, UQual&lt;U2&gt;&gt;&gt;; }</span></span>
<span id="cb20-15"><a href="#cb20-15"></a><span class="va">+  struct basic_common_reference&lt;pair&lt;T1, T2&gt;, pair&lt;U1, U2&gt;, TQual, UQual&gt; {</span></span>
<span id="cb20-16"><a href="#cb20-16"></a><span class="va">+    using type = pair&lt;common_reference_t&lt;TQual&lt;T1&gt;, UQual&lt;U1&gt;&gt;,</span></span>
<span id="cb20-17"><a href="#cb20-17"></a><span class="va">+                      common_reference_t&lt;TQual&lt;T2&gt;, UQual&lt;U2&gt;&gt;&gt;;</span></span>
<span id="cb20-18"><a href="#cb20-18"></a><span class="va">+  };</span></span>
<span id="cb20-19"><a href="#cb20-19"></a><span class="va">+</span></span>
<span id="cb20-20"><a href="#cb20-20"></a><span class="va">+  template&lt;class T1, class T2, class U1, class U2&gt;</span></span>
<span id="cb20-21"><a href="#cb20-21"></a><span class="va">+    requires requires { typename pair&lt;common_type_t&lt;T1, U1&gt;, common_type_t&lt;T2, U2&gt;&gt;; }</span></span>
<span id="cb20-22"><a href="#cb20-22"></a><span class="va">+  struct common_type&lt;pair&lt;T1, T2&gt;, pair&lt;U1, U2&gt;&gt; {</span></span>
<span id="cb20-23"><a href="#cb20-23"></a><span class="va">+    using type = pair&lt;common_type_t&lt;T1, U1&gt;, common_type_t&lt;T2, U2&gt;&gt;;</span></span>
<span id="cb20-24"><a href="#cb20-24"></a><span class="va">+  };</span></span>
<span id="cb20-25"><a href="#cb20-25"></a></span>
<span id="cb20-26"><a href="#cb20-26"></a>   // [pairs.spec], pair specialized algorithms</span>
<span id="cb20-27"><a href="#cb20-27"></a>   template&lt;class T1, class T2&gt;</span>
<span id="cb20-28"><a href="#cb20-28"></a>     constexpr bool operator==(const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span>
<span id="cb20-29"><a href="#cb20-29"></a>   template&lt;class T1, class T2&gt;</span>
<span id="cb20-30"><a href="#cb20-30"></a>     constexpr common_comparison_category_t&lt;<em>synth-three-way-result</em>&lt;T1&gt;,</span>
<span id="cb20-31"><a href="#cb20-31"></a>                                            <em>synth-three-way-result</em>&lt;T2&gt;&gt;</span>
<span id="cb20-32"><a href="#cb20-32"></a>       operator&lt;=&gt;(const pair&lt;T1, T2&gt;&amp;, const pair&lt;T1, T2&gt;&amp;);</span>
<span id="cb20-33"><a href="#cb20-33"></a></span>
<span id="cb20-34"><a href="#cb20-34"></a>   template&lt;class T1, class T2&gt;</span>
<span id="cb20-35"><a href="#cb20-35"></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="cb20-36"><a href="#cb20-36"></a><span class="va">+  template&lt;class... Types&gt;</span></span>
<span id="cb20-37"><a href="#cb20-37"></a><span class="va">+    constexpr void swap(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y) noexcept(noexcept(x.swap(y)));</span></span>
<span id="cb20-38"><a href="#cb20-38"></a> }</span></code></pre></div>
</div>
</blockquote>
<ol start="2" type="1">
<li>Edit <span>20.4.2 <a href="https://wg21.link/pairs.pair">[pairs.pair]</a></span> as indicated:</li>
</ol>
<blockquote>
<div>
<div class="sourceCode" id="cb21"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb21-1"><a href="#cb21-1"></a> namespace std {</span>
<span id="cb21-2"><a href="#cb21-2"></a>   template&lt;class T1, class T2&gt;</span>
<span id="cb21-3"><a href="#cb21-3"></a>   struct pair {</span>
<span id="cb21-4"><a href="#cb21-4"></a>     using first_type  = T1;</span>
<span id="cb21-5"><a href="#cb21-5"></a>     using second_type = T2;</span>
<span id="cb21-6"><a href="#cb21-6"></a></span>
<span id="cb21-7"><a href="#cb21-7"></a>     T1 first;</span>
<span id="cb21-8"><a href="#cb21-8"></a>     T2 second;</span>
<span id="cb21-9"><a href="#cb21-9"></a></span>
<span id="cb21-10"><a href="#cb21-10"></a>     pair(const pair&amp;) = default;</span>
<span id="cb21-11"><a href="#cb21-11"></a>     pair(pair&amp;&amp;) = default;</span>
<span id="cb21-12"><a href="#cb21-12"></a>     constexpr explicit(<em>see below</em>) pair();</span>
<span id="cb21-13"><a href="#cb21-13"></a>     constexpr explicit(<em>see below</em>) pair(const T1&amp; x, const T2&amp; y);</span>
<span id="cb21-14"><a href="#cb21-14"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb21-15"><a href="#cb21-15"></a>       constexpr explicit(<em>see below</em>) pair(U1&amp;&amp; x, U2&amp;&amp; y);</span>
<span id="cb21-16"><a href="#cb21-16"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb21-17"><a href="#cb21-17"></a><span class="va">+      constexpr explicit(<em>see below</em>) pair(pair&lt;U1, U2&gt;&amp; p);</span></span>
<span id="cb21-18"><a href="#cb21-18"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb21-19"><a href="#cb21-19"></a>       constexpr explicit(<em>see below</em>) pair(const pair&lt;U1, U2&gt;&amp; p);</span>
<span id="cb21-20"><a href="#cb21-20"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb21-21"><a href="#cb21-21"></a>       constexpr explicit(<em>see below</em>) pair(pair&lt;U1, U2&gt;&amp;&amp; p);</span>
<span id="cb21-22"><a href="#cb21-22"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb21-23"><a href="#cb21-23"></a><span class="va">+      constexpr explicit(<em>see below</em>) pair(const pair&lt;U1, U2&gt;&amp;&amp; p);</span></span>
<span id="cb21-24"><a href="#cb21-24"></a>     template&lt;class... Args1, class... Args2&gt;</span>
<span id="cb21-25"><a href="#cb21-25"></a>       constexpr pair(piecewise_construct_t,</span>
<span id="cb21-26"><a href="#cb21-26"></a>                      tuple&lt;Args1...&gt; first_args, tuple&lt;Args2...&gt; second_args);</span>
<span id="cb21-27"><a href="#cb21-27"></a></span>
<span id="cb21-28"><a href="#cb21-28"></a>     constexpr pair&amp; operator=(const pair&amp; p);</span>
<span id="cb21-29"><a href="#cb21-29"></a><span class="va">+    constexpr const pair&amp; operator=(const pair&amp; p) const;</span></span>
<span id="cb21-30"><a href="#cb21-30"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb21-31"><a href="#cb21-31"></a>       constexpr pair&amp; operator=(const pair&lt;U1, U2&gt;&amp; p);</span>
<span id="cb21-32"><a href="#cb21-32"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb21-33"><a href="#cb21-33"></a><span class="va">+      constexpr const pair&amp; operator=(const pair&lt;U1, U2&gt;&amp; p) const;</span></span>
<span id="cb21-34"><a href="#cb21-34"></a>     constexpr pair&amp; operator=(pair&amp;&amp; p) noexcept(<em>see below</em>);</span>
<span id="cb21-35"><a href="#cb21-35"></a><span class="va">+    constexpr const pair&amp; operator=(pair&amp;&amp; p) const;</span></span>
<span id="cb21-36"><a href="#cb21-36"></a>     template&lt;class U1, class U2&gt;</span>
<span id="cb21-37"><a href="#cb21-37"></a>       constexpr pair&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp; p);</span>
<span id="cb21-38"><a href="#cb21-38"></a><span class="va">+    template&lt;class U1, class U2&gt;</span></span>
<span id="cb21-39"><a href="#cb21-39"></a><span class="va">+      constexpr const pair&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp; p) const;</span></span>
<span id="cb21-40"><a href="#cb21-40"></a></span>
<span id="cb21-41"><a href="#cb21-41"></a>     constexpr void swap(pair&amp; p) noexcept(<em>see below</em>);</span>
<span id="cb21-42"><a href="#cb21-42"></a><span class="va">+    constexpr void swap(const pair&amp; p) noexcept(<em>see below</em>);</span></span>
<span id="cb21-43"><a href="#cb21-43"></a>   };</span>
<span id="cb21-44"><a href="#cb21-44"></a></span>
<span id="cb21-45"><a href="#cb21-45"></a>   template&lt;class T1, class T2&gt;</span>
<span id="cb21-46"><a href="#cb21-46"></a>     pair(T1, T2) -&gt; pair&lt;T1, T2&gt;;</span>
<span id="cb21-47"><a href="#cb21-47"></a> }</span></code></pre></div>
</div>
<p>[…]</p>
<div class="add" style="color: #006e28">

<div>
<div class="sourceCode" id="cb22"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb22-1"><a href="#cb22-1"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) pair(pair&lt;U1, U2&gt;&amp; p);</span>
<span id="cb22-2"><a href="#cb22-2"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) pair(const pair&lt;U1, U2&gt;&amp; p);</span>
<span id="cb22-3"><a href="#cb22-3"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) pair(pair&lt;U1, U2&gt;&amp;&amp; p);</span>
<span id="cb22-4"><a href="#cb22-4"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) pair(const pair&lt;U1, U2&gt;&amp;&amp; p);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> Let <code class="sourceCode default">FWD(u)</code> be <code class="sourceCode default">static_cast&lt;decltype(u)&gt;(u)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(17.1)</a></span> <code class="sourceCode default">is_constructible_v&lt;first_type, decltype(get&lt;0&gt;(FWD(p)))&gt;</code> is <code class="sourceCode default">true</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(17.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;second_type, decltype(get&lt;1&gt;(FWD(p)))&gt;</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> Initializes <code class="sourceCode default">first</code> with <code class="sourceCode default">get&lt;0&gt;(FWD(p))</code> and <code class="sourceCode default">second</code> with <code class="sourceCode default">get&lt;1&gt;(FWD(p))</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!is_convertible_v&lt;decltype(get&lt;0&gt;(FWD(p))), first_type&gt; || !is_convertible_v&lt;decltype(get&lt;1&gt;(FWD(p))), second_type&gt;</code>.</p>
</blockquote>
</div>

</div>
<div class="rm" style="color: #bf0303">

<div>
<div class="sourceCode" id="cb23"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb23-1"><a href="#cb23-1"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) pair(const pair&lt;U1, U2&gt;&amp; p);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(14.1)</a></span> <code class="sourceCode default">is_constructible_v&lt;first_type, const U1&amp;&gt;</code> is <code class="sourceCode default">true</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(14.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;second_type, const U2&amp;&gt;</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Effects:</em> Initializes members from the corresponding members of the argument.</p>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!is_convertible_v&lt;const U1&amp;, first_type&gt; || !is_convertible_v&lt;const U2&amp;, second_type&gt;</code></p>
</blockquote>
<div class="sourceCode" id="cb24"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb24-1"><a href="#cb24-1"></a>template&lt;class U1, class U2&gt; constexpr explicit(<em>see below</em>) pair(pair&lt;U1, U2&gt;&amp;&amp; p);</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(17.1)</a></span> <code class="sourceCode default">is_constructible_v&lt;first_type, U1&gt;</code> is <code class="sourceCode default">true</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(17.2)</a></span> <code class="sourceCode default">is_constructible_v&lt;second_type, U2&gt;</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Effects:</em> Initializes <code class="sourceCode default">first</code> with <code class="sourceCode default">std::forward&lt;U1&gt;(p.first)</code> and <code class="sourceCode default">second</code> with <code class="sourceCode default">std::forward&lt;U2&gt;(p.second)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Remarks:</em> The expression inside <code class="sourceCode default">explicit</code> is equivalent to: <code class="sourceCode default">!is_convertible_v&lt;U1, first_type&gt; || !is_convertible_v&lt;U2, second_type&gt;</code></p>
</blockquote>
</div>

</div>
<div class="add" style="color: #006e28">

<div>
<div class="sourceCode" id="cb25"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb25-1"><a href="#cb25-1"></a>constexpr const pair&amp; operator=(const pair&amp; p) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">is_copy_assignable&lt;const first_type&gt;</code> is <code class="sourceCode default">true</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_copy_assignable&lt;const second_type&gt;</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects</em>: Assigns <code class="sourceCode default">p.first</code> to <code class="sourceCode default">first</code> and <code class="sourceCode default">p.second</code> to <code class="sourceCode default">second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb26"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb26-1"><a href="#cb26-1"></a>template&lt;class U1, class U2&gt; constexpr const pair&amp; operator=(const pair&lt;U1, U2&gt;&amp; p) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">is_assignable_v&lt;const first_type&amp;, const U1&amp;&gt;</code> is <code class="sourceCode default">true</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_assignable_v&lt;const second_type&amp;, const U2&amp;&gt;</code> is <code class="sourceCode default">true</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> Assigns <code class="sourceCode default">p.first</code> to <code class="sourceCode default">first</code> and <code class="sourceCode default">p.second</code> to <code class="sourceCode default">second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb27"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb27-1"><a href="#cb27-1"></a>constexpr const pair&amp; operator=(pair&amp;&amp; p) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">is_assignable&lt;const first_type&amp;, first_type&gt;</code> is <code class="sourceCode default">true</code> and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_assignable&lt;const second_type&amp;, second_type&gt;</code> is <code class="sourceCode default">true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects</em>: Assigns <code class="sourceCode default">std::forward&lt;first_type&gt;(p.first)</code> to <code class="sourceCode default">first</code> and <code class="sourceCode default">std::forward&lt;second_type&gt;(p.second)</code> to <code class="sourceCode default">second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
<div class="sourceCode" id="cb28"><pre class="sourceCode default cpp"><code class="sourceCode default"><span id="cb28-1"><a href="#cb28-1"></a>template&lt;class U1, class U2&gt; constexpr const pair&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp; p) const;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Constraints:</em></p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(?.1)</a></span> <code class="sourceCode default">is_assignable_v&lt;const first_type&amp;, U1&gt;</code> is <code class="sourceCode default">true</code>, and</li>
<li><span class="marginalizedparent"><a class="marginalized">(?.2)</a></span> <code class="sourceCode default">is_assignable_v&lt;const second_type&amp;, U2&gt;</code> is <code class="sourceCode default">true</code></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Effects:</em> Assigns <code class="sourceCode default">std::forward&lt;U1&gt;(p.first)</code> to <code class="sourceCode default">first</code> and <code class="sourceCode default">std::forward&lt;U2&gt;(u.second)</code> to <code class="sourceCode default">second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">?</a></span> <em>Returns</em>: <code class="sourceCode default">*this</code>.</p>
</blockquote>
</div>

</div>
<div>
<blockquote>
<div>
<div class="sourceCode" id="cb29"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb29-1"><a href="#cb29-1"></a>  constexpr void swap(pair&amp; p) noexcept(<em>see below</em>);</span>
<span id="cb29-2"><a href="#cb29-2"></a><span class="va">+ constexpr void swap(const pair&amp; p) const noexcept(<em>see below</em>);</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">35</a></span> <em>Preconditions</em>: <code class="sourceCode cpp">first</code> is swappable with (<span>16.4.4.3 <a href="https://wg21.link/swappable.requirements">[swappable.requirements]</a></span>) <code class="sourceCode cpp">p<span class="op">.</span>first</code> and <code class="sourceCode cpp">second</code> is swappable with <code class="sourceCode cpp">p<span class="op">.</span>second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">36</a></span> <em>Effects</em>: Swaps <code class="sourceCode cpp">first</code> with <code class="sourceCode cpp">p<span class="op">.</span>first</code> and <code class="sourceCode cpp">second</code> with <code class="sourceCode cpp">p<span class="op">.</span>second</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">37</a></span> <em>Remarks</em>: The expression inside <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <code class="sourceCode cpp">is_nothrow_swappable_v<span class="op">&lt;</span>first_type<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> is_nothrow_swappable_v<span class="op">&lt;</span>second_type<span class="op">&gt;</span></code> <span class="diffins">for the first overload.</span></li>
<li><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <span class="diffins"><code class="sourceCode cpp">is_nothrow_swappable_v<span class="op">&lt;</span><span class="kw">const</span> first_type<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> is_nothrow_swappable_v<span class="op">&lt;</span><span class="kw">const</span> second_type<span class="op">&gt;</span></code> for the second overload.</span></li>
</ul>
</blockquote>
</div>
</blockquote>
<ol start="3" type="1">
<li>Edit <span>20.4.3 <a href="https://wg21.link/pairs.spec">[pairs.spec]</a></span> as indicated:</li>
</ol>
<blockquote>
<div>
<blockquote>
<div>
<div class="sourceCode" id="cb30"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb30-1"><a href="#cb30-1"></a>  template&lt;class T1, class T2&gt;</span>
<span id="cb30-2"><a href="#cb30-2"></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="cb30-3"><a href="#cb30-3"></a><span class="va">+ template&lt;class T1, class T2&gt;</span></span>
<span id="cb30-4"><a href="#cb30-4"></a><span class="va">+   constexpr void swap(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y) noexcept(noexcept(x.swap(y)));</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Constraints</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> <span class="diffins">For the first overload,</span> <code class="sourceCode cpp">is_swappable_v<span class="op">&lt;</span>T1<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code> and <code class="sourceCode cpp">is_swappable_v<span class="op">&lt;</span>T2<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(3.2)</a></span> <span class="diffins">For the second overload, <code class="sourceCode cpp">is_swappable_v<span class="op">&lt;</span><span class="kw">const</span> T1<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code> and <code class="sourceCode cpp">is_swappable_v<span class="op">&lt;</span><span class="kw">const</span> T2<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</span></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Equivalent to <code class="sourceCode cpp">x<span class="op">.</span>swap<span class="op">(</span>y<span class="op">)</span></code>.</p>
</blockquote>
</div>
</blockquote>
<ol start="4" type="1">
<li>Edit <span>20.10.2 <a href="https://wg21.link/memory.syn">[memory.syn]</a></span>, header <code class="sourceCode cpp"><span class="op">&lt;</span>memory<span class="op">&gt;</span></code> synopsis, as indicated:</li>
</ol>
<blockquote>
<div>
<div class="sourceCode" id="cb31"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb31-1"><a href="#cb31-1"></a> #include &lt;compare&gt;              // see [compare.syn]</span>
<span id="cb31-2"><a href="#cb31-2"></a></span>
<span id="cb31-3"><a href="#cb31-3"></a> namespace std {</span>
<span id="cb31-4"><a href="#cb31-4"></a>   // [...]</span>
<span id="cb31-5"><a href="#cb31-5"></a></span>
<span id="cb31-6"><a href="#cb31-6"></a>   // [allocator.uses.construction], uses-allocator construction</span>
<span id="cb31-7"><a href="#cb31-7"></a>   template&lt;class T, class Alloc, class... Args&gt;</span>
<span id="cb31-8"><a href="#cb31-8"></a>     constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span>
<span id="cb31-9"><a href="#cb31-9"></a>                                                     Args&amp;&amp;... args) noexcept -&gt; <em>see below</em>;</span>
<span id="cb31-10"><a href="#cb31-10"></a>   template&lt;class T, class Alloc, class Tuple1, class Tuple2&gt;</span>
<span id="cb31-11"><a href="#cb31-11"></a>     constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc, piecewise_construct_t,</span>
<span id="cb31-12"><a href="#cb31-12"></a>                                                     Tuple1&amp;&amp; x, Tuple2&amp;&amp; y)</span>
<span id="cb31-13"><a href="#cb31-13"></a>                                                     noexcept -&gt; <em>see below</em>;</span>
<span id="cb31-14"><a href="#cb31-14"></a>   template&lt;class T, class Alloc&gt;</span>
<span id="cb31-15"><a href="#cb31-15"></a>     constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc) noexcept -&gt; <em>see below</em>;</span>
<span id="cb31-16"><a href="#cb31-16"></a>   template&lt;class T, class Alloc, class U, class V&gt;</span>
<span id="cb31-17"><a href="#cb31-17"></a>     constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span>
<span id="cb31-18"><a href="#cb31-18"></a>                                                     U&amp;&amp; u, V&amp;&amp; v) noexcept -&gt; <em>see below</em>;</span>
<span id="cb31-19"><a href="#cb31-19"></a><span class="va">+  template&lt;class T, class Alloc, class U, class V&gt;</span></span>
<span id="cb31-20"><a href="#cb31-20"></a><span class="va">+    constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span></span>
<span id="cb31-21"><a href="#cb31-21"></a><span class="va">+                                                    pair&lt;U,V&gt;&amp; pr) noexcept -&gt; <em>see below</em>;</span></span>
<span id="cb31-22"><a href="#cb31-22"></a>   template&lt;class T, class Alloc, class U, class V&gt;</span>
<span id="cb31-23"><a href="#cb31-23"></a>     constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span>
<span id="cb31-24"><a href="#cb31-24"></a>                                                     const pair&lt;U,V&gt;&amp; pr) noexcept -&gt; <em>see below</em>;</span>
<span id="cb31-25"><a href="#cb31-25"></a>   template&lt;class T, class Alloc, class U, class V&gt;</span>
<span id="cb31-26"><a href="#cb31-26"></a>     constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span>
<span id="cb31-27"><a href="#cb31-27"></a>                                                     pair&lt;U,V&gt;&amp;&amp; pr) noexcept -&gt; <em>see below</em>;</span>
<span id="cb31-28"><a href="#cb31-28"></a><span class="va">+  template&lt;class T, class Alloc, class U, class V&gt;</span></span>
<span id="cb31-29"><a href="#cb31-29"></a><span class="va">+    constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span></span>
<span id="cb31-30"><a href="#cb31-30"></a><span class="va">+                                                    const pair&lt;U,V&gt;&amp;&amp; pr) noexcept -&gt; <em>see below</em>;</span></span>
<span id="cb31-31"><a href="#cb31-31"></a>   template&lt;class T, class Alloc, class... Args&gt;</span>
<span id="cb31-32"><a href="#cb31-32"></a>     constexpr T make_obj_using_allocator(const Alloc&amp; alloc, Args&amp;&amp;... args);</span>
<span id="cb31-33"><a href="#cb31-33"></a>   template&lt;class T, class Alloc, class... Args&gt;</span>
<span id="cb31-34"><a href="#cb31-34"></a>     constexpr T* uninitialized_construct_using_allocator(T* p, const Alloc&amp; alloc,</span>
<span id="cb31-35"><a href="#cb31-35"></a>                                                          Args&amp;&amp;... args);</span>
<span id="cb31-36"><a href="#cb31-36"></a></span>
<span id="cb31-37"><a href="#cb31-37"></a>   // [...]</span>
<span id="cb31-38"><a href="#cb31-38"></a> }</span></code></pre></div>
</div>
</blockquote>
<ol start="5" type="1">
<li>Edit <span>20.10.8.2 <a href="https://wg21.link/allocator.uses.construction">[allocator.uses.construction]</a></span> as indicated:</li>
</ol>
<blockquote>
<div>
<blockquote>
<div>
<div class="sourceCode" id="cb32"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb32-1"><a href="#cb32-1"></a><span class="va">+ template&lt;class T, class Alloc, class U, class V&gt;</span></span>
<span id="cb32-2"><a href="#cb32-2"></a><span class="va">+   constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span></span>
<span id="cb32-3"><a href="#cb32-3"></a><span class="va">+                                                   pair&lt;U,V&gt;&amp; pr) noexcept -&gt; <em>see below</em>;</span></span>
<span id="cb32-4"><a href="#cb32-4"></a>  template&lt;class T, class Alloc, class U, class V&gt;</span>
<span id="cb32-5"><a href="#cb32-5"></a>    constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span>
<span id="cb32-6"><a href="#cb32-6"></a>                                                    const pair&lt;U,V&gt;&amp; pr) noexcept -&gt; <em>see below</em>;</span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Constraints</em>: <code class="sourceCode cpp">T</code> is a specialization of <code class="sourceCode cpp">pair</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb33"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb33-1"><a href="#cb33-1"></a><span class="cf">return</span> uses_allocator_construction_args<span class="op">&lt;</span>T<span class="op">&gt;(</span>alloc, piecewise_construct,</span>
<span id="cb33-2"><a href="#cb33-2"></a>                                           forward_as_tuple<span class="op">(</span>pr<span class="op">.</span>first<span class="op">)</span>,</span>
<span id="cb33-3"><a href="#cb33-3"></a>                                           forward_as_tuple<span class="op">(</span>pr<span class="op">.</span>second<span class="op">))</span>;</span></code></pre></div>
</blockquote>
<div>
<div class="sourceCode" id="cb34"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb34-1"><a href="#cb34-1"></a>  template&lt;class T, class Alloc, class U, class V&gt;</span>
<span id="cb34-2"><a href="#cb34-2"></a>    constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span>
<span id="cb34-3"><a href="#cb34-3"></a>                                                    pair&lt;U,V&gt;&amp;&amp; pr) noexcept -&gt; <em>see below</em>;</span>
<span id="cb34-4"><a href="#cb34-4"></a><span class="va">+ template&lt;class T, class Alloc, class U, class V&gt;</span></span>
<span id="cb34-5"><a href="#cb34-5"></a><span class="va">+   constexpr auto uses_allocator_construction_args(const Alloc&amp; alloc,</span></span>
<span id="cb34-6"><a href="#cb34-6"></a><span class="va">+                                                   const pair&lt;U,V&gt;&amp;&amp; pr) noexcept -&gt; <em>see below</em>;</span></span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Constraints</em>: <code class="sourceCode cpp">T</code> is a specialization of <code class="sourceCode cpp">pair</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Effects</em>: Equivalent to:</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="cf">return</span> uses_allocator_construction_args<span class="op">&lt;</span>T<span class="op">&gt;(</span>alloc, piecewise_construct,</span>
<span id="cb35-2"><a href="#cb35-2"></a>                                           forward_as_tuple<span class="op">(</span><span class="diffdel">std::move(pr).first</span><span class="diffins">get&lt;0&gt;(std::move(pr))</span><span class="op">)</span>,</span>
<span id="cb35-3"><a href="#cb35-3"></a>                                           forward_as_tuple<span class="op">(</span><span class="diffdel">std::move(pr).second</span><span class="diffins">get&lt;1&gt;(std::move(pr))</span><span class="op">))</span>;</span></code></pre></div>
</blockquote>
</blockquote>
</div>
</blockquote>
</div>
<h2 data-number="5.3" id="vectorboolreference"><span class="header-section-number">5.3</span> <code class="sourceCode cpp">vector<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;::</span>reference</code><a href="#vectorboolreference" class="self-link"></a></h2>
<p>Edit <span>22.3.12 <a href="https://wg21.link/vector.bool">[vector.bool]</a></span>, class template partial specialization <code class="sourceCode cpp">vector<span class="op">&lt;</span><span class="dt">bool</span>, Allocator<span class="op">&gt;</span></code> synopsis, as indicated:</p>
<div>
<div class="sourceCode" id="cb36"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb36-1"><a href="#cb36-1"></a> namespace std {</span>
<span id="cb36-2"><a href="#cb36-2"></a>   template&lt;class Allocator&gt;</span>
<span id="cb36-3"><a href="#cb36-3"></a>   class vector&lt;bool, Allocator&gt; {</span>
<span id="cb36-4"><a href="#cb36-4"></a>   public:</span>
<span id="cb36-5"><a href="#cb36-5"></a>     // [...]</span>
<span id="cb36-6"><a href="#cb36-6"></a></span>
<span id="cb36-7"><a href="#cb36-7"></a>     // bit reference</span>
<span id="cb36-8"><a href="#cb36-8"></a>     class reference {</span>
<span id="cb36-9"><a href="#cb36-9"></a>       friend class vector;</span>
<span id="cb36-10"><a href="#cb36-10"></a>       constexpr reference() noexcept;</span>
<span id="cb36-11"><a href="#cb36-11"></a>     public:</span>
<span id="cb36-12"><a href="#cb36-12"></a>       constexpr reference(const reference&amp;) = default;</span>
<span id="cb36-13"><a href="#cb36-13"></a>       constexpr ~reference();</span>
<span id="cb36-14"><a href="#cb36-14"></a>       constexpr operator bool() const noexcept;</span>
<span id="cb36-15"><a href="#cb36-15"></a>       constexpr reference&amp; operator=(const bool x) noexcept;</span>
<span id="cb36-16"><a href="#cb36-16"></a>       constexpr reference&amp; operator=(const reference&amp; x) noexcept;</span>
<span id="cb36-17"><a href="#cb36-17"></a><span class="va">+      constexpr const reference&amp; operator=(bool x) const noexcept;</span></span>
<span id="cb36-18"><a href="#cb36-18"></a>       constexpr void flip() noexcept;   // flips the bit</span>
<span id="cb36-19"><a href="#cb36-19"></a>     };</span>
<span id="cb36-20"><a href="#cb36-20"></a></span>
<span id="cb36-21"><a href="#cb36-21"></a>     // [...]</span>
<span id="cb36-22"><a href="#cb36-22"></a>   };</span>
<span id="cb36-23"><a href="#cb36-23"></a> }</span></code></pre></div>
</div>
<h2 data-number="5.4" id="addition-to-ranges"><span class="header-section-number">5.4</span> Addition to <code class="sourceCode cpp"><span class="op">&lt;</span>ranges<span class="op">&gt;</span></code><a href="#addition-to-ranges" class="self-link"></a></h2>
<p>Add the following to <span>24.2 <a href="https://wg21.link/ranges.syn">[ranges.syn]</a></span>, header <code class="sourceCode cpp"><span class="op">&lt;</span>ranges<span class="op">&gt;</span></code> synopsis:</p>
<div class="sourceCode" id="cb37"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb37-1"><a href="#cb37-1"></a><span class="co">// [...]</span></span>
<span id="cb37-2"><a href="#cb37-2"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb37-3"><a href="#cb37-3"></a>  <span class="co">// [...]</span></span>
<span id="cb37-4"><a href="#cb37-4"></a></span>
<span id="cb37-5"><a href="#cb37-5"></a>  <span class="co">// [range.zip], zip view</span></span>
<span id="cb37-6"><a href="#cb37-6"></a>  <span class="kw">template</span><span class="op">&lt;</span>input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb37-7"><a href="#cb37-7"></a>      <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb37-8"><a href="#cb37-8"></a>  <span class="kw">class</span> zip_view;</span>
<span id="cb37-9"><a href="#cb37-9"></a></span>
<span id="cb37-10"><a href="#cb37-10"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb37-11"><a href="#cb37-11"></a>  <span class="kw">inline</span> <span class="kw">constexpr</span> <span class="dt">bool</span> enable_borrowed_range<span class="op">&lt;</span>zip_view<span class="op">&lt;</span>Views<span class="op">...&gt;&gt;</span></span>
<span id="cb37-12"><a href="#cb37-12"></a>      <span class="op">=</span> <span class="op">(</span>enable_borrowed_range<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb37-13"><a href="#cb37-13"></a></span>
<span id="cb37-14"><a href="#cb37-14"></a>  <span class="kw">namespace</span> views <span class="op">{</span> <span class="kw">inline</span> <span class="kw">constexpr</span> <em>unspecified</em> zip <span class="op">=</span> <em>unspecified</em>; <span class="op">}</span></span>
<span id="cb37-15"><a href="#cb37-15"></a></span>
<span id="cb37-16"><a href="#cb37-16"></a>  <span class="co">// [range.zip.transform], zip transform view</span></span>
<span id="cb37-17"><a href="#cb37-17"></a>  <span class="kw">template</span><span class="op">&lt;</span>copy_constructible F, input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb37-18"><a href="#cb37-18"></a>    <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb37-19"><a href="#cb37-19"></a>             regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb37-20"><a href="#cb37-20"></a>             <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;&gt;</span></span>
<span id="cb37-21"><a href="#cb37-21"></a>  <span class="kw">class</span> zip_transform_view;</span>
<span id="cb37-22"><a href="#cb37-22"></a></span>
<span id="cb37-23"><a href="#cb37-23"></a>  <span class="kw">namespace</span> views <span class="op">{</span> <span class="kw">inline</span> <span class="kw">constexpr</span> <em>unspecified</em> zip_transform <span class="op">=</span> <em>unspecified</em>; <span class="op">}</span></span>
<span id="cb37-24"><a href="#cb37-24"></a></span>
<span id="cb37-25"><a href="#cb37-25"></a>  <span class="co">// [range.adjacent], adjacent view</span></span>
<span id="cb37-26"><a href="#cb37-26"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb37-27"><a href="#cb37-27"></a>      <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb37-28"><a href="#cb37-28"></a>  <span class="kw">class</span> adjacent_view;</span>
<span id="cb37-29"><a href="#cb37-29"></a></span>
<span id="cb37-30"><a href="#cb37-30"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> V, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb37-31"><a href="#cb37-31"></a>  <span class="kw">inline</span> <span class="kw">constexpr</span> <span class="dt">bool</span> enable_borrowed_range<span class="op">&lt;</span>adjacent_view<span class="op">&lt;</span>V, N<span class="op">&gt;&gt;</span></span>
<span id="cb37-32"><a href="#cb37-32"></a>      <span class="op">=</span> enable_borrowed_range<span class="op">&lt;</span>V<span class="op">&gt;</span>;</span>
<span id="cb37-33"><a href="#cb37-33"></a></span>
<span id="cb37-34"><a href="#cb37-34"></a>  <span class="kw">namespace</span> views <span class="op">{</span></span>
<span id="cb37-35"><a href="#cb37-35"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb37-36"><a href="#cb37-36"></a>    <span class="kw">inline</span> <span class="kw">constexpr</span> <em>unspecified</em> adjacent <span class="op">=</span> <em>unspecified</em>;</span>
<span id="cb37-37"><a href="#cb37-37"></a>    <span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">auto</span> pairwise <span class="op">=</span> adjacent<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;</span>;</span>
<span id="cb37-38"><a href="#cb37-38"></a>  <span class="op">}</span></span>
<span id="cb37-39"><a href="#cb37-39"></a></span>
<span id="cb37-40"><a href="#cb37-40"></a>  <span class="co">// [range.adjacent.transform], adjacent transform view</span></span>
<span id="cb37-41"><a href="#cb37-41"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, copy_constructible F, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb37-42"><a href="#cb37-42"></a>    <span class="kw">requires</span> <em>see below</em></span>
<span id="cb37-43"><a href="#cb37-43"></a>  <span class="kw">class</span> adjacent_transform_view;</span>
<span id="cb37-44"><a href="#cb37-44"></a></span>
<span id="cb37-45"><a href="#cb37-45"></a>  <span class="kw">namespace</span> views <span class="op">{</span></span>
<span id="cb37-46"><a href="#cb37-46"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb37-47"><a href="#cb37-47"></a>    <span class="kw">inline</span> <span class="kw">constexpr</span> <em>unspecified</em> adjacent_transform <span class="op">=</span> <em>unspecified</em>;</span>
<span id="cb37-48"><a href="#cb37-48"></a>    <span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">auto</span> pairwise_transform <span class="op">=</span> adjacent_transform<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;</span>;</span>
<span id="cb37-49"><a href="#cb37-49"></a>  <span class="op">}</span></span>
<span id="cb37-50"><a href="#cb37-50"></a><span class="op">}</span></span></code></pre></div>
<h2 data-number="5.5" id="zip"><span class="header-section-number">5.5</span> <code class="sourceCode cpp">zip</code><a href="#zip" class="self-link"></a></h2>
<p>Add the following subclause to <span>24.7 <a href="https://wg21.link/range.adaptors">[range.adaptors]</a></span>.</p>
<h3 class="unnumbered" data-number id="zip-view-range.zip">24.7.? Zip view [range.zip]<a href="#zip-view-range.zip" class="self-link"></a></h3>
<h4 class="unnumbered" data-number id="overview-range.zip.overview">24.7.?.1 Overview [range.zip.overview]<a href="#overview-range.zip.overview" class="self-link"></a></h4>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code class="sourceCode cpp">zip_view</code> takes any number of <code class="sourceCode cpp">view</code>s and produces a <code class="sourceCode cpp">view</code> that iterates over these views in parallel, in the form of a <code class="sourceCode cpp">tuple</code> or <code class="sourceCode cpp">pair</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The name <code class="sourceCode cpp">views<span class="op">::</span>zip</code> denotes a customization point object (<span>16.3.3.3.6 <a href="https://wg21.link/customization.point.object">[customization.point.object]</a></span>). Given a pack of subexpressions <code class="sourceCode cpp">Es<span class="op">...</span></code>, the expression <code class="sourceCode cpp">views<span class="op">::</span>zip<span class="op">(</span>Es<span class="op">...)</span></code> is expression-equivalent to</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> <code class="sourceCode cpp"><em>decay-copy</em><span class="op">(</span>views<span class="op">::</span>empty<span class="op">&lt;</span>tuple<span class="op">&lt;&gt;&gt;)</span></code> if <code class="sourceCode cpp">Es</code> is an empty pack,</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> otherwise, <code class="sourceCode cpp">zip_view<span class="op">&lt;</span>views<span class="op">::</span>all_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">((</span>Es<span class="op">))&gt;...&gt;(</span>Es<span class="op">...)</span></code>.</li>
</ul>
<h4 class="unnumbered" data-number id="class-template-zip_view-range.zip.view">24.7.?.2 Class template <code class="sourceCode cpp">zip_view</code> [range.zip.view]<a href="#class-template-zip_view-range.zip.view" class="self-link"></a></h4>
<div class="sourceCode" id="cb38"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb38-1"><a href="#cb38-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb38-2"><a href="#cb38-2"></a></span>
<span id="cb38-3"><a href="#cb38-3"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Rs<span class="op">&gt;</span></span>
<span id="cb38-4"><a href="#cb38-4"></a><span class="kw">concept</span> <em>zip-is-common</em> <span class="op">=</span>             <span class="co">// exposition only</span></span>
<span id="cb38-5"><a href="#cb38-5"></a>  <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Rs<span class="op">)</span> <span class="op">==</span> <span class="dv">1</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>common_range<span class="op">&lt;</span>Rs<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...))</span> <span class="op">||</span></span>
<span id="cb38-6"><a href="#cb38-6"></a>  <span class="op">(!(</span>bidirectional_range<span class="op">&lt;</span>Rs<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>common_range<span class="op">&lt;</span>Rs<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...))</span> <span class="op">||</span></span>
<span id="cb38-7"><a href="#cb38-7"></a>  <span class="op">((</span>random_access_range<span class="op">&lt;</span>Rs<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>sized_range<span class="op">&lt;</span>Rs<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...))</span>;</span>
<span id="cb38-8"><a href="#cb38-8"></a></span>
<span id="cb38-9"><a href="#cb38-9"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Ts<span class="op">&gt;</span></span>
<span id="cb38-10"><a href="#cb38-10"></a><span class="kw">using</span> <em>tuple-or-pair</em> <span class="op">=</span> <em>see below</em>;  <span class="co">// exposition only</span></span>
<span id="cb38-11"><a href="#cb38-11"></a></span>
<span id="cb38-12"><a href="#cb38-12"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> F, <span class="kw">class</span> Tuple<span class="op">&gt;</span></span>
<span id="cb38-13"><a href="#cb38-13"></a><span class="kw">constexpr</span> <span class="kw">auto</span> <em>tuple-transform</em><span class="op">(</span>F<span class="op">&amp;&amp;</span> f, Tuple<span class="op">&amp;&amp;</span> tuple<span class="op">)</span> <span class="co">// exposition only</span></span>
<span id="cb38-14"><a href="#cb38-14"></a><span class="op">{</span></span>
<span id="cb38-15"><a href="#cb38-15"></a>  <span class="cf">return</span> apply<span class="op">([&amp;]&lt;</span><span class="kw">class</span><span class="op">...</span> Ts<span class="op">&gt;(</span>Ts<span class="op">&amp;&amp;...</span> elements<span class="op">){</span></span>
<span id="cb38-16"><a href="#cb38-16"></a>    <span class="cf">return</span> <em>tuple-or-pair</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, Ts<span class="op">&gt;...&gt;(</span></span>
<span id="cb38-17"><a href="#cb38-17"></a>      invoke<span class="op">(</span>f, std<span class="op">::</span>forward<span class="op">&lt;</span>Ts<span class="op">&gt;(</span>elements<span class="op">))...</span></span>
<span id="cb38-18"><a href="#cb38-18"></a>    <span class="op">)</span>;</span>
<span id="cb38-19"><a href="#cb38-19"></a>  <span class="op">}</span>, std<span class="op">::</span>forward<span class="op">&lt;</span>Tuple<span class="op">&gt;(</span>tuple<span class="op">))</span>;</span>
<span id="cb38-20"><a href="#cb38-20"></a><span class="op">}</span></span>
<span id="cb38-21"><a href="#cb38-21"></a></span>
<span id="cb38-22"><a href="#cb38-22"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> F, <span class="kw">class</span> Tuple<span class="op">&gt;</span></span>
<span id="cb38-23"><a href="#cb38-23"></a><span class="kw">constexpr</span> <span class="dt">void</span> <em>tuple-for-each</em><span class="op">(</span>F<span class="op">&amp;&amp;</span> f, Tuple<span class="op">&amp;&amp;</span> tuple<span class="op">)</span> <span class="co">// exposition only</span></span>
<span id="cb38-24"><a href="#cb38-24"></a><span class="op">{</span></span>
<span id="cb38-25"><a href="#cb38-25"></a>  apply<span class="op">([&amp;]&lt;</span><span class="kw">class</span><span class="op">...</span> Ts<span class="op">&gt;(</span>Ts<span class="op">&amp;&amp;...</span> elements<span class="op">){</span></span>
<span id="cb38-26"><a href="#cb38-26"></a>    <span class="op">(</span>invoke<span class="op">(</span>f, std<span class="op">::</span>forward<span class="op">&lt;</span>Ts<span class="op">&gt;(</span>elements<span class="op">))</span>, <span class="op">...)</span>;</span>
<span id="cb38-27"><a href="#cb38-27"></a>  <span class="op">}</span>, std<span class="op">::</span>forward<span class="op">&lt;</span>Tuple<span class="op">&gt;(</span>tuple<span class="op">))</span>;</span>
<span id="cb38-28"><a href="#cb38-28"></a><span class="op">}</span></span>
<span id="cb38-29"><a href="#cb38-29"></a></span>
<span id="cb38-30"><a href="#cb38-30"></a><span class="kw">template</span><span class="op">&lt;</span>input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb38-31"><a href="#cb38-31"></a>  <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb38-32"><a href="#cb38-32"></a><span class="kw">class</span> zip_view <span class="op">:</span> <span class="kw">public</span> view_interface<span class="op">&lt;</span>zip_view<span class="op">&lt;</span>Views<span class="op">...&gt;&gt;{</span></span>
<span id="cb38-33"><a href="#cb38-33"></a>  tuple<span class="op">&lt;</span>Views<span class="op">...&gt;</span> <em>views_</em>;                <span class="co">// exposition only</span></span>
<span id="cb38-34"><a href="#cb38-34"></a></span>
<span id="cb38-35"><a href="#cb38-35"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>iterator</em>;         <span class="co">// exposition only</span></span>
<span id="cb38-36"><a href="#cb38-36"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>sentinel</em>;         <span class="co">// exposition only</span></span>
<span id="cb38-37"><a href="#cb38-37"></a></span>
<span id="cb38-38"><a href="#cb38-38"></a><span class="kw">public</span><span class="op">:</span></span>
<span id="cb38-39"><a href="#cb38-39"></a>  <span class="kw">constexpr</span> zip_view<span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb38-40"><a href="#cb38-40"></a>  <span class="kw">constexpr</span> <span class="kw">explicit</span> zip_view<span class="op">(</span>Views<span class="op">...</span> views<span class="op">)</span>;</span>
<span id="cb38-41"><a href="#cb38-41"></a></span>
<span id="cb38-42"><a href="#cb38-42"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="kw">requires</span> <span class="op">(!(</span><em>simple-view</em><span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)){</span></span>
<span id="cb38-43"><a href="#cb38-43"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span><em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>begin, <em>views_</em><span class="op">))</span>;</span>
<span id="cb38-44"><a href="#cb38-44"></a>  <span class="op">}</span></span>
<span id="cb38-45"><a href="#cb38-45"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> <span class="op">(</span>range<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...){</span></span>
<span id="cb38-46"><a href="#cb38-46"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span><em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>begin, <em>views_</em><span class="op">))</span>;</span>
<span id="cb38-47"><a href="#cb38-47"></a>  <span class="op">}</span></span>
<span id="cb38-48"><a href="#cb38-48"></a></span>
<span id="cb38-49"><a href="#cb38-49"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">requires</span> <span class="op">(!(</span><em>simple-view</em><span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">!</span><em>zip-is-common</em><span class="op">&lt;</span>Views<span class="op">...&gt;){</span></span>
<span id="cb38-50"><a href="#cb38-50"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span><em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>end, <em>views_</em><span class="op">))</span>;</span>
<span id="cb38-51"><a href="#cb38-51"></a>  <span class="op">}</span></span>
<span id="cb38-52"><a href="#cb38-52"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">requires</span> <span class="op">(!(</span><em>simple-view</em><span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <em>zip-is-common</em><span class="op">&lt;</span>Views<span class="op">...&gt;){</span></span>
<span id="cb38-53"><a href="#cb38-53"></a>    <span class="cf">if</span> <span class="kw">constexpr</span> <span class="op">((</span>random_access_range<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)){</span></span>
<span id="cb38-54"><a href="#cb38-54"></a>      <span class="cf">return</span> begin<span class="op">()</span> <span class="op">+</span> size<span class="op">()</span>;</span>
<span id="cb38-55"><a href="#cb38-55"></a>    <span class="op">}</span></span>
<span id="cb38-56"><a href="#cb38-56"></a>    <span class="cf">else</span> <span class="op">{</span></span>
<span id="cb38-57"><a href="#cb38-57"></a>      <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span><em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>end, <em>views_</em><span class="op">))</span>;</span>
<span id="cb38-58"><a href="#cb38-58"></a>    <span class="op">}</span></span>
<span id="cb38-59"><a href="#cb38-59"></a>  <span class="op">}</span></span>
<span id="cb38-60"><a href="#cb38-60"></a></span>
<span id="cb38-61"><a href="#cb38-61"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> <span class="op">((</span>range<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">!</span><em>zip-is-common</em><span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">...&gt;){</span></span>
<span id="cb38-62"><a href="#cb38-62"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span><em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>end, <em>views_</em><span class="op">))</span>;</span>
<span id="cb38-63"><a href="#cb38-63"></a>  <span class="op">}</span></span>
<span id="cb38-64"><a href="#cb38-64"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> <span class="op">((</span>range<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <em>zip-is-common</em><span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">...&gt;){</span></span>
<span id="cb38-65"><a href="#cb38-65"></a>    <span class="cf">if</span> <span class="kw">constexpr</span> <span class="op">((</span>random_access_range<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)){</span></span>
<span id="cb38-66"><a href="#cb38-66"></a>      <span class="cf">return</span> begin<span class="op">()</span> <span class="op">+</span> size<span class="op">()</span>;</span>
<span id="cb38-67"><a href="#cb38-67"></a>    <span class="op">}</span></span>
<span id="cb38-68"><a href="#cb38-68"></a>    <span class="cf">else</span> <span class="op">{</span></span>
<span id="cb38-69"><a href="#cb38-69"></a>      <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span><em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>end, <em>views_</em><span class="op">))</span>;</span>
<span id="cb38-70"><a href="#cb38-70"></a>    <span class="op">}</span></span>
<span id="cb38-71"><a href="#cb38-71"></a>  <span class="op">}</span></span>
<span id="cb38-72"><a href="#cb38-72"></a></span>
<span id="cb38-73"><a href="#cb38-73"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">requires</span> <span class="op">(</span>sized_range<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb38-74"><a href="#cb38-74"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> <span class="op">(</span>sized_range<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb38-75"><a href="#cb38-75"></a><span class="op">}</span>;</span>
<span id="cb38-76"><a href="#cb38-76"></a></span>
<span id="cb38-77"><a href="#cb38-77"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Rs<span class="op">&gt;</span></span>
<span id="cb38-78"><a href="#cb38-78"></a>  zip_view<span class="op">(</span>Rs<span class="op">&amp;&amp;...)</span> <span class="op">-&gt;</span> zip_view<span class="op">&lt;</span>views<span class="op">::</span>all_t<span class="op">&lt;</span>Rs<span class="op">&gt;...&gt;</span>;</span>
<span id="cb38-79"><a href="#cb38-79"></a></span>
<span id="cb38-80"><a href="#cb38-80"></a><span class="op">}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> Given some pack of types <code class="sourceCode cpp">Ts</code>, the alias template <code class="sourceCode cpp"><em>tuple-or-pair</em></code> is defined as follows:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> If <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>Ts<span class="op">)</span></code> is 2, <code class="sourceCode cpp"><em>tuple-or-pair</em><span class="op">&lt;</span>Ts<span class="op">...&gt;</span></code> denotes <code class="sourceCode cpp">pair<span class="op">&lt;</span>Ts<span class="op">...&gt;</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> Otherwise, <code class="sourceCode cpp"><em>tuple-or-pair</em><span class="op">&lt;</span>Ts<span class="op">...&gt;</span></code> denotes <code class="sourceCode cpp">tuple<span class="op">&lt;</span>Ts<span class="op">...&gt;</span></code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> Two <code class="sourceCode cpp">zip_view</code> objects have the same underlying sequence only if and only if the corresponding elements of <code class="sourceCode cpp"><em>views_</em></code> are equal (<span>18.2 <a href="https://wg21.link/concepts.equality">[concepts.equality]</a></span>) and have the same underlying sequence. <span class="note"><span>[ <em>Note ?:</em> </span>In particular, comparison of iterators obtained from <code class="sourceCode cpp">zip_view</code> objects that do not have the same underlying sequence is not required to produce meaningful results (<span>23.3.4.11 <a href="https://wg21.link/iterator.concept.forward">[iterator.concept.forward]</a></span>).<span> — <em>end note</em> ]</span></span></p>
<div>
<div class="sourceCode" id="cb39"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb39-1"><a href="#cb39-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> zip_view<span class="op">(</span>Views<span class="op">...</span> views<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>views_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>views<span class="op">)...</span></code>.</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="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">requires</span> <span class="op">(</span>sized_range<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb40-2"><a href="#cb40-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> <span class="op">(</span>sized_range<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb41"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb41-1"><a href="#cb41-1"></a><span class="cf">return</span> apply<span class="op">([](</span><span class="kw">auto</span><span class="op">...</span> sizes<span class="op">){</span></span>
<span id="cb41-2"><a href="#cb41-2"></a>  <span class="cf">return</span> ranges<span class="op">::</span>min<span class="op">({</span></span>
<span id="cb41-3"><a href="#cb41-3"></a>    common_type_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">(</span>sizes<span class="op">)...&gt;(</span>sizes<span class="op">)...</span></span>
<span id="cb41-4"><a href="#cb41-4"></a>  <span class="op">})</span>;</span>
<span id="cb41-5"><a href="#cb41-5"></a><span class="op">}</span>, <em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>size, <em>views_</em><span class="op">))</span>;</span></code></pre></div>
</blockquote>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-zip_view_iterator_-range.zip.iterator">24.7.?.3 Class template <code class="sourceCode cpp">zip_view<span class="op">::</span><em>iterator</em></code> [range.zip.iterator]<a href="#class-template-zip_view_iterator_-range.zip.iterator" class="self-link"></a></h4>
<div class="sourceCode" id="cb42"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb42-1"><a href="#cb42-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb42-2"><a href="#cb42-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb42-3"><a href="#cb42-3"></a>    <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb42-4"><a href="#cb42-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb42-5"><a href="#cb42-5"></a>  <span class="kw">class</span> zip_view<span class="op">&lt;</span>Views<span class="op">...&gt;::</span><em>iterator</em> <span class="op">{</span></span>
<span id="cb42-6"><a href="#cb42-6"></a>    <em>tuple-or-pair</em><span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span> <em>current_</em>;                             <span class="co">// exposition only</span></span>
<span id="cb42-7"><a href="#cb42-7"></a>    <span class="kw">constexpr</span> <span class="kw">explicit</span> <em>iterator</em><span class="op">(</span><em>tuple-or-pair</em><span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span> current<span class="op">)</span>; <span class="co">// exposition only</span></span>
<span id="cb42-8"><a href="#cb42-8"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb42-9"><a href="#cb42-9"></a>    <span class="kw">using</span> iterator_category <span class="op">=</span> input_iterator_tag; <span class="co">// not always present</span></span>
<span id="cb42-10"><a href="#cb42-10"></a>    <span class="kw">using</span> iterator_concept  <span class="op">=</span> <em>see below</em>;</span>
<span id="cb42-11"><a href="#cb42-11"></a>    <span class="kw">using</span> value_type <span class="op">=</span> <em>tuple-or-pair</em><span class="op">&lt;</span>range_value_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span>;</span>
<span id="cb42-12"><a href="#cb42-12"></a>    <span class="kw">using</span> difference_type <span class="op">=</span> common_type_t<span class="op">&lt;</span>range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span>;</span>
<span id="cb42-13"><a href="#cb42-13"></a></span>
<span id="cb42-14"><a href="#cb42-14"></a>    <em>iterator</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb42-15"><a href="#cb42-15"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb42-16"><a href="#cb42-16"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> <span class="op">(</span>convertible_to<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>Views<span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-17"><a href="#cb42-17"></a></span>
<span id="cb42-18"><a href="#cb42-18"></a>    <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span>;</span>
<span id="cb42-19"><a href="#cb42-19"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span>
<span id="cb42-20"><a href="#cb42-20"></a>    <span class="kw">constexpr</span> <span class="dt">void</span> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span>
<span id="cb42-21"><a href="#cb42-21"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> <span class="op">(</span>forward_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-22"><a href="#cb42-22"></a></span>
<span id="cb42-23"><a href="#cb42-23"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> <span class="op">(</span>bidirectional_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-24"><a href="#cb42-24"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> <span class="op">(</span>bidirectional_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-25"><a href="#cb42-25"></a></span>
<span id="cb42-26"><a href="#cb42-26"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span></span>
<span id="cb42-27"><a href="#cb42-27"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-28"><a href="#cb42-28"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span></span>
<span id="cb42-29"><a href="#cb42-29"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-30"><a href="#cb42-30"></a></span>
<span id="cb42-31"><a href="#cb42-31"></a>    <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span></span>
<span id="cb42-32"><a href="#cb42-32"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-33"><a href="#cb42-33"></a></span>
<span id="cb42-34"><a href="#cb42-34"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-35"><a href="#cb42-35"></a>      <span class="kw">requires</span> <span class="op">(</span>equality_comparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-36"><a href="#cb42-36"></a></span>
<span id="cb42-37"><a href="#cb42-37"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-38"><a href="#cb42-38"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-39"><a href="#cb42-39"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-40"><a href="#cb42-40"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-41"><a href="#cb42-41"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-42"><a href="#cb42-42"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-43"><a href="#cb42-43"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-44"><a href="#cb42-44"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-45"><a href="#cb42-45"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-46"><a href="#cb42-46"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span></span>
<span id="cb42-47"><a href="#cb42-47"></a>               <span class="op">(</span>three_way_comparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-48"><a href="#cb42-48"></a></span>
<span id="cb42-49"><a href="#cb42-49"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb42-50"><a href="#cb42-50"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-51"><a href="#cb42-51"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb42-52"><a href="#cb42-52"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-53"><a href="#cb42-53"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb42-54"><a href="#cb42-54"></a>      <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-55"><a href="#cb42-55"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb42-56"><a href="#cb42-56"></a>      <span class="kw">requires</span> <span class="op">(</span>sized_sentinel_for<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-57"><a href="#cb42-57"></a></span>
<span id="cb42-58"><a href="#cb42-58"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> iter_move<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb42-59"><a href="#cb42-59"></a>      <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span>
<span id="cb42-60"><a href="#cb42-60"></a></span>
<span id="cb42-61"><a href="#cb42-61"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">void</span> iter_swap<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> l, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> r<span class="op">)</span></span>
<span id="cb42-62"><a href="#cb42-62"></a>      <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span></span>
<span id="cb42-63"><a href="#cb42-63"></a>      <span class="kw">requires</span> <span class="op">(</span>indirectly_swappable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb42-64"><a href="#cb42-64"></a>  <span class="op">}</span>;</span>
<span id="cb42-65"><a href="#cb42-65"></a><span class="op">}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code class="sourceCode cpp"><em>iterator</em><span class="op">::</span>iterator_concept</code> is defined as follows:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> If every type in <code class="sourceCode cpp">Views</code> models <code class="sourceCode cpp">random_access_range</code>, then <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">random_access_iterator_tag</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> Otherwise, if every type in <code class="sourceCode cpp">Views</code> models <code class="sourceCode cpp">bidirectional_range</code>, then <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">bidirectional_iterator_tag</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.3)</a></span> Otherwise, if every type in <code class="sourceCode cpp">Views</code> models <code class="sourceCode cpp">forward_range</code>, then <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">forward_iterator_tag</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.4)</a></span> Otherwise, <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">input_iterator_tag</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <code class="sourceCode cpp"><em>iterator</em><span class="op">::</span>iterator_category</code> is present if and only if every type in <code class="sourceCode cpp">Views</code> models <code class="sourceCode cpp">forward_range</code>.</p>
<div>
<div class="sourceCode" id="cb43"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb43-1"><a href="#cb43-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> <em>iterator</em><span class="op">(</span><em>tuple-or-pair</em><span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span> current<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>current_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>current<span class="op">)</span></code>.</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="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb44-2"><a href="#cb44-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> <span class="op">(</span>convertible_to<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>Views<span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>current_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>current_</em><span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb46"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb46-1"><a href="#cb46-1"></a>  <span class="cf">return</span> <em>tuple-transform</em><span class="op">([](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="op">*</span>i; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb47"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb47-1"><a href="#cb47-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb48"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb48-1"><a href="#cb48-1"></a>  <em>tuple-for-each</em><span class="op">([](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">{</span> <span class="op">++</span>i; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span>
<span id="cb48-2"><a href="#cb48-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb49"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb49-1"><a href="#cb49-1"></a><span class="kw">constexpr</span> <span class="dt">void</span> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to <code class="sourceCode cpp"><span class="op">++*</span><span class="kw">this</span>;</code>.</p>
</blockquote>
<div class="sourceCode" id="cb50"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb50-1"><a href="#cb50-1"></a><span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> <span class="op">(</span>forward_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb51"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb51-1"><a href="#cb51-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb51-2"><a href="#cb51-2"></a>  <span class="op">++*</span><span class="kw">this</span>;</span>
<span id="cb51-3"><a href="#cb51-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb52"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb52-1"><a href="#cb52-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> <span class="op">(</span>bidirectional_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb53"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb53-1"><a href="#cb53-1"></a>  <em>tuple-for-each</em><span class="op">([](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">{</span> <span class="op">--</span>i; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span>
<span id="cb53-2"><a href="#cb53-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb54"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb54-1"><a href="#cb54-1"></a><span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> <span class="op">(</span>bidirectional_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb55"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb55-1"><a href="#cb55-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb55-2"><a href="#cb55-2"></a>  <span class="op">--*</span><span class="kw">this</span>;</span>
<span id="cb55-3"><a href="#cb55-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb56"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb56-1"><a href="#cb56-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span></span>
<span id="cb56-2"><a href="#cb56-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb57"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb57-1"><a href="#cb57-1"></a>  <em>tuple-for-each</em><span class="op">([](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">{</span> i <span class="op">+=</span> x; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span>
<span id="cb57-2"><a href="#cb57-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb58"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb58-1"><a href="#cb58-1"></a>  <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span></span>
<span id="cb58-2"><a href="#cb58-2"></a>    <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb59"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb59-1"><a href="#cb59-1"></a>  <em>tuple-for-each</em><span class="op">([](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">{</span> i <span class="op">-=</span> x; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span>
<span id="cb59-2"><a href="#cb59-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb60"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb60-1"><a href="#cb60-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span></span>
<span id="cb60-2"><a href="#cb60-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb61"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb61-1"><a href="#cb61-1"></a>  <span class="cf">return</span> <em>tuple-transform</em><span class="op">([&amp;](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> i<span class="op">[</span>n<span class="op">]</span>; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb62"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb62-1"><a href="#cb62-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb62-2"><a href="#cb62-2"></a>  <span class="kw">requires</span> <span class="op">(</span>equality_comparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Returns</em>:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(14.1)</a></span> <code class="sourceCode cpp">x<span class="op">.</span><em>current_</em> <span class="op">==</span> y<span class="op">.</span><em>current_</em></code> if <code class="sourceCode cpp"><span class="op">(</span>bidirectional_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(14.2)</a></span> Otherwise, <code class="sourceCode cpp"><span class="kw">true</span></code> if there exists an integer 0 ≤ <em>i</em> &lt; <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span></code> such that <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>x<span class="op">.</span><em>current_</em><span class="op">)</span> <span class="op">==</span> get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>y<span class="op">.</span><em>current_</em><span class="op">))</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(14.3)</a></span> Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <span class="note"><span>[ <em>Note ?:</em> </span>For non-bidirectional views, the use of logical OR on the result of individual comparisons allows <code class="sourceCode cpp">zip_view</code> to model <code class="sourceCode cpp">common_range</code> when all constituent views model <code class="sourceCode cpp">common_range</code>.<span> — <em>end note</em> ]</span></span></p>
</blockquote>
<div class="sourceCode" id="cb63"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb63-1"><a href="#cb63-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb63-2"><a href="#cb63-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<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><em>current_</em> <span class="op">&lt;</span> y<span class="op">.</span><em>current_</em>;</code></p>
</blockquote>
<div class="sourceCode" id="cb64"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb64-1"><a href="#cb64-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb64-2"><a href="#cb64-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<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>
</blockquote>
<div class="sourceCode" id="cb65"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb65-1"><a href="#cb65-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb65-2"><a href="#cb65-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<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>
</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">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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb66-2"><a href="#cb66-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<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>
</blockquote>
<div class="sourceCode" id="cb67"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb67-1"><a href="#cb67-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb67-2"><a href="#cb67-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span></span>
<span id="cb67-3"><a href="#cb67-3"></a>            <span class="op">(</span>three_way_comparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">20</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span><em>current_</em> <span class="op">&lt;=&gt;</span> y<span class="op">.</span><em>current_</em>;</code></p>
</blockquote>
<div class="sourceCode" id="cb68"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb68-1"><a href="#cb68-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb68-2"><a href="#cb68-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb68-3"><a href="#cb68-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb68-4"><a href="#cb68-4"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">21</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb69"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb69-1"><a href="#cb69-1"></a>  <span class="cf">return</span> <em>iterator</em><span class="op">(</span><em>tuple-transform</em><span class="op">([&amp;](</span><span class="kw">auto</span><span class="op">&amp;</span> it<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> it <span class="op">+</span> n; <span class="op">}</span>, i<span class="op">.</span><em>current_</em><span class="op">))</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb70"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb70-1"><a href="#cb70-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb70-2"><a href="#cb70-2"></a>  <span class="kw">requires</span> <span class="op">(</span>random_access_range<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">22</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb71"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb71-1"><a href="#cb71-1"></a>  <span class="cf">return</span> <em>iterator</em><span class="op">(</span><em>tuple-transform</em><span class="op">([&amp;](</span><span class="kw">auto</span><span class="op">&amp;</span> it<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> it <span class="op">-</span> n; <span class="op">}</span>, i<span class="op">.</span><em>current_</em><span class="op">))</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb72"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb72-1"><a href="#cb72-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb72-2"><a href="#cb72-2"></a>  <span class="kw">requires</span> <span class="op">(</span>sized_sentinel_for<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">23</a></span> Let <em>DIST(i)</em> be <code class="sourceCode cpp">get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>x<span class="op">.</span><em>current_</em><span class="op">)</span> <span class="op">-</span> get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>y<span class="op">.</span><em>current_</em><span class="op">)</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">24</a></span> <em>Returns:</em> The value with the smallest absolute value among <em>DIST(n)</em> for all integers 0 ≤ <em>n</em> &lt; <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span></code>,</p>
</blockquote>
<div class="sourceCode" id="cb73"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb73-1"><a href="#cb73-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> iter_move<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb73-2"><a href="#cb73-2"></a>  <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb74"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb74-1"><a href="#cb74-1"></a>  <span class="cf">return</span> <em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>iter_move, i<span class="op">.</span><em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span> <em>Remarks:</em> The expression within <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to</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="op">(</span><span class="kw">noexcept</span><span class="op">(</span>ranges<span class="op">::</span>iter_move<span class="op">(</span>declval<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;()))</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span></span>
<span id="cb75-2"><a href="#cb75-2"></a>  <span class="op">(</span>is_nothrow_move_constructible_v<span class="op">&lt;</span>range_rvalue_reference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb76"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb76-1"><a href="#cb76-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">void</span> iter_swap<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> l, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> r<span class="op">)</span></span>
<span id="cb76-2"><a href="#cb76-2"></a>  <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span></span>
<span id="cb76-3"><a href="#cb76-3"></a>  <span class="kw">requires</span> <span class="op">(</span>indirectly_swappable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">27</a></span> <em>Effects</em>: For every integer <em>i</em> in <code class="sourceCode cpp"><span class="op">[</span><span class="dv">0</span>, <span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">))</span></code>, performs <code class="sourceCode cpp">ranges<span class="op">::</span>iter_swap<span class="op">(</span>get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>l<span class="op">.</span><em>current_</em><span class="op">)</span>, get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>r<span class="op">.</span><em>current_</em><span class="op">))</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">28</a></span> <em>Remarks:</em> The expression within <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to the logical AND of the following expressions:</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">noexcept</span><span class="op">(</span>ranges<span class="op">::</span>iter_swap<span class="op">(</span>get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>l<span class="op">.</span><em>current_</em><span class="op">)</span>, get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>r<span class="op">.</span><em>current_</em><span class="op">)))</span></span></code></pre></div>
</blockquote>
<p>for every integer <em>i</em> in <code class="sourceCode cpp"><span class="op">[</span><span class="dv">0</span>, <span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">))</span></code>.</p>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-zip_view_sentinel_-range.zip.sentinel">24.7.?.4 Class template <code class="sourceCode cpp">zip_view<span class="op">::</span><em>sentinel</em></code> [range.zip.sentinel]<a href="#class-template-zip_view_sentinel_-range.zip.sentinel" class="self-link"></a></h4>
<div class="sourceCode" id="cb78"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb78-1"><a href="#cb78-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb78-2"><a href="#cb78-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb78-3"><a href="#cb78-3"></a>    <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb78-4"><a href="#cb78-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb78-5"><a href="#cb78-5"></a>  <span class="kw">class</span> zip_view<span class="op">&lt;</span>Views<span class="op">...&gt;::</span><em>sentinel</em> <span class="op">{</span></span>
<span id="cb78-6"><a href="#cb78-6"></a>    <em>tuple-or-pair</em><span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span> <em>end_</em>;                                <span class="co">// exposition only</span></span>
<span id="cb78-7"><a href="#cb78-7"></a>    <span class="kw">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span><em>tuple-or-pair</em><span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span> end<span class="op">)</span>;    <span class="co">// exposition only</span></span>
<span id="cb78-8"><a href="#cb78-8"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb78-9"><a href="#cb78-9"></a>    <em>sentinel</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb78-10"><a href="#cb78-10"></a>    <span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb78-11"><a href="#cb78-11"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> <span class="op">(</span>convertible_to<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span>Views<span class="op">&gt;</span>, sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span>
<span id="cb78-12"><a href="#cb78-12"></a></span>
<span id="cb78-13"><a href="#cb78-13"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb78-14"><a href="#cb78-14"></a>      <span class="kw">requires</span> <span class="op">(</span>sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span>
<span id="cb78-15"><a href="#cb78-15"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb78-16"><a href="#cb78-16"></a></span>
<span id="cb78-17"><a href="#cb78-17"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb78-18"><a href="#cb78-18"></a>      <span class="kw">requires</span> <span class="op">(</span>sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span>
<span id="cb78-19"><a href="#cb78-19"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> common_type_t<span class="op">&lt;</span>range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;...&gt;</span></span>
<span id="cb78-20"><a href="#cb78-20"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb78-21"><a href="#cb78-21"></a></span>
<span id="cb78-22"><a href="#cb78-22"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb78-23"><a href="#cb78-23"></a>      <span class="kw">requires</span> <span class="op">(</span>sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span>
<span id="cb78-24"><a href="#cb78-24"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> common_type_t<span class="op">&lt;</span>range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;...&gt;</span></span>
<span id="cb78-25"><a href="#cb78-25"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x<span class="op">)</span>;</span>
<span id="cb78-26"><a href="#cb78-26"></a>  <span class="op">}</span>;</span>
<span id="cb78-27"><a href="#cb78-27"></a><span class="op">}</span></span></code></pre></div>
<div>
<div class="sourceCode" id="cb79"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb79-1"><a href="#cb79-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span><em>tuple-or-pair</em><span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span> end<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>end_</em></code> with <code class="sourceCode cpp">end</code>.</p>
</blockquote>
<div class="sourceCode" id="cb80"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb80-1"><a href="#cb80-1"></a><span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb80-2"><a href="#cb80-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> <span class="op">(</span>convertible_to<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span>Views<span class="op">&gt;</span>, sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>end_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>end_</em><span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb81"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb81-1"><a href="#cb81-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb81-2"><a href="#cb81-2"></a>  <span class="kw">requires</span> <span class="op">(</span>sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span>
<span id="cb81-3"><a href="#cb81-3"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if there exists an integer 0 ≤ <em>i</em> &lt; <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span></code> such that <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>x<span class="op">.</span><em>current_</em><span class="op">)</span> <span class="op">==</span> get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>y<span class="op">.</span><em>end_</em><span class="op">))</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb82"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb82-1"><a href="#cb82-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb82-2"><a href="#cb82-2"></a>  <span class="kw">requires</span> <span class="op">(</span>sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span>
<span id="cb82-3"><a href="#cb82-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> common_type_t<span class="op">&lt;</span>range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;...&gt;</span></span>
<span id="cb82-4"><a href="#cb82-4"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> Let <em>DIST(i)</em> be <code class="sourceCode cpp">get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>x<span class="op">.</span><em>current_</em><span class="op">)</span> <span class="op">-</span> get<span class="op">&lt;</span><em>i</em><span class="op">&gt;(</span>y<span class="op">.</span><em>end_</em><span class="op">)</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns:</em> The value with the smallest absolute value among <em>DIST(n)</em> for all integers 0 ≤ <em>n</em> &lt; <code class="sourceCode cpp"><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span></code>,</p>
</blockquote>
<div class="sourceCode" id="cb83"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb83-1"><a href="#cb83-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb83-2"><a href="#cb83-2"></a>  <span class="kw">requires</span> <span class="op">(</span>sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></span>
<span id="cb83-3"><a href="#cb83-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> common_type_t<span class="op">&lt;</span>range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, Views<span class="op">&gt;&gt;...&gt;</span></span>
<span id="cb83-4"><a href="#cb83-4"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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>
</blockquote>
</div>
<h2 data-number="5.6" id="zip_transform"><span class="header-section-number">5.6</span> <code class="sourceCode cpp">zip_transform</code><a href="#zip_transform" class="self-link"></a></h2>
<p>Add the following subclause to <span>24.7 <a href="https://wg21.link/range.adaptors">[range.adaptors]</a></span>.</p>
<h3 class="unnumbered" data-number id="zip-transform-view-range.zip.transform">24.7.? Zip transform view [range.zip.transform]<a href="#zip-transform-view-range.zip.transform" class="self-link"></a></h3>
<h4 class="unnumbered" data-number id="overview-range.zip.transform.overview">24.7.?.1 Overview [range.zip.transform.overview]<a href="#overview-range.zip.transform.overview" class="self-link"></a></h4>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code class="sourceCode cpp">zip_transform_view</code> takes an invocable object and any number of <code class="sourceCode cpp">view</code>s and produces a <code class="sourceCode cpp">view</code> whose <em>M <sup>th</sup></em> element is the result of applying the invocable object to the <em>M <sup>th</sup></em> elements of all views.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The name <code class="sourceCode cpp">views<span class="op">::</span>zip_transform</code> denotes a customization point object (<span>16.3.3.3.6 <a href="https://wg21.link/customization.point.object">[customization.point.object]</a></span>). Given a subexpression <code class="sourceCode cpp">F</code> and a pack of subexpressions <code class="sourceCode cpp">Es<span class="op">...</span></code>,</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> if <code class="sourceCode cpp">Es</code> is an empty pack, let <code class="sourceCode cpp">FD</code> be <code class="sourceCode cpp">decay_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">((</span>F<span class="op">))&gt;</span></code>.
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1.1)</a></span> if <code class="sourceCode cpp">copy_constructible<span class="op">&lt;</span>FD<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> regular_invocable<span class="op">&lt;</span>FD<span class="op">&amp;&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">false</span></code>, <code class="sourceCode cpp">views<span class="op">::</span>zip_transform<span class="op">(</span>F, Es<span class="op">...)</span></code> is ill-formed.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.1.2)</a></span> Otherwise, the expression <code class="sourceCode cpp">views<span class="op">::</span>zip_transform<span class="op">(</span>F, Es<span class="op">...)</span></code> is expression-equivalent to <code class="sourceCode cpp"><span class="op">(</span><span class="dt">void</span><span class="op">)</span>F, <em>decay-copy</em><span class="op">(</span>views<span class="op">::</span>empty<span class="op">&lt;</span>decay_t<span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>FD<span class="op">&amp;&gt;&gt;&gt;)</span></code>.</li>
</ul></li>
<li><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> Otherwise, the expression <code class="sourceCode cpp">views<span class="op">::</span>zip_transform<span class="op">(</span>F, Es<span class="op">...)</span></code> is expression-equivalent to<code class="sourceCode cpp">zip_transform_view<span class="op">(</span>F, Es<span class="op">...)</span></code>.</li>
</ul>
<h4 class="unnumbered" data-number id="class-template-zip_transform_view-range.zip.transform.view">24.7.?.2 Class template <code class="sourceCode cpp">zip_transform_view</code> [range.zip.transform.view]<a href="#class-template-zip_transform_view-range.zip.transform.view" class="self-link"></a></h4>
<div class="sourceCode" id="cb84"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb84-1"><a href="#cb84-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb84-2"><a href="#cb84-2"></a></span>
<span id="cb84-3"><a href="#cb84-3"></a><span class="kw">template</span><span class="op">&lt;</span>copy_constructible F, input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb84-4"><a href="#cb84-4"></a>  <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb84-5"><a href="#cb84-5"></a>            regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb84-6"><a href="#cb84-6"></a>            <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;&gt;</span></span>
<span id="cb84-7"><a href="#cb84-7"></a><span class="kw">class</span> zip_transform_view <span class="op">:</span> <span class="kw">public</span> view_interface<span class="op">&lt;</span>zip_transform_view<span class="op">&lt;</span>F, Views<span class="op">...&gt;&gt;</span> <span class="op">{</span></span>
<span id="cb84-8"><a href="#cb84-8"></a>  <em>semiregular-box</em><span class="op">&lt;</span>F<span class="op">&gt;</span> <em>fun_</em>;               <span class="co">// exposition only</span></span>
<span id="cb84-9"><a href="#cb84-9"></a>  zip_view<span class="op">&lt;</span>Views<span class="op">...&gt;</span> <em>zip_</em>;               <span class="co">// exposition only</span></span>
<span id="cb84-10"><a href="#cb84-10"></a></span>
<span id="cb84-11"><a href="#cb84-11"></a>  <span class="kw">using</span> <em>InnerView</em> <span class="op">=</span> zip_view<span class="op">&lt;</span>Views<span class="op">...&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb84-12"><a href="#cb84-12"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb84-13"><a href="#cb84-13"></a>  <span class="kw">using</span> <em>ziperator</em> <span class="op">=</span> iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, <em>InnerView</em><span class="op">&gt;&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb84-14"><a href="#cb84-14"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb84-15"><a href="#cb84-15"></a>  <span class="kw">using</span> <em>zentinel</em> <span class="op">=</span> sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, <em>InnerView</em><span class="op">&gt;&gt;</span>;   <span class="co">// exposition only</span></span>
<span id="cb84-16"><a href="#cb84-16"></a></span>
<span id="cb84-17"><a href="#cb84-17"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>iterator</em>;         <span class="co">// exposition only</span></span>
<span id="cb84-18"><a href="#cb84-18"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>sentinel</em>;         <span class="co">// exposition only</span></span>
<span id="cb84-19"><a href="#cb84-19"></a></span>
<span id="cb84-20"><a href="#cb84-20"></a><span class="kw">public</span><span class="op">:</span></span>
<span id="cb84-21"><a href="#cb84-21"></a>  <span class="kw">constexpr</span> zip_transform_view<span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb84-22"><a href="#cb84-22"></a></span>
<span id="cb84-23"><a href="#cb84-23"></a>  <span class="kw">constexpr</span> <span class="kw">explicit</span> zip_transform_view<span class="op">(</span>F fun, Views<span class="op">...</span> views<span class="op">)</span>;</span>
<span id="cb84-24"><a href="#cb84-24"></a></span>
<span id="cb84-25"><a href="#cb84-25"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="op">{</span></span>
<span id="cb84-26"><a href="#cb84-26"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>zip_</em><span class="op">.</span>begin<span class="op">())</span>;</span>
<span id="cb84-27"><a href="#cb84-27"></a>  <span class="op">}</span></span>
<span id="cb84-28"><a href="#cb84-28"></a></span>
<span id="cb84-29"><a href="#cb84-29"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="kw">const</span></span>
<span id="cb84-30"><a href="#cb84-30"></a>    <span class="kw">requires</span> range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb84-31"><a href="#cb84-31"></a>             regular_invocable<span class="op">&lt;</span><span class="kw">const</span> F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;...&gt;</span></span>
<span id="cb84-32"><a href="#cb84-32"></a>  <span class="op">{</span></span>
<span id="cb84-33"><a href="#cb84-33"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>zip_</em><span class="op">.</span>begin<span class="op">())</span>;</span>
<span id="cb84-34"><a href="#cb84-34"></a>  <span class="op">}</span></span>
<span id="cb84-35"><a href="#cb84-35"></a></span>
<span id="cb84-36"><a href="#cb84-36"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="op">{</span></span>
<span id="cb84-37"><a href="#cb84-37"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span><em>zip_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb84-38"><a href="#cb84-38"></a>  <span class="op">}</span></span>
<span id="cb84-39"><a href="#cb84-39"></a></span>
<span id="cb84-40"><a href="#cb84-40"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">requires</span> common_range<span class="op">&lt;</span><em>InnerView</em><span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb84-41"><a href="#cb84-41"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>zip_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb84-42"><a href="#cb84-42"></a>  <span class="op">}</span></span>
<span id="cb84-43"><a href="#cb84-43"></a></span>
<span id="cb84-44"><a href="#cb84-44"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span></span>
<span id="cb84-45"><a href="#cb84-45"></a>    <span class="kw">requires</span> range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb84-46"><a href="#cb84-46"></a>             regular_invocable<span class="op">&lt;</span><span class="kw">const</span> F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;...&gt;</span></span>
<span id="cb84-47"><a href="#cb84-47"></a>  <span class="op">{</span></span>
<span id="cb84-48"><a href="#cb84-48"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span><em>zip_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb84-49"><a href="#cb84-49"></a>  <span class="op">}</span></span>
<span id="cb84-50"><a href="#cb84-50"></a></span>
<span id="cb84-51"><a href="#cb84-51"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span></span>
<span id="cb84-52"><a href="#cb84-52"></a>    <span class="kw">requires</span> common_range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb84-53"><a href="#cb84-53"></a>             regular_invocable<span class="op">&lt;</span><span class="kw">const</span> F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span><span class="kw">const</span> Views<span class="op">&gt;...&gt;</span></span>
<span id="cb84-54"><a href="#cb84-54"></a>  <span class="op">{</span></span>
<span id="cb84-55"><a href="#cb84-55"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>zip_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb84-56"><a href="#cb84-56"></a>  <span class="op">}</span></span>
<span id="cb84-57"><a href="#cb84-57"></a></span>
<span id="cb84-58"><a href="#cb84-58"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span><em>InnerView</em><span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb84-59"><a href="#cb84-59"></a>    <span class="cf">return</span> <em>zip_</em><span class="op">.</span>size<span class="op">()</span>;</span>
<span id="cb84-60"><a href="#cb84-60"></a>  <span class="op">}</span></span>
<span id="cb84-61"><a href="#cb84-61"></a></span>
<span id="cb84-62"><a href="#cb84-62"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb84-63"><a href="#cb84-63"></a>    <span class="cf">return</span> <em>zip_</em><span class="op">.</span>size<span class="op">()</span>;</span>
<span id="cb84-64"><a href="#cb84-64"></a>  <span class="op">}</span></span>
<span id="cb84-65"><a href="#cb84-65"></a><span class="op">}</span>;</span>
<span id="cb84-66"><a href="#cb84-66"></a></span>
<span id="cb84-67"><a href="#cb84-67"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> F, <span class="kw">class</span><span class="op">...</span> Rs<span class="op">&gt;</span></span>
<span id="cb84-68"><a href="#cb84-68"></a>  zip_transform_view<span class="op">(</span>F, Rs<span class="op">&amp;&amp;...)</span> <span class="op">-&gt;</span> zip_transform_view<span class="op">&lt;</span>F, views<span class="op">::</span>all_t<span class="op">&lt;</span>Rs<span class="op">&gt;...&gt;</span>;</span>
<span id="cb84-69"><a href="#cb84-69"></a></span>
<span id="cb84-70"><a href="#cb84-70"></a><span class="op">}</span></span></code></pre></div>
<div>
<div class="sourceCode" id="cb85"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb85-1"><a href="#cb85-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> zip_transform_view<span class="op">(</span>F fun, Views<span class="op">...</span> views<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>fun_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>fun<span class="op">)</span></code> and <code class="sourceCode cpp"><em>zip_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>views<span class="op">)...</span></code>.</p>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-zip_transform_view_iterator_-range.zip.transform.iterator">24.7.?.3 Class template <code class="sourceCode cpp">zip_transform_view<span class="op">::</span><em>iterator</em></code> [range.zip.transform.iterator]<a href="#class-template-zip_transform_view_iterator_-range.zip.transform.iterator" class="self-link"></a></h4>
<div class="sourceCode" id="cb86"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb86-1"><a href="#cb86-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb86-2"><a href="#cb86-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>copy_constructible F, input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb86-3"><a href="#cb86-3"></a>    <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb86-4"><a href="#cb86-4"></a>              regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb86-5"><a href="#cb86-5"></a>              <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;&gt;</span></span>
<span id="cb86-6"><a href="#cb86-6"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb86-7"><a href="#cb86-7"></a>  <span class="kw">class</span> zip_transform_view<span class="op">&lt;</span>F, Views<span class="op">...&gt;::</span><em>iterator</em> <span class="op">{</span></span>
<span id="cb86-8"><a href="#cb86-8"></a>    <span class="kw">using</span> <em>Parent</em> <span class="op">=</span> <em>maybe-const</em><span class="op">&lt;</span>Const, zip_transform_view<span class="op">&gt;</span>;      <span class="co">// exposition only</span></span>
<span id="cb86-9"><a href="#cb86-9"></a>    <span class="kw">using</span> <em>Base</em> <span class="op">=</span> <em>maybe-const</em><span class="op">&lt;</span>Const, <em>InnerView</em><span class="op">&gt;</span>;                 <span class="co">// exposition only</span></span>
<span id="cb86-10"><a href="#cb86-10"></a>    <em>Parent</em><span class="op">*</span> <em>parent_</em> <span class="op">=</span> <span class="kw">nullptr</span>;                                  <span class="co">// exposition only</span></span>
<span id="cb86-11"><a href="#cb86-11"></a>    <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> <em>inner_</em> <span class="op">=</span> <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;()</span>;               <span class="co">// exposition only</span></span>
<span id="cb86-12"><a href="#cb86-12"></a></span>
<span id="cb86-13"><a href="#cb86-13"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>Parent</em><span class="op">&amp;</span> parent, <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>; <span class="co">// exposition only</span></span>
<span id="cb86-14"><a href="#cb86-14"></a></span>
<span id="cb86-15"><a href="#cb86-15"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb86-16"><a href="#cb86-16"></a>    <span class="kw">using</span> iterator_category <span class="op">=</span> <em>see below</em>;                        <span class="co">// not always present</span></span>
<span id="cb86-17"><a href="#cb86-17"></a>    <span class="kw">using</span> iterator_concept  <span class="op">=</span> <span class="kw">typename</span> <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;::</span>iterator_concept;</span>
<span id="cb86-18"><a href="#cb86-18"></a>    <span class="kw">using</span> value_type <span class="op">=</span></span>
<span id="cb86-19"><a href="#cb86-19"></a>      remove_cvref_t<span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, F<span class="op">&gt;&amp;</span>, range_reference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;&gt;</span>;</span>
<span id="cb86-20"><a href="#cb86-20"></a>    <span class="kw">using</span> difference_type <span class="op">=</span> range_difference_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-21"><a href="#cb86-21"></a></span>
<span id="cb86-22"><a href="#cb86-22"></a>    <em>iterator</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb86-23"><a href="#cb86-23"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb86-24"><a href="#cb86-24"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb86-25"><a href="#cb86-25"></a></span>
<span id="cb86-26"><a href="#cb86-26"></a>    <span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span> <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span>
<span id="cb86-27"><a href="#cb86-27"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span>
<span id="cb86-28"><a href="#cb86-28"></a>    <span class="kw">constexpr</span> <span class="dt">void</span> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span>
<span id="cb86-29"><a href="#cb86-29"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> forward_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-30"><a href="#cb86-30"></a></span>
<span id="cb86-31"><a href="#cb86-31"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-32"><a href="#cb86-32"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-33"><a href="#cb86-33"></a></span>
<span id="cb86-34"><a href="#cb86-34"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span> <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-35"><a href="#cb86-35"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span> <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-36"><a href="#cb86-36"></a></span>
<span id="cb86-37"><a href="#cb86-37"></a>    <span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span> <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-38"><a href="#cb86-38"></a></span>
<span id="cb86-39"><a href="#cb86-39"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-40"><a href="#cb86-40"></a>      <span class="kw">requires</span> equality_comparable<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb86-41"><a href="#cb86-41"></a></span>
<span id="cb86-42"><a href="#cb86-42"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-43"><a href="#cb86-43"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-44"><a href="#cb86-44"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-45"><a href="#cb86-45"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-46"><a href="#cb86-46"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-47"><a href="#cb86-47"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-48"><a href="#cb86-48"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-49"><a href="#cb86-49"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-50"><a href="#cb86-50"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-51"><a href="#cb86-51"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span> three_way_comparable<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb86-52"><a href="#cb86-52"></a></span>
<span id="cb86-53"><a href="#cb86-53"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb86-54"><a href="#cb86-54"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-55"><a href="#cb86-55"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb86-56"><a href="#cb86-56"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-57"><a href="#cb86-57"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb86-58"><a href="#cb86-58"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb86-59"><a href="#cb86-59"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb86-60"><a href="#cb86-60"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb86-61"><a href="#cb86-61"></a>  <span class="op">}</span>;</span>
<span id="cb86-62"><a href="#cb86-62"></a><span class="op">}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The member <em>typedef-name</em> <code class="sourceCode cpp"><em>iterator</em><span class="op">::</span>iterator_category</code> is defined if and only if <code class="sourceCode cpp"><em>Base</em></code> models <code class="sourceCode cpp">forward_range</code>. In that case, <code class="sourceCode cpp"><em>iterator</em><span class="op">::</span>iterator_category</code> is defined as follows:</p>
<ul>
<li>If <code class="sourceCode cpp">invoke_result_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, F<span class="op">&gt;&amp;</span>, range_reference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;...&gt;</span></code> is not an lvalue reference, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">input_iterator_tag</code>.</li>
<li>Otherwise, let <code class="sourceCode cpp">Cs<span class="op">...</span></code> denote the pack of types <code class="sourceCode cpp">iterator_traits<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, Views<span class="op">&gt;&gt;&gt;::</span>iterator_category<span class="op">...</span></code>.
<ul>
<li>If <code class="sourceCode cpp"><span class="op">(</span>derived_from<span class="op">&lt;</span>Cs, random_access_iterator_tag<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">random_access_iterator_tag</code>;</li>
<li>Otherwise, if <code class="sourceCode cpp"><span class="op">(</span>derived_from<span class="op">&lt;</span>Cs, bidirectional_iterator_tag<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">bidirectional_iterator_tag</code>;</li>
<li>Otherwise, if <code class="sourceCode cpp"><span class="op">(</span>derived_from<span class="op">&lt;</span>Cs, forward_iterator_tag<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">forward_iterator_tag</code>;</li>
<li>Otherwise, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">input_iterator_tag</code>.</li>
</ul></li>
</ul>
<div>
<div class="sourceCode" id="cb87"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb87-1"><a href="#cb87-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>Parent</em><span class="op">&amp;</span> parent, <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>parent_</em></code> with <code class="sourceCode cpp">addressof<span class="op">(</span>parent<span class="op">)</span></code> and <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>inner<span class="op">)</span></code>.</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">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb88-2"><a href="#cb88-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>parent_</em></code> with <code class="sourceCode cpp">i<span class="op">.</span><em>parent_</em></code> and <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>inner_</em><span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb89"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb89-1"><a href="#cb89-1"></a><span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span> <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb90"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb90-1"><a href="#cb90-1"></a>  <span class="cf">return</span> apply<span class="op">([&amp;](</span><span class="kw">const</span> <span class="kw">auto</span><span class="op">&amp;...</span> iters<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span></span>
<span id="cb90-2"><a href="#cb90-2"></a>    <span class="cf">return</span> invoke<span class="op">(*</span><em>parent_</em><span class="op">-&gt;</span><em>fun_</em>, <span class="op">*</span>iters<span class="op">...)</span>;</span>
<span id="cb90-3"><a href="#cb90-3"></a>  <span class="op">}</span>, <em>inner_</em><span class="op">.</span><em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Remarks:</em> Let <code class="sourceCode cpp">Is</code> be the pack <code class="sourceCode cpp"><span class="dv">0</span>, <span class="dv">1</span>, <span class="op">...</span>, <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)-</span><span class="dv">1</span><span class="op">)</span></code>. The expression within <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to <code class="sourceCode cpp"><span class="kw">noexcept</span><span class="op">(</span>invoke<span class="op">(*</span><em>parent_</em><span class="op">-&gt;</span><em>fun_</em>, <span class="op">*</span>get<span class="op">&lt;</span>Is<span class="op">&gt;(</span><em>inner_</em><span class="op">.</span><em>current_</em><span class="op">)...))</span></code>.</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">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb92"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb92-1"><a href="#cb92-1"></a>  <span class="op">++</span><em>inner_</em>;</span>
<span id="cb92-2"><a href="#cb92-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb93"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb93-1"><a href="#cb93-1"></a><span class="kw">constexpr</span> <span class="dt">void</span> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to <code class="sourceCode cpp"><span class="op">++*</span><span class="kw">this</span>;</code>.</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> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> forward_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb95"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb95-1"><a href="#cb95-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb95-2"><a href="#cb95-2"></a>  <span class="op">++*</span><span class="kw">this</span>;</span>
<span id="cb95-3"><a href="#cb95-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb96"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb96-1"><a href="#cb96-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb97"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb97-1"><a href="#cb97-1"></a>  <span class="op">--</span><em>inner_</em>;</span>
<span id="cb97-2"><a href="#cb97-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</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="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb99"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb99-1"><a href="#cb99-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb99-2"><a href="#cb99-2"></a>  <span class="op">--*</span><span class="kw">this</span>;</span>
<span id="cb99-3"><a href="#cb99-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb100"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb100-1"><a href="#cb100-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span></span>
<span id="cb100-2"><a href="#cb100-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb101"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb101-1"><a href="#cb101-1"></a>  <em>inner_</em> <span class="op">+=</span> x;</span>
<span id="cb101-2"><a href="#cb101-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb102"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb102-1"><a href="#cb102-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span></span>
<span id="cb102-2"><a href="#cb102-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb103"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb103-1"><a href="#cb103-1"></a>  <em>inner_</em> <span class="op">-=</span> x;</span>
<span id="cb103-2"><a href="#cb103-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb104"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb104-1"><a href="#cb104-1"></a><span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span></span>
<span id="cb104-2"><a href="#cb104-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb105"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb105-1"><a href="#cb105-1"></a>  <span class="cf">return</span> apply<span class="op">([&amp;](</span><span class="kw">const</span> <span class="kw">auto</span><span class="op">&amp;...</span> iters<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span></span>
<span id="cb105-2"><a href="#cb105-2"></a>    <span class="cf">return</span> invoke<span class="op">(*</span><em>parent_</em><span class="op">-&gt;</span><em>fun_</em>, iters<span class="op">[</span>n<span class="op">]...)</span>;</span>
<span id="cb105-3"><a href="#cb105-3"></a>  <span class="op">}</span>, <em>inner_</em><span class="op">.</span><em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb106"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb106-1"><a href="#cb106-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb106-2"><a href="#cb106-2"></a>  <span class="kw">requires</span> equality_comparable<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb106-3"><a href="#cb106-3"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb106-4"><a href="#cb106-4"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb106-5"><a href="#cb106-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">&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb106-6"><a href="#cb106-6"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb106-7"><a href="#cb106-7"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb106-8"><a href="#cb106-8"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb106-9"><a href="#cb106-9"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb106-10"><a href="#cb106-10"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb106-11"><a href="#cb106-11"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb106-12"><a href="#cb106-12"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span> three_way_comparable<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span> Let <em><code class="sourceCode cpp">op</code></em> be the operator.</p>
<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><em>inner_</em> <em>op</em> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
<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">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb107-2"><a href="#cb107-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb107-3"><a href="#cb107-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb107-4"><a href="#cb107-4"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <em>iterator</em><span class="op">(*</span>i<span class="op">.</span><em>parent_</em>, i<span class="op">.</span><em>inner_</em> <span class="op">+</span> n<span class="op">)</span>;</code></p>
</blockquote>
<div class="sourceCode" id="cb108"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb108-1"><a href="#cb108-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb108-2"><a href="#cb108-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <em>iterator</em><span class="op">(*</span>i<span class="op">.</span><em>parent_</em>, i<span class="op">.</span><em>inner_</em> <span class="op">-</span> n<span class="op">)</span>;</code></p>
</blockquote>
<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">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb109-2"><a href="#cb109-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span><em>inner_</em> <span class="op">-</span> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-zip_transform_view_sentinel_-range.zip.transform.sentinel">24.7.?.4 Class template <code class="sourceCode cpp">zip_transform_view<span class="op">::</span><em>sentinel</em></code> [range.zip.transform.sentinel]<a href="#class-template-zip_transform_view_sentinel_-range.zip.transform.sentinel" class="self-link"></a></h4>
<div class="sourceCode" id="cb110"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb110-1"><a href="#cb110-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb110-2"><a href="#cb110-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>copy_constructible F, input_range<span class="op">...</span> Views<span class="op">&gt;</span></span>
<span id="cb110-3"><a href="#cb110-3"></a>    <span class="kw">requires</span> <span class="op">(</span>view<span class="op">&lt;</span>Views<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span> <span class="op">&amp;&amp;</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">...(</span>Views<span class="op">)</span> <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb110-4"><a href="#cb110-4"></a>              regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb110-5"><a href="#cb110-5"></a>              <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, range_reference_t<span class="op">&lt;</span>Views<span class="op">&gt;...&gt;&gt;</span></span>
<span id="cb110-6"><a href="#cb110-6"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb110-7"><a href="#cb110-7"></a>  <span class="kw">class</span> zip_transform_view<span class="op">&lt;</span>F, Views<span class="op">...&gt;::</span><em>sentinel</em> <span class="op">{</span></span>
<span id="cb110-8"><a href="#cb110-8"></a>    <em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> <em>inner_</em>;                             <span class="co">// exposition only</span></span>
<span id="cb110-9"><a href="#cb110-9"></a>    <span class="kw">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>; <span class="co">// exposition only</span></span>
<span id="cb110-10"><a href="#cb110-10"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb110-11"><a href="#cb110-11"></a>    <em>sentinel</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb110-12"><a href="#cb110-12"></a>    <span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb110-13"><a href="#cb110-13"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb110-14"><a href="#cb110-14"></a></span>
<span id="cb110-15"><a href="#cb110-15"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb110-16"><a href="#cb110-16"></a>      <span class="kw">requires</span> sentinel_for<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb110-17"><a href="#cb110-17"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb110-18"><a href="#cb110-18"></a></span>
<span id="cb110-19"><a href="#cb110-19"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb110-20"><a href="#cb110-20"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb110-21"><a href="#cb110-21"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb110-22"><a href="#cb110-22"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb110-23"><a href="#cb110-23"></a></span>
<span id="cb110-24"><a href="#cb110-24"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb110-25"><a href="#cb110-25"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb110-26"><a href="#cb110-26"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb110-27"><a href="#cb110-27"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span>
<span id="cb110-28"><a href="#cb110-28"></a>  <span class="op">}</span>;</span>
<span id="cb110-29"><a href="#cb110-29"></a><span class="op">}</span></span></code></pre></div>
<div>
<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">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">inner</code>.</p>
</blockquote>
<div class="sourceCode" id="cb112"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb112-1"><a href="#cb112-1"></a><span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb112-2"><a href="#cb112-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>inner_</em><span class="op">)</span></code>.</p>
</blockquote>
<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="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb113-2"><a href="#cb113-2"></a>  <span class="kw">requires</span> sentinel_for<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb113-3"><a href="#cb113-3"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>inner_</em> <span class="op">==</span> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
<div class="sourceCode" id="cb114"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb114-1"><a href="#cb114-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb114-2"><a href="#cb114-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb114-3"><a href="#cb114-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb114-4"><a href="#cb114-4"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb114-5"><a href="#cb114-5"></a></span>
<span id="cb114-6"><a href="#cb114-6"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb114-7"><a href="#cb114-7"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>zentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>ziperator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb114-8"><a href="#cb114-8"></a><span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb114-9"><a href="#cb114-9"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>inner_</em> <span class="op">-</span> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
</div>
<h2 data-number="5.7" id="adjacent"><span class="header-section-number">5.7</span> <code class="sourceCode cpp">adjacent</code><a href="#adjacent" class="self-link"></a></h2>
<p>Add the following subclause to <span>24.7 <a href="https://wg21.link/range.adaptors">[range.adaptors]</a></span>.</p>
<h3 class="unnumbered" data-number id="adjacent-view-range.adjacent">24.7.? Adjacent view [range.adjacent]<a href="#adjacent-view-range.adjacent" class="self-link"></a></h3>
<h4 class="unnumbered" data-number id="overview-range.adjacent.overview">24.7.?.1 Overview [range.adjacent.overview]<a href="#overview-range.adjacent.overview" class="self-link"></a></h4>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code class="sourceCode cpp">adjacent_view</code> takes a <code class="sourceCode cpp">view</code> and produces a <code class="sourceCode cpp">view</code> whose <em>M</em> <sup>th</sup> element is a <code class="sourceCode cpp">tuple</code> or <code class="sourceCode cpp">pair</code> of the M <sup>th</sup> through (<em>M</em> + <em>N</em> - 1)<sup>th</sup> elements of the original view. If the original view has fewer than <em>N</em> elements, the resulting view is empty.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The name <code class="sourceCode cpp">views<span class="op">::</span>adjacent<span class="op">&lt;</span>N<span class="op">&gt;</span></code> denotes a range adaptor object (<span>24.7.2 <a href="https://wg21.link/range.adaptor.object">[range.adaptor.object]</a></span>). Given a subexpression <code class="sourceCode cpp">E</code> and a constant expression <code class="sourceCode cpp">N</code>, the expression <code class="sourceCode cpp">views<span class="op">::</span>adjacent<span class="op">&lt;</span>N<span class="op">&gt;(</span>E<span class="op">)</span></code> is expression-equivalent to</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> <code class="sourceCode cpp"><span class="op">(</span><span class="dt">void</span><span class="op">)</span>E, <em>decay-copy</em><span class="op">(</span>views<span class="op">::</span>empty<span class="op">&lt;</span>tuple<span class="op">&lt;&gt;&gt;)</span></code> if <code class="sourceCode cpp">N</code> is equal to <code class="sourceCode cpp"><span class="dv">0</span></code>,</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> otherwise, <code class="sourceCode cpp">adjacent_view<span class="op">&lt;</span>views<span class="op">::</span>all_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">((</span>E<span class="op">))&gt;</span>, N<span class="op">&gt;(</span>E<span class="op">)</span></code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> Define <code class="sourceCode cpp"><em>REPEAT</em><span class="op">(</span>T, N<span class="op">)</span></code> as a pack of <em>N</em> types, each of which denotes the same type as <code class="sourceCode cpp">T</code>.</p>
<h4 class="unnumbered" data-number id="class-template-adjacent_view-range.adjacent.view">24.7.?.2 Class template <code class="sourceCode cpp">adjacent_view</code> [range.adjacent.view]<a href="#class-template-adjacent_view-range.adjacent.view" class="self-link"></a></h4>
<div class="sourceCode" id="cb115"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb115-1"><a href="#cb115-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb115-2"><a href="#cb115-2"></a></span>
<span id="cb115-3"><a href="#cb115-3"></a><span class="kw">template</span><span class="op">&lt;</span>forward_range V, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb115-4"><a href="#cb115-4"></a>  <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb115-5"><a href="#cb115-5"></a><span class="kw">class</span> adjacent_view <span class="op">:</span> <span class="kw">public</span> view_interface<span class="op">&lt;</span>adjacent_view<span class="op">&lt;</span>V, N<span class="op">&gt;&gt;{</span></span>
<span id="cb115-6"><a href="#cb115-6"></a>  V <em>base_</em> <span class="op">=</span> V<span class="op">()</span>;                     <span class="co">// exposition only</span></span>
<span id="cb115-7"><a href="#cb115-7"></a></span>
<span id="cb115-8"><a href="#cb115-8"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>iterator</em>;     <span class="co">// exposition only</span></span>
<span id="cb115-9"><a href="#cb115-9"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>sentinel</em>;     <span class="co">// exposition only</span></span>
<span id="cb115-10"><a href="#cb115-10"></a></span>
<span id="cb115-11"><a href="#cb115-11"></a>  <span class="kw">struct</span> <em>as_sentinel</em><span class="op">{}</span>;              <span class="co">// exposition only</span></span>
<span id="cb115-12"><a href="#cb115-12"></a></span>
<span id="cb115-13"><a href="#cb115-13"></a><span class="kw">public</span><span class="op">:</span></span>
<span id="cb115-14"><a href="#cb115-14"></a>  <span class="kw">constexpr</span> adjacent_view<span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb115-15"><a href="#cb115-15"></a>  <span class="kw">constexpr</span> <span class="kw">explicit</span> adjacent_view<span class="op">(</span>V base<span class="op">)</span>;</span>
<span id="cb115-16"><a href="#cb115-16"></a></span>
<span id="cb115-17"><a href="#cb115-17"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="kw">requires</span> <span class="op">(!</span><em>simple-view</em><span class="op">&lt;</span>V<span class="op">&gt;)</span> <span class="op">{</span></span>
<span id="cb115-18"><a href="#cb115-18"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span>ranges<span class="op">::</span>begin<span class="op">(</span><em>base_</em><span class="op">)</span>, ranges<span class="op">::</span>end<span class="op">(</span><em>base_</em><span class="op">))</span>;</span>
<span id="cb115-19"><a href="#cb115-19"></a>  <span class="op">}</span></span>
<span id="cb115-20"><a href="#cb115-20"></a></span>
<span id="cb115-21"><a href="#cb115-21"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> range<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb115-22"><a href="#cb115-22"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span>ranges<span class="op">::</span>begin<span class="op">(</span><em>base_</em><span class="op">)</span>, ranges<span class="op">::</span>end<span class="op">(</span><em>base_</em><span class="op">))</span>;</span>
<span id="cb115-23"><a href="#cb115-23"></a>  <span class="op">}</span></span>
<span id="cb115-24"><a href="#cb115-24"></a></span>
<span id="cb115-25"><a href="#cb115-25"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">requires</span> <span class="op">(!</span><em>simple-view</em><span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>common_range<span class="op">&lt;</span>V<span class="op">&gt;)</span> <span class="op">{</span></span>
<span id="cb115-26"><a href="#cb115-26"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span>ranges<span class="op">::</span>end<span class="op">(</span><em>base_</em><span class="op">))</span>;</span>
<span id="cb115-27"><a href="#cb115-27"></a>  <span class="op">}</span></span>
<span id="cb115-28"><a href="#cb115-28"></a></span>
<span id="cb115-29"><a href="#cb115-29"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">requires</span> <span class="op">(!</span><em>simple-view</em><span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> common_range<span class="op">&lt;</span>V<span class="op">&gt;){</span></span>
<span id="cb115-30"><a href="#cb115-30"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span><em>as_sentinel</em><span class="op">{}</span>, ranges<span class="op">::</span>begin<span class="op">(</span><em>base_</em><span class="op">)</span>, ranges<span class="op">::</span>end<span class="op">(</span><em>base_</em><span class="op">))</span>;</span>
<span id="cb115-31"><a href="#cb115-31"></a>  <span class="op">}</span></span>
<span id="cb115-32"><a href="#cb115-32"></a></span>
<span id="cb115-33"><a href="#cb115-33"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> range<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb115-34"><a href="#cb115-34"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span>ranges<span class="op">::</span>end<span class="op">(</span><em>base_</em><span class="op">))</span>;</span>
<span id="cb115-35"><a href="#cb115-35"></a>  <span class="op">}</span></span>
<span id="cb115-36"><a href="#cb115-36"></a></span>
<span id="cb115-37"><a href="#cb115-37"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> common_range<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb115-38"><a href="#cb115-38"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span><em>as_sentinel</em><span class="op">{}</span>, ranges<span class="op">::</span>begin<span class="op">(</span><em>base_</em><span class="op">)</span>, ranges<span class="op">::</span>end<span class="op">(</span><em>base_</em><span class="op">))</span>;</span>
<span id="cb115-39"><a href="#cb115-39"></a>  <span class="op">}</span></span>
<span id="cb115-40"><a href="#cb115-40"></a></span>
<span id="cb115-41"><a href="#cb115-41"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span>V<span class="op">&gt;</span>;</span>
<span id="cb115-42"><a href="#cb115-42"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span>;</span>
<span id="cb115-43"><a href="#cb115-43"></a><span class="op">}</span>;</span>
<span id="cb115-44"><a href="#cb115-44"></a></span>
<span id="cb115-45"><a href="#cb115-45"></a><span class="op">}</span></span></code></pre></div>
<div>
<div class="sourceCode" id="cb116"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb116-1"><a href="#cb116-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> adjacent_view<span class="op">(</span>V base<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>base_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>base<span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb117"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb117-1"><a href="#cb117-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span>V<span class="op">&gt;</span>;</span>
<span id="cb117-2"><a href="#cb117-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb118"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb118-1"><a href="#cb118-1"></a><span class="kw">auto</span> sz <span class="op">=</span> ranges<span class="op">::</span>size<span class="op">(</span><em>base_</em><span class="op">)</span>;</span>
<span id="cb118-2"><a href="#cb118-2"></a>sz <span class="op">-=</span> std<span class="op">::</span>min<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">(</span>sz<span class="op">)&gt;(</span>sz, N<span class="op">-</span><span class="dv">1</span><span class="op">)</span>;</span>
<span id="cb118-3"><a href="#cb118-3"></a><span class="cf">return</span> sz;</span></code></pre></div>
</blockquote>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-adjacent_view_iterator_-range.adjacent.iterator">24.7.?.3 Class template <code class="sourceCode cpp">adjacent_view<span class="op">::</span><em>iterator</em></code> [range.adjacent.iterator]<a href="#class-template-adjacent_view_iterator_-range.adjacent.iterator" class="self-link"></a></h4>
<div class="sourceCode" id="cb119"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb119-1"><a href="#cb119-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb119-2"><a href="#cb119-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb119-3"><a href="#cb119-3"></a>    <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb119-4"><a href="#cb119-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb119-5"><a href="#cb119-5"></a>  <span class="kw">class</span> adjacent_view<span class="op">&lt;</span>V, N<span class="op">&gt;::</span><em>iterator</em> <span class="op">{</span></span>
<span id="cb119-6"><a href="#cb119-6"></a>    <span class="kw">using</span> <em>Base</em> <span class="op">=</span> <em>maybe-const</em><span class="op">&lt;</span>Const, V<span class="op">&gt;</span>;                                             <span class="co">// exposition only</span></span>
<span id="cb119-7"><a href="#cb119-7"></a>    array<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, N<span class="op">&gt;</span> <em>current_</em> <span class="op">=</span> array<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, N<span class="op">&gt;()</span>;             <span class="co">// exposition only</span></span>
<span id="cb119-8"><a href="#cb119-8"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> first, sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> last<span class="op">)</span>;              <span class="co">// exposition only</span></span>
<span id="cb119-9"><a href="#cb119-9"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span>as_sentinel, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> first, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> last<span class="op">)</span>; <span class="co">// exposition only</span></span>
<span id="cb119-10"><a href="#cb119-10"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb119-11"><a href="#cb119-11"></a>    <span class="kw">using</span> iterator_category <span class="op">=</span> input_iterator_tag;</span>
<span id="cb119-12"><a href="#cb119-12"></a>    <span class="kw">using</span> iterator_concept  <span class="op">=</span> <em>see below</em>;</span>
<span id="cb119-13"><a href="#cb119-13"></a>    <span class="kw">using</span> value_type <span class="op">=</span> <em>tuple-or-pair</em><span class="op">&lt;</span><em>REPEAT</em><span class="op">(</span>range_value_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, N<span class="op">)...&gt;</span>;</span>
<span id="cb119-14"><a href="#cb119-14"></a>    <span class="kw">using</span> difference_type <span class="op">=</span> range_difference_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-15"><a href="#cb119-15"></a></span>
<span id="cb119-16"><a href="#cb119-16"></a>    <em>iterator</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb119-17"><a href="#cb119-17"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb119-18"><a href="#cb119-18"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span>
<span id="cb119-19"><a href="#cb119-19"></a></span>
<span id="cb119-20"><a href="#cb119-20"></a>    <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span>;</span>
<span id="cb119-21"><a href="#cb119-21"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span>
<span id="cb119-22"><a href="#cb119-22"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span>
<span id="cb119-23"><a href="#cb119-23"></a></span>
<span id="cb119-24"><a href="#cb119-24"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-25"><a href="#cb119-25"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-26"><a href="#cb119-26"></a></span>
<span id="cb119-27"><a href="#cb119-27"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span></span>
<span id="cb119-28"><a href="#cb119-28"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-29"><a href="#cb119-29"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span></span>
<span id="cb119-30"><a href="#cb119-30"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-31"><a href="#cb119-31"></a></span>
<span id="cb119-32"><a href="#cb119-32"></a>    <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span></span>
<span id="cb119-33"><a href="#cb119-33"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-34"><a href="#cb119-34"></a></span>
<span id="cb119-35"><a href="#cb119-35"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb119-36"><a href="#cb119-36"></a></span>
<span id="cb119-37"><a href="#cb119-37"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb119-38"><a href="#cb119-38"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-39"><a href="#cb119-39"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb119-40"><a href="#cb119-40"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-41"><a href="#cb119-41"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb119-42"><a href="#cb119-42"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-43"><a href="#cb119-43"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb119-44"><a href="#cb119-44"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-45"><a href="#cb119-45"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb119-46"><a href="#cb119-46"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb119-47"><a href="#cb119-47"></a>               three_way_comparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span>
<span id="cb119-48"><a href="#cb119-48"></a></span>
<span id="cb119-49"><a href="#cb119-49"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb119-50"><a href="#cb119-50"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-51"><a href="#cb119-51"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb119-52"><a href="#cb119-52"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-53"><a href="#cb119-53"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb119-54"><a href="#cb119-54"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb119-55"><a href="#cb119-55"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb119-56"><a href="#cb119-56"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span>
<span id="cb119-57"><a href="#cb119-57"></a></span>
<span id="cb119-58"><a href="#cb119-58"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> iter_move<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span> <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span>
<span id="cb119-59"><a href="#cb119-59"></a></span>
<span id="cb119-60"><a href="#cb119-60"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">void</span> iter_swap<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> l, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> r<span class="op">)</span></span>
<span id="cb119-61"><a href="#cb119-61"></a>      <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span></span>
<span id="cb119-62"><a href="#cb119-62"></a>      <span class="kw">requires</span> indirectly_swappable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span>
<span id="cb119-63"><a href="#cb119-63"></a>  <span class="op">}</span>;</span>
<span id="cb119-64"><a href="#cb119-64"></a><span class="op">}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code class="sourceCode cpp"><em>iterator</em><span class="op">::</span>iterator_concept</code> is defined as follows:</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> If <code class="sourceCode cpp">V</code> models <code class="sourceCode cpp">random_access_range</code>, then <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">random_access_iterator_tag</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> Otherwise, if <code class="sourceCode cpp">V</code> models <code class="sourceCode cpp">bidirectional_range</code>, then <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">bidirectional_iterator_tag</code>.</li>
<li><span class="marginalizedparent"><a class="marginalized">(1.3)</a></span> Otherwise, <code class="sourceCode cpp">iterator_concept</code> denotes <code class="sourceCode cpp">forward_iterator_tag</code>.</li>
</ul>
<div>
<div class="sourceCode" id="cb120"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb120-1"><a href="#cb120-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> first, sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> last<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Postconditions</em>: <code class="sourceCode cpp"><em>current_</em>[0] <span class="op">==</span> first</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, and for every integer <em>i</em> in <code class="sourceCode cpp"><span class="op">[</span><span class="dv">1</span>, N<span class="op">)</span></code>, <code class="sourceCode cpp"><em>current_</em><span class="op">[</span><em>i</em><span class="op">]</span> <span class="op">==</span> ranges<span class="op">::</span>next<span class="op">(</span><em>current_</em><span class="op">[</span><em>i</em><span class="op">-</span><span class="dv">1</span><span class="op">]</span>, <span class="dv">1</span>, last<span class="op">)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb121"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb121-1"><a href="#cb121-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span>as_sentinel, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> first, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> last<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Postconditions</em>: If <code class="sourceCode cpp"><em>Base</em></code> does not model <code class="sourceCode cpp">bidirectional_range</code>, each element of <code class="sourceCode cpp"><em>current_</em></code> is equal to <code class="sourceCode cpp">last</code>. Otherwise, <code class="sourceCode cpp"><em>current_</em>[N-1] <span class="op">==</span> last</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, and for every integer <em>i</em> in <code class="sourceCode cpp"><span class="op">[</span><span class="dv">0</span>, N<span class="op">-</span><span class="dv">1</span><span class="op">)</span></code>, <code class="sourceCode cpp"><em>current_</em><span class="op">[</span><em>i</em><span class="op">]</span> <span class="op">==</span> ranges<span class="op">::</span>prev<span class="op">(</span><em>current_</em><span class="op">[</span><em>i</em><span class="op">+</span><span class="dv">1</span><span class="op">]</span>, <span class="dv">1</span>, first<span class="op">)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</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="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb122-2"><a href="#cb122-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> <span class="op">(</span>convertible_to<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Initializes each element of <code class="sourceCode cpp"><em>current_</em></code> with the corresponding element of <code class="sourceCode cpp">i<span class="op">.</span><em>current_</em></code> as an xvalue.</p>
</blockquote>
<div class="sourceCode" id="cb123"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb123-1"><a href="#cb123-1"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects</em>: Equivalent to:</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="cf">return</span> <em>tuple-transform</em><span class="op">([](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="op">*</span>i; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb125"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb125-1"><a href="#cb125-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb126"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb126-1"><a href="#cb126-1"></a>  ranges<span class="op">::</span>copy<span class="op">(</span><em>current_</em> <span class="op">|</span> views<span class="op">::</span>drop<span class="op">(</span><span class="dv">1</span><span class="op">)</span>, <em>current_</em><span class="op">.</span>begin<span class="op">())</span>;</span>
<span id="cb126-2"><a href="#cb126-2"></a>  <span class="op">++</span><em>current_</em><span class="op">.</span>back<span class="op">()</span>;</span>
<span id="cb126-3"><a href="#cb126-3"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</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">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb128"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb128-1"><a href="#cb128-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb128-2"><a href="#cb128-2"></a>  <span class="op">++*</span><span class="kw">this</span>;</span>
<span id="cb128-3"><a href="#cb128-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb129"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb129-1"><a href="#cb129-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb130"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb130-1"><a href="#cb130-1"></a>  ranges<span class="op">::</span>copy_backward<span class="op">(</span><em>current_</em> <span class="op">|</span> views<span class="op">::</span>take<span class="op">(</span>N <span class="op">-</span> <span class="dv">1</span><span class="op">)</span>, <em>current_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb130-2"><a href="#cb130-2"></a>  <span class="op">--</span><em>current_</em><span class="op">.</span>front<span class="op">()</span>;</span>
<span id="cb130-3"><a href="#cb130-3"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</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">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb132"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb132-1"><a href="#cb132-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb132-2"><a href="#cb132-2"></a>  <span class="op">--*</span><span class="kw">this</span>;</span>
<span id="cb132-3"><a href="#cb132-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb133"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb133-1"><a href="#cb133-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span></span>
<span id="cb133-2"><a href="#cb133-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb134"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb134-1"><a href="#cb134-1"></a>  <span class="cf">for</span><span class="op">(</span><span class="kw">auto</span><span class="op">&amp;</span> i <span class="op">:</span> <em>current_</em><span class="op">)</span> <span class="op">{</span> i <span class="op">+=</span> x; <span class="op">}</span></span>
<span id="cb134-2"><a href="#cb134-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</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="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span></span>
<span id="cb135-2"><a href="#cb135-2"></a>    <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb136"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb136-1"><a href="#cb136-1"></a>  <span class="cf">for</span><span class="op">(</span><span class="kw">auto</span><span class="op">&amp;</span> i <span class="op">:</span> <em>current_</em><span class="op">)</span> <span class="op">{</span> i <span class="op">-=</span> x; <span class="op">}</span></span>
<span id="cb136-2"><a href="#cb136-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb137"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb137-1"><a href="#cb137-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span></span>
<span id="cb137-2"><a href="#cb137-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb138"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb138-1"><a href="#cb138-1"></a>  <span class="cf">return</span> <em>tuple-transform</em><span class="op">([&amp;](</span><span class="kw">auto</span><span class="op">&amp;</span> i<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> i<span class="op">[</span>n<span class="op">]</span>; <span class="op">}</span>, <em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb139"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb139-1"><a href="#cb139-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>current_</em><span class="op">.</span>back<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb140"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb140-1"><a href="#cb140-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb140-2"><a href="#cb140-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<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><em>current_</em><span class="op">.</span>back<span class="op">()</span> <span class="op">&lt;</span> y<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span>;</code></p>
</blockquote>
<div class="sourceCode" id="cb141"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb141-1"><a href="#cb141-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb141-2"><a href="#cb141-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">15</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>
</blockquote>
<div class="sourceCode" id="cb142"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb142-1"><a href="#cb142-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb142-2"><a href="#cb142-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">16</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>
</blockquote>
<div class="sourceCode" id="cb143"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb143-1"><a href="#cb143-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb143-2"><a href="#cb143-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<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">&lt;</span> y<span class="op">)</span>;</code></p>
</blockquote>
<div class="sourceCode" id="cb144"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb144-1"><a href="#cb144-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb144-2"><a href="#cb144-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb144-3"><a href="#cb144-3"></a>           three_way_comparable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span> <span class="op">&lt;=&gt;</span> y<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span>;</code></p>
</blockquote>
<div class="sourceCode" id="cb145"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb145-1"><a href="#cb145-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb145-2"><a href="#cb145-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb145-3"><a href="#cb145-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb145-4"><a href="#cb145-4"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb146"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb146-1"><a href="#cb146-1"></a>  <span class="kw">auto</span> r <span class="op">=</span> i;</span>
<span id="cb146-2"><a href="#cb146-2"></a>  r <span class="op">+=</span> n;</span>
<span id="cb146-3"><a href="#cb146-3"></a>  <span class="cf">return</span> r;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb147"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb147-1"><a href="#cb147-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb147-2"><a href="#cb147-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">20</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb148"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb148-1"><a href="#cb148-1"></a>  <span class="kw">auto</span> r <span class="op">=</span> i;</span>
<span id="cb148-2"><a href="#cb148-2"></a>  r <span class="op">-=</span> n;</span>
<span id="cb148-3"><a href="#cb148-3"></a>  <span class="cf">return</span> r;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb149"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb149-1"><a href="#cb149-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb149-2"><a href="#cb149-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">21</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span> <span class="op">-</span> y<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb150"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb150-1"><a href="#cb150-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> iter_move<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span> <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">22</a></span> <em>Effects</em>: 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> <em>tuple-transform</em><span class="op">(</span>ranges<span class="op">::</span>iter_move, i<span class="op">.</span><em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p><span class="marginalizedparent"><a class="marginalized">23</a></span> <em>Remarks:</em> The expression within <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to</p>
<blockquote>
<div class="sourceCode" id="cb152"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb152-1"><a href="#cb152-1"></a>  <span class="kw">noexcept</span><span class="op">(</span>ranges<span class="op">::</span>iter_move<span class="op">(</span>declval<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;()))</span> <span class="op">&amp;&amp;</span></span>
<span id="cb152-2"><a href="#cb152-2"></a>  is_nothrow_move_constructible_v<span class="op">&lt;</span>range_rvalue_reference_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span></span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb153"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb153-1"><a href="#cb153-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="dt">void</span> iter_swap<span class="op">(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> l, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> r<span class="op">)</span></span>
<span id="cb153-2"><a href="#cb153-2"></a>  <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span></span>
<span id="cb153-3"><a href="#cb153-3"></a>  <span class="kw">requires</span> indirectly_swappable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">24</a></span> <em>Preconditions:</em> None of the iterators in <code class="sourceCode cpp">l<span class="op">.</span><em>current_</em></code> is equal to an iterator in <code class="sourceCode cpp">r<span class="op">.</span><em>current_</em></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span> <em>Effects</em>: For every integer <em>i</em> in <code class="sourceCode cpp"><span class="op">[</span><span class="dv">0</span>, N<span class="op">)</span></code>, performs <code class="sourceCode cpp">ranges<span class="op">::</span>iter_swap<span class="op">(</span>l<span class="op">.</span><em>current_</em><span class="op">[</span><em>i</em><span class="op">]</span>, r<span class="op">.</span><em>current_</em><span class="op">[</span><em>i</em><span class="op">])</span></code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span> <em>Remarks:</em> The expression within <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to:</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">noexcept</span><span class="op">(</span>ranges<span class="op">::</span>iter_swap<span class="op">(</span>declval<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;()</span>, declval<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;()))</span></span></code></pre></div>
</blockquote>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-adjacent_view_sentinel_-range.adjacent.sentinel">24.7.?.4 Class template <code class="sourceCode cpp">adjacent_view<span class="op">::</span><em>sentinel</em></code> [range.adjacent.sentinel]<a href="#class-template-adjacent_view_sentinel_-range.adjacent.sentinel" class="self-link"></a></h4>
<div class="sourceCode" id="cb155"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb155-1"><a href="#cb155-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb155-2"><a href="#cb155-2"></a>  <span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb155-3"><a href="#cb155-3"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb155-4"><a href="#cb155-4"></a>    <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span></span>
<span id="cb155-5"><a href="#cb155-5"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb155-6"><a href="#cb155-6"></a>  <span class="kw">class</span> adjacent_view<span class="op">&lt;</span>V, N<span class="op">&gt;::</span><em>sentinel</em> <span class="op">{</span></span>
<span id="cb155-7"><a href="#cb155-7"></a>    <span class="kw">using</span> <em>Base</em> <span class="op">=</span> <em>maybe-const</em><span class="op">&lt;</span>Const, V<span class="op">&gt;</span>;                     <span class="co">// exposition only</span></span>
<span id="cb155-8"><a href="#cb155-8"></a>    sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <em>end_</em> <span class="op">=</span> sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;()</span>;             <span class="co">// exposition only</span></span>
<span id="cb155-9"><a href="#cb155-9"></a>    <span class="kw">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> end<span class="op">)</span>;      <span class="co">// exposition only</span></span>
<span id="cb155-10"><a href="#cb155-10"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb155-11"><a href="#cb155-11"></a>    <em>sentinel</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb155-12"><a href="#cb155-12"></a>    <span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb155-13"><a href="#cb155-13"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span>
<span id="cb155-14"><a href="#cb155-14"></a></span>
<span id="cb155-15"><a href="#cb155-15"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb155-16"><a href="#cb155-16"></a>      <span class="kw">requires</span> sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;&gt;</span></span>
<span id="cb155-17"><a href="#cb155-17"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb155-18"><a href="#cb155-18"></a></span>
<span id="cb155-19"><a href="#cb155-19"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb155-20"><a href="#cb155-20"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;&gt;</span></span>
<span id="cb155-21"><a href="#cb155-21"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;</span></span>
<span id="cb155-22"><a href="#cb155-22"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb155-23"><a href="#cb155-23"></a></span>
<span id="cb155-24"><a href="#cb155-24"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb155-25"><a href="#cb155-25"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;&gt;</span></span>
<span id="cb155-26"><a href="#cb155-26"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;</span></span>
<span id="cb155-27"><a href="#cb155-27"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x<span class="op">)</span>;</span>
<span id="cb155-28"><a href="#cb155-28"></a>  <span class="op">}</span>;</span>
<span id="cb155-29"><a href="#cb155-29"></a><span class="op">}</span></span></code></pre></div>
<div>
<div class="sourceCode" id="cb156"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb156-1"><a href="#cb156-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> end<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>end_</em></code> with <code class="sourceCode cpp">end</code>.</p>
</blockquote>
<div class="sourceCode" id="cb157"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb157-1"><a href="#cb157-1"></a><span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb157-2"><a href="#cb157-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>end_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>end_</em><span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb158"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb158-1"><a href="#cb158-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb158-2"><a href="#cb158-2"></a>  <span class="kw">requires</span> sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;&gt;</span></span>
<span id="cb158-3"><a href="#cb158-3"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>current_</em><span class="op">.</span>back<span class="op">()</span> <span class="op">==</span> y<span class="op">.</span><em>end_</em>;</code>.</p>
</blockquote>
<div class="sourceCode" id="cb159"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb159-1"><a href="#cb159-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb159-2"><a href="#cb159-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;&gt;</span></span>
<span id="cb159-3"><a href="#cb159-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;</span></span>
<span id="cb159-4"><a href="#cb159-4"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>current_</em><span class="op">.</span>back<span class="op">()</span> <span class="op">-</span> y<span class="op">.</span><em>end_</em>;</code>.</p>
</blockquote>
<div class="sourceCode" id="cb160"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb160-1"><a href="#cb160-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb160-2"><a href="#cb160-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span>sentinel_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;&gt;</span></span>
<span id="cb160-3"><a href="#cb160-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, V<span class="op">&gt;&gt;</span></span>
<span id="cb160-4"><a href="#cb160-4"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>end_</em> <span class="op">-</span> x<span class="op">.</span><em>current_</em><span class="op">.</span>back<span class="op">()</span>;</code>.</p>
</blockquote>
</div>
<h2 data-number="5.8" id="adjacent_transform"><span class="header-section-number">5.8</span> <code class="sourceCode cpp">adjacent_transform</code><a href="#adjacent_transform" class="self-link"></a></h2>
<p>Add the following subclause to <span>24.7 <a href="https://wg21.link/range.adaptors">[range.adaptors]</a></span>.</p>
<h3 class="unnumbered" data-number id="adjacent-transform-view-range.adjacent.transform">24.7.? Adjacent transform view [range.adjacent.transform]<a href="#adjacent-transform-view-range.adjacent.transform" class="self-link"></a></h3>
<h4 class="unnumbered" data-number id="overview-range.adjacent.transform.overview">24.7.?.1 Overview [range.adjacent.transform.overview]<a href="#overview-range.adjacent.transform.overview" class="self-link"></a></h4>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code class="sourceCode cpp">adjacent_transform_view</code> takes an invocable object and a <code class="sourceCode cpp">view</code> and produces a <code class="sourceCode cpp">view</code> whose <em>M <sup>th</sup></em> element is the result of applying the invocable object to the <em>M</em> <sup>th</sup> through (<em>M</em> + <em>N</em> - 1)<sup>th</sup> elements of the original view. If the original view has fewer than <em>N</em> elements, the resulting view is empty.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The name <code class="sourceCode cpp">views<span class="op">::</span>adjacent_transform<span class="op">&lt;</span>N<span class="op">&gt;</span></code> denotes a range adaptor object (<span>24.7.2 <a href="https://wg21.link/range.adaptor.object">[range.adaptor.object]</a></span>). Given subexpressions <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code>,</p>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> if <code class="sourceCode cpp">N</code> is equal to 0, <code class="sourceCode cpp">views<span class="op">::</span>adjacent_transform<span class="op">&lt;</span>N<span class="op">&gt;(</span>E, F<span class="op">)</span></code> is expression-equivalent to <code class="sourceCode cpp"><span class="op">(</span><span class="dt">void</span><span class="op">)</span>E, views<span class="op">::</span>zip_transform<span class="op">(</span>F<span class="op">)</span></code>, except that the evaluations of <code class="sourceCode cpp">E</code> and <code class="sourceCode cpp">F</code> are indeterminately sequenced.</li>
<li><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> Otherwise, the expression <code class="sourceCode cpp">views<span class="op">::</span>adjacent_transform<span class="op">&lt;</span>N<span class="op">&gt;(</span>E, F<span class="op">)</span></code> is expression-equivalent to <code class="sourceCode cpp">adjacent_transform_view<span class="op">&lt;</span>views<span class="op">::</span>all_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">((</span>E<span class="op">))&gt;</span>, decay_t<span class="op">&lt;</span>F<span class="op">&gt;</span>, N<span class="op">&gt;(</span>E, F<span class="op">)</span></code>.</li>
</ul>
<h4 class="unnumbered" data-number id="class-template-adjacent_transform_view-range.adjacent.transform.view">24.7.?.2 Class template <code class="sourceCode cpp">adjacent_transform_view</code> [range.adjacent.transform.view]<a href="#class-template-adjacent_transform_view-range.adjacent.transform.view" class="self-link"></a></h4>
<div class="sourceCode" id="cb161"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb161-1"><a href="#cb161-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb161-2"><a href="#cb161-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, copy_constructible F, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb161-3"><a href="#cb161-3"></a>   <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb161-4"><a href="#cb161-4"></a>            regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, N<span class="op">)...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb161-5"><a href="#cb161-5"></a>            <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, N<span class="op">)...&gt;&gt;</span></span>
<span id="cb161-6"><a href="#cb161-6"></a>  <span class="kw">class</span> adjacent_transform_view <span class="op">:</span> <span class="kw">public</span> view_interface<span class="op">&lt;</span>adjacent_transform_view<span class="op">&lt;</span>V, F, N<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
<span id="cb161-7"><a href="#cb161-7"></a>  <em>semiregular-box</em><span class="op">&lt;</span>F<span class="op">&gt;</span> <em>fun_</em>;                  <span class="co">// exposition only</span></span>
<span id="cb161-8"><a href="#cb161-8"></a>  adjacent_view<span class="op">&lt;</span>V, N<span class="op">&gt;</span> <em>inner_</em>;               <span class="co">// exposition only</span></span>
<span id="cb161-9"><a href="#cb161-9"></a></span>
<span id="cb161-10"><a href="#cb161-10"></a>  <span class="kw">using</span> <em>InnerView</em> <span class="op">=</span> adjacent_view<span class="op">&lt;</span>V, N<span class="op">&gt;</span>;    <span class="co">// exposition only</span></span>
<span id="cb161-11"><a href="#cb161-11"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb161-12"><a href="#cb161-12"></a>  <span class="kw">using</span> <em>inner-iterator</em> <span class="op">=</span> iterator_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, <em>InnerView</em><span class="op">&gt;&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb161-13"><a href="#cb161-13"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb161-14"><a href="#cb161-14"></a>  <span class="kw">using</span> <em>inner-sentinel</em> <span class="op">=</span> sentinel_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, <em>InnerView</em><span class="op">&gt;&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb161-15"><a href="#cb161-15"></a></span>
<span id="cb161-16"><a href="#cb161-16"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>iterator</em>;         <span class="co">// exposition only</span></span>
<span id="cb161-17"><a href="#cb161-17"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;</span> <span class="kw">class</span> <em>sentinel</em>;         <span class="co">// exposition only</span></span>
<span id="cb161-18"><a href="#cb161-18"></a></span>
<span id="cb161-19"><a href="#cb161-19"></a><span class="kw">public</span><span class="op">:</span></span>
<span id="cb161-20"><a href="#cb161-20"></a>  <span class="kw">constexpr</span> adjacent_transform_view<span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb161-21"><a href="#cb161-21"></a></span>
<span id="cb161-22"><a href="#cb161-22"></a>  <span class="kw">constexpr</span> <span class="kw">explicit</span> adjacent_transform_view<span class="op">(</span>V base, F fun<span class="op">)</span>;</span>
<span id="cb161-23"><a href="#cb161-23"></a></span>
<span id="cb161-24"><a href="#cb161-24"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="op">{</span></span>
<span id="cb161-25"><a href="#cb161-25"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>inner_</em><span class="op">.</span>begin<span class="op">())</span>;</span>
<span id="cb161-26"><a href="#cb161-26"></a>  <span class="op">}</span></span>
<span id="cb161-27"><a href="#cb161-27"></a></span>
<span id="cb161-28"><a href="#cb161-28"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> begin<span class="op">()</span> <span class="kw">const</span></span>
<span id="cb161-29"><a href="#cb161-29"></a>    <span class="kw">requires</span> range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb161-30"><a href="#cb161-30"></a>             regular_invocable<span class="op">&lt;</span><span class="kw">const</span> F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span>, N<span class="op">)...&gt;</span></span>
<span id="cb161-31"><a href="#cb161-31"></a>  <span class="op">{</span></span>
<span id="cb161-32"><a href="#cb161-32"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>inner_</em><span class="op">.</span>begin<span class="op">())</span>;</span>
<span id="cb161-33"><a href="#cb161-33"></a>  <span class="op">}</span></span>
<span id="cb161-34"><a href="#cb161-34"></a></span>
<span id="cb161-35"><a href="#cb161-35"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="op">{</span></span>
<span id="cb161-36"><a href="#cb161-36"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(</span><em>inner_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb161-37"><a href="#cb161-37"></a>  <span class="op">}</span></span>
<span id="cb161-38"><a href="#cb161-38"></a></span>
<span id="cb161-39"><a href="#cb161-39"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">requires</span> common_range<span class="op">&lt;</span><em>InnerView</em><span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb161-40"><a href="#cb161-40"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>inner_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb161-41"><a href="#cb161-41"></a>  <span class="op">}</span></span>
<span id="cb161-42"><a href="#cb161-42"></a></span>
<span id="cb161-43"><a href="#cb161-43"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span></span>
<span id="cb161-44"><a href="#cb161-44"></a>    <span class="kw">requires</span> range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb161-45"><a href="#cb161-45"></a>             regular_invocable<span class="op">&lt;</span><span class="kw">const</span> F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span>, N<span class="op">)...&gt;</span></span>
<span id="cb161-46"><a href="#cb161-46"></a>  <span class="op">{</span></span>
<span id="cb161-47"><a href="#cb161-47"></a>    <span class="cf">return</span> <em>sentinel</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(</span><em>inner_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb161-48"><a href="#cb161-48"></a>  <span class="op">}</span></span>
<span id="cb161-49"><a href="#cb161-49"></a></span>
<span id="cb161-50"><a href="#cb161-50"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> end<span class="op">()</span> <span class="kw">const</span></span>
<span id="cb161-51"><a href="#cb161-51"></a>    <span class="kw">requires</span> common_range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb161-52"><a href="#cb161-52"></a>             regular_invocable<span class="op">&lt;</span><span class="kw">const</span> F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span><span class="kw">const</span> V<span class="op">&gt;</span>, N<span class="op">)...&gt;</span></span>
<span id="cb161-53"><a href="#cb161-53"></a>  <span class="op">{</span></span>
<span id="cb161-54"><a href="#cb161-54"></a>    <span class="cf">return</span> <em>iterator</em><span class="op">&lt;</span><span class="kw">true</span><span class="op">&gt;(*</span><span class="kw">this</span>, <em>inner_</em><span class="op">.</span>end<span class="op">())</span>;</span>
<span id="cb161-55"><a href="#cb161-55"></a>  <span class="op">}</span></span>
<span id="cb161-56"><a href="#cb161-56"></a></span>
<span id="cb161-57"><a href="#cb161-57"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span><em>InnerView</em><span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb161-58"><a href="#cb161-58"></a>    <span class="cf">return</span> <em>inner_</em><span class="op">.</span>size<span class="op">()</span>;</span>
<span id="cb161-59"><a href="#cb161-59"></a>  <span class="op">}</span></span>
<span id="cb161-60"><a href="#cb161-60"></a></span>
<span id="cb161-61"><a href="#cb161-61"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> size<span class="op">()</span> <span class="kw">const</span> <span class="kw">requires</span> sized_range<span class="op">&lt;</span><span class="kw">const</span> <em>InnerView</em><span class="op">&gt;</span> <span class="op">{</span></span>
<span id="cb161-62"><a href="#cb161-62"></a>    <span class="cf">return</span> <em>inner_</em><span class="op">.</span>size<span class="op">()</span>;</span>
<span id="cb161-63"><a href="#cb161-63"></a>  <span class="op">}</span></span>
<span id="cb161-64"><a href="#cb161-64"></a><span class="op">}</span>;</span>
<span id="cb161-65"><a href="#cb161-65"></a></span>
<span id="cb161-66"><a href="#cb161-66"></a><span class="op">}</span></span></code></pre></div>
<div>
<div class="sourceCode" id="cb162"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb162-1"><a href="#cb162-1"></a><span class="kw">constexpr</span> <span class="kw">explicit</span> adjacent_transform_view<span class="op">(</span>V base, F fun<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>fun_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>fun<span class="op">)</span></code> and <code class="sourceCode cpp"><em>inner</em>__</code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>base<span class="op">)</span></code>.</p>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-adjacent_transform_view_iterator_-range.adjacent.transform.iterator">24.7.?.3 Class template <code class="sourceCode cpp">adjacent_transform_view<span class="op">::</span><em>iterator</em></code> [range.adjacent.transform.iterator]<a href="#class-template-adjacent_transform_view_iterator_-range.adjacent.transform.iterator" class="self-link"></a></h4>
<div class="sourceCode" id="cb163"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb163-1"><a href="#cb163-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb163-2"><a href="#cb163-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, copy_constructible F, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb163-3"><a href="#cb163-3"></a>    <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb163-4"><a href="#cb163-4"></a>             regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, N<span class="op">)...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb163-5"><a href="#cb163-5"></a>             <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, N<span class="op">)...&gt;&gt;</span></span>
<span id="cb163-6"><a href="#cb163-6"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb163-7"><a href="#cb163-7"></a>  <span class="kw">class</span> adjacent_transform_view<span class="op">&lt;</span>F, V<span class="op">...&gt;::</span><em>iterator</em> <span class="op">{</span></span>
<span id="cb163-8"><a href="#cb163-8"></a>    <span class="kw">using</span> <em>Parent</em> <span class="op">=</span> <em>maybe-const</em><span class="op">&lt;</span>Const, adjacent_transform_view<span class="op">&gt;</span>;      <span class="co">// exposition only</span></span>
<span id="cb163-9"><a href="#cb163-9"></a>    <span class="kw">using</span> <em>Base</em> <span class="op">=</span> <em>maybe-const</em><span class="op">&lt;</span>Const, V<span class="op">&gt;</span>;                              <span class="co">// exposition only</span></span>
<span id="cb163-10"><a href="#cb163-10"></a>    <em>Parent</em><span class="op">*</span> <em>parent_</em> <span class="op">=</span> <span class="kw">nullptr</span>;                                       <span class="co">// exposition only</span></span>
<span id="cb163-11"><a href="#cb163-11"></a>    <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> <em>inner_</em> <span class="op">=</span> <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;()</span>;          <span class="co">// exposition only</span></span>
<span id="cb163-12"><a href="#cb163-12"></a></span>
<span id="cb163-13"><a href="#cb163-13"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>Parent</em><span class="op">&amp;</span> parent, <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>; <span class="co">// exposition only</span></span>
<span id="cb163-14"><a href="#cb163-14"></a></span>
<span id="cb163-15"><a href="#cb163-15"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb163-16"><a href="#cb163-16"></a>    <span class="kw">using</span> iterator_category <span class="op">=</span> <em>see below</em>;</span>
<span id="cb163-17"><a href="#cb163-17"></a>    <span class="kw">using</span> iterator_concept  <span class="op">=</span> <span class="kw">typename</span> <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;::</span>iterator_concept;</span>
<span id="cb163-18"><a href="#cb163-18"></a>    <span class="kw">using</span> value_type <span class="op">=</span></span>
<span id="cb163-19"><a href="#cb163-19"></a>      remove_cvref_t<span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, F<span class="op">&gt;&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, N<span class="op">)...&gt;&gt;</span>;</span>
<span id="cb163-20"><a href="#cb163-20"></a>    <span class="kw">using</span> difference_type <span class="op">=</span> range_difference_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-21"><a href="#cb163-21"></a></span>
<span id="cb163-22"><a href="#cb163-22"></a>    <em>iterator</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb163-23"><a href="#cb163-23"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb163-24"><a href="#cb163-24"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>inner-iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb163-25"><a href="#cb163-25"></a></span>
<span id="cb163-26"><a href="#cb163-26"></a>    <span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span> <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span>
<span id="cb163-27"><a href="#cb163-27"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span>
<span id="cb163-28"><a href="#cb163-28"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span>
<span id="cb163-29"><a href="#cb163-29"></a></span>
<span id="cb163-30"><a href="#cb163-30"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-31"><a href="#cb163-31"></a>    <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-32"><a href="#cb163-32"></a></span>
<span id="cb163-33"><a href="#cb163-33"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span> <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-34"><a href="#cb163-34"></a>    <span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span> <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-35"><a href="#cb163-35"></a></span>
<span id="cb163-36"><a href="#cb163-36"></a>    <span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span> <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-37"><a href="#cb163-37"></a></span>
<span id="cb163-38"><a href="#cb163-38"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb163-39"><a href="#cb163-39"></a></span>
<span id="cb163-40"><a href="#cb163-40"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb163-41"><a href="#cb163-41"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-42"><a href="#cb163-42"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb163-43"><a href="#cb163-43"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-44"><a href="#cb163-44"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb163-45"><a href="#cb163-45"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-46"><a href="#cb163-46"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb163-47"><a href="#cb163-47"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-48"><a href="#cb163-48"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb163-49"><a href="#cb163-49"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span> three_way_comparable<span class="op">&lt;</span><em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb163-50"><a href="#cb163-50"></a></span>
<span id="cb163-51"><a href="#cb163-51"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb163-52"><a href="#cb163-52"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-53"><a href="#cb163-53"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb163-54"><a href="#cb163-54"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-55"><a href="#cb163-55"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb163-56"><a href="#cb163-56"></a>      <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb163-57"><a href="#cb163-57"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb163-58"><a href="#cb163-58"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb163-59"><a href="#cb163-59"></a>  <span class="op">}</span>;</span>
<span id="cb163-60"><a href="#cb163-60"></a><span class="op">}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The member <em>typedef-name</em> <code class="sourceCode cpp"><em>iterator</em><span class="op">::</span>iterator_category</code> is defined as follows:</p>
<ul>
<li>If <code class="sourceCode cpp">invoke_result_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>Const, F<span class="op">&gt;&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>, N<span class="op">)...&gt;</span></code> is not an lvalue reference, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">input_iterator_tag</code>.</li>
<li>Otherwise, let <code class="sourceCode cpp">C</code> denote the type <code class="sourceCode cpp">iterator_traits<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span><em>Base</em><span class="op">&gt;&gt;::</span>iterator_category</code>.
<ul>
<li>If <code class="sourceCode cpp">derived_from<span class="op">&lt;</span>C, random_access_iterator_tag<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">random_access_iterator_tag</code>;</li>
<li>Otherwise, if <code class="sourceCode cpp">derived_from<span class="op">&lt;</span>C, bidirectional_iterator_tag<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">bidirectional_iterator_tag</code>;</li>
<li>Otherwise, if <code class="sourceCode cpp">derived_from<span class="op">&lt;</span>C, forward_iterator_tag<span class="op">&gt;</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">forward_iterator_tag</code>;</li>
<li>Otherwise, <code class="sourceCode cpp">iterator_category</code> denotes <code class="sourceCode cpp">input_iterator_tag</code>.</li>
</ul></li>
</ul>
<div>
<div class="sourceCode" id="cb164"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb164-1"><a href="#cb164-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>Parent</em><span class="op">&amp;</span> parent, <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>parent_</em></code> with <code class="sourceCode cpp">addressof<span class="op">(</span>parent<span class="op">)</span></code> and <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>inner<span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb165"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb165-1"><a href="#cb165-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">(</span><em>iterator</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb165-2"><a href="#cb165-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>inner-iterator</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>parent_</em></code> with <code class="sourceCode cpp">i<span class="op">.</span><em>parent_</em></code> and <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>inner_</em><span class="op">)</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb166"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb166-1"><a href="#cb166-1"></a><span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span> <span class="kw">noexcept</span><span class="op">(</span><em>see below</em><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb167"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb167-1"><a href="#cb167-1"></a>  <span class="cf">return</span> apply<span class="op">([&amp;](</span><span class="kw">const</span> <span class="kw">auto</span><span class="op">&amp;...</span> iters<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span></span>
<span id="cb167-2"><a href="#cb167-2"></a>    <span class="cf">return</span> invoke<span class="op">(*</span><em>parent_</em><span class="op">-&gt;</span><em>fun_</em>, <span class="op">*</span>iters<span class="op">...)</span>;</span>
<span id="cb167-3"><a href="#cb167-3"></a>  <span class="op">}</span>, <em>inner_</em><span class="op">.</span><em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Remarks:</em> Let <code class="sourceCode cpp">Is</code> be the pack <code class="sourceCode cpp"><span class="dv">0</span>, <span class="dv">1</span>, <span class="op">...</span>, <span class="op">(</span>N<span class="op">-</span><span class="dv">1</span><span class="op">)</span></code>. The expression within <code class="sourceCode cpp"><span class="kw">noexcept</span></code> is equivalent to <code class="sourceCode cpp"><span class="kw">noexcept</span><span class="op">(</span>invoke<span class="op">(*</span><em>parent_</em><span class="op">-&gt;</span><em>fun_</em>, <span class="op">*</span>get<span class="op">&lt;</span>Is<span class="op">&gt;(</span><em>inner_</em><span class="op">.</span><em>current_</em><span class="op">)...))</span></code>.</p>
</blockquote>
<div class="sourceCode" id="cb168"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb168-1"><a href="#cb168-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">++()</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb169"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb169-1"><a href="#cb169-1"></a>  <span class="op">++</span><em>inner_</em>;</span>
<span id="cb169-2"><a href="#cb169-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb170"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb170-1"><a href="#cb170-1"></a><span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb171"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb171-1"><a href="#cb171-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb171-2"><a href="#cb171-2"></a>  <span class="op">++*</span><span class="kw">this</span>;</span>
<span id="cb171-3"><a href="#cb171-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb172"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb172-1"><a href="#cb172-1"></a><span class="kw">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">--()</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb173"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb173-1"><a href="#cb173-1"></a>  <span class="op">--</span><em>inner_</em>;</span>
<span id="cb173-2"><a href="#cb173-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb174"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb174-1"><a href="#cb174-1"></a><span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">requires</span> bidirectional_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb175"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb175-1"><a href="#cb175-1"></a>  <span class="kw">auto</span> tmp <span class="op">=</span> <span class="op">*</span><span class="kw">this</span>;</span>
<span id="cb175-2"><a href="#cb175-2"></a>  <span class="op">--*</span><span class="kw">this</span>;</span>
<span id="cb175-3"><a href="#cb175-3"></a>  <span class="cf">return</span> tmp;</span></code></pre></div>
</blockquote>
</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">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">+=(</span>difference_type x<span class="op">)</span></span>
<span id="cb176-2"><a href="#cb176-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb177"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb177-1"><a href="#cb177-1"></a>  <em>inner_</em> <span class="op">+=</span> x;</span>
<span id="cb177-2"><a href="#cb177-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</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">constexpr</span> <em>iterator</em><span class="op">&amp;</span> <span class="kw">operator</span><span class="op">-=(</span>difference_type x<span class="op">)</span></span>
<span id="cb178-2"><a href="#cb178-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Effects</em>: Equivalent to:</p>
<blockquote>
<div class="sourceCode" id="cb179"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb179-1"><a href="#cb179-1"></a>  <em>inner_</em> <span class="op">-=</span> x;</span>
<span id="cb179-2"><a href="#cb179-2"></a>  <span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb180"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb180-1"><a href="#cb180-1"></a><span class="kw">constexpr</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="kw">operator</span><span class="op">[](</span>difference_type n<span class="op">)</span> <span class="kw">const</span></span>
<span id="cb180-2"><a href="#cb180-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Effects</em>: Equivalent to:</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="cf">return</span> apply<span class="op">([&amp;](</span><span class="kw">const</span> <span class="kw">auto</span><span class="op">&amp;...</span> iters<span class="op">)</span> <span class="op">-&gt;</span> <span class="kw">decltype</span><span class="op">(</span><span class="kw">auto</span><span class="op">)</span> <span class="op">{</span></span>
<span id="cb181-2"><a href="#cb181-2"></a>    <span class="cf">return</span> invoke<span class="op">(*</span><em>parent_</em><span class="op">-&gt;</span><em>fun_</em>, iters<span class="op">[</span>n<span class="op">]...)</span>;</span>
<span id="cb181-3"><a href="#cb181-3"></a>  <span class="op">}</span>, <em>inner_</em><span class="op">.</span><em>current_</em><span class="op">)</span>;</span></code></pre></div>
</blockquote>
</blockquote>
<div class="sourceCode" id="cb182"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb182-1"><a href="#cb182-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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb182-2"><a href="#cb182-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">&lt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb182-3"><a href="#cb182-3"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb182-4"><a href="#cb182-4"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb182-5"><a href="#cb182-5"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb182-6"><a href="#cb182-6"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb182-7"><a href="#cb182-7"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb182-8"><a href="#cb182-8"></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> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb182-9"><a href="#cb182-9"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb182-10"><a href="#cb182-10"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="op">&lt;=&gt;(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb182-11"><a href="#cb182-11"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span> <span class="op">&amp;&amp;</span> three_way_comparable<span class="op">&lt;</span><em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span> Let <em><code class="sourceCode cpp">op</code></em> be the operator.</p>
<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><em>inner_</em> <em>op</em> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
<div class="sourceCode" id="cb183"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb183-1"><a href="#cb183-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb183-2"><a href="#cb183-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span>
<span id="cb183-3"><a href="#cb183-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">+(</span>difference_type n, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i<span class="op">)</span></span>
<span id="cb183-4"><a href="#cb183-4"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <em>iterator</em><span class="op">(*</span>i<span class="op">.</span><em>parent_</em>, i<span class="op">.</span><em>inner_</em> <span class="op">+</span> n<span class="op">)</span>;</code></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">friend</span> <span class="kw">constexpr</span> <em>iterator</em> <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> i, difference_type n<span class="op">)</span></span>
<span id="cb184-2"><a href="#cb184-2"></a>  <span class="kw">requires</span> random_access_range<span class="op">&lt;</span><em>Base</em><span class="op">&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> <em>iterator</em><span class="op">(*</span>i<span class="op">.</span><em>parent_</em>, i<span class="op">.</span><em>inner_</em> <span class="op">-</span> n<span class="op">)</span>;</code></p>
</blockquote>
<div class="sourceCode" id="cb185"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb185-1"><a href="#cb185-1"></a><span class="kw">friend</span> <span class="kw">constexpr</span> difference_type <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&amp;</span> y<span class="op">)</span></span>
<span id="cb185-2"><a href="#cb185-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> x<span class="op">.</span><em>inner_</em> <span class="op">-</span> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
</div>
<h4 class="unnumbered" data-number id="class-template-adjacent_transform_view_sentinel_-range.adjacent.transform.sentinel">24.7.?.4 Class template <code class="sourceCode cpp">adjacent_transform_view<span class="op">::</span><em>sentinel</em></code> [range.adjacent.transform.sentinel]<a href="#class-template-adjacent_transform_view_sentinel_-range.adjacent.transform.sentinel" class="self-link"></a></h4>
<div class="sourceCode" id="cb186"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb186-1"><a href="#cb186-1"></a><span class="kw">namespace</span> std<span class="op">::</span>ranges <span class="op">{</span></span>
<span id="cb186-2"><a href="#cb186-2"></a>  <span class="kw">template</span><span class="op">&lt;</span>forward_range V, copy_constructible F, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb186-3"><a href="#cb186-3"></a>    <span class="kw">requires</span> view<span class="op">&lt;</span>V<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">(</span>N <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">&amp;&amp;</span> is_object_v<span class="op">&lt;</span>F<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb186-4"><a href="#cb186-4"></a>             regular_invocable<span class="op">&lt;</span>F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, N<span class="op">)...&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb186-5"><a href="#cb186-5"></a>             <em>can-reference</em><span class="op">&lt;</span>invoke_result_t<span class="op">&lt;</span>F<span class="op">&amp;</span>, <em>REPEAT</em><span class="op">(</span>range_reference_t<span class="op">&lt;</span>V<span class="op">&gt;</span>, N<span class="op">)...&gt;&gt;</span></span>
<span id="cb186-6"><a href="#cb186-6"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> Const<span class="op">&gt;</span></span>
<span id="cb186-7"><a href="#cb186-7"></a>  <span class="kw">class</span> adjacent_transform_view<span class="op">&lt;</span>V, F, N<span class="op">&gt;::</span><em>sentinel</em> <span class="op">{</span></span>
<span id="cb186-8"><a href="#cb186-8"></a>    <em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> <em>inner_</em>;                              <span class="co">// exposition only</span></span>
<span id="cb186-9"><a href="#cb186-9"></a>    <span class="kw">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>;  <span class="co">// exposition only</span></span>
<span id="cb186-10"><a href="#cb186-10"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb186-11"><a href="#cb186-11"></a>    <em>sentinel</em><span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb186-12"><a href="#cb186-12"></a>    <span class="kw">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb186-13"><a href="#cb186-13"></a>      <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span>
<span id="cb186-14"><a href="#cb186-14"></a></span>
<span id="cb186-15"><a href="#cb186-15"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb186-16"><a href="#cb186-16"></a>      <span class="kw">requires</span> sentinel_for<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb186-17"><a href="#cb186-17"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb186-18"><a href="#cb186-18"></a></span>
<span id="cb186-19"><a href="#cb186-19"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb186-20"><a href="#cb186-20"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb186-21"><a href="#cb186-21"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb186-22"><a href="#cb186-22"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb186-23"><a href="#cb186-23"></a></span>
<span id="cb186-24"><a href="#cb186-24"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb186-25"><a href="#cb186-25"></a>      <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb186-26"><a href="#cb186-26"></a>    <span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb186-27"><a href="#cb186-27"></a>      <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span>
<span id="cb186-28"><a href="#cb186-28"></a>  <span class="op">}</span>;</span>
<span id="cb186-29"><a href="#cb186-29"></a><span class="op">}</span></span></code></pre></div>
<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">constexpr</span> <span class="kw">explicit</span> <em>sentinel</em><span class="op">(</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span> inner<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">inner</code>.</p>
</blockquote>
<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">constexpr</span> <em>sentinel</em><span class="op">(</span><em>sentinel</em><span class="op">&lt;!</span>Const<span class="op">&gt;</span> i<span class="op">)</span></span>
<span id="cb188-2"><a href="#cb188-2"></a>  <span class="kw">requires</span> Const <span class="op">&amp;&amp;</span> convertible_to<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span><span class="kw">false</span><span class="op">&gt;</span>, <em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;&gt;</span>;</span></code></pre></div>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects</em>: Initializes <code class="sourceCode cpp"><em>inner_</em></code> with <code class="sourceCode cpp">std<span class="op">::</span>move<span class="op">(</span>i<span class="op">.</span><em>inner_</em><span class="op">)</span></code>.</p>
</blockquote>
<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="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb189-2"><a href="#cb189-2"></a>  <span class="kw">requires</span> sentinel_for<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb189-3"><a href="#cb189-3"></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> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>inner_</em> <span class="op">==</span> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
<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="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb190-2"><a href="#cb190-2"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb190-3"><a href="#cb190-3"></a><span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb190-4"><a href="#cb190-4"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> x, <span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> y<span class="op">)</span>;</span>
<span id="cb190-5"><a href="#cb190-5"></a></span>
<span id="cb190-6"><a href="#cb190-6"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">bool</span> OtherConst<span class="op">&gt;</span></span>
<span id="cb190-7"><a href="#cb190-7"></a>  <span class="kw">requires</span> sized_sentinel_for<span class="op">&lt;</span><em>inner-sentinel</em><span class="op">&lt;</span>Const<span class="op">&gt;</span>, <em>inner-iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&gt;</span></span>
<span id="cb190-8"><a href="#cb190-8"></a><span class="kw">friend</span> <span class="kw">constexpr</span> range_difference_t<span class="op">&lt;</span><em>maybe-const</em><span class="op">&lt;</span>OtherConst, <em>InnerView</em><span class="op">&gt;&gt;</span></span>
<span id="cb190-9"><a href="#cb190-9"></a>  <span class="kw">operator</span><span class="op">-(</span><span class="kw">const</span> <em>sentinel</em><span class="op">&amp;</span> x, <span class="kw">const</span> <em>iterator</em><span class="op">&lt;</span>OtherConst<span class="op">&gt;&amp;</span> y<span class="op">)</span>;</span></code></pre></div>
<blockquote>
<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><em>inner_</em> <span class="op">-</span> y<span class="op">.</span><em>inner_</em>;</code></p>
</blockquote>
</div>
<h2 data-number="5.9" id="feature-test-macro"><span class="header-section-number">5.9</span> Feature-test macro<a href="#feature-test-macro" class="self-link"></a></h2>
<p>Add the following macro definition to <span>17.3.2 <a href="https://wg21.link/version.syn">[version.syn]</a></span>, header <code class="sourceCode cpp"><span class="op">&lt;</span>version<span class="op">&gt;</span></code> synopsis, with the value selected by the editor to reflect the date of adoption of this paper:</p>
<div class="sourceCode" id="cb191"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb191-1"><a href="#cb191-1"></a><span class="pp">#define __cpp_lib_ranges_zip </span><span class="dv">20</span><span class="er">XXXXL</span><span class="pp"> </span><span class="co">// also in &lt;ranges&gt;, &lt;tuple&gt;, &lt;utility&gt;</span></span></code></pre></div>
<h1 data-number="6" style="border-bottom:1px solid #cccccc" id="acknowledgements"><span class="header-section-number">6</span> Acknowledgements<a href="#acknowledgements" class="self-link"></a></h1>
<p>Thanks to Barry Revzin for implementing this entire paper from spec and finding several wording issues in the process.</p>
<h1 data-number="7" style="border-bottom:1px solid #cccccc" id="bibliography"><span class="header-section-number">7</span> References<a href="#bibliography" class="self-link"></a></h1>
<div id="refs" class="references hanging-indent" role="doc-bibliography">
<div id="ref-N4878">
<p>[N4878] Thomas Köppe. 2020-12-15. Working Draft, Standard for Programming Language C++. <br />
<a href="https://wg21.link/n4878">https://wg21.link/n4878</a></p>
</div>
<div id="ref-P2214R0">
<p>[P2214R0] Barry Revzin, Conor Hoekstra, Tim Song. 2020-10-15. A Plan for C++23 Ranges. <br />
<a href="https://wg21.link/p2214r0">https://wg21.link/p2214r0</a></p>
</div>
<div id="ref-range-v3.1592">
<p>[range-v3.1592] kitegi. 2020. <code class="sourceCode cpp">zip</code> does not satisfy the semantic requirements of <code class="sourceCode cpp">bidirectional_iterator</code> when the ranges have different lengths. <br />
<a href="https://github.com/ericniebler/range-v3/issues/1592">https://github.com/ericniebler/range-v3/issues/1592</a></p>
</div>
<div id="ref-range-v3.704">
<p>[range-v3.704] Eric Niebler. 2017. Demand-driven view strength weakening. <br />
<a href="https://github.com/ericniebler/range-v3/issues/704">https://github.com/ericniebler/range-v3/issues/704</a></p>
</div>
</div>
</div>
</div>
</body>
</html>
