<!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="2022-02-16" />
  <title>ranges::copy should say output_iterator somewhere</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 { 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; }
div.quote {
border-left: 7px solid #ccc;
background: #f9f9f9;
margin: 1.5em 10px;
padding-left: 20px;
}
code.diff span.va { color: #000000; background-color: var(--diff-ins); }
code.diff span.st { color: #000000; background-color: var(--diff-del); }
</style>
  <link href="data:image/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">ranges<span class="op">::</span>copy</code> should say <code class="sourceCode cpp">output_iterator</code> somewhere</h1>

<table style="border:none;float:right">
  <tr>
    <td>Document #:</td>
    <td>P2550R0</td>
  </tr>
  <tr>
    <td>Date:</td>
    <td>2022-02-16</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>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to:</td>
    <td>
      Barry Revzin<br>&lt;<a href="mailto:barry.revzin@gmail.com" class="email">barry.revzin@gmail.com</a>&gt;<br>
    </td>
  </tr>
</table>

</header>
<div style="clear:both">
<div id="TOC" role="doc-toc">
<h1 id="toctitle">Contents</h1>
<ul>
<li><a href="#introduction"><span class="toc-section-number">1</span> Introduction<span></span></a>
<ul>
<li><a href="#output-concept-hierarchy"><span class="toc-section-number">1.1</span> Output concept hierarchy<span></span></a></li>
<li><a href="#does-anything-in-ranges-use-output_iterator"><span class="toc-section-number">1.2</span> Does anything in Ranges use <code class="sourceCode cpp">output_iterator</code>?<span></span></a></li>
</ul></li>
<li><a href="#proposal-a-weaker-output-iterator"><span class="toc-section-number">2</span> Proposal: A Weaker Output Iterator<span></span></a>
<ul>
<li><a href="#summary-of-proposal"><span class="toc-section-number">2.1</span> Summary of Proposal<span></span></a></li>
</ul></li>
<li><a href="#wording"><span class="toc-section-number">3</span> Wording<span></span></a>
<ul>
<li><a href="#concept-weak_output_iterator"><span class="toc-section-number">3.1</span> <code class="sourceCode cpp"><span class="kw">concept</span> weak_output_iterator</code><span></span></a></li>
<li><a href="#concept-mergeable"><span class="toc-section-number">3.2</span> <code class="sourceCode cpp"><span class="kw">concept</span> mergeable</code><span></span></a></li>
<li><a href="#concept-weak_output_range"><span class="toc-section-number">3.3</span> <code class="sourceCode cpp"><span class="kw">concept</span> weak_output_range</code><span></span></a></li>
<li><a href="#algorithms"><span class="toc-section-number">3.4</span> Algorithms<span></span></a>
<ul>
<li><a href="#rangescopy"><span class="toc-section-number">3.4.1</span> <code class="sourceCode cpp">ranges<span class="op">::</span>copy</code><span></span></a></li>
<li><a href="#rangescopy_n"><span class="toc-section-number">3.4.2</span> <code class="sourceCode cpp">ranges<span class="op">::</span>copy_n</code><span></span></a></li>
<li><a href="#rangescopy_if"><span class="toc-section-number">3.4.3</span> <code class="sourceCode cpp">ranges<span class="op">::</span>copy_if</code><span></span></a></li>
<li><a href="#rangesmove"><span class="toc-section-number">3.4.4</span> <code class="sourceCode cpp">ranges<span class="op">::</span>move</code><span></span></a></li>
<li><a href="#rangestransform"><span class="toc-section-number">3.4.5</span> <code class="sourceCode cpp">ranges<span class="op">::</span>transform</code><span></span></a></li>
<li><a href="#rangesreplace_copy"><span class="toc-section-number">3.4.6</span> <code class="sourceCode cpp">ranges<span class="op">::</span>replace_copy</code><span></span></a></li>
<li><a href="#rangesfill"><span class="toc-section-number">3.4.7</span> <code class="sourceCode cpp">ranges<span class="op">::</span>fill</code><span></span></a></li>
<li><a href="#rangesgenerate"><span class="toc-section-number">3.4.8</span> <code class="sourceCode cpp">ranges<span class="op">::</span>generate</code><span></span></a></li>
<li><a href="#rangesremove_copy"><span class="toc-section-number">3.4.9</span> <code class="sourceCode cpp">ranges<span class="op">::</span>remove_copy</code><span></span></a></li>
<li><a href="#rangesunique_copy"><span class="toc-section-number">3.4.10</span> <code class="sourceCode cpp">ranges<span class="op">::</span>unique_copy</code><span></span></a></li>
<li><a href="#rangesreverse_copy"><span class="toc-section-number">3.4.11</span> <code class="sourceCode cpp">ranges<span class="op">::</span>reverse_copy</code><span></span></a></li>
<li><a href="#rangesrotate_copy"><span class="toc-section-number">3.4.12</span> <code class="sourceCode cpp">ranges<span class="op">::</span>rotate_copy</code><span></span></a></li>
<li><a href="#rangespartition_copy"><span class="toc-section-number">3.4.13</span> <code class="sourceCode cpp">ranges<span class="op">::</span>partition_copy</code><span></span></a></li>
<li><a href="#rangesmerge"><span class="toc-section-number">3.4.14</span> <code class="sourceCode cpp">ranges<span class="op">::</span>merge</code><span></span></a></li>
<li><a href="#rangesset_union"><span class="toc-section-number">3.4.15</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_union</code><span></span></a></li>
<li><a href="#rangesset_intersection"><span class="toc-section-number">3.4.16</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_intersection</code><span></span></a></li>
<li><a href="#rangesset_difference"><span class="toc-section-number">3.4.17</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_difference</code><span></span></a></li>
<li><a href="#rangesset_symmetric_difference"><span class="toc-section-number">3.4.18</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_symmetric_difference</code><span></span></a></li>
<li><a href="#rangesiota"><span class="toc-section-number">3.4.19</span> <code class="sourceCode cpp">ranges<span class="op">::</span>iota</code><span></span></a></li>
</ul></li>
</ul></li>
<li><a href="#acknowledgements"><span class="toc-section-number">4</span> Acknowledgements<span></span></a></li>
<li><a href="#bibliography"><span class="toc-section-number">5</span> References<span></span></a></li>
</ul>
</div>
<h1 data-number="1" style="border-bottom:1px solid #cccccc" id="introduction"><span class="header-section-number">1</span> Introduction<a href="#introduction" class="self-link"></a></h1>
<p>In the beginning, we had:</p>
<blockquote>
<div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> InputIterator, <span class="kw">class</span> OutputIterator<span class="op">&gt;</span></span>
<span id="cb1-2"><a href="#cb1-2"></a>  <span class="kw">constexpr</span> OutputIterator copy<span class="op">(</span>InputIterator first, InputIterator last,</span>
<span id="cb1-3"><a href="#cb1-3"></a>                                OutputIterator result<span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p>And then, in C++20, we added Concepts and Ranges - which came with a whole library of <code class="sourceCode cpp"><span class="kw">concept</span></code>s for the standard library, in particular for iterators and ragnes. This included a concept <code class="sourceCode cpp">input_iterator</code> and <code class="sourceCode cpp">output_iterator</code>. We also added new rangified versions of all the algorithms, constrained using these concepts.</p>
<p>The new overloads look like this:</p>
<blockquote>
<div class="sourceCode" id="cb2"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb2-1"><a href="#cb2-1"></a><span class="kw">template</span><span class="op">&lt;</span>input_iterator I, sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S, weakly_incrementable O<span class="op">&gt;</span></span>
<span id="cb2-2"><a href="#cb2-2"></a>  <span class="kw">requires</span> indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb2-3"><a href="#cb2-3"></a>  <span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span> ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span>
<span id="cb2-4"><a href="#cb2-4"></a><span class="kw">template</span><span class="op">&lt;</span>input_range R, weakly_incrementable O<span class="op">&gt;</span></span>
<span id="cb2-5"><a href="#cb2-5"></a>  <span class="kw">requires</span> indirectly_copyable<span class="op">&lt;</span>iterator_t<span class="op">&lt;</span>R<span class="op">&gt;</span>, O<span class="op">&gt;</span></span>
<span id="cb2-6"><a href="#cb2-6"></a>  <span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>borrowed_iterator_t<span class="op">&lt;</span>R<span class="op">&gt;</span>, O<span class="op">&gt;</span> ranges<span class="op">::</span>copy<span class="op">(</span>R<span class="op">&amp;&amp;</span> r, O result<span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p>The crux of this paper is that <code class="sourceCode cpp">std<span class="op">::</span>copy</code> takes an <code class="sourceCode cpp">OutputIterator</code> (even if the name of this parameter does nothing), but <code class="sourceCode cpp">std<span class="op">::</span>ranges<span class="op">::</span>copy</code> does not have anything named <code class="sourceCode cpp">output_iterator</code> in this constraints at all. That just seems wrong. Output iterator is a thing that users understand, but “weakly incrementable” and “indirectly copyable,” while reasonable names for the functionality they require, are not particularly well known and are not really useful when they show up in diagnostics.</p>
<p>We should do better here.</p>
<h2 data-number="1.1" id="output-concept-hierarchy"><span class="header-section-number">1.1</span> Output concept hierarchy<a href="#output-concept-hierarchy" class="self-link"></a></h2>
<p>Let me start with what all the relevant <code class="sourceCode cpp"><span class="kw">concept</span></code>s actually are:</p>
<blockquote>
<div class="sourceCode" id="cb3"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb3-1"><a href="#cb3-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> I<span class="op">&gt;</span></span>
<span id="cb3-2"><a href="#cb3-2"></a>  <span class="kw">concept</span> weakly_incrementable <span class="op">=</span></span>
<span id="cb3-3"><a href="#cb3-3"></a>    movable<span class="op">&lt;</span>I<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb3-4"><a href="#cb3-4"></a>    <span class="kw">requires</span><span class="op">(</span>I i<span class="op">)</span> <span class="op">{</span></span>
<span id="cb3-5"><a href="#cb3-5"></a>      <span class="kw">typename</span> iter_difference_t<span class="op">&lt;</span>I<span class="op">&gt;</span>;</span>
<span id="cb3-6"><a href="#cb3-6"></a>      <span class="kw">requires</span> <em>is-signed-integer-like</em><span class="op">&lt;</span>iter_difference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span>;</span>
<span id="cb3-7"><a href="#cb3-7"></a>      <span class="op">{</span> <span class="op">++</span>i <span class="op">}</span> <span class="op">-&gt;</span> same_as<span class="op">&lt;</span>I<span class="op">&amp;&gt;</span>;   <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-8"><a href="#cb3-8"></a>      i<span class="op">++</span>;                      <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-9"><a href="#cb3-9"></a>    <span class="op">}</span>;</span>
<span id="cb3-10"><a href="#cb3-10"></a></span>
<span id="cb3-11"><a href="#cb3-11"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> I<span class="op">&gt;</span></span>
<span id="cb3-12"><a href="#cb3-12"></a>  <span class="kw">concept</span> input_or_output_iterator <span class="op">=</span></span>
<span id="cb3-13"><a href="#cb3-13"></a>    <span class="kw">requires</span><span class="op">(</span>I i<span class="op">)</span> <span class="op">{</span></span>
<span id="cb3-14"><a href="#cb3-14"></a>      <span class="op">{</span> <span class="op">*</span>i <span class="op">}</span> <span class="op">-&gt;</span> <em>can-reference</em>;</span>
<span id="cb3-15"><a href="#cb3-15"></a>    <span class="op">}</span> <span class="op">&amp;&amp;</span></span>
<span id="cb3-16"><a href="#cb3-16"></a>    weakly_incrementable<span class="op">&lt;</span>I<span class="op">&gt;</span>;</span>
<span id="cb3-17"><a href="#cb3-17"></a></span>
<span id="cb3-18"><a href="#cb3-18"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Out, <span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb3-19"><a href="#cb3-19"></a>  <span class="kw">concept</span> indirectly_writable <span class="op">=</span></span>
<span id="cb3-20"><a href="#cb3-20"></a>    <span class="kw">requires</span><span class="op">(</span>Out<span class="op">&amp;&amp;</span> o, T<span class="op">&amp;&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
<span id="cb3-21"><a href="#cb3-21"></a>      <span class="op">*</span>o <span class="op">=</span> std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span>;  <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-22"><a href="#cb3-22"></a>      <span class="op">*</span>std<span class="op">::</span>forward<span class="op">&lt;</span>Out<span class="op">&gt;(</span>o<span class="op">)</span> <span class="op">=</span> std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span>;   <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-23"><a href="#cb3-23"></a>      <span class="kw">const_cast</span><span class="op">&lt;</span><span class="kw">const</span> iter_reference_t<span class="op">&lt;</span>Out<span class="op">&gt;&amp;&amp;&gt;(*</span>o<span class="op">)</span> <span class="op">=</span></span>
<span id="cb3-24"><a href="#cb3-24"></a>        std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span>;     <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-25"><a href="#cb3-25"></a>      <span class="kw">const_cast</span><span class="op">&lt;</span><span class="kw">const</span> iter_reference_t<span class="op">&lt;</span>Out<span class="op">&gt;&amp;&amp;&gt;(*</span>std<span class="op">::</span>forward<span class="op">&lt;</span>Out<span class="op">&gt;(</span>o<span class="op">))</span> <span class="op">=</span></span>
<span id="cb3-26"><a href="#cb3-26"></a>        std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span>;     <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-27"><a href="#cb3-27"></a>    <span class="op">}</span>;</span>
<span id="cb3-28"><a href="#cb3-28"></a></span>
<span id="cb3-29"><a href="#cb3-29"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> In, <span class="kw">class</span> Out<span class="op">&gt;</span></span>
<span id="cb3-30"><a href="#cb3-30"></a>  <span class="kw">concept</span> indirectly_copyable <span class="op">=</span></span>
<span id="cb3-31"><a href="#cb3-31"></a>    indirectly_readable<span class="op">&lt;</span>In<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb3-32"><a href="#cb3-32"></a>    indirectly_writable<span class="op">&lt;</span>Out, iter_reference_t<span class="op">&lt;</span>In<span class="op">&gt;&gt;</span>;</span>
<span id="cb3-33"><a href="#cb3-33"></a></span>
<span id="cb3-34"><a href="#cb3-34"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> I, <span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb3-35"><a href="#cb3-35"></a>  <span class="kw">concept</span> output_iterator <span class="op">=</span></span>
<span id="cb3-36"><a href="#cb3-36"></a>    input_or_output_iterator<span class="op">&lt;</span>I<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb3-37"><a href="#cb3-37"></a>    indirectly_writable<span class="op">&lt;</span>I, T<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb3-38"><a href="#cb3-38"></a>    <span class="kw">requires</span><span class="op">(</span>I i, T<span class="op">&amp;&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
<span id="cb3-39"><a href="#cb3-39"></a>      <span class="op">*</span>i<span class="op">++</span> <span class="op">=</span> std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span>;        <span class="co">// not required to be equality-preserving</span></span>
<span id="cb3-40"><a href="#cb3-40"></a>    <span class="op">}</span>;</span></code></pre></div>
</blockquote>
<p>Or, in graph form:</p>
<blockquote>
<p><img src="data:image/png;base64,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" title="output iterator concept hierarchy" alt="output iterator concept hierarchy" /></p>
</blockquote>
<p>And let me present two possible specifications for <code class="sourceCode cpp">ranges<span class="op">::</span>copy</code>.</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>In C++20</strong>
</div></th>
<th><div style="text-align:center">
<strong>Hypothetical</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div class="sourceCode" id="cb4"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb4-1"><a href="#cb4-1"></a><span class="kw">template</span> <span class="op">&lt;</span>input_iterator I,</span>
<span id="cb4-2"><a href="#cb4-2"></a>          sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S,</span>
<span id="cb4-3"><a href="#cb4-3"></a>          weakly_incrementable O<span class="op">&gt;</span></span>
<span id="cb4-4"><a href="#cb4-4"></a>  <span class="kw">requires</span> indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb4-5"><a href="#cb4-5"></a><span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb4-6"><a href="#cb4-6"></a>ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span></code></pre></div></td>
<td><div class="sourceCode" id="cb5"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb5-1"><a href="#cb5-1"></a><span class="kw">template</span> <span class="op">&lt;</span>input_iterator I,</span>
<span id="cb5-2"><a href="#cb5-2"></a>          sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S,</span>
<span id="cb5-3"><a href="#cb5-3"></a>          output_iterator<span class="op">&lt;</span>iter_reference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span> O<span class="op">&gt;</span></span>
<span id="cb5-4"><a href="#cb5-4"></a><span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb5-5"><a href="#cb5-5"></a>ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span></code></pre></div></td>
</tr>
</tbody>
</table>
<p>Now, the one on the right actually says <code class="sourceCode cpp">output_iterator</code>, which I think is extremely valuable. But are the requirements any different?</p>
<p>In C++20, we require:</p>
<ul>
<li><code class="sourceCode cpp">O</code> is <code class="sourceCode cpp">weakly_incrementable</code></li>
<li><code class="sourceCode cpp">indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></code>, which means <code class="sourceCode cpp">I</code> is <code class="sourceCode cpp">indirectly_readable</code> (which is already required by <code class="sourceCode cpp">input_iterator</code>) and <code class="sourceCode cpp">O</code> is <code class="sourceCode cpp">indirectly_writable<span class="op">&lt;</span>iter_reference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span></code></li>
</ul>
<p>The hypothetical version requires <code class="sourceCode cpp">output_iterator<span class="op">&lt;</span>iter_reference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span></code>, which breaks down into:</p>
<ul>
<li><code class="sourceCode cpp">input_or_output_iterator</code>
<ul>
<li>dereferencable (already required by <code class="sourceCode cpp">indirectly_writable</code>, since you have to have <code class="sourceCode cpp"><span class="op">*</span>o <span class="op">=</span> expr;</code> work)</li>
<li><code class="sourceCode cpp">weakly_incrementable</code> (explicitly required in C++20)</li>
</ul></li>
<li><code class="sourceCode cpp">indirectly_writable</code> (explicitly required in C++20)</li>
<li><code class="sourceCode cpp"><span class="op">*</span>i<span class="op">++</span> <span class="op">=</span> t;</code> (<em>not</em> required in C++20)</li>
</ul>
<p>Basically: the two formulations have identical requirements <em>except</em> that today’s specification of <code class="sourceCode cpp">std<span class="op">::</span>ranges<span class="op">::</span>copy</code> does not require <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++</span> <span class="op">=</span> t;</code> to work, while my hypothetical one does. Generally speaking, this is a good thing. It may be syntactically nice to write <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++</span> <span class="op">=</span> t;</code> instead of <code class="sourceCode cpp"><span class="op">*</span>out <span class="op">=</span> t; <span class="op">++</span>out;</code>, but it’s not actually necessary to solve any problems. This makes <code class="sourceCode cpp">ranges<span class="op">::</span>copy</code> more usable, but it means that our most output-y of output algorithms doesn’t use <code class="sourceCode cpp">output_iterator</code>.</p>
<h2 data-number="1.2" id="does-anything-in-ranges-use-output_iterator"><span class="header-section-number">1.2</span> Does anything in Ranges use <code class="sourceCode cpp">output_iterator</code>?<a href="#does-anything-in-ranges-use-output_iterator" class="self-link"></a></h2>
<p>I thought it’d be useful to go through everything in <code class="sourceCode cpp"><span class="op">&lt;</span>algorithm<span class="op">&gt;</span></code> that uses an output iterator (if not an <code class="sourceCode cpp">output_iterator</code>) and catalogue all the kinds of constraints we have on them. There are many different approaches (in the below, <code class="sourceCode cpp">X</code> just denotes some type, <code class="sourceCode cpp">O</code> is our output iterator, <code class="sourceCode cpp">I</code> is the corresponding input iterator):</p>
<ul>
<li><code class="sourceCode cpp">weakly_incrementable<span class="op">&lt;</span>O<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></code>: <code class="sourceCode cpp">ranges<span class="op">::</span>copy</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>copy_n</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>copy_if</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>remove_copy</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>remove_copy_if</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>unique_copy</code> (although this one has a disjunction that might include other constraints), <code class="sourceCode cpp">ranges<span class="op">::</span>reverse_copy</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>rotate_copy</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>partition_copy</code></li>
<li><code class="sourceCode cpp">weakly_incrementable<span class="op">&lt;</span>O<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> indirectly_movable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></code>: <code class="sourceCode cpp">ranges<span class="op">::</span>move</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>move_if</code></li>
<li><code class="sourceCode cpp">weakly_incrementable<span class="op">&lt;</span>O<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> indirectly_writable<span class="op">&lt;</span>O, X<span class="op">&gt;</span></code>: <code class="sourceCode cpp">ranges<span class="op">::</span>transform</code></li>
<li><code class="sourceCode cpp">output_iterator<span class="op">&lt;</span>O, X<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></code>: <code class="sourceCode cpp">ranges<span class="op">::</span>replace_copy</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>replace_copy_if</code></li>
<li><code class="sourceCode cpp">output_iterator<span class="op">&lt;</span>O, X<span class="op">&gt;</span></code>: <code class="sourceCode cpp">ranges<span class="op">::</span>fill</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>fill_n</code></li>
<li><code class="sourceCode cpp">input_or_output_iterator<span class="op">&lt;</span>O<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> indirectly_writable<span class="op">&lt;</span>O, X<span class="op">&gt;</span></code>: <code class="sourceCode cpp">ranges<span class="op">::</span>generate</code> (see below), <code class="sourceCode cpp">ranges<span class="op">::</span>generate_n</code></li>
<li><code class="sourceCode cpp">weakly_incrementable<span class="op">&lt;</span>O<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> mergeable<span class="op">&lt;</span>I1, I2, O, X, X<span class="op">&gt;</span></code> (technically <code class="sourceCode cpp">mergeable</code>’s requirements on <code class="sourceCode cpp">O</code> are just <code class="sourceCode cpp">indirectly_copyable</code>, but putting it separately for completeness): <code class="sourceCode cpp">ranges<span class="op">::</span>merge</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>set_union</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>set_intersection</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>set_difference</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>set_symmetric_difference</code></li>
</ul>
<p>Put differently, there are only 4 algorithms that use <code class="sourceCode cpp">output_iterator</code>: <code class="sourceCode cpp">ranges<span class="op">::</span>replace_copy</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>replace_copy_if</code>, <code class="sourceCode cpp">ranges<span class="op">::</span>fill</code>, and <code class="sourceCode cpp">ranges<span class="op">::</span>fill_n</code>.</p>
<p>There are, separately, 2 algorithms that use <code class="sourceCode cpp">output_range<span class="op">&lt;</span>R<span class="op">&gt;</span></code> (which requires its iterator to be an <code class="sourceCode cpp">output_iterator</code>): <code class="sourceCode cpp">ranges<span class="op">::</span>fill</code> and <code class="sourceCode cpp">ranges<span class="op">::</span>generate</code>. While <code class="sourceCode cpp">ranges<span class="op">::</span>fill</code> has the same requirements on its iterator/sentinel and range overloads, <code class="sourceCode cpp">ranges<span class="op">::</span>generate</code> does not. The consequence of this is, for instance:</p>
<blockquote>
<div class="sourceCode" id="cb6"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb6-1"><a href="#cb6-1"></a><span class="kw">auto</span> some_generator<span class="op">()</span> <span class="op">-&gt;</span> std<span class="op">::</span>generator<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;</span>;</span>
<span id="cb6-2"><a href="#cb6-2"></a><span class="kw">auto</span> some_func<span class="op">()</span> <span class="op">-&gt;</span> <span class="dt">int</span>;</span>
<span id="cb6-3"><a href="#cb6-3"></a></span>
<span id="cb6-4"><a href="#cb6-4"></a><span class="dt">void</span> f<span class="op">()</span> <span class="op">{</span></span>
<span id="cb6-5"><a href="#cb6-5"></a>    <span class="kw">auto</span> g <span class="op">=</span> some_generator<span class="op">()</span>;</span>
<span id="cb6-6"><a href="#cb6-6"></a>    std<span class="op">::</span>ranges<span class="op">::</span>generate<span class="op">(</span>g, some_func<span class="op">)</span>;                  <span class="co">// error</span></span>
<span id="cb6-7"><a href="#cb6-7"></a>    std<span class="op">::</span>ranges<span class="op">::</span>generate<span class="op">(</span>g<span class="op">.</span>begin<span class="op">()</span>, g<span class="op">.</span>end<span class="op">()</span>, some_func<span class="op">)</span>; <span class="co">// ok</span></span>
<span id="cb6-8"><a href="#cb6-8"></a><span class="op">}</span></span></code></pre></div>
</blockquote>
<p>Since <span class="citation" data-cites="P2502R0">[<a href="#ref-P2502R0" role="doc-biblioref">P2502R0</a>]</span>’s <code class="sourceCode cpp">generator</code> (like all other input-only ranges in the standard library right now) has a postfix <code class="sourceCode cpp"><span class="kw">operator</span><span class="op">++</span></code> that returns <code class="sourceCode cpp"><span class="dt">void</span></code>, this makes <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++</span></code> ill-formed, which means that <code class="sourceCode cpp">iterator_t<span class="op">&lt;</span>generator<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;&gt;</span></code> is not an <code class="sourceCode cpp">output_iterator<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;</span></code> which means that <code class="sourceCode cpp">generator<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;</span></code> is not an <code class="sourceCode cpp">output_range<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;</span></code>. That makes the range overload fail. But <code class="sourceCode cpp">iterator_t<span class="op">&lt;</span>generator<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;&gt;</span></code> is <code class="sourceCode cpp">weakly_incrementable</code> and <code class="sourceCode cpp">indirectly_writable<span class="op">&lt;</span><span class="dt">int</span><span class="op">&amp;&gt;</span></code>, which are all the requirements of the iterator/sentinel overload, so this… works? The inconsistency is a problem.</p>
<p>Now, <code class="sourceCode cpp">indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></code> is really two constraints put together. It requires that <code class="sourceCode cpp">I</code> is an <code class="sourceCode cpp">input_iterator</code> and that <code class="sourceCode cpp">O</code> is <code class="sourceCode cpp">indirectly_writable<span class="op">&lt;</span>iter_reference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span></code>. This constraint is by far the most common formulation for output ranges. But it’s a bit redundant, since all of these algorithms already separately require <code class="sourceCode cpp">input_iterator<span class="op">&lt;</span>I<span class="op">&gt;</span></code>. The only new requirement that <code class="sourceCode cpp">indirectly_copyable</code> brings in is the <code class="sourceCode cpp">indirectly_writable</code> one. What I mean is that instead of:</p>
<blockquote>
<div class="sourceCode" id="cb7"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb7-1"><a href="#cb7-1"></a><span class="kw">template</span><span class="op">&lt;</span>input_iterator I, sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S, weakly_incrementable O<span class="op">&gt;</span></span>
<span id="cb7-2"><a href="#cb7-2"></a>  <span class="kw">requires</span> indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb7-3"><a href="#cb7-3"></a>  <span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span> ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p>we could get the same exact same requirements (no more, no less) by instead writing:</p>
<blockquote>
<div class="sourceCode" id="cb8"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb8-1"><a href="#cb8-1"></a><span class="kw">template</span><span class="op">&lt;</span>input_iterator I, sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S, weakly_incrementable O<span class="op">&gt;</span></span>
<span id="cb8-2"><a href="#cb8-2"></a>  <span class="kw">requires</span> indirectly_writable<span class="op">&lt;</span>O, iter_reference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span></span>
<span id="cb8-3"><a href="#cb8-3"></a>  <span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span> ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span></code></pre></div>
</blockquote>
<p>The same idea could hold for the algorithms requiring <code class="sourceCode cpp">indirectly_movable</code> (replaced with a different kind of <code class="sourceCode cpp">indirectly_writable</code> constraint).</p>
<h1 data-number="2" style="border-bottom:1px solid #cccccc" id="proposal-a-weaker-output-iterator"><span class="header-section-number">2</span> Proposal: A Weaker Output Iterator<a href="#proposal-a-weaker-output-iterator" class="self-link"></a></h1>
<p>We can’t remove the <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++=</span> r;</code> requirement from <code class="sourceCode cpp">output_iterator</code>. It’s 2022, surely somebody has written some C++20 code by now, and might rely on that part of the <code class="sourceCode cpp"><span class="kw">concept</span></code>. Similarly, we cannot add the <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++</span> <span class="op">=</span> r;</code> requirement to all the algorithms which take an output iterator, since likewise somebody could have written C++20 code that passes in a type into these algorithms that meets every requirement but that one, and this added constraint would break their code.</p>
<p>However, the current state of affairs isn’t great. Algorithm requirements are inconsistent and aren’t written using terms that the algorithms have historically used, which users are familiar with.</p>
<p>If this were 2019 or 2020, I would suggest that we either drop the <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++</span> <span class="op">=</span> r;</code> requirement from <code class="sourceCode cpp">output_iterator</code> or strengthen all the algorithms to require <code class="sourceCode cpp">output_iterator</code>. But it’s 2022, and we can clearly do neither. Consequently, this paper does not propose anything that would change the behavior of any valid C++20 code.</p>
<p>Instead, the problem this paper seeks to solve is to unify the requirements that all the output algorithms use. We cannot unify around the stronger concept, so instead we can introduce a new, weaker output iterator concept:</p>
<blockquote>
<div class="sourceCode" id="cb9"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb9-1"><a href="#cb9-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> I, <span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb9-2"><a href="#cb9-2"></a>  <span class="kw">concept</span> weak_output_iterator <span class="op">=</span></span>
<span id="cb9-3"><a href="#cb9-3"></a>    input_or_output_iterator<span class="op">&lt;</span>I<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb9-4"><a href="#cb9-4"></a>    indirectly_writable<span class="op">&lt;</span>I, T<span class="op">&gt;</span>;</span>
<span id="cb9-5"><a href="#cb9-5"></a></span>
<span id="cb9-6"><a href="#cb9-6"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> I, <span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb9-7"><a href="#cb9-7"></a>  <span class="kw">concept</span> output_iterator <span class="op">=</span></span>
<span id="cb9-8"><a href="#cb9-8"></a>    weak_output_iterator<span class="op">&lt;</span>I, T<span class="op">&gt;</span> <span class="op">&amp;&amp;</span></span>
<span id="cb9-9"><a href="#cb9-9"></a>    <span class="kw">requires</span><span class="op">(</span>I i, T<span class="op">&amp;&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
<span id="cb9-10"><a href="#cb9-10"></a>      <span class="op">*</span>i<span class="op">++</span> <span class="op">=</span> std<span class="op">::</span>forward<span class="op">&lt;</span>T<span class="op">&gt;(</span>t<span class="op">)</span>;        <span class="co">// not required to be equality-preserving</span></span>
<span id="cb9-11"><a href="#cb9-11"></a>    <span class="op">}</span>;</span></code></pre></div>
</blockquote>
<p>With such a concept, we can go through all the algorithms and respecify them to just use it. For example, <code class="sourceCode cpp">ranges<span class="op">::</span>copy</code> becomes:</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>In C++20</strong>
</div></th>
<th><div style="text-align:center">
<strong>Proposed</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div class="sourceCode" id="cb10"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb10-1"><a href="#cb10-1"></a><span class="kw">template</span> <span class="op">&lt;</span>input_iterator I,</span>
<span id="cb10-2"><a href="#cb10-2"></a>          sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S,</span>
<span id="cb10-3"><a href="#cb10-3"></a>          weakly_incrementable O<span class="op">&gt;</span></span>
<span id="cb10-4"><a href="#cb10-4"></a>  <span class="kw">requires</span> indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb10-5"><a href="#cb10-5"></a><span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb10-6"><a href="#cb10-6"></a>ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span></code></pre></div></td>
<td><div class="sourceCode" id="cb11"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb11-1"><a href="#cb11-1"></a><span class="kw">template</span> <span class="op">&lt;</span>input_iterator I,</span>
<span id="cb11-2"><a href="#cb11-2"></a>          sentinel_for<span class="op">&lt;</span>I<span class="op">&gt;</span> S,</span>
<span id="cb11-3"><a href="#cb11-3"></a>          weak_output_iterator<span class="op">&lt;</span>iter_reference_t<span class="op">&lt;</span>I<span class="op">&gt;&gt;</span> O<span class="op">&gt;</span></span>
<span id="cb11-4"><a href="#cb11-4"></a><span class="kw">constexpr</span> ranges<span class="op">::</span>copy_result<span class="op">&lt;</span>I, O<span class="op">&gt;</span></span>
<span id="cb11-5"><a href="#cb11-5"></a>ranges<span class="op">::</span>copy<span class="op">(</span>I first, S last, O result<span class="op">)</span>;</span></code></pre></div></td>
</tr>
</tbody>
</table>
<p>Unlike my hypothetical spelling earlier, these two now have identical requirements.</p>
<h2 data-number="2.1" id="summary-of-proposal"><span class="header-section-number">2.1</span> Summary of Proposal<a href="#summary-of-proposal" class="self-link"></a></h2>
<p>This proposal introduces:</p>
<ul>
<li>A new concept <code class="sourceCode cpp">weak_output_iterator</code>, that <code class="sourceCode cpp">output_iterator</code> adds the <code class="sourceCode cpp"><span class="op">*</span>out<span class="op">++</span> <span class="op">=</span> r;</code> requirement on top of.</li>
<li>A new concept <code class="sourceCode cpp">weak_output_range</code>, which requires <code class="sourceCode cpp">weak_output_iterator</code>. <code class="sourceCode cpp">output_range</code> is re-specified to refine <code class="sourceCode cpp">weak_output_range</code>.</li>
<li>Modifying the <code class="sourceCode cpp">mergeable</code> concept to use <code class="sourceCode cpp">weak_output_iterator</code>. This does not change the requirements of this concept in any way.</li>
<li>All output algorithms now require <code class="sourceCode cpp">weak_output_iterator</code>
<ul>
<li>In most cases, that’s re-specifying <code class="sourceCode cpp">weakly_incrementable</code> and <code class="sourceCode cpp">indirectly_writable</code> (no requirements change, just better name)</li>
<li>In some cases, that’s <em>weakening</em> the requirement on those algorithms that require <code class="sourceCode cpp">output_iterator</code> (all currently valid code is still valid)</li>
</ul></li>
</ul>
<p>As a result, all the output algorithms will have the same constraints (including different overloads of the same algorithm), and all those constraints will have <code class="sourceCode cpp">output_iterator</code> in them somewhere (even if it’s <code class="sourceCode cpp">weak_output_iterator</code>).</p>
<h1 data-number="3" style="border-bottom:1px solid #cccccc" id="wording"><span class="header-section-number">3</span> Wording<a href="#wording" class="self-link"></a></h1>
<h2 data-number="3.1" id="concept-weak_output_iterator"><span class="header-section-number">3.1</span> <code class="sourceCode cpp"><span class="kw">concept</span> weak_output_iterator</code><a href="#concept-weak_output_iterator" class="self-link"></a></h2>
<p>Change <span>23.2 <a href="https://wg21.link/iterator.synopsis">[iterator.synopsis]</a></span>:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb12"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb12-1"><a href="#cb12-1"></a>namespace std {</span>
<span id="cb12-2"><a href="#cb12-2"></a>  // ...</span>
<span id="cb12-3"><a href="#cb12-3"></a></span>
<span id="cb12-4"><a href="#cb12-4"></a>  // [iterator.concept.output], concept output_iterator</span>
<span id="cb12-5"><a href="#cb12-5"></a><span class="va">+ template&lt;class I, class T&gt;</span></span>
<span id="cb12-6"><a href="#cb12-6"></a><span class="va">+   concept weak_output_iterator = <em>see below</em>;</span></span>
<span id="cb12-7"><a href="#cb12-7"></a></span>
<span id="cb12-8"><a href="#cb12-8"></a>  template&lt;class I, class T&gt;</span>
<span id="cb12-9"><a href="#cb12-9"></a>    concept output_iterator = see below;</span>
<span id="cb12-10"><a href="#cb12-10"></a></span>
<span id="cb12-11"><a href="#cb12-11"></a>  // ...</span>
<span id="cb12-12"><a href="#cb12-12"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change <span>23.3.4.10 <a href="https://wg21.link/iterator.concept.output">[iterator.concept.output]</a></span> <span class="ednote" style="color: #0000ff">[ Editor&#39;s note: The semantic effects are specific to <code class="sourceCode default">output_iterator</code>, not <code class="sourceCode default">weak_output_iterator</code> ]</span>:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_1" id="pnum_1">1</a></span> The <span class="addu"><code class="sourceCode cpp">weak_output_iterator</code> and</span> <code class="sourceCode cpp">output_iterator</code> <span class="rm" style="color: #bf0303"><del>concept defines</del></span> <span class="addu">concepts define</span> requirements for a type that can be used to write values (from the requirement for <code class="sourceCode cpp">indirectly_writable</code> ([iterator.concept.writable])) and which can be both pre- and post-incremented. [<em>Note 1</em>: Output iterators are not required to model <code class="sourceCode cpp">equality_comparable</code>. — <em>end note</em>]</p>
<div>
<div class="sourceCode" id="cb13"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb13-1"><a href="#cb13-1"></a><span class="va">+ template&lt;class I, class T&gt;</span></span>
<span id="cb13-2"><a href="#cb13-2"></a><span class="va">+   concept weak_output_iterator =</span></span>
<span id="cb13-3"><a href="#cb13-3"></a><span class="va">+     input_or_output_iterator&lt;I&gt; &amp;&amp;</span></span>
<span id="cb13-4"><a href="#cb13-4"></a><span class="va">+     indirectly_writable&lt;I, T&gt;;</span></span>
<span id="cb13-5"><a href="#cb13-5"></a></span>
<span id="cb13-6"><a href="#cb13-6"></a>  template&lt;class I, class T&gt;</span>
<span id="cb13-7"><a href="#cb13-7"></a>    concept output_iterator =</span>
<span id="cb13-8"><a href="#cb13-8"></a><span class="st">-     input_or_output_iterator&lt;I&gt; &amp;&amp;</span></span>
<span id="cb13-9"><a href="#cb13-9"></a><span class="st">-     indirectly_writable&lt;I, T&gt; &amp;&amp;</span></span>
<span id="cb13-10"><a href="#cb13-10"></a><span class="va">+     weak_output_iterator&lt;I, T&gt; &amp;&amp;</span></span>
<span id="cb13-11"><a href="#cb13-11"></a>      requires(I i, T&amp;&amp; t) {</span>
<span id="cb13-12"><a href="#cb13-12"></a>        *i++ = std::forward&lt;T&gt;(t);        // not required to be equality-preserving</span>
<span id="cb13-13"><a href="#cb13-13"></a>      };</span></code></pre></div>
</div>
<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_2" id="pnum_2">2</a></span> Let <code class="sourceCode cpp">E</code> be an expression such that <code class="sourceCode cpp"><span class="kw">decltype</span><span class="op">((</span>E<span class="op">))</span></code> is <code class="sourceCode cpp">T</code>, and let <code class="sourceCode cpp">i</code> be a dereferenceable object of type <code class="sourceCode cpp">I</code>. <code class="sourceCode cpp">I</code> and <code class="sourceCode cpp">T</code> model <code class="sourceCode cpp">output_iterator<span class="op">&lt;</span>I, T<span class="op">&gt;</span></code> only if <code class="sourceCode cpp"><span class="op">*</span>i<span class="op">++</span> <span class="op">=</span> E;</code> has effects equivalent to: <code class="sourceCode cpp"><span class="op">*</span>i <span class="op">=</span> E; <span class="op">++</span>i;</code></p>
</blockquote>
<h2 data-number="3.2" id="concept-mergeable"><span class="header-section-number">3.2</span> <code class="sourceCode cpp"><span class="kw">concept</span> mergeable</code><a href="#concept-mergeable" class="self-link"></a></h2>
<p>Change <span>23.3.7.7 <a href="https://wg21.link/alg.req.mergeable">[alg.req.mergeable]</a></span>:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_3" id="pnum_3">1</a></span> The <code class="sourceCode cpp">mergeable</code> concept specifies the requirements of algorithms that merge sorted sequences into an output sequence by copying elements.</p>
<div>
<div class="sourceCode" id="cb14"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb14-1"><a href="#cb14-1"></a>template&lt;class I1, class I2, class Out, class R = ranges::less,</span>
<span id="cb14-2"><a href="#cb14-2"></a>         class P1 = identity, class P2 = identity&gt;</span>
<span id="cb14-3"><a href="#cb14-3"></a>  concept mergeable =</span>
<span id="cb14-4"><a href="#cb14-4"></a>    input_iterator&lt;I1&gt; &amp;&amp;</span>
<span id="cb14-5"><a href="#cb14-5"></a>    input_iterator&lt;I2&gt; &amp;&amp;</span>
<span id="cb14-6"><a href="#cb14-6"></a><span class="st">-   weakly_incrementable&lt;Out&gt; &amp;&amp;</span></span>
<span id="cb14-7"><a href="#cb14-7"></a><span class="st">-   indirectly_copyable&lt;I1, Out&gt; &amp;&amp;</span></span>
<span id="cb14-8"><a href="#cb14-8"></a><span class="st">-   indirectly_copyable&lt;I2, Out&gt; &amp;&amp;</span></span>
<span id="cb14-9"><a href="#cb14-9"></a><span class="va">+   weak_output_iterator&lt;Out, iter_reference_t&lt;I1&gt;&gt; &amp;&amp;</span></span>
<span id="cb14-10"><a href="#cb14-10"></a><span class="va">+   weak_output_iterator&lt;Out, iter_reference_t&lt;I2&gt;&gt; &amp;&amp;</span></span>
<span id="cb14-11"><a href="#cb14-11"></a>    indirect_strict_weak_order&lt;R, projected&lt;I1, P1&gt;, projected&lt;I2, P2&gt;&gt;;</span></code></pre></div>
</div>
</blockquote>
<h2 data-number="3.3" id="concept-weak_output_range"><span class="header-section-number">3.3</span> <code class="sourceCode cpp"><span class="kw">concept</span> weak_output_range</code><a href="#concept-weak_output_range" class="self-link"></a></h2>
<p>Change <span>24.2 <a href="https://wg21.link/ranges.syn">[ranges.syn]</a></span>:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb15"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb15-1"><a href="#cb15-1"></a>namespace std::ranges {</span>
<span id="cb15-2"><a href="#cb15-2"></a>  // ...</span>
<span id="cb15-3"><a href="#cb15-3"></a></span>
<span id="cb15-4"><a href="#cb15-4"></a>  // [range.refinements], other range refinements</span>
<span id="cb15-5"><a href="#cb15-5"></a><span class="va">+ template&lt;class R, class T&gt;</span></span>
<span id="cb15-6"><a href="#cb15-6"></a><span class="va">+   concept weak_output_range = <em>see below</em>;</span></span>
<span id="cb15-7"><a href="#cb15-7"></a></span>
<span id="cb15-8"><a href="#cb15-8"></a>  template&lt;class R, class T&gt;</span>
<span id="cb15-9"><a href="#cb15-9"></a>    concept output_range = see below;</span>
<span id="cb15-10"><a href="#cb15-10"></a></span>
<span id="cb15-11"><a href="#cb15-11"></a>  // ...</span>
<span id="cb15-12"><a href="#cb15-12"></a>}</span></code></pre></div>
</div>
</blockquote>
<p>Change <span>24.4.5 <a href="https://wg21.link/range.refinements">[range.refinements]</a></span>:</p>
<blockquote>
<p><span class="marginalizedparent"><a class="marginalized" href="#pnum_4" id="pnum_4">1</a></span> The <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">output_range</code></span></del></span> <span class="addu"><code class="sourceCode cpp">weak_output_range</code></span> concept specifies requirements of a range type for which <code class="sourceCode cpp">ranges<span class="op">::</span>begin</code> returns a model of <span class="rm" style="color: #bf0303"><del><span><code class="sourceCode default">output_iterator</code></span></del></span> <span class="addu"><code class="sourceCode cpp">weak_output_iterator</code></span> ([iterator.concept.output]). <span class="addu"><code class="sourceCode cpp">output_range</code>,</span> <code class="sourceCode cpp">input_range</code>, <code class="sourceCode cpp">forward_range</code>, <code class="sourceCode cpp">bidirectional_range</code>, and <code class="sourceCode cpp">random_access_range</code> are defined similarly.</p>
<div>
<div class="sourceCode" id="cb16"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb16-1"><a href="#cb16-1"></a><span class="va">+ template&lt;class R, class T&gt;</span></span>
<span id="cb16-2"><a href="#cb16-2"></a><span class="va">+   concept weak_output_range =</span></span>
<span id="cb16-3"><a href="#cb16-3"></a><span class="va">+     range&lt;R&gt; &amp;&amp; weak_output_iterator&lt;iterator_t&lt;R&gt;, T&gt;;</span></span>
<span id="cb16-4"><a href="#cb16-4"></a></span>
<span id="cb16-5"><a href="#cb16-5"></a>  template&lt;class R, class T&gt;</span>
<span id="cb16-6"><a href="#cb16-6"></a>    concept output_range =</span>
<span id="cb16-7"><a href="#cb16-7"></a><span class="st">-     range&lt;R&gt; &amp;&amp; output_iterator&lt;iterator_t&lt;R&gt;, T&gt;;</span></span>
<span id="cb16-8"><a href="#cb16-8"></a><span class="va">+     weak_output_range&lt;R&gt; &amp;&amp; output_iterator&lt;iterator_t&lt;R&gt;, T&gt;;</span></span>
<span id="cb16-9"><a href="#cb16-9"></a></span>
<span id="cb16-10"><a href="#cb16-10"></a>  template&lt;class T&gt;</span>
<span id="cb16-11"><a href="#cb16-11"></a>    concept input_range =</span>
<span id="cb16-12"><a href="#cb16-12"></a>      range&lt;T&gt; &amp;&amp; input_iterator&lt;iterator_t&lt;T&gt;&gt;;</span>
<span id="cb16-13"><a href="#cb16-13"></a></span>
<span id="cb16-14"><a href="#cb16-14"></a>  template&lt;class T&gt;</span>
<span id="cb16-15"><a href="#cb16-15"></a>    concept forward_range =</span>
<span id="cb16-16"><a href="#cb16-16"></a>      input_range&lt;T&gt; &amp;&amp; forward_iterator&lt;iterator_t&lt;T&gt;&gt;;</span>
<span id="cb16-17"><a href="#cb16-17"></a></span>
<span id="cb16-18"><a href="#cb16-18"></a>  template&lt;class T&gt;</span>
<span id="cb16-19"><a href="#cb16-19"></a>    concept bidirectional_range =</span>
<span id="cb16-20"><a href="#cb16-20"></a>      forward_range&lt;T&gt; &amp;&amp; bidirectional_iterator&lt;iterator_t&lt;T&gt;&gt;;</span>
<span id="cb16-21"><a href="#cb16-21"></a></span>
<span id="cb16-22"><a href="#cb16-22"></a>  template&lt;class T&gt;</span>
<span id="cb16-23"><a href="#cb16-23"></a>    concept random_access_range =</span>
<span id="cb16-24"><a href="#cb16-24"></a>      bidirectional_range&lt;T&gt; &amp;&amp; random_access_iterator&lt;iterator_t&lt;T&gt;&gt;;</span></code></pre></div>
</div>
</blockquote>
<h2 data-number="3.4" id="algorithms"><span class="header-section-number">3.4</span> Algorithms<a href="#algorithms" class="self-link"></a></h2>
<p>Change all the constraints to use <code class="sourceCode cpp">weak_output_iterator</code> or <code class="sourceCode cpp">weak_output_range</code> in the algorithms. The wording diff here only includes the synopsis, the same changes need to be made in these algorithms’ corresponding definition too. These are all in <span>25.4 <a href="https://wg21.link/algorithm.syn">[algorithm.syn]</a></span>, broken up by algorithm for convenience:</p>
<h3 data-number="3.4.1" id="rangescopy"><span class="header-section-number">3.4.1</span> <code class="sourceCode cpp">ranges<span class="op">::</span>copy</code><a href="#rangescopy" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb17"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb17-1"><a href="#cb17-1"></a>namespace std::ranges {</span>
<span id="cb17-2"><a href="#cb17-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb17-3"><a href="#cb17-3"></a>      using copy_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb17-4"><a href="#cb17-4"></a></span>
<span id="cb17-5"><a href="#cb17-5"></a><span class="st">-   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weakly_incrementable O&gt;</span></span>
<span id="cb17-6"><a href="#cb17-6"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb17-7"><a href="#cb17-7"></a><span class="va">+   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O&gt;</span></span>
<span id="cb17-8"><a href="#cb17-8"></a>      constexpr copy_result&lt;I, O&gt;</span>
<span id="cb17-9"><a href="#cb17-9"></a>        copy(I first, S last, O result);</span>
<span id="cb17-10"><a href="#cb17-10"></a></span>
<span id="cb17-11"><a href="#cb17-11"></a><span class="st">-   template&lt;input_range R, weakly_incrementable O&gt;</span></span>
<span id="cb17-12"><a href="#cb17-12"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb17-13"><a href="#cb17-13"></a><span class="va">+   template&lt;input_range R, weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O&gt;</span></span>
<span id="cb17-14"><a href="#cb17-14"></a>      constexpr copy_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb17-15"><a href="#cb17-15"></a>        copy(R&amp;&amp; r, O result);</span>
<span id="cb17-16"><a href="#cb17-16"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.2" id="rangescopy_n"><span class="header-section-number">3.4.2</span> <code class="sourceCode cpp">ranges<span class="op">::</span>copy_n</code><a href="#rangescopy_n" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb18"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb18-1"><a href="#cb18-1"></a>namespace std::ranges {</span>
<span id="cb18-2"><a href="#cb18-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb18-3"><a href="#cb18-3"></a>      using copy_n_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb18-4"><a href="#cb18-4"></a></span>
<span id="cb18-5"><a href="#cb18-5"></a><span class="st">-   template&lt;input_iterator I, weakly_incrementable O&gt;</span></span>
<span id="cb18-6"><a href="#cb18-6"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb18-7"><a href="#cb18-7"></a><span class="va">+   template&lt;input_iterator I, weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O&gt;</span></span>
<span id="cb18-8"><a href="#cb18-8"></a>      constexpr copy_n_result&lt;I, O&gt;</span>
<span id="cb18-9"><a href="#cb18-9"></a>        copy_n(I first, iter_difference_t&lt;I&gt; n, O result);</span>
<span id="cb18-10"><a href="#cb18-10"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.3" id="rangescopy_if"><span class="header-section-number">3.4.3</span> <code class="sourceCode cpp">ranges<span class="op">::</span>copy_if</code><a href="#rangescopy_if" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb19"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb19-1"><a href="#cb19-1"></a>namespace std::ranges {</span>
<span id="cb19-2"><a href="#cb19-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb19-3"><a href="#cb19-3"></a>      using copy_if_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb19-4"><a href="#cb19-4"></a></span>
<span id="cb19-5"><a href="#cb19-5"></a><span class="st">-   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weakly_incrementable O,</span></span>
<span id="cb19-6"><a href="#cb19-6"></a><span class="va">+   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O,</span></span>
<span id="cb19-7"><a href="#cb19-7"></a>             class Proj = identity,</span>
<span id="cb19-8"><a href="#cb19-8"></a>             indirect_unary_predicate&lt;projected&lt;I, Proj&gt;&gt; Pred&gt;</span>
<span id="cb19-9"><a href="#cb19-9"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb19-10"><a href="#cb19-10"></a>      constexpr copy_if_result&lt;I, O&gt;</span>
<span id="cb19-11"><a href="#cb19-11"></a>        copy_if(I first, S last, O result, Pred pred, Proj proj = {});</span>
<span id="cb19-12"><a href="#cb19-12"></a></span>
<span id="cb19-13"><a href="#cb19-13"></a><span class="st">-   template&lt;input_range R, weakly_incrementable O,</span></span>
<span id="cb19-14"><a href="#cb19-14"></a><span class="va">+   template&lt;input_range R, weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O,</span></span>
<span id="cb19-15"><a href="#cb19-15"></a>             class Proj = identity,</span>
<span id="cb19-16"><a href="#cb19-16"></a>             indirect_unary_predicate&lt;projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt; Pred&gt;</span>
<span id="cb19-17"><a href="#cb19-17"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb19-18"><a href="#cb19-18"></a>      constexpr copy_if_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb19-19"><a href="#cb19-19"></a>        copy_if(R&amp;&amp; r, O result, Pred pred, Proj proj = {});</span>
<span id="cb19-20"><a href="#cb19-20"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.4" id="rangesmove"><span class="header-section-number">3.4.4</span> <code class="sourceCode cpp">ranges<span class="op">::</span>move</code><a href="#rangesmove" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb20"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb20-1"><a href="#cb20-1"></a>namespace std::ranges {</span>
<span id="cb20-2"><a href="#cb20-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb20-3"><a href="#cb20-3"></a>      using move_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb20-4"><a href="#cb20-4"></a></span>
<span id="cb20-5"><a href="#cb20-5"></a><span class="st">-   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weakly_incrementable O&gt;</span></span>
<span id="cb20-6"><a href="#cb20-6"></a><span class="st">-     requires indirectly_movable&lt;I, O&gt;</span></span>
<span id="cb20-7"><a href="#cb20-7"></a><span class="va">+   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weak_output_iterator&lt;iter_rvalue_reference_t&lt;I&gt;&gt; O&gt;</span></span>
<span id="cb20-8"><a href="#cb20-8"></a>      constexpr move_result&lt;I, O&gt;</span>
<span id="cb20-9"><a href="#cb20-9"></a>        move(I first, S last, O result);</span>
<span id="cb20-10"><a href="#cb20-10"></a></span>
<span id="cb20-11"><a href="#cb20-11"></a><span class="st">-   template&lt;input_range R, weakly_incrementable O&gt;</span></span>
<span id="cb20-12"><a href="#cb20-12"></a><span class="st">-     requires indirectly_movable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb20-13"><a href="#cb20-13"></a><span class="va">+   template&lt;input_range, weak_output_iterator&lt;range_rvalue_reference_t&lt;R&gt;&gt; O&gt;</span></span>
<span id="cb20-14"><a href="#cb20-14"></a>      constexpr move_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb20-15"><a href="#cb20-15"></a>        move(R&amp;&amp; r, O result);</span>
<span id="cb20-16"><a href="#cb20-16"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.5" id="rangestransform"><span class="header-section-number">3.4.5</span> <code class="sourceCode cpp">ranges<span class="op">::</span>transform</code><a href="#rangestransform" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: Here, I’m using <code class="sourceCode cpp"><span class="kw">class</span> O</code> and having a trailing <code class="sourceCode cpp"><span class="kw">requires</span> weak_output_iterator<span class="op">&lt;</span>O, T<span class="op">&gt;</span></code> because the relevant type <code class="sourceCode cpp">T</code> here is based on <code class="sourceCode cpp">Proj</code>, which is declared after <code class="sourceCode cpp">O</code>. ]</span></p>
<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::ranges {</span>
<span id="cb21-2"><a href="#cb21-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb21-3"><a href="#cb21-3"></a>      using unary_transform_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb21-4"><a href="#cb21-4"></a></span>
<span id="cb21-5"><a href="#cb21-5"></a><span class="st">-   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, weakly_incrementable O,</span></span>
<span id="cb21-6"><a href="#cb21-6"></a><span class="va">+   template&lt;input_iterator I, sentinel_for&lt;I&gt; S, class O,</span></span>
<span id="cb21-7"><a href="#cb21-7"></a>             copy_constructible F, class Proj = identity&gt;</span>
<span id="cb21-8"><a href="#cb21-8"></a><span class="st">-     requires indirectly_writable&lt;O, indirect_result_t&lt;F&amp;, projected&lt;I, Proj&gt;&gt;&gt;</span></span>
<span id="cb21-9"><a href="#cb21-9"></a><span class="va">+     requires weak_output_iterator&lt;O, indirect_result_t&lt;F&amp;, projected&lt;I, Proj&gt;&gt;&gt;</span></span>
<span id="cb21-10"><a href="#cb21-10"></a>      constexpr unary_transform_result&lt;I, O&gt;</span>
<span id="cb21-11"><a href="#cb21-11"></a>        transform(I first1, S last1, O result, F op, Proj proj = {});</span>
<span id="cb21-12"><a href="#cb21-12"></a></span>
<span id="cb21-13"><a href="#cb21-13"></a><span class="st">-   template&lt;input_range R, weakly_incrementable O, copy_constructible F,</span></span>
<span id="cb21-14"><a href="#cb21-14"></a><span class="va">+   template&lt;input_range R, class O, copy_constructible F,</span></span>
<span id="cb21-15"><a href="#cb21-15"></a>             class Proj = identity&gt;</span>
<span id="cb21-16"><a href="#cb21-16"></a><span class="st">-     requires indirectly_writable&lt;O, indirect_result_t&lt;F&amp;, projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt;&gt;</span></span>
<span id="cb21-17"><a href="#cb21-17"></a><span class="va">+     requires weak_output_iterator&lt;O, indirect_result_t&lt;F&amp;, projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt;&gt;</span></span>
<span id="cb21-18"><a href="#cb21-18"></a>      constexpr unary_transform_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb21-19"><a href="#cb21-19"></a>        transform(R&amp;&amp; r, O result, F op, Proj proj = {});</span>
<span id="cb21-20"><a href="#cb21-20"></a></span>
<span id="cb21-21"><a href="#cb21-21"></a>    template&lt;class I1, class I2, class O&gt;</span>
<span id="cb21-22"><a href="#cb21-22"></a>      using binary_transform_result = in_in_out_result&lt;I1, I2, O&gt;;</span>
<span id="cb21-23"><a href="#cb21-23"></a></span>
<span id="cb21-24"><a href="#cb21-24"></a>    template&lt;input_iterator I1, sentinel_for&lt;I1&gt; S1, input_iterator I2, sentinel_for&lt;I2&gt; S2,</span>
<span id="cb21-25"><a href="#cb21-25"></a><span class="st">-            weakly_incrementable O, copy_constructible F, class Proj1 = identity,</span></span>
<span id="cb21-26"><a href="#cb21-26"></a><span class="va">+            class O, copy_constructible F, class Proj1 = identity,</span></span>
<span id="cb21-27"><a href="#cb21-27"></a>             class Proj2 = identity&gt;</span>
<span id="cb21-28"><a href="#cb21-28"></a><span class="st">-     requires indirectly_writable&lt;O, indirect_result_t&lt;F&amp;, projected&lt;I1, Proj1&gt;,</span></span>
<span id="cb21-29"><a href="#cb21-29"></a><span class="va">+     requires weak_output_iterator&lt;O, indirect_result_t&lt;F&amp;, projected&lt;I1, Proj1&gt;,</span></span>
<span id="cb21-30"><a href="#cb21-30"></a>                                             projected&lt;I2, Proj2&gt;&gt;&gt;</span>
<span id="cb21-31"><a href="#cb21-31"></a>      constexpr binary_transform_result&lt;I1, I2, O&gt;</span>
<span id="cb21-32"><a href="#cb21-32"></a>        transform(I1 first1, S1 last1, I2 first2, S2 last2, O result,</span>
<span id="cb21-33"><a href="#cb21-33"></a>                  F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb21-34"><a href="#cb21-34"></a></span>
<span id="cb21-35"><a href="#cb21-35"></a><span class="st">-   template&lt;input_range R1, input_range R2, weakly_incrementable O,</span></span>
<span id="cb21-36"><a href="#cb21-36"></a><span class="va">+   template&lt;input_range R1, input_range R2, class O,</span></span>
<span id="cb21-37"><a href="#cb21-37"></a>             copy_constructible F, class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb21-38"><a href="#cb21-38"></a><span class="st">-     requires indirectly_writable&lt;O, indirect_result_t&lt;F&amp;, projected&lt;iterator_t&lt;R1&gt;, Proj1&gt;,</span></span>
<span id="cb21-39"><a href="#cb21-39"></a><span class="va">+     requires weak_output_iterator&lt;O, indirect_result_t&lt;F&amp;, projected&lt;iterator_t&lt;R1&gt;, Proj1&gt;,</span></span>
<span id="cb21-40"><a href="#cb21-40"></a>                                             projected&lt;iterator_t&lt;R2&gt;, Proj2&gt;&gt;&gt;</span>
<span id="cb21-41"><a href="#cb21-41"></a>      constexpr binary_transform_result&lt;borrowed_iterator_t&lt;R1&gt;, borrowed_iterator_t&lt;R2&gt;, O&gt;</span>
<span id="cb21-42"><a href="#cb21-42"></a>        transform(R1&amp;&amp; r1, R2&amp;&amp; r2, O result,</span>
<span id="cb21-43"><a href="#cb21-43"></a>                  F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb21-44"><a href="#cb21-44"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.6" id="rangesreplace_copy"><span class="header-section-number">3.4.6</span> <code class="sourceCode cpp">ranges<span class="op">::</span>replace_copy</code><a href="#rangesreplace_copy" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: This is one of the algorithms that had already required <code class="sourceCode cpp">output_iterator</code>, its requirements are being weakened. ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb22"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb22-1"><a href="#cb22-1"></a>namespace std::ranges {</span>
<span id="cb22-2"><a href="#cb22-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb22-3"><a href="#cb22-3"></a>      using replace_copy_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb22-4"><a href="#cb22-4"></a></span>
<span id="cb22-5"><a href="#cb22-5"></a>    template&lt;input_iterator I, sentinel_for&lt;I&gt; S, class T1, class T2,</span>
<span id="cb22-6"><a href="#cb22-6"></a><span class="st">-            output_iterator&lt;const T2&amp;&gt; O,</span></span>
<span id="cb22-7"><a href="#cb22-7"></a><span class="va">+            weak_output_iterator&lt;const T2&amp;&gt; O,</span></span>
<span id="cb22-8"><a href="#cb22-8"></a>             class Proj = identity&gt;</span>
<span id="cb22-9"><a href="#cb22-9"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt; &amp;&amp;</span></span>
<span id="cb22-10"><a href="#cb22-10"></a><span class="va">+     requires weak_output_iterator&lt;O, iter_reference_t&lt;I&gt;&gt;</span></span>
<span id="cb22-11"><a href="#cb22-11"></a>               indirect_binary_predicate&lt;ranges::equal_to, projected&lt;I, Proj&gt;, const T1*&gt;</span>
<span id="cb22-12"><a href="#cb22-12"></a>      constexpr replace_copy_result&lt;I, O&gt;</span>
<span id="cb22-13"><a href="#cb22-13"></a>        replace_copy(I first, S last, O result, const T1&amp; old_value, const T2&amp; new_value,</span>
<span id="cb22-14"><a href="#cb22-14"></a>                     Proj proj = {});</span>
<span id="cb22-15"><a href="#cb22-15"></a>    template&lt;input_range R, class T1, class T2,</span>
<span id="cb22-16"><a href="#cb22-16"></a><span class="st">-            output_iterator&lt;const T2&amp;&gt; O,</span></span>
<span id="cb22-17"><a href="#cb22-17"></a><span class="va">+            weak_output_iterator&lt;const T2&amp;&gt; O,</span></span>
<span id="cb22-18"><a href="#cb22-18"></a>             class Proj = identity&gt;</span>
<span id="cb22-19"><a href="#cb22-19"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt; &amp;&amp;</span></span>
<span id="cb22-20"><a href="#cb22-20"></a><span class="va">+     requires weak_output_iterator&lt;O, range_reference_t&lt;R&gt;&gt; &amp;&amp;</span></span>
<span id="cb22-21"><a href="#cb22-21"></a>               indirect_binary_predicate&lt;ranges::equal_to,</span>
<span id="cb22-22"><a href="#cb22-22"></a>                                         projected&lt;iterator_t&lt;R&gt;, Proj&gt;, const T1*&gt;</span>
<span id="cb22-23"><a href="#cb22-23"></a>      constexpr replace_copy_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb22-24"><a href="#cb22-24"></a>        replace_copy(R&amp;&amp; r, O result, const T1&amp; old_value, const T2&amp; new_value,</span>
<span id="cb22-25"><a href="#cb22-25"></a>                     Proj proj = {});</span>
<span id="cb22-26"><a href="#cb22-26"></a></span>
<span id="cb22-27"><a href="#cb22-27"></a>    template&lt;class I, class O&gt;</span>
<span id="cb22-28"><a href="#cb22-28"></a>      using replace_copy_if_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb22-29"><a href="#cb22-29"></a></span>
<span id="cb22-30"><a href="#cb22-30"></a>    template&lt;input_iterator I, sentinel_for&lt;I&gt; S, class T,</span>
<span id="cb22-31"><a href="#cb22-31"></a><span class="st">-            output_iterator&lt;const T&amp;&gt; O,</span></span>
<span id="cb22-32"><a href="#cb22-32"></a><span class="va">+            weak_output_iterator&lt;const T&amp;&gt; O,</span></span>
<span id="cb22-33"><a href="#cb22-33"></a>             class Proj = identity, indirect_unary_predicate&lt;projected&lt;I, Proj&gt;&gt; Pred&gt;</span>
<span id="cb22-34"><a href="#cb22-34"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb22-35"><a href="#cb22-35"></a><span class="va">+     requires weak_output_iterator&lt;O, iter_reference_t&lt;I&gt;&gt;</span></span>
<span id="cb22-36"><a href="#cb22-36"></a>      constexpr replace_copy_if_result&lt;I, O&gt;</span>
<span id="cb22-37"><a href="#cb22-37"></a>        replace_copy_if(I first, S last, O result, Pred pred, const T&amp; new_value,</span>
<span id="cb22-38"><a href="#cb22-38"></a>                        Proj proj = {});</span>
<span id="cb22-39"><a href="#cb22-39"></a>    template&lt;input_range R, class T,</span>
<span id="cb22-40"><a href="#cb22-40"></a><span class="st">-            output_iterator&lt;const T&amp;&gt; O,</span></span>
<span id="cb22-41"><a href="#cb22-41"></a><span class="va">+            weak_output_iterator&lt;const T&amp;&gt; O,</span></span>
<span id="cb22-42"><a href="#cb22-42"></a>             class Proj = identity,</span>
<span id="cb22-43"><a href="#cb22-43"></a>             indirect_unary_predicate&lt;projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt; Pred&gt;</span>
<span id="cb22-44"><a href="#cb22-44"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb22-45"><a href="#cb22-45"></a><span class="va">+     requires weak_output_iterator&lt;O, range_reference_t&lt;R&gt;&gt;</span></span>
<span id="cb22-46"><a href="#cb22-46"></a>      constexpr replace_copy_if_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb22-47"><a href="#cb22-47"></a>        replace_copy_if(R&amp;&amp; r, O result, Pred pred, const T&amp; new_value,</span>
<span id="cb22-48"><a href="#cb22-48"></a>                        Proj proj = {});</span>
<span id="cb22-49"><a href="#cb22-49"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.7" id="rangesfill"><span class="header-section-number">3.4.7</span> <code class="sourceCode cpp">ranges<span class="op">::</span>fill</code><a href="#rangesfill" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: This was the one, consistent algorithm that required both <code class="sourceCode cpp">output_iterator</code> and <code class="sourceCode cpp">output_range</code>. Now it (still consistently) requires <code class="sourceCode cpp">weak_output_iterator</code> and <code class="sourceCode cpp">weak_output_range</code>. ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb23"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb23-1"><a href="#cb23-1"></a>namespace std::ranges {</span>
<span id="cb23-2"><a href="#cb23-2"></a>    template&lt;class T,</span>
<span id="cb23-3"><a href="#cb23-3"></a><span class="st">-            output_iterator&lt;const T&amp;&gt; O,</span></span>
<span id="cb23-4"><a href="#cb23-4"></a><span class="va">+            weak_output_iterator&lt;const T&amp;&gt; O,</span></span>
<span id="cb23-5"><a href="#cb23-5"></a>             sentinel_for&lt;O&gt; S&gt;</span>
<span id="cb23-6"><a href="#cb23-6"></a>      constexpr O fill(O first, S last, const T&amp; value);</span>
<span id="cb23-7"><a href="#cb23-7"></a>    template&lt;class T,</span>
<span id="cb23-8"><a href="#cb23-8"></a><span class="st">-            output_range&lt;const T&amp;&gt; R&gt;</span></span>
<span id="cb23-9"><a href="#cb23-9"></a><span class="va">+            weak_output_range&lt;const T&amp;&gt; R&gt;</span></span>
<span id="cb23-10"><a href="#cb23-10"></a>      constexpr borrowed_iterator_t&lt;R&gt; fill(R&amp;&amp; r, const T&amp; value);</span>
<span id="cb23-11"><a href="#cb23-11"></a>    template&lt;class T,</span>
<span id="cb23-12"><a href="#cb23-12"></a><span class="st">-            output_iterator&lt;const T&amp;&gt; O&gt;</span></span>
<span id="cb23-13"><a href="#cb23-13"></a><span class="va">+            weak_output_iterator&lt;const T&amp;&gt; O&gt;</span></span>
<span id="cb23-14"><a href="#cb23-14"></a>      constexpr O fill_n(O first, iter_difference_t&lt;O&gt; n, const T&amp; value);</span>
<span id="cb23-15"><a href="#cb23-15"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.8" id="rangesgenerate"><span class="header-section-number">3.4.8</span> <code class="sourceCode cpp">ranges<span class="op">::</span>generate</code><a href="#rangesgenerate" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: This was the inconsistent algorithm, which now becomes consistent ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb24"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb24-1"><a href="#cb24-1"></a>namespace std::ranges {</span>
<span id="cb24-2"><a href="#cb24-2"></a><span class="st">-   template&lt;input_or_output_iterator O,</span></span>
<span id="cb24-3"><a href="#cb24-3"></a><span class="va">+   template&lt;class O,</span></span>
<span id="cb24-4"><a href="#cb24-4"></a>             sentinel_for&lt;O&gt; S, copy_constructible F&gt;</span>
<span id="cb24-5"><a href="#cb24-5"></a>      requires invocable&lt;F&amp;&gt; &amp;&amp;</span>
<span id="cb24-6"><a href="#cb24-6"></a><span class="st">-              indirectly_writable&lt;O, invoke_result_t&lt;F&amp;&gt;&gt;</span></span>
<span id="cb24-7"><a href="#cb24-7"></a><span class="va">+              weak_output_iterator&lt;O, invoke_result_t&lt;F&amp;&gt;&gt;</span></span>
<span id="cb24-8"><a href="#cb24-8"></a>      constexpr O generate(O first, S last, F gen);</span>
<span id="cb24-9"><a href="#cb24-9"></a></span>
<span id="cb24-10"><a href="#cb24-10"></a>   template&lt;class R, copy_constructible F&gt;</span>
<span id="cb24-11"><a href="#cb24-11"></a>      requires invocable&lt;F&amp;&gt; &amp;&amp;</span>
<span id="cb24-12"><a href="#cb24-12"></a><span class="st">-              output_range&lt;R, invoke_result_t&lt;F&amp;&gt;&gt;</span></span>
<span id="cb24-13"><a href="#cb24-13"></a><span class="va">+              weak_output_range&lt;R, invoke_result_t&lt;F&amp;&gt;&gt;</span></span>
<span id="cb24-14"><a href="#cb24-14"></a>      constexpr borrowed_iterator_t&lt;R&gt; generate(R&amp;&amp; r, F gen);</span>
<span id="cb24-15"><a href="#cb24-15"></a></span>
<span id="cb24-16"><a href="#cb24-16"></a><span class="st">-   template&lt;input_or_output_iterator O,</span></span>
<span id="cb24-17"><a href="#cb24-17"></a><span class="va">+   template&lt;class O,</span></span>
<span id="cb24-18"><a href="#cb24-18"></a>             copy_constructible F&gt;</span>
<span id="cb24-19"><a href="#cb24-19"></a>      requires invocable&lt;F&amp;&gt; &amp;&amp;</span>
<span id="cb24-20"><a href="#cb24-20"></a><span class="st">-              indirectly_writable&lt;O, invoke_result_t&lt;F&amp;&gt;&gt;</span></span>
<span id="cb24-21"><a href="#cb24-21"></a><span class="va">+              weak_output_iterator&lt;O, invoke_result_t&lt;F&amp;&gt;&gt;</span></span>
<span id="cb24-22"><a href="#cb24-22"></a>      constexpr O generate_n(O first, iter_difference_t&lt;O&gt; n, F gen);</span>
<span id="cb24-23"><a href="#cb24-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.9" id="rangesremove_copy"><span class="header-section-number">3.4.9</span> <code class="sourceCode cpp">ranges<span class="op">::</span>remove_copy</code><a href="#rangesremove_copy" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb25"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb25-1"><a href="#cb25-1"></a>namespace std::ranges {</span>
<span id="cb25-2"><a href="#cb25-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb25-3"><a href="#cb25-3"></a>      using remove_copy_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb25-4"><a href="#cb25-4"></a></span>
<span id="cb25-5"><a href="#cb25-5"></a>    template&lt;input_iterator I, sentinel_for&lt;I&gt; S,</span>
<span id="cb25-6"><a href="#cb25-6"></a><span class="st">-            weakly_incrementable O,</span></span>
<span id="cb25-7"><a href="#cb25-7"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O,</span></span>
<span id="cb25-8"><a href="#cb25-8"></a>             class T,</span>
<span id="cb25-9"><a href="#cb25-9"></a>             class Proj = identity&gt;</span>
<span id="cb25-10"><a href="#cb25-10"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt; &amp;&amp;</span></span>
<span id="cb25-11"><a href="#cb25-11"></a><span class="va">+     requires</span></span>
<span id="cb25-12"><a href="#cb25-12"></a>               indirect_binary_predicate&lt;ranges::equal_to, projected&lt;I, Proj&gt;, const T*&gt;</span>
<span id="cb25-13"><a href="#cb25-13"></a>      constexpr remove_copy_result&lt;I, O&gt;</span>
<span id="cb25-14"><a href="#cb25-14"></a>        remove_copy(I first, S last, O result, const T&amp; value, Proj proj = {});</span>
<span id="cb25-15"><a href="#cb25-15"></a></span>
<span id="cb25-16"><a href="#cb25-16"></a>    template&lt;input_range R,</span>
<span id="cb25-17"><a href="#cb25-17"></a><span class="st">-            weakly_incrementable O,</span></span>
<span id="cb25-18"><a href="#cb25-18"></a><span class="va">+            weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O,</span></span>
<span id="cb25-19"><a href="#cb25-19"></a>             class T, class Proj = identity&gt;</span>
<span id="cb25-20"><a href="#cb25-20"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt; &amp;&amp;</span></span>
<span id="cb25-21"><a href="#cb25-21"></a><span class="va">+     requires</span></span>
<span id="cb25-22"><a href="#cb25-22"></a>               indirect_binary_predicate&lt;ranges::equal_to,</span>
<span id="cb25-23"><a href="#cb25-23"></a>                                         projected&lt;iterator_t&lt;R&gt;, Proj&gt;, const T*&gt;</span>
<span id="cb25-24"><a href="#cb25-24"></a>      constexpr remove_copy_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb25-25"><a href="#cb25-25"></a>        remove_copy(R&amp;&amp; r, O result, const T&amp; value, Proj proj = {});</span>
<span id="cb25-26"><a href="#cb25-26"></a></span>
<span id="cb25-27"><a href="#cb25-27"></a>    template&lt;class I, class O&gt;</span>
<span id="cb25-28"><a href="#cb25-28"></a>      using remove_copy_if_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb25-29"><a href="#cb25-29"></a></span>
<span id="cb25-30"><a href="#cb25-30"></a>    template&lt;input_iterator I, sentinel_for&lt;I&gt; S,</span>
<span id="cb25-31"><a href="#cb25-31"></a><span class="st">-            weakly_incrementable O,</span></span>
<span id="cb25-32"><a href="#cb25-32"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O,</span></span>
<span id="cb25-33"><a href="#cb25-33"></a>             class Proj = identity, indirect_unary_predicate&lt;projected&lt;I, Proj&gt;&gt; Pred&gt;</span>
<span id="cb25-34"><a href="#cb25-34"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb25-35"><a href="#cb25-35"></a>      constexpr remove_copy_if_result&lt;I, O&gt;</span>
<span id="cb25-36"><a href="#cb25-36"></a>        remove_copy_if(I first, S last, O result, Pred pred, Proj proj = {});</span>
<span id="cb25-37"><a href="#cb25-37"></a></span>
<span id="cb25-38"><a href="#cb25-38"></a>    template&lt;input_range R,</span>
<span id="cb25-39"><a href="#cb25-39"></a><span class="st">-            weakly_incrementable O,</span></span>
<span id="cb25-40"><a href="#cb25-40"></a><span class="va">+            weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O,</span></span>
<span id="cb25-41"><a href="#cb25-41"></a>             class Proj = identity,</span>
<span id="cb25-42"><a href="#cb25-42"></a>             indirect_unary_predicate&lt;projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt; Pred&gt;</span>
<span id="cb25-43"><a href="#cb25-43"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb25-44"><a href="#cb25-44"></a>      constexpr remove_copy_if_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb25-45"><a href="#cb25-45"></a>        remove_copy_if(R&amp;&amp; r, O result, Pred pred, Proj proj = {});</span>
<span id="cb25-46"><a href="#cb25-46"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.10" id="rangesunique_copy"><span class="header-section-number">3.4.10</span> <code class="sourceCode cpp">ranges<span class="op">::</span>unique_copy</code><a href="#rangesunique_copy" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: The constraints here have a disjunction, but <code class="sourceCode cpp">indirectly_copyable<span class="op">&lt;</span>I, O<span class="op">&gt;</span></code> is always required, which is the <code class="sourceCode cpp">weak_output_iterator</code> constraint. ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb26"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb26-1"><a href="#cb26-1"></a>namespace std::ranges {</span>
<span id="cb26-2"><a href="#cb26-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb26-3"><a href="#cb26-3"></a>      using unique_copy_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb26-4"><a href="#cb26-4"></a></span>
<span id="cb26-5"><a href="#cb26-5"></a>    template&lt;input_iterator I, sentinel_for&lt;I&gt; S,</span>
<span id="cb26-6"><a href="#cb26-6"></a><span class="st">-            weakly_incrementable O,</span></span>
<span id="cb26-7"><a href="#cb26-7"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O,</span></span>
<span id="cb26-8"><a href="#cb26-8"></a>             class Proj = identity,</span>
<span id="cb26-9"><a href="#cb26-9"></a>             indirect_equivalence_relation&lt;projected&lt;I, Proj&gt;&gt; C = ranges::equal_to&gt;</span>
<span id="cb26-10"><a href="#cb26-10"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt; &amp;&amp;</span></span>
<span id="cb26-11"><a href="#cb26-11"></a><span class="va">+     requires</span></span>
<span id="cb26-12"><a href="#cb26-12"></a>               (forward_iterator&lt;I&gt; ||</span>
<span id="cb26-13"><a href="#cb26-13"></a>                (input_iterator&lt;O&gt; &amp;&amp; same_as&lt;iter_value_t&lt;I&gt;, iter_value_t&lt;O&gt;&gt;) ||</span>
<span id="cb26-14"><a href="#cb26-14"></a>                indirectly_copyable_storable&lt;I, O&gt;)</span>
<span id="cb26-15"><a href="#cb26-15"></a>      constexpr unique_copy_result&lt;I, O&gt;</span>
<span id="cb26-16"><a href="#cb26-16"></a>        unique_copy(I first, S last, O result, C comp = {}, Proj proj = {});</span>
<span id="cb26-17"><a href="#cb26-17"></a></span>
<span id="cb26-18"><a href="#cb26-18"></a>    template&lt;input_range R,</span>
<span id="cb26-19"><a href="#cb26-19"></a><span class="st">-            weakly_incrementable O,</span></span>
<span id="cb26-20"><a href="#cb26-20"></a><span class="va">+            weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O,</span></span>
<span id="cb26-21"><a href="#cb26-21"></a>             class Proj = identity,</span>
<span id="cb26-22"><a href="#cb26-22"></a>             indirect_equivalence_relation&lt;projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt; C = ranges::equal_to&gt;</span>
<span id="cb26-23"><a href="#cb26-23"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt; &amp;&amp;</span></span>
<span id="cb26-24"><a href="#cb26-24"></a><span class="va">+     requires</span></span>
<span id="cb26-25"><a href="#cb26-25"></a>               (forward_iterator&lt;iterator_t&lt;R&gt;&gt; ||</span>
<span id="cb26-26"><a href="#cb26-26"></a>                (input_iterator&lt;O&gt; &amp;&amp; same_as&lt;range_value_t&lt;R&gt;, iter_value_t&lt;O&gt;&gt;) ||</span>
<span id="cb26-27"><a href="#cb26-27"></a>                indirectly_copyable_storable&lt;iterator_t&lt;R&gt;, O&gt;)</span>
<span id="cb26-28"><a href="#cb26-28"></a>      constexpr unique_copy_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb26-29"><a href="#cb26-29"></a>        unique_copy(R&amp;&amp; r, O result, C comp = {}, Proj proj = {});</span>
<span id="cb26-30"><a href="#cb26-30"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.11" id="rangesreverse_copy"><span class="header-section-number">3.4.11</span> <code class="sourceCode cpp">ranges<span class="op">::</span>reverse_copy</code><a href="#rangesreverse_copy" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb27"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb27-1"><a href="#cb27-1"></a>namespace std::ranges {</span>
<span id="cb27-2"><a href="#cb27-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb27-3"><a href="#cb27-3"></a>      using reverse_copy_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb27-4"><a href="#cb27-4"></a></span>
<span id="cb27-5"><a href="#cb27-5"></a>    template&lt;bidirectional_iterator I, sentinel_for&lt;I&gt; S,</span>
<span id="cb27-6"><a href="#cb27-6"></a><span class="st">-            weakly_incrementable O&gt;</span></span>
<span id="cb27-7"><a href="#cb27-7"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O&gt;</span></span>
<span id="cb27-8"><a href="#cb27-8"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb27-9"><a href="#cb27-9"></a>      constexpr reverse_copy_result&lt;I, O&gt;</span>
<span id="cb27-10"><a href="#cb27-10"></a>        reverse_copy(I first, S last, O result);</span>
<span id="cb27-11"><a href="#cb27-11"></a></span>
<span id="cb27-12"><a href="#cb27-12"></a>    template&lt;bidirectional_range R,</span>
<span id="cb27-13"><a href="#cb27-13"></a><span class="st">-            weakly_incrementable O&gt;</span></span>
<span id="cb27-14"><a href="#cb27-14"></a><span class="va">+            weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O&gt;</span></span>
<span id="cb27-15"><a href="#cb27-15"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb27-16"><a href="#cb27-16"></a>      constexpr reverse_copy_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb27-17"><a href="#cb27-17"></a>        reverse_copy(R&amp;&amp; r, O result);</span>
<span id="cb27-18"><a href="#cb27-18"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.12" id="rangesrotate_copy"><span class="header-section-number">3.4.12</span> <code class="sourceCode cpp">ranges<span class="op">::</span>rotate_copy</code><a href="#rangesrotate_copy" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb28"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb28-1"><a href="#cb28-1"></a>namespace std::ranges {</span>
<span id="cb28-2"><a href="#cb28-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb28-3"><a href="#cb28-3"></a>      using rotate_copy_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb28-4"><a href="#cb28-4"></a></span>
<span id="cb28-5"><a href="#cb28-5"></a>    template&lt;forward_iterator I, sentinel_for&lt;I&gt; S,</span>
<span id="cb28-6"><a href="#cb28-6"></a><span class="st">-            weakly_incrementable O&gt;</span></span>
<span id="cb28-7"><a href="#cb28-7"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O&gt;</span></span>
<span id="cb28-8"><a href="#cb28-8"></a><span class="st">-     requires indirectly_copyable&lt;I, O&gt;</span></span>
<span id="cb28-9"><a href="#cb28-9"></a>      constexpr rotate_copy_result&lt;I, O&gt;</span>
<span id="cb28-10"><a href="#cb28-10"></a>        rotate_copy(I first, I middle, S last, O result);</span>
<span id="cb28-11"><a href="#cb28-11"></a></span>
<span id="cb28-12"><a href="#cb28-12"></a><span class="st">-   template&lt;forward_range R, weakly_incrementable O&gt;</span></span>
<span id="cb28-13"><a href="#cb28-13"></a><span class="va">+   template&lt;forward_range R, weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O&gt;</span></span>
<span id="cb28-14"><a href="#cb28-14"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O&gt;</span></span>
<span id="cb28-15"><a href="#cb28-15"></a>      constexpr rotate_copy_result&lt;borrowed_iterator_t&lt;R&gt;, O&gt;</span>
<span id="cb28-16"><a href="#cb28-16"></a>        rotate_copy(R&amp;&amp; r, iterator_t&lt;R&gt; middle, O result);</span>
<span id="cb28-17"><a href="#cb28-17"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.13" id="rangespartition_copy"><span class="header-section-number">3.4.13</span> <code class="sourceCode cpp">ranges<span class="op">::</span>partition_copy</code><a href="#rangespartition_copy" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb29"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb29-1"><a href="#cb29-1"></a>namespace std::ranges {</span>
<span id="cb29-2"><a href="#cb29-2"></a>    template&lt;class I, class O1, class O2&gt;</span>
<span id="cb29-3"><a href="#cb29-3"></a>      using partition_copy_result = in_out_out_result&lt;I, O1, O2&gt;;</span>
<span id="cb29-4"><a href="#cb29-4"></a></span>
<span id="cb29-5"><a href="#cb29-5"></a>    template&lt;input_iterator I, sentinel_for&lt;I&gt; S,</span>
<span id="cb29-6"><a href="#cb29-6"></a><span class="st">-            weakly_incrementable O1, weakly_incrementable O2,</span></span>
<span id="cb29-7"><a href="#cb29-7"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O1,</span></span>
<span id="cb29-8"><a href="#cb29-8"></a><span class="va">+            weak_output_iterator&lt;iter_reference_t&lt;I&gt;&gt; O2,</span></span>
<span id="cb29-9"><a href="#cb29-9"></a>             class Proj = identity, indirect_unary_predicate&lt;projected&lt;I, Proj&gt;&gt; Pred&gt;</span>
<span id="cb29-10"><a href="#cb29-10"></a><span class="st">-     requires indirectly_copyable&lt;I, O1&gt; &amp;&amp; indirectly_copyable&lt;I, O2&gt;</span></span>
<span id="cb29-11"><a href="#cb29-11"></a>      constexpr partition_copy_result&lt;I, O1, O2&gt;</span>
<span id="cb29-12"><a href="#cb29-12"></a>        partition_copy(I first, S last, O1 out_true, O2 out_false, Pred pred,</span>
<span id="cb29-13"><a href="#cb29-13"></a>                       Proj proj = {});</span>
<span id="cb29-14"><a href="#cb29-14"></a></span>
<span id="cb29-15"><a href="#cb29-15"></a>    template&lt;input_range R,</span>
<span id="cb29-16"><a href="#cb29-16"></a><span class="st">-            weakly_incrementable O1, weakly_incrementable O2,</span></span>
<span id="cb29-17"><a href="#cb29-17"></a><span class="va">+            weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O1,</span></span>
<span id="cb29-18"><a href="#cb29-18"></a><span class="va">+            weak_output_iterator&lt;range_reference_t&lt;R&gt;&gt; O2,</span></span>
<span id="cb29-19"><a href="#cb29-19"></a>             class Proj = identity,</span>
<span id="cb29-20"><a href="#cb29-20"></a>             indirect_unary_predicate&lt;projected&lt;iterator_t&lt;R&gt;, Proj&gt;&gt; Pred&gt;</span>
<span id="cb29-21"><a href="#cb29-21"></a><span class="st">-     requires indirectly_copyable&lt;iterator_t&lt;R&gt;, O1&gt; &amp;&amp;</span></span>
<span id="cb29-22"><a href="#cb29-22"></a><span class="st">-              indirectly_copyable&lt;iterator_t&lt;R&gt;, O2&gt;</span></span>
<span id="cb29-23"><a href="#cb29-23"></a>      constexpr partition_copy_result&lt;borrowed_iterator_t&lt;R&gt;, O1, O2&gt;</span>
<span id="cb29-24"><a href="#cb29-24"></a>        partition_copy(R&amp;&amp; r, O1 out_true, O2 out_false, Pred pred, Proj proj = {});</span>
<span id="cb29-25"><a href="#cb29-25"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.14" id="rangesmerge"><span class="header-section-number">3.4.14</span> <code class="sourceCode cpp">ranges<span class="op">::</span>merge</code><a href="#rangesmerge" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: <code class="sourceCode cpp">mergeable</code> now requires <code class="sourceCode cpp">weak_output_iterator<span class="op">&lt;</span>O, iter_reference_t<span class="op">&lt;</span>I1<span class="op">&gt;&gt;</span></code> and <code class="sourceCode cpp">weak_output_iterator<span class="op">&lt;</span>O, iter_reference_t<span class="op">&lt;</span>I2<span class="op">&gt;&gt;</span></code> (for the two input iterators, <code class="sourceCode cpp">I1</code>, and <code class="sourceCode cpp">I2</code>). The extra <code class="sourceCode cpp">weakly_incrementable<span class="op">&lt;</span>O<span class="op">&gt;</span></code> here doesn’t really add anything, but keeping it around would make the merging algorithms the only ones that require <code class="sourceCode cpp">weakly_incrementable</code>, which is differently consistent. So I’m suggesting we change to <code class="sourceCode cpp"><span class="kw">class</span></code>. ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb30"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb30-1"><a href="#cb30-1"></a>namespace std::ranges {</span>
<span id="cb30-2"><a href="#cb30-2"></a>    template&lt;class I1, class I2, class O&gt;</span>
<span id="cb30-3"><a href="#cb30-3"></a>      using merge_result = in_in_out_result&lt;I1, I2, O&gt;;</span>
<span id="cb30-4"><a href="#cb30-4"></a></span>
<span id="cb30-5"><a href="#cb30-5"></a>    template&lt;input_iterator I1, sentinel_for&lt;I1&gt; S1, input_iterator I2, sentinel_for&lt;I2&gt; S2,</span>
<span id="cb30-6"><a href="#cb30-6"></a><span class="st">-            weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,</span></span>
<span id="cb30-7"><a href="#cb30-7"></a><span class="va">+            class O, class Comp = ranges::less, class Proj1 = identity,</span></span>
<span id="cb30-8"><a href="#cb30-8"></a>             class Proj2 = identity&gt;</span>
<span id="cb30-9"><a href="#cb30-9"></a>      requires mergeable&lt;I1, I2, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb30-10"><a href="#cb30-10"></a>      constexpr merge_result&lt;I1, I2, O&gt;</span>
<span id="cb30-11"><a href="#cb30-11"></a>        merge(I1 first1, S1 last1, I2 first2, S2 last2, O result,</span>
<span id="cb30-12"><a href="#cb30-12"></a>              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb30-13"><a href="#cb30-13"></a></span>
<span id="cb30-14"><a href="#cb30-14"></a><span class="st">-   template&lt;input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,</span></span>
<span id="cb30-15"><a href="#cb30-15"></a><span class="va">+   template&lt;input_range R1, input_range R2, class O, class Comp = ranges::less,</span></span>
<span id="cb30-16"><a href="#cb30-16"></a>             class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb30-17"><a href="#cb30-17"></a>      requires mergeable&lt;iterator_t&lt;R1&gt;, iterator_t&lt;R2&gt;, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb30-18"><a href="#cb30-18"></a>      constexpr merge_result&lt;borrowed_iterator_t&lt;R1&gt;, borrowed_iterator_t&lt;R2&gt;, O&gt;</span>
<span id="cb30-19"><a href="#cb30-19"></a>        merge(R1&amp;&amp; r1, R2&amp;&amp; r2, O result,</span>
<span id="cb30-20"><a href="#cb30-20"></a>              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb30-21"><a href="#cb30-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.15" id="rangesset_union"><span class="header-section-number">3.4.15</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_union</code><a href="#rangesset_union" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: Same idea as <code class="sourceCode cpp">ranges<span class="op">::</span>merge</code>, here and for the other set algorithms ]</span></p>
<blockquote>
<div>
<div class="sourceCode" id="cb31"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb31-1"><a href="#cb31-1"></a>namespace std::ranges {</span>
<span id="cb31-2"><a href="#cb31-2"></a>    template&lt;class I1, class I2, class O&gt;</span>
<span id="cb31-3"><a href="#cb31-3"></a>      using set_union_result = in_in_out_result&lt;I1, I2, O&gt;;</span>
<span id="cb31-4"><a href="#cb31-4"></a></span>
<span id="cb31-5"><a href="#cb31-5"></a>    template&lt;input_iterator I1, sentinel_for&lt;I1&gt; S1, input_iterator I2, sentinel_for&lt;I2&gt; S2,</span>
<span id="cb31-6"><a href="#cb31-6"></a><span class="st">-            weakly_incrementable O, class Comp = ranges::less,</span></span>
<span id="cb31-7"><a href="#cb31-7"></a><span class="va">+            class O, class Comp = ranges::less,</span></span>
<span id="cb31-8"><a href="#cb31-8"></a>             class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb31-9"><a href="#cb31-9"></a>      requires mergeable&lt;I1, I2, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb31-10"><a href="#cb31-10"></a>      constexpr set_union_result&lt;I1, I2, O&gt;</span>
<span id="cb31-11"><a href="#cb31-11"></a>        set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},</span>
<span id="cb31-12"><a href="#cb31-12"></a>                  Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb31-13"><a href="#cb31-13"></a></span>
<span id="cb31-14"><a href="#cb31-14"></a><span class="st">-   template&lt;input_range R1, input_range R2, weakly_incrementable O,</span></span>
<span id="cb31-15"><a href="#cb31-15"></a><span class="va">+   template&lt;input_range R1, input_range R2, class O,</span></span>
<span id="cb31-16"><a href="#cb31-16"></a>             class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb31-17"><a href="#cb31-17"></a>      requires mergeable&lt;iterator_t&lt;R1&gt;, iterator_t&lt;R2&gt;, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb31-18"><a href="#cb31-18"></a>      constexpr set_union_result&lt;borrowed_iterator_t&lt;R1&gt;, borrowed_iterator_t&lt;R2&gt;, O&gt;</span>
<span id="cb31-19"><a href="#cb31-19"></a>        set_union(R1&amp;&amp; r1, R2&amp;&amp; r2, O result, Comp comp = {},</span>
<span id="cb31-20"><a href="#cb31-20"></a>                  Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb31-21"><a href="#cb31-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.16" id="rangesset_intersection"><span class="header-section-number">3.4.16</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_intersection</code><a href="#rangesset_intersection" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb32"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb32-1"><a href="#cb32-1"></a>namespace std::ranges {</span>
<span id="cb32-2"><a href="#cb32-2"></a>    template&lt;class I1, class I2, class O&gt;</span>
<span id="cb32-3"><a href="#cb32-3"></a>      using set_intersection_result = in_in_out_result&lt;I1, I2, O&gt;;</span>
<span id="cb32-4"><a href="#cb32-4"></a></span>
<span id="cb32-5"><a href="#cb32-5"></a>    template&lt;input_iterator I1, sentinel_for&lt;I1&gt; S1, input_iterator I2, sentinel_for&lt;I2&gt; S2,</span>
<span id="cb32-6"><a href="#cb32-6"></a><span class="st">-            weakly_incrementable O, class Comp = ranges::less,</span></span>
<span id="cb32-7"><a href="#cb32-7"></a><span class="va">+            class O, class Comp = ranges::less,</span></span>
<span id="cb32-8"><a href="#cb32-8"></a>             class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb32-9"><a href="#cb32-9"></a>      requires mergeable&lt;I1, I2, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb32-10"><a href="#cb32-10"></a>      constexpr set_intersection_result&lt;I1, I2, O&gt;</span>
<span id="cb32-11"><a href="#cb32-11"></a>        set_intersection(I1 first1, S1 last1, I2 first2, S2 last2, O result,</span>
<span id="cb32-12"><a href="#cb32-12"></a>                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb32-13"><a href="#cb32-13"></a></span>
<span id="cb32-14"><a href="#cb32-14"></a><span class="st">-   template&lt;input_range R1, input_range R2, weakly_incrementable O,</span></span>
<span id="cb32-15"><a href="#cb32-15"></a><span class="va">+   template&lt;input_range R1, input_range R2, class O,</span></span>
<span id="cb32-16"><a href="#cb32-16"></a>             class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb32-17"><a href="#cb32-17"></a>      requires mergeable&lt;iterator_t&lt;R1&gt;, iterator_t&lt;R2&gt;, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb32-18"><a href="#cb32-18"></a>      constexpr set_intersection_result&lt;borrowed_iterator_t&lt;R1&gt;, borrowed_iterator_t&lt;R2&gt;, O&gt;</span>
<span id="cb32-19"><a href="#cb32-19"></a>        set_intersection(R1&amp;&amp; r1, R2&amp;&amp; r2, O result,</span>
<span id="cb32-20"><a href="#cb32-20"></a>                         Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb32-21"><a href="#cb32-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.17" id="rangesset_difference"><span class="header-section-number">3.4.17</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_difference</code><a href="#rangesset_difference" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb33"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb33-1"><a href="#cb33-1"></a>namespace std::ranges {</span>
<span id="cb33-2"><a href="#cb33-2"></a>    template&lt;class I, class O&gt;</span>
<span id="cb33-3"><a href="#cb33-3"></a>      using set_difference_result = in_out_result&lt;I, O&gt;;</span>
<span id="cb33-4"><a href="#cb33-4"></a></span>
<span id="cb33-5"><a href="#cb33-5"></a>    template&lt;input_iterator I1, sentinel_for&lt;I1&gt; S1, input_iterator I2, sentinel_for&lt;I2&gt; S2,</span>
<span id="cb33-6"><a href="#cb33-6"></a><span class="st">-            weakly_incrementable O, class Comp = ranges::less,</span></span>
<span id="cb33-7"><a href="#cb33-7"></a><span class="va">+            class O, class Comp = ranges::less,</span></span>
<span id="cb33-8"><a href="#cb33-8"></a>             class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb33-9"><a href="#cb33-9"></a>      requires mergeable&lt;I1, I2, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb33-10"><a href="#cb33-10"></a>      constexpr set_difference_result&lt;I1, O&gt;</span>
<span id="cb33-11"><a href="#cb33-11"></a>        set_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,</span>
<span id="cb33-12"><a href="#cb33-12"></a>                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb33-13"><a href="#cb33-13"></a></span>
<span id="cb33-14"><a href="#cb33-14"></a><span class="st">-   template&lt;input_range R1, input_range R2, weakly_incrementable O,</span></span>
<span id="cb33-15"><a href="#cb33-15"></a><span class="va">+   template&lt;input_range R1, input_range R2, class O,</span></span>
<span id="cb33-16"><a href="#cb33-16"></a>             class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb33-17"><a href="#cb33-17"></a>      requires mergeable&lt;iterator_t&lt;R1&gt;, iterator_t&lt;R2&gt;, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb33-18"><a href="#cb33-18"></a>      constexpr set_difference_result&lt;borrowed_iterator_t&lt;R1&gt;, O&gt;</span>
<span id="cb33-19"><a href="#cb33-19"></a>        set_difference(R1&amp;&amp; r1, R2&amp;&amp; r2, O result,</span>
<span id="cb33-20"><a href="#cb33-20"></a>                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb33-21"><a href="#cb33-21"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.18" id="rangesset_symmetric_difference"><span class="header-section-number">3.4.18</span> <code class="sourceCode cpp">ranges<span class="op">::</span>set_symmetric_difference</code><a href="#rangesset_symmetric_difference" class="self-link"></a></h3>
<blockquote>
<div>
<div class="sourceCode" id="cb34"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb34-1"><a href="#cb34-1"></a>namespace std::ranges {</span>
<span id="cb34-2"><a href="#cb34-2"></a>    template&lt;class I1, class I2, class O&gt;</span>
<span id="cb34-3"><a href="#cb34-3"></a>      using set_symmetric_difference_result = in_in_out_result&lt;I1, I2, O&gt;;</span>
<span id="cb34-4"><a href="#cb34-4"></a></span>
<span id="cb34-5"><a href="#cb34-5"></a>    template&lt;input_iterator I1, sentinel_for&lt;I1&gt; S1, input_iterator I2, sentinel_for&lt;I2&gt; S2,</span>
<span id="cb34-6"><a href="#cb34-6"></a><span class="st">-            weakly_incrementable O, class Comp = ranges::less,</span></span>
<span id="cb34-7"><a href="#cb34-7"></a><span class="va">+            class O, class Comp = ranges::less,</span></span>
<span id="cb34-8"><a href="#cb34-8"></a>             class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb34-9"><a href="#cb34-9"></a>      requires mergeable&lt;I1, I2, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb34-10"><a href="#cb34-10"></a>      constexpr set_symmetric_difference_result&lt;I1, I2, O&gt;</span>
<span id="cb34-11"><a href="#cb34-11"></a>        set_symmetric_difference(I1 first1, S1 last1, I2 first2, S2 last2, O result,</span>
<span id="cb34-12"><a href="#cb34-12"></a>                                 Comp comp = {}, Proj1 proj1 = {},</span>
<span id="cb34-13"><a href="#cb34-13"></a>                                 Proj2 proj2 = {});</span>
<span id="cb34-14"><a href="#cb34-14"></a></span>
<span id="cb34-15"><a href="#cb34-15"></a><span class="st">-   template&lt;input_range R1, input_range R2, weakly_incrementable O,</span></span>
<span id="cb34-16"><a href="#cb34-16"></a><span class="va">+   template&lt;input_range R1, input_range R2, class O,</span></span>
<span id="cb34-17"><a href="#cb34-17"></a>             class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity&gt;</span>
<span id="cb34-18"><a href="#cb34-18"></a>      requires mergeable&lt;iterator_t&lt;R1&gt;, iterator_t&lt;R2&gt;, O, Comp, Proj1, Proj2&gt;</span>
<span id="cb34-19"><a href="#cb34-19"></a>      constexpr set_symmetric_difference_result&lt;borrowed_iterator_t&lt;R1&gt;,</span>
<span id="cb34-20"><a href="#cb34-20"></a>                                                borrowed_iterator_t&lt;R2&gt;, O&gt;</span>
<span id="cb34-21"><a href="#cb34-21"></a>        set_symmetric_difference(R1&amp;&amp; r1, R2&amp;&amp; r2, O result, Comp comp = {},</span>
<span id="cb34-22"><a href="#cb34-22"></a>                                 Proj1 proj1 = {}, Proj2 proj2 = {});</span>
<span id="cb34-23"><a href="#cb34-23"></a>}</span></code></pre></div>
</div>
</blockquote>
<h3 data-number="3.4.19" id="rangesiota"><span class="header-section-number">3.4.19</span> <code class="sourceCode cpp">ranges<span class="op">::</span>iota</code><a href="#rangesiota" class="self-link"></a></h3>
<p><span class="draftnote" style="color: #01796F">[ Drafting note: This one is in <code class="sourceCode cpp"><span class="op">&lt;</span>numeric<span class="op">&gt;</span></code>, just adopted by way of <span class="citation" data-cites="P2440R1">[<a href="#ref-P2440R1" role="doc-biblioref">P2440R1</a>]</span> ]</span>:</p>
<blockquote>
<div>
<div class="sourceCode" id="cb35"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb35-1"><a href="#cb35-1"></a>namespace std::ranges {</span>
<span id="cb35-2"><a href="#cb35-2"></a>    template&lt;class O, class T&gt;</span>
<span id="cb35-3"><a href="#cb35-3"></a>      using iota_result = out_value_result&lt;O, T&gt;;</span>
<span id="cb35-4"><a href="#cb35-4"></a></span>
<span id="cb35-5"><a href="#cb35-5"></a><span class="st">-   template&lt;input_or_output_iterator O, sentinel_for&lt;O&gt; S, weakly_incrementable T&gt;</span></span>
<span id="cb35-6"><a href="#cb35-6"></a><span class="st">-     requires indirectly_writable&lt;O, const T&amp;&gt;</span></span>
<span id="cb35-7"><a href="#cb35-7"></a><span class="va">+   template&lt;weakly_incrementable T, weak_output_iterator&lt;const T&amp;&gt; O, sentinel_for&lt;O&gt; S&gt;</span></span>
<span id="cb35-8"><a href="#cb35-8"></a>      constexpr iota_result&lt;O, T&gt; iota(O first, S last, T value);</span>
<span id="cb35-9"><a href="#cb35-9"></a></span>
<span id="cb35-10"><a href="#cb35-10"></a><span class="st">-   template&lt;weakly_incrementable T, output_range&lt;const T&amp;&gt; R&gt;</span></span>
<span id="cb35-11"><a href="#cb35-11"></a><span class="va">+   template&lt;weakly_incrementable T, weak_output_range&lt;const T&amp;&gt; R&gt;</span></span>
<span id="cb35-12"><a href="#cb35-12"></a>      constexpr iota_result&lt;borrowed_iterator_t&lt;R&gt;, T&gt; iota(R&amp;&amp; r, T value);</span>
<span id="cb35-13"><a href="#cb35-13"></a>}</span></code></pre></div>
</div>
</blockquote>
<h1 data-number="4" style="border-bottom:1px solid #cccccc" id="acknowledgements"><span class="header-section-number">4</span> Acknowledgements<a href="#acknowledgements" class="self-link"></a></h1>
<p>Thanks to Tim Song for all the help.</p>
<h1 data-number="5" style="border-bottom:1px solid #cccccc" id="bibliography"><span class="header-section-number">5</span> References<a href="#bibliography" class="self-link"></a></h1>
<div id="refs" class="references hanging-indent" role="doc-bibliography">
<div id="ref-P2440R1">
<p>[P2440R1] Tim Song. 2021-12-06. ranges::iota, ranges::shift_left, and ranges::shift_right. <br />
<a href="https://wg21.link/p2440r1">https://wg21.link/p2440r1</a></p>
</div>
<div id="ref-P2502R0">
<p>[P2502R0] Casey Carter. 2021-12-13. std::generator: Synchronous Coroutine Generator for Ranges. <br />
<a href="https://wg21.link/p2502r0">https://wg21.link/p2502r0</a></p>
</div>
</div>
</div>
</div>
</body>
</html>
