<!doctype html><html lang="en">
 <head>
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P1035R2: Input range adaptors</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in §N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .assertion  for assertions                    (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/******************************************************************************/
/*                                   Body                                     */
/******************************************************************************/

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;               /* limit line length to 50em for readability   */
		margin: 0 auto;                /* center text within page                     */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag     */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		/* Colors */
		color: black;
		background: white top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		color: white;
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		border-color: #c00;
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 2;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
			color: black;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			background: white;
			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;
			background: white;
		}
		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		#toc-nav > a:hover,
		#toc-nav > a:focus {
			background: #f8f8f8;
		}
		#toc-nav > a:not(:hover):not(:focus) {
			color: #707070;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}

		#toc-toggle-inline {
			vertical-align: 0.05em;
			font-size: 80%;
			color: gray;
			color: hsla(203,20%,40%,.7);
			border-style: none;
			background: transparent;
			position: relative;
		}
		#toc-toggle-inline:hover:not(:active),
		#toc-toggle-inline:focus:not(:active) {
			text-shadow: 1px 1px silver;
			top: -1px;
			left: -1px;
		}

		#toc-nav :active {
			color: #C00;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;    /* Inherit the font family. */
		line-height: 1.2;        /* Keep wrapped headings compact */
		hyphens: manual;         /* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		background: transparent;
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#subtitle {
		/* #subtitle is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	 border-left: 0.5em solid #DEF;
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	  padding: .5em;
	  border: thin solid #ddd; border-radius: .5em;
	  margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	  margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	  margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	 margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	 margin-left: -2em;
	}
	dl.switch {
	 padding-left: 2em;
	}
	dl.switch > dt {
	 text-indent: -1.5em;
	 margin-top: 1em;
	}
	dl.switch > dt + dt {
	 margin-top: 0;
	}
	dl.switch > dt::before {
	 content: '\21AA';
	 padding: 0 0.5em 0 0;
	 display: inline-block;
	 width: 1em;
	 text-align: right;
	 line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: medium;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del { color: red;  text-decoration: line-through; }
	ins { color: #080; text-decoration: underline;    }

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

  /* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #C00;
		border-color: #C00;
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	/* For autogen numbers, add
	   .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,    .sidefigure img,    figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote {
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	   or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #E0CB52;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	   or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52E052;
		background: #E9FBE9;
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary::before,
	details.note > summary > .marker {
		text-transform: uppercase;
		display: block;
		color: hsl(120, 70%, 30%);
	}
	/* Add .note::before { content: "Note"; } for autogen label,
	   or use class="marker" to mark up the label in source. */

	details.note > summary {
		display: block;
		color: hsl(120, 70%, 30%);
	}
	details.note[open] > summary {
		border-bottom: 1px silver solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		background: #EEE;
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-style: none solid;
		background: #FFEECC;
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement > .marker {
		color: #B35F00;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 1em;
		right: 1em;
		bottom: 1em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #DEF;
		margin: 1.2em 0;
		border-left: 0.5em solid #8CCBF2;
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def           td.footnote {
		padding-top: 0.6em;
	}
	table.def           td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		 <table class="data"> highlights structural relationships in a table
		 when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		 Use class="complex data" for particularly complicated tables --
		 (This will draw more lines: busier, but clearer.)

		 Use class="long" on table cells with paragraph-like contents
		 (This will adjust text alignment accordingly.)
		 Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
	 vertical-align: baseline;
	 text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
		line-height: 1.1rem; /* consistent spacing */
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li             { font-weight: bold;   }
	.toc > li li          { font-weight: normal; }
	.toc > li li li       { font-size:   95%;    }
	.toc > li li li li    { font-size:   90%;    }
	.toc > li li li li .secno { font-size: 85%; }
	.toc > li li li li li { font-size:   85%;    }
	.toc > li li li li li .secno { font-size: 100%; }

	/* @supports not (display:grid) { */
		.toc > li             { margin: 1.5rem 0;    }
		.toc > li li          { margin: 0.3rem 0;    }
		.toc > li li li       { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}

		.toc li {
			clear: both;
		}

		:not(li) > .toc              { margin-left:  5rem; }
		.toc .secno                  { margin-left: -5rem; }
		.toc > li li li .secno       { margin-left: -7rem; }
		.toc > li li li li .secno    { margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc              { margin-left:  4rem; }
			.toc .secno                  { margin-left: -4rem; }
			.toc > li li li              { margin-left:  1rem; }
			.toc > li li li .secno       { margin-left: -5rem; }
			.toc > li li li li .secno    { margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
	/* } */

	@supports (display:grid) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			   comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover {
			background: rgba(75%, 75%, 75%, .25);
			border-bottom: 3px solid #054572;
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index       { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li    { margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em }
	ul.index dl    { margin-top: 0; }
	ul.index dt    { margin: .2em 0 .2em 20px;}
	ul.index dd    { margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li span {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		background: #f7f8f9;
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}

/******************************************************************************/
/*                                    Legacy                                  */
/******************************************************************************/

	/* This rule is inherited from past style sheets. No idea what it's for. */
	.hide { display: none }



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-left: calc(13px + 26.5rem - 50vw);
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-left: calc(40em - 50vw) !important;
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-left: 0 !important;
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			 * http://lea.verou.me/2012/04/background-attachment-local/
			 *
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
			            top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
			            top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }
  </style>
  <meta content="Bikeshed version e9290f0f6bc01459c8b7bdfa2bb91f6985fc5c67" name="generator">
  <link href="https://wg21.link/p1035" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="b469d0c56d2a86eead2750b5b772fa7a6c3080e8" name="document-revision">
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-syntax-highlighting */

.highlight:not(.idl) { background: hsl(24, 20%, 95%); }
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</style>
<style>/* style-selflinks */

.heading, .issue, .note, .example, li, dt {
    position: relative;
}
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;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: gray;
    color: white;
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: black;
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }</style>
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: #005a9c;
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1035R2<br>Input range adaptors</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2018-10-08">2018-10-08</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://wg21.link/p1035">https://wg21.link/p1035</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:cjdb.ns@gmail.com">Christopher Di Bella</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:casey@carter.com">Casey Carter</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:corentin.jabot@gmail.com">Corentin Jabot</a>
     <dt>Audience:
     <dd>LEWG
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>P1035 proposes to introduce seven additional range adaptors in the C++20 timeframe.</p>
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li>
     <a href="#changes"><span class="secno">1</span> <span class="content">Changes</span></a>
     <ol class="toc">
      <li><a href="#from-r1-to-r2"><span class="secno">1.1</span> <span class="content">From R1 to R2</span></a>
      <li><a href="#from-r0-to-r1"><span class="secno">1.2</span> <span class="content">From R0 to R1</span></a>
     </ol>
    <li><a href="#acknowledgements"><span class="secno">2</span> <span class="content">Acknowledgements</span></a>
    <li><a href="#motivation"><span class="secno">3</span> <span class="content">Motivation</span></a>
    <li>
     <a href="#proposals"><span class="secno">4</span> <span class="content">Proposals</span></a>
     <ol class="toc">
      <li>
       <a href="#zip_view"><span class="secno">4.1</span> <span class="content"><code class="highlight"><c- n>zip_view</c-></code></span></a>
       <ol class="toc">
        <li>
         <a href="#motivation①"><span class="secno">4.1.1</span> <span class="content">Motivation</span></a>
         <ol class="toc">
          <li><a href="#zip_with-in-c20"><span class="secno">4.1.1.1</span> <span class="content"><code class="highlight"><c- n>zip_with</c-></code> in C++20</span></a>
         </ol>
        <li>
         <a href="#problems-with-pair-and-tuple"><span class="secno">4.1.2</span> <span class="content">Problems with <code class="highlight"><c- n>pair</c-></code> and <code class="highlight"><c- n>tuple</c-></code></span></a>
         <ol class="toc">
          <li><a href="#pros-and-cons-for-fixing-tuple-and-possibly-pair"><span class="secno">4.1.2.1</span> <span class="content">Pros and cons for fixing <code class="highlight"><c- n>tuple</c-></code> (and possibly <code class="highlight"><c- n>pair</c-></code>)</span></a>
          <li><a href="#pros-and-cons-for-introducing-an-exposition-only-__tuple_hack-and-possibly-__pair_hack"><span class="secno">4.1.2.2</span> <span class="content">Pros and cons for introducing an exposition-only <code class="highlight"><c- n>__tuple_hack</c-></code> (and possibly <code class="highlight"><c- n>__pair_hack</c-></code>)</span></a>
          <li><a href="#ensure-tuple-and-pair-assignment-operators-are-constexpr"><span class="secno">4.1.2.3</span> <span class="content">Ensure <code class="highlight"><c- n>tuple</c-></code> and <code class="highlight"><c- n>pair</c-></code> assignment operators are <code class="highlight"><c- k>constexpr</c-></code></span></a>
         </ol>
        <li>
         <a href="#example-implementation"><span class="secno">4.1.3</span> <span class="content">Example implementation</span></a>
         <ol class="toc">
          <li><a href="#zip_view-constructors"><span class="secno">4.1.3.1</span> <span class="content"><code class="highlight"><c- n>zip_view</c-></code> constructors</span></a>
          <li><a href="#zip_view-begin"><span class="secno">4.1.3.2</span> <span class="content"><code class="highlight"><c- n>zip_view</c-></code> begin</span></a>
          <li><a href="#zip_view-end"><span class="secno">4.1.3.3</span> <span class="content"><code class="highlight"><c- n>zip_view</c-></code> end</span></a>
          <li><a href="#zip_viewrs-iterator-exposition-only"><span class="secno">4.1.3.4</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-></code> iterator (exposition-only)</span></a>
          <li><a href="#zip_view__zipperator-members"><span class="secno">4.1.3.5</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> members</span></a>
          <li><a href="#zip_view__zipperator-constructors"><span class="secno">4.1.3.6</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> constructors</span></a>
          <li><a href="#zip_view__zipperator-element-access"><span class="secno">4.1.3.7</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> element access</span></a>
          <li><a href="#zip_view__zipperator-advance"><span class="secno">4.1.3.8</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> advance</span></a>
          <li><a href="#zip_view__zipperator-comparisons"><span class="secno">4.1.3.9</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> comparisons</span></a>
          <li><a href="#zip_viewrs__zipperator-arithmetic"><span class="secno">4.1.3.10</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-></code> arithmetic</span></a>
          <li><a href="#zip_viewrs__zipperator-iter_move"><span class="secno">4.1.3.11</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-></code> iter_move</span></a>
          <li><a href="#zip_viewrs__zipperator-iter_swap"><span class="secno">4.1.3.12</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-></code> iter_swap</span></a>
          <li><a href="#zip_viewrs-sentinel-exposition-only"><span class="secno">4.1.3.13</span> <span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-></code> sentinel (exposition-only)</span></a>
         </ol>
       </ol>
      <li><a href="#viewzip"><span class="secno">4.2</span> <span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>zip</c-></code></span></a>
      <li>
       <a href="#basic_istream_view"><span class="secno">4.3</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code></span></a>
       <ol class="toc">
        <li><a href="#motivation②"><span class="secno">4.3.1</span> <span class="content">Motivation</span></a>
        <li>
         <a href="#interface"><span class="secno">4.3.2</span> <span class="content">Interface</span></a>
         <ol class="toc">
          <li><a href="#concept-streamextractable"><span class="secno">4.3.2.1</span> <span class="content">Concept <code class="highlight"><c- n>StreamExtractable</c-></code></span></a>
          <li><a href="#concept-streaminsertable"><span class="secno">4.3.2.2</span> <span class="content">Concept <code class="highlight"><c- n>StreamInsertable</c-></code></span></a>
          <li><a href="#basic_istream_view-constructor"><span class="secno">4.3.2.3</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> constructor</span></a>
          <li><a href="#basic_istream_view-begin"><span class="secno">4.3.2.4</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> begin</span></a>
          <li><a href="#basic_istream_view-end"><span class="secno">4.3.2.5</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> end</span></a>
          <li><a href="#basic_istream_view__iterator"><span class="secno">4.3.2.6</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code></span></a>
          <li><a href="#basic_istream_view__iterator-constructor"><span class="secno">4.3.2.7</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> constructor</span></a>
          <li><a href="#basic_istream_view__iterator-next"><span class="secno">4.3.2.8</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> next</span></a>
          <li><a href="#basic_istream_view__iterator-value"><span class="secno">4.3.2.9</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> value</span></a>
          <li><a href="#basic_istream_view__iterator-comparison-functions"><span class="secno">4.3.2.10</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> comparison functions</span></a>
          <li><a href="#basic_istream_view-factory"><span class="secno">4.3.2.11</span> <span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> factory</span></a>
         </ol>
       </ol>
      <li><a href="#introducing-associated-types-for-ranges"><span class="secno">4.4</span> <span class="content">Introducing associated types for ranges</span></a>
      <li>
       <a href="#take_while_view"><span class="secno">4.5</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-></code></span></a>
       <ol class="toc">
        <li><a href="#motivation③"><span class="secno">4.5.1</span> <span class="content">Motivation</span></a>
        <li><a href="#notes"><span class="secno">4.5.2</span> <span class="content">Notes</span></a>
        <li>
         <a href="#interface-and-specification"><span class="secno">4.5.3</span> <span class="content">Interface and specification</span></a>
         <ol class="toc">
          <li><a href="#take_while_view-constructors"><span class="secno">4.5.3.1</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-></code> constructors</span></a>
          <li><a href="#take_while_view-conversion"><span class="secno">4.5.3.2</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-></code> conversion</span></a>
          <li><a href="#take_while_view-range-begin"><span class="secno">4.5.3.3</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-></code> range begin</span></a>
          <li><a href="#take_while_view-range-end"><span class="secno">4.5.3.4</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-></code> range end</span></a>
         </ol>
        <li><a href="#take_while_view__sentinel"><span class="secno">4.5.4</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code></span></a>
        <li><a href="#take_while_view__sentinel-constructor"><span class="secno">4.5.5</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code> constructor</span></a>
        <li><a href="#take_while_view__sentinel-conversion"><span class="secno">4.5.6</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code> conversion</span></a>
        <li><a href="#take_while_view__sentinel-comparisons"><span class="secno">4.5.7</span> <span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code> comparisons</span></a>
       </ol>
      <li><a href="#viewtake_while"><span class="secno">4.6</span> <span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>take_while</c-></code></span></a>
      <li>
       <a href="#drop_view"><span class="secno">4.7</span> <span class="content"><code class="highlight"><c- n>drop_view</c-></code></span></a>
       <ol class="toc">
        <li><a href="#motivation④"><span class="secno">4.7.1</span> <span class="content">Motivation</span></a>
        <li>
         <a href="#interface①"><span class="secno">4.7.2</span> <span class="content">Interface</span></a>
         <ol class="toc">
          <li><a href="#drop_view-constructor"><span class="secno">4.7.2.1</span> <span class="content"><code class="highlight"><c- n>drop_view</c-></code> constructor</span></a>
          <li><a href="#drop_view-conversion"><span class="secno">4.7.2.2</span> <span class="content"><code class="highlight"><c- n>drop_view</c-></code> conversion</span></a>
          <li><a href="#drop_view-range-begin"><span class="secno">4.7.2.3</span> <span class="content"><code class="highlight"><c- n>drop_view</c-></code> range begin</span></a>
          <li><a href="#drop_view-range-end"><span class="secno">4.7.2.4</span> <span class="content"><code class="highlight"><c- n>drop_view</c-></code> range end</span></a>
          <li><a href="#drop_view-size"><span class="secno">4.7.2.5</span> <span class="content"><code class="highlight"><c- n>drop_view</c-></code> size</span></a>
         </ol>
       </ol>
      <li><a href="#viewdrop"><span class="secno">4.8</span> <span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop</c-></code></span></a>
      <li>
       <a href="#drop_while_view"><span class="secno">4.9</span> <span class="content"><code class="highlight"><c- n>drop_while_view</c-></code></span></a>
       <ol class="toc">
        <li><a href="#motivation⑤"><span class="secno">4.9.1</span> <span class="content">Motivation</span></a>
        <li>
         <a href="#interface②"><span class="secno">4.9.2</span> <span class="content">Interface</span></a>
         <ol class="toc">
          <li><a href="#drop_while_view-constructors"><span class="secno">4.9.2.1</span> <span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> constructors</span></a>
          <li><a href="#drop_while_view-conversion"><span class="secno">4.9.2.2</span> <span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> conversion</span></a>
          <li><a href="#drop_while_view-begin"><span class="secno">4.9.2.3</span> <span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> begin</span></a>
          <li><a href="#drop_while_view-end"><span class="secno">4.9.2.4</span> <span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> end</span></a>
         </ol>
       </ol>
      <li><a href="#viewdrop_while"><span class="secno">4.10</span> <span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop_while</c-></code></span></a>
      <li>
       <a href="#keys-and-values"><span class="secno">4.11</span> <span class="content"><code class="highlight"><c- n>keys</c-></code> and <code class="highlight"><c- n>values</c-></code></span></a>
       <ol class="toc">
        <li><a href="#motivation⑥"><span class="secno">4.11.1</span> <span class="content">Motivation</span></a>
        <li><a href="#implementation"><span class="secno">4.11.2</span> <span class="content">Implementation</span></a>
       </ol>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="changes"><span class="secno">1. </span><span class="content">Changes</span><a class="self-link" href="#changes"></a></h2>
   <h3 class="heading settled" data-level="1.1" id="from-r1-to-r2"><span class="secno">1.1. </span><span class="content">From R1 to R2</span><a class="self-link" href="#from-r1-to-r2"></a></h3>
   <ul>
    <li data-md>
     <p>Expanded acknowledgements and co-authors.</p>
    <li data-md>
     <p>Removed <code class="highlight"><c- n>zip_with_view</c-></code>.</p>
    <li data-md>
     <p>Added <code class="highlight"><c- n>zip_view</c-></code>.</p>
    <li data-md>
     <p>Added <code class="highlight"><c- n>keys</c-></code> and <code class="highlight"><c- n>values</c-></code>.</p>
    <li data-md>
     <p>Added content for associated types for ranges.</p>
   </ul>
   <h3 class="heading settled" data-level="1.2" id="from-r0-to-r1"><span class="secno">1.2. </span><span class="content">From R0 to R1</span><a class="self-link" href="#from-r0-to-r1"></a></h3>
   <ul>
    <li data-md>
     <p>Revised <code class="highlight"><c- n>istream_range</c-></code>.</p>
    <li data-md>
     <p>Renamed to <code class="highlight"><c- n>basic_istream_view</c-></code>.</p>
    <li data-md>
     <p>Introduced some relevant concepts.</p>
    <li data-md>
     <p>Introduced <code class="highlight"><c- n>drop_view</c-></code>, <code class="highlight"><c- n>take_while_view</c-></code>, <code class="highlight"><c- n>drop_while_view</c-></code>.</p>
    <li data-md>
     <p>Teased <code class="highlight"><c- n>zip_with_view</c-></code>.</p>
    <li data-md>
     <p>Teased associated types for ranges.</p>
   </ul>
   <h2 class="heading settled" data-level="2" id="acknowledgements"><span class="secno">2. </span><span class="content">Acknowledgements</span><a class="self-link" href="#acknowledgements"></a></h2>
   <p>We would like to acknowledge the following people for their assistance with this proposal:</p>
   <ul>
    <li data-md>
     <p>Eric Niebler, for providing <a data-link-type="biblio" href="#biblio-range-v3">[range-v3]</a> as a reference implementation.</p>
    <li data-md>
     <p>Tim Song, Steve Downey, and Barry Revzin for their reviews of P1035.</p>
   </ul>
   <h2 class="heading settled" data-level="3" id="motivation"><span class="secno">3. </span><span class="content">Motivation</span><a class="self-link" href="#motivation"></a></h2>
   <p><a data-link-type="biblio" href="#biblio-p0789">[P0789]</a> introduces the notion of a range adaptor and twelve pioneering range adaptors that
improve declarative, range-based programming. For example, it is possible to perform an inline,
in-place, lazy reverse like so:</p>
<pre class="language-cpp highlight"><c- k>namespace</c-> <c- n>ranges</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- p>;</c->
<c- k>namespace</c-> <c- n>view</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>ranges</c-><c- o>::</c-><c- n>view</c-><c- p>;</c->

<c- c1>// Old</c->
<c- k>auto</c-> <c- n>i</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>rbegin</c-><c- p>(</c-><c- n>employees</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>rend</c-><c- p>(</c-><c- n>employees</c-><c- p>),</c-> <c- s>"Lovelace"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>employee</c-><c- o>::</c-><c- n>surname</c-><c- p>);</c->

<c- c1>// New</c->
<c- k>auto</c-> <c- n>j</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find</c-><c- p>(</c-><c- n>employees</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>reverse</c-><c- p>,</c-> <c- s>"Lovelace"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>employee</c-><c- o>::</c-><c- n>surname</c-><c- p>);</c->
<c- p>[[</c-><c- nl>assert</c-><c- p>:</c-> <c- n>i</c-> <c- o>==</c-> <c- n>j</c-><c- p>]];</c->
</pre>
   <p>P1035 recognises that P0789 introduces only a few of the widely experimented-with range adaptors in <a data-link-type="biblio" href="#biblio-range-v3">[range-v3]</a>, and would like to add a few more to complete the C++20 phase of range adaptors.</p>
   <h2 class="heading settled" data-level="4" id="proposals"><span class="secno">4. </span><span class="content">Proposals</span><a class="self-link" href="#proposals"></a></h2>
   <p>Unless otherwise requested, each sub-subsection below should be polled individually from other
sub-subsections. Two major questions are to be asked per range adaptor. It is up to LEWG to decide
the exact phrasing, but the author’s intentions are listed below.</p>
   <ol>
    <li data-md>
     <p>Do we want this range adaptor in C++20?</p>
     <ol>
      <li data-md>
       <p>As-is?</p>
      <li data-md>
       <p>With modifications, as suggested by LEWG?</p>
     </ol>
    <li data-md>
     <p>If we do not want this range adaptor in C++20, do we want it in C++23?</p>
     <ol>
      <li data-md>
       <p>As-is?</p>
      <li data-md>
       <p>With modificaitons, as suggested by LEWG?</p>
     </ol>
   </ol>
   <h3 class="heading settled" data-level="4.1" id="zip_view"><span class="secno">4.1. </span><span class="content"><code class="highlight"><c- n>zip_view</c-></code></span><a class="self-link" href="#zip_view"></a></h3>
   <p><b>Note: This section was formerly titled <i><code class="highlight"><c- n>zip_with_view</c-></code></i> in P1035R1. Due to
complications in the design process, <code class="highlight"><c- n>zip_with_view</c-></code> will not be proposed, but <code class="highlight"><c- n>zip_view</c-></code> shall be.
A subsubsection below articulates how to emulate <code class="highlight"><c- n>zip_with_view</c-></code> below.</b></p>
   <h4 class="heading settled" data-level="4.1.1" id="motivation①"><span class="secno">4.1.1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation①"></a></h4>
   <p>A zip, also known as a <a data-link-type="biblio" href="#biblio-convolution">[convolution]</a> operation, performs a transformation on multiple input
ranges. The typical zip operation transforms several input ranges into a single input range
containing a tuple with the <i>i</i>th element from each range, and terminates when the smallest
finite range is delimited.</p>
   <p>Iterating over multiple ranges simultaneously is a useful feature. Both <a data-link-type="biblio" href="#biblio-ewg43">[EWG43]</a> and <a data-link-type="biblio" href="#biblio-p0026">[P0026]</a> ask
for this functionality at a language level. While these papers request a useful feature that
benefits raw loops, they don’t address algorithmic composition, which is important for ensuring both
correctness and simplicity. A <code class="highlight"><c- n>zip_view</c-></code> will allow programmers to iterate over multiple ranges at
the same time when requiring either a raw loop or an algorithm.</p>
   <table>
    <tbody>
     <tr>
      <th>Current (C++17)
      <th>Proposed (C++20)
     <tr>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>x</c-> <c- o>=</c-> <c- n>vector</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>{</c-><c- d>/* ... */</c-><c- p>};</c->
<c- k>auto</c-> <c- n>y</c-> <c- o>=</c-> <c- n>vector</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>{</c-><c- d>/* ... */</c-><c- p>};</c->
<c- c1>// ...</c->
<c- k>auto</c-> <c- n>xit</c-> <c- o>=</c-> <c- n>begin</c-><c- p>(</c-><c- n>x</c-><c- p>);</c->
<c- k>auto</c-> <c- n>yit</c-> <c- o>=</c-> <c- n>begin</c-><c- p>(</c-><c- n>y</c-><c- p>);</c->
<c- k>for</c-> <c- p>(;</c-> <c- n>xit</c-> <c- o>!=</c-> <c- n>end</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- n>and</c-> <c- n>yit</c-> <c- o>!=</c-> <c- n>end</c-><c- p>(</c-><c- n>y</c-><c- p>);</c-> <c- o>++</c-><c- n>xit</c-><c- p>,</c-> <c- p>(</c-><c- b>void</c-><c- p>)</c-><c- o>++</c-><c- n>yit</c-><c- p>)</c-> <c- p>{</c->
   <c- c1>// ...</c->
<c- p>}</c->
</pre>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>x</c-> <c- o>=</c-> <c- n>vector</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>{</c-><c- d>/* ... */</c-><c- p>};</c->
<c- k>auto</c-> <c- n>y</c-> <c- o>=</c-> <c- n>vector</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>{</c-><c- d>/* ... */</c-><c- p>};</c->
<c- c1>// ...</c->
<c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>xy</c-> <c- o>=</c-> <c- n>view</c-><c- o>::</c-><c- n>zip</c-><c- p>(</c-><c- n>x</c-><c- p>,</c-> <c- n>y</c-><c- p>);</c-> <c- k>auto</c-> <c- p>[</c-><c- n>xi</c-><c- p>,</c-> <c- n>yi</c-><c- p>]</c-> <c- o>:</c-> <c- n>xy</c-><c- p>)</c-> <c- p>{</c->
   <c- c1>// ...</c->
<c- p>}</c->
</pre>
   </table>
   <p>Another motivating example for using <code class="highlight"><c- n>zip</c-></code> involves replacing raw loops with algorithms and range
adaptors, but still being able to index the operation in question.</p>
   <table>
    <tbody>
     <tr>
      <th>Current (C++17)
      <th>Proposed (C++20)
     <tr>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>vector</c-><c- p>(</c-><c- n>istream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>cin</c-><c- p>),</c->
                <c- n>istream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>());</c->
<c- k>auto</c-> <c- n>weighted_sum</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c->
<c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- n>ranges</c-><c- o>::</c-><c- n>distance</c-><c- p>(</c-><c- n>v</c-><c- p>);</c-> <c- o>++</c-><c- n>i</c-><c- p>)</c-> <c- p>{</c->
   <c- n>weighted_sum</c-> <c- o>+=</c-> <c- n>i</c-> <c- o>*</c-> <c- n>v</c-><c- p>[</c-><c- n>i</c-><c- p>];</c->
<c- p>}</c->
</pre>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>in</c-> <c- o>=</c-> <c- n>view</c-><c- o>::</c-><c- n>zip</c-><c- p>(</c-><c- n>view</c-><c- o>::</c-><c- n>iota</c-><c- p>(</c-><c- mi>0</c-><c- p>),</c-> <c- n>istream_view</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>cin</c-><c- p>));</c->
<c- k>auto</c-> <c- k>const</c-> <c- n>weighted_sum</c-> <c- o>=</c-> <c- n>accumulate</c-><c- p>(</c-><c- n>begin</c-><c- p>(</c-><c- n>in</c-><c- p>),</c-> <c- n>end</c-><c- p>(</c-><c- n>in</c-><c- p>),</c->
   <c- p>[](</c-><c- k>auto</c-> <c- k>const</c-> <c- n>a</c-><c- p>,</c-> <c- k>auto</c-> <c- k>const</c-> <c- n>b</c-><c- p>){</c->
      <c- k>auto</c-> <c- k>const</c-> <c- p>[</c-><c- n>index</c-><c- p>,</c-> <c- n>in</c-><c- p>]</c-> <c- o>=</c-> <c- n>b</c-><c- p>;</c->
      <c- k>return</c-> <c- n>a</c-> <c- o>+</c-> <c- p>(</c-><c- n>index</c-> <c- o>*</c-> <c- n>in</c-><c- p>);</c->
   <c- p>});</c->
</pre>
   </table>
   <p>Finally, people who work in the parallelism and heterogeneous industries are not able to take full
advantage of the Parallel STL at present due to the limited number of input ranges each algorithm
can support. <code class="highlight"><c- n>zip_view</c-></code> will permit this (see <a data-link-type="biblio" href="#biblio-p0836">[P0836]</a> §2.1 for how this is beneficial).</p>
   <p>The benefits of this proposed approach include:</p>
   <ul>
    <li data-md>
     <p>More <i>declared</i> operations, leading to more declarative -- rather than imperative -- styled
programming.</p>
    <li data-md>
     <p>Eliminates state.</p>
    <li data-md>
     <p>A resulting expression can be declared <code class="highlight"><c- k>const</c-></code> without needing to rely on IILE.</p>
    <li data-md>
     <p>Temporary storage is eliminated, which helps to improve correctness, clarity, and performance.
P0836 §2.1 expands on the performance benefits for heterogeneous programming.</p>
   </ul>
   <h5 class="heading settled" data-level="4.1.1.1" id="zip_with-in-c20"><span class="secno">4.1.1.1. </span><span class="content"><code class="highlight"><c- n>zip_with</c-></code> in C++20</span><a class="self-link" href="#zip_with-in-c20"></a></h5>
   <p><code class="highlight"><c- n>zip_with</c-></code> is a generalisation of <code class="highlight"><c- n>zip</c-></code>, such that we can apply an <i>n</i>-ary function in place of
the <code class="highlight"><c- n>transform</c-></code>s above. The following is an example of how <code class="highlight"><c- n>zip_with</c-></code> can refine <code class="highlight"><c- n>zip</c-></code> when tuples
are not necessary.</p>
<pre class="language-cpp highlight"><c- n>vector</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-> <c- k>const</c-> <c- n>x</c-> <c- o>=</c-> <c- c1>// ...</c->
<c- n>vector</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-> <c- k>const</c-> <c- n>y</c-> <c- o>=</c-> <c- c1>// ...</c->
<c- b>float</c-> <c- k>const</c-> <c- n>a</c-> <c- o>=</c-> <c- c1>// ...</c->
<c- c1>// ...</c->
<c- k>auto</c-> <c- n>ax</c-> <c- o>=</c-> <c- n>x</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>transform</c-><c- p>([</c-><c- n>a</c-><c- p>](</c-><c- k>auto</c-> <c- k>const</c-> <c- n>x</c-><c- p>)</c-> <c- k>noexcept</c-> <c- p>{</c-> <c- k>return</c-> <c- n>a</c-> <c- o>*</c-> <c- n>x</c-><c- p>;</c-> <c- p>});</c->
<c- k>auto</c-> <c- n>saxpy</c-> <c- o>=</c-> <c- n>view</c-><c- o>::</c-><c- n>zip_with</c-><c- p>(</c-><c- n>plus</c-><c- o>&lt;></c-><c- p>{},</c-> <c- n>ax</c-><c- p>,</c-> <c- n>y</c-><c- p>);</c->
<c- k>auto</c-> <c- k>const</c-> <c- n>result</c-> <c- o>=</c-> <c- n>vector</c-><c- p>(</c-><c- n>begin</c-><c- p>(</c-><c- n>saxpy</c-><c- p>),</c-> <c- n>end</c-><c- p>(</c-><c- n>saxpy</c-><c- p>));</c->
</pre>
   <p>As <code class="highlight"><c- n>zip_with_view</c-></code> is no longer proposed in C++20, users wanting <code class="highlight"><c- n>zip_with</c-></code> functionality will be
required to use something akin to:</p>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>F</c-><c- o>></c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- n>compose_apply</c-><c- p>(</c-><c- n>F</c-><c- o>&amp;&amp;</c-> <c- n>f</c-><c- p>)</c-> <c- p>{</c->
   <c- k>return</c-> <c- p>[</c-><c- n>f</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>F</c-><c- o>></c-><c- p>(</c-><c- n>f</c-><c- p>)](</c-><c- k>auto</c-><c- o>&amp;&amp;</c-> <c- n>t</c-><c- p>)</c-> <c- p>{</c->
      <c- k>return</c-> <c- n>std</c-><c- o>::</c-><c- n>apply</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>F</c-><c- o>></c-><c- p>(</c-><c- n>f</c-><c- p>),</c-> <c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- n>t</c-><c- p>)</c-><c- o>></c-><c- p>(</c-><c- n>t</c-><c- p>));</c->
   <c- p>};</c->
<c- p>};</c->

<c- c1>// ...</c->
<c- k>auto</c-> <c- n>saxpy</c-> <c- o>=</c-> <c- n>zip</c-><c- p>(</c-><c- n>ax</c-><c- p>,</c-> <c- n>y</c-><c- p>)</c-> <c- o>|</c-> <c- n>transform</c-><c- p>(</c-><c- n>compose_apply</c-><c- p>(</c-><c- n>plus</c-><c- o>&lt;></c-><c- p>{}));</c->
</pre>
   <p>This isn’t an ideal approach, but some of the finer details of <code class="highlight"><c- n>zip_with_view</c-></code> that are independent
of <code class="highlight"><c- n>zip_view</c-></code> are still being worked out, and this should not preclude the usage of zipping ranges
for maximum composability.</p>
   <h4 class="heading settled" data-level="4.1.2" id="problems-with-pair-and-tuple"><span class="secno">4.1.2. </span><span class="content">Problems with <code class="highlight"><c- n>pair</c-></code> and <code class="highlight"><c- n>tuple</c-></code></span><a class="self-link" href="#problems-with-pair-and-tuple"></a></h4>
   <p><code class="highlight"><c- n>zip_view</c-></code> requires a value type to store the values of the iterators to the ranges that are
iterated over, and a reference type to access those values via an iterator to the range.
Additionally, the concept "<code class="highlight"><c- n>Writable</c-></code> wants <code class="highlight"><c- k>const</c-></code> proxy references to be assignable, so we need a
tuple-like type with <code class="highlight"><c- k>const</c-></code>-qualified assignment operators"<a data-link-type="biblio" href="#biblio-cmcstl2">[cmcstl2]</a>.</p>
   <p>Both range-v3 and the cmcstl2 implementation above use an exposition-only type derived from <code class="highlight"><c- n>tuple</c-></code> (both) or <code class="highlight"><c- n>pair</c-></code> (range-v3 only) that permits a <code class="highlight"><c- n>CommonReference</c-></code> between <code class="highlight"><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>>&amp;</c-></code> (an lvalue reference to the value type) and <code class="highlight"><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-></code> (the perceived reference
type). This is deemed to be a hack by both Eric Niebler and Casey Carter; a careful reader might
notice that the above implementation specifies this as <code class="highlight"><c- n>__tuple_hack</c-></code> (which has conveniently been
left out of P1035).</p>
   <p>Adding a third (and possibly fourth) tuple type that is exposition-only is <i>not</i> ideal: this
requires extensions to both <code class="highlight"><c- n>pair</c-></code> and <code class="highlight"><c- n>tuple</c-></code> so that they are compatible with <code class="highlight"><c- n>__tuple_hack</c-></code> and <code class="highlight"><c- n>__pair_hack</c-></code>, specialisations for all tuple utilities will be required, and overloads to <code class="highlight"><c- n>get</c-></code>, <code class="highlight"><c- n>apply</c-></code>, etc. are also necessary.</p>
   <p>Alternatively, we can provide an implicit conversion from <code class="highlight"><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>>&amp;</c-></code> to <code class="highlight"><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-></code>, and
ensure that a <code class="highlight"><c- n>common_reference</c-></code> exists (à la <code class="highlight"><c- n>basic_common_reference</c-></code>), and similarly for the other
reference types.</p>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- k>struct</c-> <c- n>tuple</c-> <c- p>{</c->
   <c- c1>// ...</c->

   <c- k>constexpr</c-> <c- n>tuple</c-> <c- k>const</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>_Elements</c-><c- p>...</c-><c- o>></c-> <c- k>const</c-><c- o>&amp;</c-><c- p>)</c->
   <c- n>requires</c-> <c- p>(</c-><c- n>__stl2</c-><c- o>::</c-><c- n>Assignable</c-><c- o>&lt;</c-><c- n>_Elements</c-> <c- k>const</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>_Elements</c-> <c- k>const</c-><c- o>&amp;></c-> <c- n>and</c-> <c- p>...);</c->

   <c- k>constexpr</c-> <c- n>tuple</c-> <c- k>const</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>_Elements</c-><c- p>...</c-><c- o>>&amp;&amp;</c-><c- p>)</c->
   <c- n>requires</c-> <c- p>(</c-><c- n>__stl2</c-><c- o>::</c-><c- n>Assignable</c-><c- o>&lt;</c-><c- n>_Elements</c-> <c- k>const</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>_Elements</c-><c- o>></c-> <c- n>and</c-> <c- p>...);</c->

   <c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Us</c-><c- o>></c->
   <c- n>requires</c-> <c- k>sizeof</c-><c- p>...(</c-><c- n>Ts</c-><c- p>)</c-> <c- o>==</c-> <c- k>sizeof</c-><c- p>...(</c-><c- n>Us</c-><c- p>)</c-> <c- n>and</c-> <c- p>(</c-><c- n>Assignable</c-><c- o>&lt;</c-><c- n>Ts</c-> <c- k>const</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>Us</c-> <c- k>const</c-><c- o>&amp;></c-> <c- n>and</c-> <c- p>...)</c->
   <c- k>constexpr</c-> <c- n>tuple</c-> <c- k>const</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Us</c-><c- p>...</c-><c- o>></c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

   <c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Us</c-><c- o>></c->
   <c- n>requires</c-> <c- k>sizeof</c-><c- p>...(</c-><c- n>Ts</c-><c- p>)</c-> <c- o>==</c-> <c- k>sizeof</c-><c- p>...(</c-><c- n>Us</c-><c- p>)</c-> <c- n>and</c-> <c- p>(</c-><c- n>Assignable</c-><c- o>&lt;</c-><c- n>Ts</c-> <c- k>const</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>Us</c-> <c- k>const</c-><c- o>&amp;></c-> <c- n>and</c-> <c- p>...)</c->
   <c- k>constexpr</c-> <c- n>tuple</c-> <c- k>const</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Us</c-><c- p>...</c-><c- o>>&amp;&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>operator</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>_Elements</c-><c- o>>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>operator</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>_Elements</c-><c- o>></c-> <c- k>const</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>operator</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>_Elements</c-><c- o>>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>operator</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>_Elements</c-><c- o>></c-> <c- k>const</c-><c- o>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>,</c-> <c- n>Ts</c-><c- o>&amp;></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>common_type</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>Ts</c-><c- o>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>,</c-> <c- n>Ts</c-><c- o>&amp;></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>common_type</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>>></c->   <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>Ts</c-><c- o>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- p>,</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>TQual</c-><c- p>,</c-> <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>UQual</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;>></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>basic_common_reference</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>TQual</c-><c- p>,</c-> <c- n>UQual</c-><c- o>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- p>,</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>TQual</c-><c- p>,</c-> <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>UQual</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;>></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>basic_common_reference</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>TQual</c-><c- p>,</c-> <c- n>UQual</c-><c- o>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->

<c- c1>// lvalue to rvalue reference</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>,</c-> <c- n>Ts</c-><c- o>&amp;&amp;></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>common_type</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>Ts</c-><c- o>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>,</c-> <c- n>Ts</c-><c- o>&amp;&amp;></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>common_type</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;</c-><c- p>...</c-><c- o>>></c->   <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>Ts</c-><c- o>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- p>,</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>TQual</c-><c- p>,</c-> <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>UQual</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;>></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>basic_common_reference</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>TQual</c-><c- p>,</c-> <c- n>UQual</c-><c- o>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- p>,</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>TQual</c-><c- p>,</c-> <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>UQual</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;>></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>basic_common_reference</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>TQual</c-><c- p>,</c-> <c- n>UQual</c-><c- o>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;&amp;>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->

<c- c1>// lvalue reference to rvalue reference</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>common_type</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;</c-><c- p>,</c-> <c- n>Ts</c-><c- o>&amp;></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_type_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>common_type</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;</c-><c- p>...</c-><c- o>>></c->   <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;</c-><c- p>,</c-> <c- n>Ts</c-><c- o>&amp;></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- p>,</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>TQual</c-><c- p>,</c-> <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>UQual</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;>></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>basic_common_reference</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>TQual</c-><c- p>,</c-> <c- n>UQual</c-><c- o>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
<c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Ts</c-><c- p>,</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>TQual</c-><c- p>,</c-> <c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- o>></c-> <c- k>class</c-> <c- nc>UQual</c-><c- o>></c->
<c- n>requires</c-> <c- p>(</c-><c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;>></c-><c- p>;</c-> <c- p>}</c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- k>struct</c-> <c- n>basic_common_reference</c-><c- o>&lt;</c-><c- n>tuple</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>TQual</c-><c- p>,</c-> <c- n>UQual</c-><c- o>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>common_reference_t</c-><c- o>&lt;</c-><c- n>TQual</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>&amp;></c-><c- p>,</c-> <c- n>UQual</c-><c- o>&lt;</c-><c- n>remove_reference_t</c-><c- o>&lt;</c-><c- n>Ts</c-><c- o>>&amp;&amp;>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
<c- p>};</c->
</pre>
   <h5 class="heading settled" data-level="4.1.2.1" id="pros-and-cons-for-fixing-tuple-and-possibly-pair"><span class="secno">4.1.2.1. </span><span class="content">Pros and cons for fixing <code class="highlight"><c- n>tuple</c-></code> (and possibly <code class="highlight"><c- n>pair</c-></code>)</span><a class="self-link" href="#pros-and-cons-for-fixing-tuple-and-possibly-pair"></a></h5>
   <table>
    <tbody>
     <tr>
      <th>Pros
      <th>Cons
     <tr>
      <td> Exactly one <code class="highlight"><c- n>tuple</c-></code> and one <code class="highlight"><c- n>pair</c-></code> exist. 
      <td>
        Consider this code: 
<pre class="highlight"><c- k>constexpr</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- b>int</c-><c- o>&amp;</c-><c- p>,</c-> <c- b>double</c-><c- o>&amp;></c-> <c- n>bad_code</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>)</c->
<c- p>{</c->
  <c- k>auto</c-> <c- n>t</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- b>double</c-><c- o>></c-><c- p>{</c-><c- n>i</c-><c- p>,</c-> <c- mf>0.0</c-><c- p>};</c->
  <c- k>return</c-> <c- n>t</c-><c- p>;</c->
<c- p>}</c->

<c- b>int</c-> <c- n>main</c-><c- p>()</c->
<c- p>{</c->
   <c- k>auto</c-> <c- k>const</c-> <c- n>t</c-> <c- o>=</c-> <c- n>bad_code</c-><c- p>(</c-><c- mi>4</c-><c- p>);</c-> <c- c1>// BOOM! Undefined behaviour.</c->
   <c- k>auto</c-> <c- k>const</c-> <c- n>u</c-> <c- o>=</c-> <c- n>bad_code</c-><c- p>(</c-><c- mi>6</c-><c- p>);</c->
   <c- k>auto</c-> <c- k>const</c-> <c- n>tu</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>get</c-><c- o>&lt;</c-><c- mi>0</c-><c- o>></c-><c- p>(</c-><c- n>t</c-><c- p>)</c-> <c- o>+</c-> <c- n>std</c-><c- o>::</c-><c- n>get</c-><c- o>&lt;</c-><c- mi>0</c-><c- o>></c-><c- p>(</c-><c- n>u</c-><c- p>);</c->
   <c- n>CHECK</c-><c- p>(</c-><c- n>tu</c-> <c- o>==</c-> <c- mi>10</c-><c- p>);</c->
<c- p>}</c->
</pre>
       <p>This program is undefined; GCC’s <code class="highlight"><c- o>-</c-><c- n>Wuninitialized</c-></code> flag identifies this, and when coupled with <code class="highlight"><c- o>-</c-><c- n>Werror</c-></code>, can force a build to fail (this is good if, and only if <code class="highlight"><c- o>-</c-><c- n>Werror</c-></code> is enabled for this
warning). A naive programmer mightn’t be aware that they’re calling a conversion operator.</p>
       <p>While this may not be motivation for LEWG to avoid making the changes to <code class="highlight"><c- n>tuple</c-></code> directly, it is
certainly important to be aware of this issue.</p>
   </table>
   <h5 class="heading settled" data-level="4.1.2.2" id="pros-and-cons-for-introducing-an-exposition-only-__tuple_hack-and-possibly-__pair_hack"><span class="secno">4.1.2.2. </span><span class="content">Pros and cons for introducing an exposition-only <code class="highlight"><c- n>__tuple_hack</c-></code> (and possibly <code class="highlight"><c- n>__pair_hack</c-></code>)</span><a class="self-link" href="#pros-and-cons-for-introducing-an-exposition-only-__tuple_hack-and-possibly-__pair_hack"></a></h5>
   <table>
    <tbody>
     <tr>
      <th>Pros
      <th>Cons
     <tr>
      <td>Dangling issue resolved (users can’t directly use exposition-only types).
      <td>More library maintainer maintenance.
     <tr>
      <td>
      <td>More overloads for <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>get</c-></code>, <code class="highlight"><c- n>tuple_cat</c-></code>, etc.
   </table>
   <h5 class="heading settled" data-level="4.1.2.3" id="ensure-tuple-and-pair-assignment-operators-are-constexpr"><span class="secno">4.1.2.3. </span><span class="content">Ensure <code class="highlight"><c- n>tuple</c-></code> and <code class="highlight"><c- n>pair</c-></code> assignment operators are <code class="highlight"><c- k>constexpr</c-></code></span><a class="self-link" href="#ensure-tuple-and-pair-assignment-operators-are-constexpr"></a></h5>
   <p>To ensure that the <code class="highlight"><c- k>constexpr</c-></code>-ness of <code class="highlight"><c- n>zip_view</c-></code> is not accidentally inhibited, this paper also
requests that there be some discussion on making the assignment operators of <code class="highlight"><c- n>pair</c-></code> and <code class="highlight"><c- n>tuple</c-></code> <code class="highlight"><c- k>constexpr</c-></code>.</p>
   <h4 class="heading settled" data-level="4.1.3" id="example-implementation"><span class="secno">4.1.3. </span><span class="content">Example implementation</span><a class="self-link" href="#example-implementation"></a></h4>
   <p>The following implementation has been taken and modified from cmcstl2:</p>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>View</c-><c- p>...</c-> <c- n>Rs</c-><c- o>></c->
<c- k>struct</c-> <c- nl>zip_view</c-> <c- p>:</c-> <c- n>view_interface</c-><c- o>&lt;</c-><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>></c-> <c- p>{</c->
<c- k>private</c-><c- o>:</c-> <c- c1>// begin exposition-only</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- b>bool</c-> <c- n>Const</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Indices</c-><c- o>></c-> <c- k>struct</c-> <c- n>__zipperator</c-><c- p>;</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- b>bool</c-> <c- n>Const</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Indices</c-><c- o>></c-> <c- k>struct</c-> <c- n>__sentinel</c-><c- p>;</c->

   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_simple</c-> <c- o>=</c-> <c- p>(</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_forward</c-> <c- o>=</c-> <c- p>(</c-><c- n>ForwardRange</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_forward_const</c-> <c- o>=</c-> <c- p>(</c-><c- n>ForwardRange</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_sized</c-> <c- o>=</c-> <c- p>(</c-><c- n>SizedRange</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_sized_const</c-> <c- o>=</c-> <c- p>(</c-><c- n>SizedRange</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->

   <c- n>tuple</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-> <c- n>ranges_</c-> <c- p>{};</c->
<c- k>public</c-><c- o>:</c-><c- c1>// end exposition-only</c->
   <c- n>zip_view</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- nf>zip_view</c-><c- p>(</c-><c- n>Rs</c-><c- p>...</c-> <c- n>rs</c-><c- p>)</c->
   <c- k>noexcept</c-><c- p>((</c-><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...))</c->
   <c- n>requires</c-> <c- k>sizeof</c-><c- p>...(</c-><c- n>Rs</c-><c- p>)</c-> <c- o>!=</c-> <c- mi>0</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- n>begin</c-><c- p>();</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>all_forward_const</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_sized</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>all_sized_const</c-><c- p>;</c->
<c- p>};</c->

<c- k>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Rs</c-><c- o>></c->
<c- n>zip_view</c-><c- p>(</c-><c- n>Rs</c-><c- o>&amp;&amp;</c-><c- p>...)</c-> <c- o>-></c-> <c- n>zip_view</c-><c- o>&lt;</c-><c- n>all_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
</pre>
   <h5 class="heading settled" data-level="4.1.3.1" id="zip_view-constructors"><span class="secno">4.1.3.1. </span><span class="content"><code class="highlight"><c- n>zip_view</c-></code> constructors</span><a class="self-link" href="#zip_view-constructors"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>zip_view</c-><c- p>(</c-><c- n>Rs</c-><c- p>...</c-> <c- n>rs</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>(</c-><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- n>requires</c-> <c- p>(</c-><c- k>sizeof</c-><c- p>...(</c-><c- n>Rs</c-><c- p>)</c-> <c- o>!=</c-> <c- mi>0</c-><c- p>);</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>ranges_</c-></code> with <code class="highlight"><c- n>rs</c-><c- p>...</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.2" id="zip_view-begin"><span class="secno">4.1.3.2. </span><span class="content"><code class="highlight"><c- n>zip_view</c-></code> begin</span><a class="self-link" href="#zip_view-begin"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>();</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>all_forward_const</c-><c- p>;</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Effects</i>: Returns an iterator containing a tuple of iterators to the beginning of each
range, such that the first iterator corresponds to the beginning of the first range, the second
tuple corresponds to the beginning of the second range, and so on.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.3" id="zip_view-end"><span class="secno">4.1.3.3. </span><span class="content"><code class="highlight"><c- n>zip_view</c-></code> end</span><a class="self-link" href="#zip_view-end"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="3">
    <li data-md>
     <p><i>Effects</i>: Returns a sentinel containing a tuple of sentinels to the end of each range, such
that the first sentinel corresponds to the end of the first range, the second sentinel
corresponds to the end of the second range, and so on.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_sized</c-><c- p>;</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_sized_const</c-><c- p>;</c->
</pre>
   <ol start="4">
    <li data-md>
     <p><i>Effects</i>: Equivalent to returning the size of the smallest range in <code class="highlight"><c- n>ranges_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.4" id="zip_viewrs-iterator-exposition-only"><span class="secno">4.1.3.4. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-></code> iterator (exposition-only)</span><a class="self-link" href="#zip_viewrs-iterator-exposition-only"></a></h5>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>View</c-><c- p>...</c-> <c- n>Rs</c-><c- o>></c->
<c- k>template</c-><c- o>&lt;</c-><c- b>bool</c-> <c- n>Const</c-><c- p>,</c-> <c- b>size_t</c-><c- p>...</c-> <c- n>Is</c-><c- o>></c->
<c- k>struct</c-> <c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- n>index_sequence</c-><c- o>&lt;</c-><c- n>Is</c-><c- p>...</c-><c- o>>></c-> <c- p>{</c->
<c- k>private</c-><c- o>:</c->
   <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- o>></c->
   <c- k>using</c-> <c- n>maybe_const</c-> <c- o>=</c-> <c- n>conditional_t</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- n>R</c-> <c- k>const</c-><c- p>,</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->

   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_random_access</c-> <c- o>=</c->
      <c- p>(</c-><c- n>RandomAccessRange</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_bidi</c-> <c- o>=</c->
      <c- p>(</c-><c- n>BidirectionalRange</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_forward</c-> <c- o>=</c->
      <c- p>(</c-><c- n>ForwardRange</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_input</c-> <c- o>=</c->
      <c- p>(</c-><c- n>InputRange</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->

   <c- k>static_assert</c-><c- p>(</c-><c- o>!</c-><c- n>Const</c-> <c- o>||</c-> <c- n>all_forward</c-><c- p>);</c->
   <c- k>static_assert</c-><c- p>(</c-><c- n>Same</c-><c- o>&lt;</c-><c- n>index_sequence_for</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-><c- p>,</c->
      <c- n>index_sequence</c-><c- o>&lt;</c-><c- n>Is</c-><c- p>...</c-><c- o>>></c-><c- p>);</c->

   <c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>*</c-> <c- n>parent_</c-> <c- o>=</c-> <c- k>nullptr</c-><c- p>;</c->
   <c- n>tuple</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-><c- p>...</c-><c- o>></c-> <c- n>iterators_</c-><c- p>{};</c->
<c- k>public</c-><c- o>:</c->
   <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- n>tuple</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-><c- p>...</c-><c- o>></c-><c- p>;</c->
   <c- k>using</c-> <c- n>iterator_category</c-> <c- o>=</c-> <c- n>see</c-><c- o>-</c-><c- n>below</c-><c- p>;</c->
   <c- k>using</c-> <c- n>difference_type</c-> <c- o>=</c-> <c- n>see</c-><c- o>-</c-><c- n>below</c-><c- p>;</c->

   <c- n>__zipperator</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
   <c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>__zipperator</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>);</c->
   <c- k>constexpr</c-> <c- nf>__zipperator</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- nf>__zipperator</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>,</c-> <c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- o>*</c-><c- p>();</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- o>*</c-><c- p>()</c-> <c- k>const</c->
   <c- n>requires</c-> <c- p>(</c-><c- n>dereferenceable</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->

   <c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>++</c-><c- p>();</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- o>++</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->

   <c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>--</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_bidi</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>--</c-><c- p>(</c-><c- b>int</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_bidi</c-><c- p>;</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c->
   <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c->
   <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>&lt;</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>></c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>&lt;=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>>=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>+</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>+</c-><c- p>(</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>-</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- n>difference_type</c-> <c- k>operator</c-><c- o>-</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c->
   <c- n>requires</c-> <c- p>(</c-><c- n>SizedSentinel</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- p>[](</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>iter_move</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c->
   <c- n>requires</c-> <c- p>((</c-><c- n>Readable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...));</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>void</c-> <c- nf>iter_swap</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>);</c->
   <c- n>requires</c-> <c- p>(</c-><c- n>IndirectlySwappable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
<c- p>};</c->
</pre>
   <h5 class="heading settled" data-level="4.1.3.5" id="zip_view__zipperator-members"><span class="secno">4.1.3.5. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> members</span><a class="self-link" href="#zip_view__zipperator-members"></a></h5>
<pre class="language-cpp highlight"><c- k>using</c-> <c- n>iterator_category</c-> <c- o>=</c-> <c- n>see</c-><c- o>-</c-><c- n>below</c-><c- p>;</c->
</pre>
   <ol start="5">
    <li data-md>
     <p><i>Effects</i>: If <code class="highlight"><c- p>(</c-><c- n>RandomAccessRange</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c-></code> is satisfied, then <code class="highlight"><c- n>iterator_category</c-></code> denotes <code class="highlight"><c- n>random_access_iterator_tag</c-></code>. Otherwise, if <code class="highlight"><c- p>(</c-><c- n>BidirectionalRange</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c-></code>, then <code class="highlight"><c- n>iterator_category</c-></code> denotes <code class="highlight"><c- n>bidirectional_iterator_tag</c-></code>. Otherwise, if <code class="highlight"><c- p>(</c-><c- n>ForwardRange</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c-></code>, then <code class="highlight"><c- n>iterator_category</c-></code> denotes <code class="highlight"><c- n>forward_iterator_category</c-></code>.
Otherwise, if <code class="highlight"><c- p>(</c-><c- n>InputRange</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c-></code> is satisfied, then <code class="highlight"><c- n>iterator_category</c-></code> denotes <code class="highlight"><c- n>input_iterator_tag</c-></code>. Otherwise, <code class="highlight"><c- n>iterator_category</c-></code> denotes <code class="highlight"><c- n>output_iterator_category</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>using</c-> <c- n>difference_type</c-> <c- o>=</c-> <c- n>see</c-><c- o>-</c-><c- n>below</c-><c- p>;</c->
</pre>
   <ol start="6">
    <li data-md>
     <p><i>Effects</i>: If <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Rs</c-><c- p>)</c-> <c- o>==</c-> <c- mi>0</c-></code>, then <code class="highlight"><c- n>difference_type</c-></code> denotes <code class="highlight"><c- b>int</c-></code>. Otherwise, <code class="highlight"><c- n>difference_type</c-></code> denotes <code class="highlight"><c- n>common_type_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>conditional_t</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- k>const</c-> <c- n>Rs</c-><c- p>,</c-> <c- n>Rs</c-><c- o>>></c-><c- p>...</c-><c- o>></c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.6" id="zip_view__zipperator-constructors"><span class="secno">4.1.3.6. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> constructors</span><a class="self-link" href="#zip_view__zipperator-constructors"></a></h5>
<pre class="language-cpp highlight"><c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>__zipperator</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>);</c->
</pre>
   <ol start="7">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>parent_</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>parent</c-><c- p>)</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>__zipperator</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
</pre>
   <ol start="8">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>parent_</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>parent</c-><c- p>)</c-></code> and <code class="highlight"><c- n>iterators_</c-></code> with the
iterator to the first element in each range (respectively).</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>__zipperator</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>,</c-> <c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="9">
    <li data-md>
     <p><i>Effects</i>: Initiaises <code class="highlight"><c- n>parent_</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>parent</c-><c- p>)</c-></code> and <code class="highlight"><c- n>iterators_</c-></code> with the <i>n</i>th iterator to each range (respectively). For any range <code class="highlight"><c- n>r</c-></code> in <code class="highlight"><c- n>Rs</c-><c- p>...</c-></code>, a program is
undefined if <code class="highlight"><c- n>n</c-> <c- o>></c-> <c- n>size</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.7" id="zip_view__zipperator-element-access"><span class="secno">4.1.3.7. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> element access</span><a class="self-link" href="#zip_view__zipperator-element-access"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- o>*</c-><c- p>();</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- o>*</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="10">
    <li data-md>
     <p><i>Effects</i>: Returns a tuple of references to the elements of each range denoted by <code class="highlight"><c- o>*</c-><c- n>i</c-></code> for
each iterator in the <code class="highlight"><c- n>__zipperator</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- p>[](</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="11">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- o>*</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-> <c- o>+</c-> <c- n>n</c-><c- p>);</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.8" id="zip_view__zipperator-advance"><span class="secno">4.1.3.8. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> advance</span><a class="self-link" href="#zip_view__zipperator-advance"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>++</c-><c- p>();</c->
</pre>
   <ol start="9">
    <li data-md>
     <p><i>Effects</i>: Equivalent to incrementing each iterator in <code class="highlight"><c- n>iterators_</c-></code>.</p>
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- k>operator</c-><c- o>++</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->
</pre>
   <ol start="13">
    <li data-md>
     <p><i>Effects</i>: Equivalent to:</p>
   </ol>
<pre class="language-cpp highlight"><c- k>if</c-> <c- nf>constexpr</c-> <c- p>(</c-><c- n>all_forward</c-><c- p>)</c-> <c- p>{</c->
   <c- k>auto</c-> <c- n>temp</c-> <c- o>=</c-> <c- o>*</c-><c- k>this</c-><c- p>;</c->
   <c- o>++*</c-><c- k>this</c-><c- p>;</c->
   <c- k>return</c-> <c- n>temp</c-><c- p>;</c->
<c- p>}</c->
<c- k>else</c-> <c- p>{</c->
   <c- o>++*</c-><c- k>this</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <br> 
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>--</c-><c- p>()</c-> <c- n>requires</c-> <c- n>all_bidi</c-><c- p>;</c->
</pre>
   <ol start="14">
    <li data-md>
     <p><i>Effects</i>: Equivalent to decrementing each iterator in <code class="highlight"><c- n>iterators_</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>--</c-><c- p>(</c-><c- b>int</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_bidi</c-><c- p>;</c->
</pre>
   <ol start="15">
    <li data-md>
     <p><i>Effects</i>: Equivalent to:</p>
   </ol>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- n>temp</c-> <c- o>=</c-> <c- o>*</c-><c- k>this</c-><c- p>;</c->
<c- o>--*</c-><c- k>this</c-><c- p>;</c->
<c- k>return</c-> <c- n>temp</c-><c- p>;</c->
</pre>
   <br> 
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="16">
    <li data-md>
     <p><i>Effects</i>: Equivalent to calling <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>advance</c-><c- p>(</c-><c- n>E</c-><c- p>,</c-> <c- n>n</c-><c- p>)</c-></code> on each iterator in <code class="highlight"><c- n>iterators_</c-></code>,
where <code class="highlight"><c- n>E</c-></code> is a placeholder for the iterator expression.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="17">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- o>*</c-><c- k>this</c-> <c- o>+=</c-> <c- o>-</c-><c- n>n</c-><c- p>;</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.9" id="zip_view__zipperator-comparisons"><span class="secno">4.1.3.9. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>::</c-><c- n>__zipperator</c-></code> comparisons</span><a class="self-link" href="#zip_view__zipperator-comparisons"></a></h5>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
</pre>
   <ol start="18">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>x</c-><c- p>.</c-><c- n>iterators_</c-> <c- o>==</c-> <c- n>y</c-><c- p>.</c-><c- n>iterators_</c-><c- p>;</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
</pre>
   <ol start="19">
    <li data-md>
     <p><i>Effets</i>: Returns <code class="highlight">true</code> if at least one iterator in <code class="highlight"><c- n>iterators_</c-></code> is equivalent to the
sentinel of its corresponding range, <code class="highlight">false</code> otherwise.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
</pre>
   <ol start="20">
    <li data-md>
     <p><i>Effects</i>: Returns <code class="highlight">true</code> if at least one iterator in <code class="highlight"><c- n>iterators_</c-></code> is equivalent to the
sentinel.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- o>!</c-><c- n>all_forward</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>Sent</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_forward</c-><c- p>;</c->
</pre>
   <ol start="21">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- o>!</c-><c- p>(</c-><c- n>x</c-> <c- o>==</c-> <c- n>y</c-><c- p>);</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>&lt;</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="22">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>x</c-><c- p>.</c-><c- n>iterators_</c-> <c- o>&lt;</c-> <c- n>y</c-><c- p>.</c-><c- n>iterators_</c-><c- p>;</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>></c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="23">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>y</c-> <c- o>&lt;</c-> <c- n>x</c-><c- p>;</c-></code></p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>&lt;=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="24">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- o>!</c-><c- p>(</c-><c- n>y</c-> <c- o>&lt;</c-> <c- n>x</c-><c- p>);</c-></code></p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>>=</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="25">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- o>!</c-><c- p>(</c-><c- n>x</c-> <c- o>&lt;</c-> <c- n>y</c-><c- p>);</c-></code></p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.10" id="zip_viewrs__zipperator-arithmetic"><span class="secno">4.1.3.10. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-></code> arithmetic</span><a class="self-link" href="#zip_viewrs__zipperator-arithmetic"></a></h5>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>+</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
<c- k>friend</c-> <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>+</c-><c- p>(</c-><c- n>difference_type</c-> <c- n>n</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="26">
    <li data-md>
     <p><i>Effects</i>: Equivalent to:</p>
   </ol>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- n>temp</c-> <c- o>=</c-> <c- n>x</c-><c- p>;</c->
<c- n>temp</c-> <c- o>+=</c-> <c- n>n</c-><c- p>;</c->
<c- k>return</c-> <c- n>temp</c-><c- p>;</c->
</pre>
   <br> 
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- n>__zipperator</c-> <c- k>operator</c-><c- o>-</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>difference_type</c-> <c- n>n</c-><c- p>)</c-> <c- n>requires</c-> <c- n>all_random_access</c-><c- p>;</c->
</pre>
   <ol start="27">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>x</c-> <c- o>+</c-> <c- o>-</c-><c- n>n</c-><c- p>;</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- n>difference_type</c-> <c- k>operator</c-><c- o>-</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c->
<c- n>requires</c-> <c- p>(</c-><c- n>SizedSentinel</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c->
</pre>
   <ol start="28">
    <li data-md>
     <p><i>Effects</i>: If <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Rs</c-><c- p>)</c-> <c- o>==</c-> <c- mi>0</c-></code>, then returns 0. Otherwise returns the greatest distance
between iterators in <code class="highlight"><c- n>x</c-><c- p>.</c-><c- n>iterators_</c-></code> and <code class="highlight"><c- n>y</c-><c- p>.</c-><c- n>iterators_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.11" id="zip_viewrs__zipperator-iter_move"><span class="secno">4.1.3.11. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-></code> iter_move</span><a class="self-link" href="#zip_viewrs__zipperator-iter_move"></a></h5>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>iter_move</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>)</c-> <c- n>requires</c-> <c- p>((</c-><c- n>Readable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...));</c->
</pre>
   <ol start="29">
    <li data-md>
     <p><i>Effects</i>: Returns a tuple containing expressions equivalent to <code class="highlight"><c- n>iter_move</c-></code> applied to each
of <code class="highlight"><c- n>x</c-><c- p>.</c-><c- n>iterators_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.12" id="zip_viewrs__zipperator-iter_swap"><span class="secno">4.1.3.12. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__zipperator</c-></code> iter_swap</span><a class="self-link" href="#zip_viewrs__zipperator-iter_swap"></a></h5>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>void</c-> <c- nf>iter_swap</c-><c- p>(</c-><c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__zipperator</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>)</c->
<c- n>requires</c-> <c- p>(</c-><c- n>IndirectlySwappable</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
</pre>
   <ol start="30">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- n>iter_swap</c-></code> applied to each iterator in <code class="highlight"><c- n>x</c-><c- p>.</c-><c- n>iterators_</c-></code> and <code class="highlight"><c- n>y</c-><c- p>.</c-><c- n>iterators_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.1.3.13" id="zip_viewrs-sentinel-exposition-only"><span class="secno">4.1.3.13. </span><span class="content"><code class="highlight"><c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-></code> sentinel (exposition-only)</span><a class="self-link" href="#zip_viewrs-sentinel-exposition-only"></a></h5>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>View</c-><c- p>...</c-> <c- n>Rs</c-><c- o>></c->
<c- k>template</c-><c- o>&lt;</c-><c- b>bool</c-> <c- n>Const</c-><c- p>,</c-> <c- b>size_t</c-><c- p>...</c-> <c- n>Is</c-><c- o>></c->
<c- k>struct</c-> <c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- n>__sentinel</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- n>index_sequence</c-><c- o>&lt;</c-><c- n>Is</c-><c- p>...</c-><c- o>>></c-> <c- p>{</c->
<c- k>private</c-><c- o>:</c->
   <c- k>using</c-> <c- n>Iter</c-> <c- o>=</c-> <c- k>typename</c-> <c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>::</c-><c- k>template</c->
      <c- n>__zipperator</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- n>index_sequence</c-><c- o>&lt;</c-><c- n>Is</c-><c- p>...</c-><c- o>>></c-><c- p>;</c->
   <c- k>friend</c-> <c- n>Iter</c-><c- p>;</c->

   <c- k>using</c-> <c- n>Parent</c-> <c- o>=</c-> <c- n>conditional_t</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- k>const</c-> <c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-><c- p>,</c-> <c- n>zip_view</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>>></c-><c- p>;</c->
   <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- n>all_forward</c-> <c- o>=</c->
      <c- p>(</c-><c- n>ForwardRange</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-> <c- o>&amp;&amp;</c-> <c- p>...);</c->
   <c- k>static_assert</c-><c- p>(</c-><c- n>all_forward</c-><c- p>);</c->
   <c- k>static_assert</c-><c- p>(</c-><c- n>Same</c-><c- o>&lt;</c-><c- n>index_sequence_for</c-><c- o>&lt;</c-><c- n>Rs</c-><c- p>...</c-><c- o>></c-><c- p>,</c->
      <c- n>index_sequence</c-><c- o>&lt;</c-><c- n>Is</c-><c- p>...</c-><c- o>>></c-><c- p>);</c->

   <c- n>tuple</c-><c- o>&lt;</c-><c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>maybe_const</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>>></c-><c- p>...</c-><c- o>></c-> <c- n>last_</c-><c- p>;</c->
<c- k>public</c-><c- o>:</c->
   <c- n>__sentinel</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
   <c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>__sentinel</c-><c- p>(</c-><c- n>Parent</c-><c- o>&amp;</c-> <c- n>parent</c-><c- p>);</c->
<c- p>};</c->
</pre>
   <h3 class="heading settled" data-level="4.2" id="viewzip"><span class="secno">4.2. </span><span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>zip</c-></code></span><a class="self-link" href="#viewzip"></a></h3>
   <p>The name <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>zip</c-></code> denotes a range view adaptor. Let <code class="highlight"><c- n>rs</c-><c- p>...</c-></code> denote a pack expansion of the
parameter pack <code class="highlight"><c- n>Rs</c-><c- p>...</c-></code>. Then, the expression <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>zip</c-><c- p>(</c-><c- n>rs</c-><c- p>...)</c-></code> is
expression-equivalent to:</p>
   <ol>
    <li data-md>
     <p><code class="highlight"><c- n>zip_view</c-><c- p>{</c-><c- n>rs</c-><c- p>...}</c-></code> if <code class="highlight"><c- p>(</c-><c- n>Range</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c-> <c- o>&amp;&amp;</c-> <c- p>(</c-><c- n>is_object_v</c-><c- o>&lt;</c-><c- n>Rs</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...)</c-></code> is satisfied.</p>
    <li data-md>
     <p>Otherwise <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>zip</c-><c- p>(</c-><c- n>rs</c-><c- p>...)</c-></code> is ill-formed.</p>
   </ol>
   <h3 class="heading settled" data-level="4.3" id="basic_istream_view"><span class="secno">4.3. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code></span><a class="self-link" href="#basic_istream_view"></a></h3>
   <h4 class="heading settled" data-level="4.3.1" id="motivation②"><span class="secno">4.3.1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation②"></a></h4>
   <p><code class="highlight"><c- n>istream_iterator</c-></code> is an abstraction over a <code class="highlight"><c- n>basic_istream</c-></code> object, so that it may be used as though
it were an input iterator. It is a great way to populate a container from the get-go, or fill a
container later in its lifetime. This is great, as copy is a standard algorithm that cleanly
communicates that we’re copying something from one range into another. There aren’t any Hidden
Surprises<sup>TM</sup>. This is also good when writing generic code, because the generic library
author does not need to care how things are inserted at the end of <code class="highlight"><c- n>v</c-></code>, only that they are.</p>
   <table>
    <tbody>
     <tr>
      <th>Without <code class="highlight"><c- n>istream_iterator</c-></code>
      <th>With <code class="highlight"><c- n>istream_iterator</c-></code>
     <tr>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- p>[]{</c->
   <c- k>auto</c-> <c- n>result</c-> <c- o>=</c-> <c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{};</c->
   <c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>cin</c-> <c- o>>></c-> <c- n>i</c-><c- p>;)</c-> <c- p>{</c->
      <c- n>result</c-><c- p>.</c-><c- n>push_back</c-><c- p>(</c-><c- n>i</c-><c- p>);</c->
   <c- p>}</c->
<c- p>}();</c->
<c- c1>// ...</c->
<c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>cin</c-> <c- o>>></c-> <c- n>i</c-><c- p>;)</c-> <c- p>{</c->
   <c- n>result</c-><c- p>.</c-><c- n>push_back</c-><c- p>(</c-><c- n>i</c-><c- p>);</c->
<c- p>}</c->
  
</pre>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>vector</c-><c- p>(</c-><c- n>istream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{</c-><c- n>cin</c-><c- p>},</c->
   <c- n>istream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{});</c->
<c- c1>// ...</c->
<c- n>copy</c-><c- p>(</c-><c- n>istream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{</c-><c- n>cin</c-><c- p>},</c->
   <c- n>istream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{},</c->
   <c- n>back_inserter</c-><c- p>(</c-><c- n>v</c-><c- p>));</c->
  
</pre>
   </table>
   <p>The problem with <code class="highlight"><c- n>istream_iterator</c-></code> is that we need to provide a bogus <code class="highlight"><c- n>istream_iterator</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>{}</c-></code> (or <code class="highlight"><c- n>default_sentinel</c-><c- p>{}</c-></code>) every time we want to use it; this acts as the sentinel for <code class="highlight"><c- n>istream_iterator</c-></code>. It is bogus, because the code is equivalent to saying "from the first element of
the istream range until the last element of the istream range", but an <code class="highlight"><c- n>istream</c-></code> range does not have
a last element. Instead, we denote the end of an istream range to be when the <code class="highlight"><c- n>istream</c-></code>'s failbit is
set. This is otherwise known as the <i>end-of-stream</i> iterator value, but it doesn’t denote a
'past-the-last element' in the same way that call to <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>end</c-></code> does. Because it is the same
for every range, the <i>end-of-stream</i> object may as well be dropped, so that we can write code
that resembles the code below.</p>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>vector</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>istream_view</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{</c-><c- n>cin</c-><c- p>});</c->
<c- c1>// ...</c->
<c- n>copy</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>istream_view</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>{</c-><c- n>cin</c-><c- p>},</c-> <c- n>back_inserter</c-><c- p>(</c-><c- n>v</c-><c- p>));</c->
</pre>
   <p>This code is cleaner: we are implicitly saying "until our <code class="highlight"><c- n>basic_istream</c-></code> object fails, insert our
input into the back of <code class="highlight"><c- n>v</c-></code>". There is less to read (and type!), and the code is simpler for it.</p>
   <h4 class="heading settled" data-level="4.3.2" id="interface"><span class="secno">4.3.2. </span><span class="content">Interface</span><a class="self-link" href="#interface"></a></h4>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-> <c- o>=</c-> <c- b>char</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-> <c- o>=</c-> <c- n>char_traits</c-><c- o>&lt;</c-><c- n>CharT</c-><c- o>>></c->
<c- n>concept</c-> <c- n>StreamExtractable</c-> <c- o>=</c-> <c- n>see</c-><c- o>-</c-><c- n>below</c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-> <c- o>=</c-> <c- b>char</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-> <c- o>=</c-> <c- n>char_traits</c-><c- o>&lt;</c-><c- n>CharT</c-><c- o>>></c->
<c- n>concept</c-> <c- n>StreamInsertable</c-> <c- o>=</c-> <c- n>see</c-><c- o>-</c-><c- n>below</c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>Semiregular</c-> <c- n>Val</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-> <c- o>=</c-> <c- n>char_traits</c-><c- o>&lt;</c-><c- n>CharT</c-><c- o>>></c->
<c- n>requires</c-> <c- n>StreamExtractable</c-><c- o>&lt;</c-><c- n>Val</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>></c->
<c- k>class</c-> <c- nc>basic_istream_view</c-> <c- o>:</c-> <c- k>public</c-> <c- n>view_interface</c-><c- o>&lt;</c-><c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>Val</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>></c-> <c- p>{</c->
<c- k>public</c-><c- o>:</c->
   <c- n>basic_istream_view</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->

   <c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>basic_istream_view</c-><c- p>(</c-><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>&amp;</c-> <c- n>stream</c-><c- p>);</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>();</c->
   <c- k>constexpr</c-> <c- n>default_sentinel</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
<c- k>private</c-><c- o>:</c->
   <c- k>struct</c-> <c- n>__iterator</c-><c- p>;</c-> <c- c1>// exposition-only</c->
   <c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>*</c-> <c- n>stream_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
   <c- n>Val</c-> <c- n>object_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-><c- o>></c->
<c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>></c-> <c- n>istream_view</c-><c- p>(</c-><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>&amp;</c-> <c- n>in</c-><c- p>);</c->
</pre>
   <h5 class="heading settled" data-level="4.3.2.1" id="concept-streamextractable"><span class="secno">4.3.2.1. </span><span class="content">Concept <code class="highlight"><c- n>StreamExtractable</c-></code></span><a class="self-link" href="#concept-streamextractable"></a></h5>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-> <c- o>=</c-> <c- b>char</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-> <c- o>=</c-> <c- n>char_traits</c-><c- o>&lt;</c-><c- n>CharT</c-><c- o>>></c->
<c- n>concept</c-> <c- n>StreamExtractable</c-> <c- o>=</c->
   <c- n>requires</c-><c- p>(</c-><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>&amp;</c-> <c- n>is</c-><c- p>,</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>t</c-><c- p>)</c-> <c- p>{</c->
      <c- p>{</c-> <c- n>is</c-> <c- o>>></c-> <c- n>t</c-> <c- p>}</c-> <c- o>-></c-> <c- n>Same</c-><c- o>&lt;</c-><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>>&amp;</c-><c- p>;</c->
   <c- p>};</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Remarks</i>: <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>is</c-><c- p>)</c-> <c- o>==</c-> <c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>is</c-> <c- o>&lt;&lt;</c-> <c- n>t</c-><c- p>)</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.2" id="concept-streaminsertable"><span class="secno">4.3.2.2. </span><span class="content">Concept <code class="highlight"><c- n>StreamInsertable</c-></code></span><a class="self-link" href="#concept-streaminsertable"></a></h5>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-> <c- o>=</c-> <c- b>char</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-> <c- o>=</c-> <c- n>char_traits</c-><c- o>&lt;</c-><c- n>CharT</c-><c- o>>></c->
<c- n>concept</c-> <c- n>StreamInsertable</c-> <c- o>=</c->
   <c- n>requires</c-><c- p>(</c-><c- n>basic_ostream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>&amp;</c-> <c- n>os</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>t</c-><c- p>)</c-> <c- p>{</c->
      <c- p>{</c-> <c- n>os</c-> <c- o>&lt;&lt;</c-> <c- n>t</c-> <c- p>}</c-> <c- o>-></c-> <c- n>Same</c-><c- o>&lt;</c-><c- n>basic_ostream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>>&amp;</c-><c- p>;</c->
   <c- p>};</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Remarks</i>: <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>os</c-><c- p>)</c-> <c- o>==</c-> <c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>os</c-> <c- o>>></c-> <c- n>t</c-><c- p>)</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.3" id="basic_istream_view-constructor"><span class="secno">4.3.2.3. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> constructor</span><a class="self-link" href="#basic_istream_view-constructor"></a></h5>
<pre class="language-cpp highlight"><c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>basic_istream_view</c-><c- p>(</c-><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>&amp;</c-> <c- n>stream</c-><c- p>);</c->
</pre>
   <ol start="3">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>stream_</c-></code> to <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>stream</c-><c- p>)</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.4" id="basic_istream_view-begin"><span class="secno">4.3.2.4. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> begin</span><a class="self-link" href="#basic_istream_view-begin"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>();</c->
</pre>
   <ol start="4">
    <li data-md>
     <p><i>Effects</i>: Equivalent to</p>
   </ol>
<pre class="language-cpp highlight"><c- o>*</c-><c- n>stream_</c-> <c- o>>></c-> <c- n>object_</c-><c- p>;</c->
<c- k>return</c-> <c- n>__iterator</c-><c- p>{</c-><c- o>*</c-><c- k>this</c-><c- p>};</c->
</pre>
   <h5 class="heading settled" data-level="4.3.2.5" id="basic_istream_view-end"><span class="secno">4.3.2.5. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> end</span><a class="self-link" href="#basic_istream_view-end"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>default_sentinel</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
   <ol start="5">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- n>default_sentinel</c-><c- p>{}</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.6" id="basic_istream_view__iterator"><span class="secno">4.3.2.6. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code></span><a class="self-link" href="#basic_istream_view__iterator"></a></h5>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>Val</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-><c- o>></c->
<c- k>class</c-> <c- nc>basic_istream_view</c-><c- o>&lt;</c-><c- n>Val</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>::</c-><c- n>__iterator</c-> <c- p>{</c->
<c- k>public</c-><c- o>:</c->
   <c- k>using</c-> <c- n>iterator_category</c-> <c- o>=</c-> <c- n>input_iterator_tag</c-><c- p>;</c->
   <c- k>using</c-> <c- n>difference_type</c-> <c- o>=</c-> <c- b>ptrdiff_t</c-><c- p>;</c->
   <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- n>Val</c-><c- p>;</c->

   <c- n>__iterator</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->

   <c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>__iterator</c-><c- p>(</c-><c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>Val</c-><c- o>>&amp;</c-> <c- n>parent</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->

   <c- n>__iterator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>++</c-><c- p>();</c->
   <c- b>void</c-> <c- k>operator</c-><c- o>++</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->

   <c- n>Val</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->

   <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>__iterator</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-><c- p>);</c->
   <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- n>__iterator</c-> <c- n>x</c-><c- p>);</c->
   <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>__iterator</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-> <c- n>y</c-><c- p>);</c->
   <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- n>__iterator</c-> <c- n>x</c-><c- p>);</c->
<c- k>private</c-><c- o>:</c->
   <c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>Val</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>*</c-> <c- n>parent_</c-> <c- o>=</c-> <c- k>nullptr</c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- p>};</c->
</pre>
   <h5 class="heading settled" data-level="4.3.2.7" id="basic_istream_view__iterator-constructor"><span class="secno">4.3.2.7. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> constructor</span><a class="self-link" href="#basic_istream_view__iterator-constructor"></a></h5>
<pre class="language-cpp highlight"><c- k>explicit</c-> <c- k>constexpr</c-> <c- nf>__iterator</c-><c- p>(</c-><c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>Val</c-><c- o>>&amp;</c-> <c- n>parent</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
   <ol start="6">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>parent_</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>parent_</c-><c- p>)</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.8" id="basic_istream_view__iterator-next"><span class="secno">4.3.2.8. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> next</span><a class="self-link" href="#basic_istream_view__iterator-next"></a></h5>
<pre class="language-cpp highlight"><c- n>__iterator</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>++</c-><c- p>();</c->
<c- b>void</c-> <c- k>operator</c-><c- o>++</c-><c- p>(</c-><c- b>int</c-><c- p>);</c->
</pre>
   <ol start="7">
    <li data-md>
     <p><i>Effects</i>: Equivalent to</p>
   </ol>
<pre class="language-cpp highlight"><c- o>*</c-><c- n>parent_</c-><c- o>-></c-><c- n>stream_</c-> <c- o>>></c-> <c- n>parent_</c-><c- o>-></c-><c- n>object_</c-><c- p>;</c->
</pre>
   <h5 class="heading settled" data-level="4.3.2.9" id="basic_istream_view__iterator-value"><span class="secno">4.3.2.9. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> value</span><a class="self-link" href="#basic_istream_view__iterator-value"></a></h5>
<pre class="language-cpp highlight"><c- n>Val</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="8">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>parent_</c-><c- o>-></c-><c- n>value_</c-><c- p>;</c-></code></p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.10" id="basic_istream_view__iterator-comparison-functions"><span class="secno">4.3.2.10. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-><c- o>::</c-><c- n>__iterator</c-></code> comparison functions</span><a class="self-link" href="#basic_istream_view__iterator-comparison-functions"></a></h5>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>__iterator</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-><c- p>);</c->
</pre>
   <ol start="9">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- o>!*</c-><c- n>x</c-><c- p>.</c-><c- n>parent_</c-><c- o>-></c-><c- n>stream_</c-><c- p>;</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- n>__iterator</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <ol start="10">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- n>x</c-> <c- o>==</c-> <c- n>y</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>__iterator</c-> <c- n>x</c-><c- p>,</c-> <c- n>default_sentinel</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <ol start="11">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- o>!</c-><c- p>(</c-><c- n>x</c-> <c- o>==</c-> <c- n>y</c-><c- p>)</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>default_sentinel</c-> <c- n>y</c-><c- p>,</c-> <c- n>__iterator</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <ol start="12">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- o>!</c-><c- p>(</c-><c- n>x</c-> <c- o>==</c-> <c- n>y</c-><c- p>)</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.3.2.11" id="basic_istream_view-factory"><span class="secno">4.3.2.11. </span><span class="content"><code class="highlight"><c- n>basic_istream_view</c-></code> factory</span><a class="self-link" href="#basic_istream_view-factory"></a></h5>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- k>class</c-> <c- nc>CharT</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Traits</c-><c- o>></c->
<c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>></c-> <c- n>istream_view</c-><c- p>(</c-><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>>&amp;</c-> <c- n>s</c-><c- p>);</c->
</pre>
   <ol start="13">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>basic_istream_view</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>CharT</c-><c- p>,</c-> <c- n>Traits</c-><c- o>></c-><c- p>{</c-><c- n>s</c-><c- p>};</c-></code>.</p>
   </ol>
   <h3 class="heading settled" data-level="4.4" id="introducing-associated-types-for-ranges"><span class="secno">4.4. </span><span class="content">Introducing associated types for ranges</span><a class="self-link" href="#introducing-associated-types-for-ranges"></a></h3>
   <p><b>Note: This section was formerly titled <i>Reviewing <code class="highlight"><c- n>iter_value_t</c-></code>, etc., and introducing <code class="highlight"><c- n>range_value_t</c-></code>, etc.</i> in P1035R1, but the current title is more accurate.</b></p>
   <p><a data-link-type="biblio" href="#biblio-p1037">[P1037]</a> introduced <code class="highlight"><c- n>iter_difference_t</c-></code>, <code class="highlight"><c- n>iter_value_t</c-></code>, <code class="highlight"><c- n>iter_reference_t</c-></code>, and <code class="highlight"><c- n>iter_rvalue_reference_t</c-></code>, which dispatch to templates that correclty identify the associated
types for iterators (formerly known as iterator traits). The current mechanism supports iterators,
but not ranges. For example, in order to extract an range’s value type, we are required to do one of
three things:</p>
   <ol>
    <li> Use the traditional <code class="highlight"><c- k>typename</c-> <c- n>T</c-><c- o>::</c-><c- n>value_type</c-></code>. As we have had template aliases since C++11,
      this has probably been abandoned in many projects (not cited). 
    <li>
      Define our own associated type à la 
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
<c- n>requires</c-> <c- n>requires</c-> <c- p>{</c-> <c- k>typename</c-> <c- n>T</c-><c- o>::</c-><c- n>value_type</c-><c- p>;</c-> <c- p>}</c->
<c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- k>typename</c-> <c- n>T</c-><c- o>::</c-><c- n>value_type</c-><c- p>;</c->
</pre>
     <p>This was apparently possible in the Ranges TS (albeit in much more detail) <a data-link-type="biblio" href="#biblio-iterassoctypesvalue_type">[iter.assoc.types.value_type]</a>, but P1037 has redefined <code class="highlight"><c- n>value_type_t</c-></code> as <code class="highlight"><c- n>iter_value_t</c-></code>, which
focuses on iterators, rather than anything defining <code class="highlight"><c- n>value_type</c-></code> alias. We <i>could</i> do this in
C++20, but we then risk <code class="highlight"><c- n>R</c-><c- o>::</c-><c- n>value_type</c-></code> being different to <code class="highlight"><c- n>R</c-><c- o>::</c-><c- n>iterator</c-><c- o>::</c-><c- n>value_type</c-></code> (consider <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-> <c- k>const</c-><c- o>>::</c-><c- n>value_type</c-></code> and <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-> <c- k>const</c-><c- o>>::</c-><c- n>iterator</c-><c- o>::</c-><c- n>value_type</c-></code>, which are <code class="highlight"><c- b>int</c-> <c- k>const</c-></code> and <code class="highlight"><c- b>int</c-></code>, respectively)<a data-link-type="biblio" href="#biblio-value_type">[value_type]</a>.</p>
    <li> Use <code class="highlight"><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-></code>, which what we probably want, and is also a mouthful. 
   </ol>
   <p>When discussing extending <code class="highlight"><c- n>iter_value_t</c-></code> so that it can also operate on ranges, Casey Carter had
this to say:</p>
   <blockquote>
     What should <code class="highlight"><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> be when <code class="highlight"><c- n>T</c-></code> is an iterator with value type <code class="highlight"><c- n>U</c-></code> and a range with
   value type <code class="highlight"><c- n>V</c-></code>? 
    <p>Alternately: What is <code class="highlight"><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>array</c-><c- o>&lt;</c-><c- k>const</c-> <c- b>int</c-><c- o>>></c-></code>? <code class="highlight"><c- n>array</c-><c- o>&lt;</c-><c- k>const</c-> <c- b>int</c-><c- o>>::</c-><c- n>value_type</c-></code> is <code class="highlight"><c- k>const</c-> <c- b>int</c-></code>, but <code class="highlight"><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>array</c-><c- o>&lt;</c-><c- k>const</c-> <c- b>int</c-><c- o>>></c-></code> is <code class="highlight"><c- b>int</c-></code>.</p>
    <p>Specific examples aside, early attempts to make the associated type aliases "polymorphic" kept
   running into ambiguities that we had to disambiguate or simply declare broken.</p>
    <p>I’d rather see <code class="highlight"><c- n>range_value_t</c-></code> et al proposed.</p>
   </blockquote>
   <p>P1035 introduces shorthands for <code class="highlight"><c- n>iter_foo_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-></code> as <code class="highlight"><c- n>range_foo_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-></code>, which in turn have
been taken from range-v3.</p>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>Range</c-> <c- n>R</c-><c- o>></c->
<c- k>using</c-> <c- n>range_difference_t</c-> <c- o>=</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>Range</c-> <c- n>R</c-><c- o>></c->
<c- k>using</c-> <c- n>range_size_t</c-> <c- o>=</c-> <c- n>make_unsigned_t</c-><c- o>&lt;</c-><c- n>range_difference_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>InputRange</c-> <c- n>R</c-><c- o>></c->
<c- k>using</c-> <c- n>range_value_t</c-> <c- o>=</c-> <c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>InputRange</c-> <c- n>R</c-><c- o>></c->
<c- k>using</c-> <c- n>range_reference_t</c-> <c- o>=</c-> <c- n>iter_reference_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>InputRange</c-> <c- n>R</c-><c- o>></c->
<c- k>using</c-> <c- n>range_rvalue_reference_t</c-> <c- o>=</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>Range</c-> <c- n>R</c-><c- o>></c->
<c- n>requires</c-> <c- n>Same</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
<c- k>using</c-> <c- n>range_common_iterator_t</c-> <c- o>=</c-> <c- n>common_iterator</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->
</pre>
   <p>These have an enormous amount of usage in range-v3, and will ensure consistency between generic code
that uses ranges and generic code that uses iterators (which are essential for underpinning all
range abstractions in C++).</p>
   <h3 class="heading settled" data-level="4.5" id="take_while_view"><span class="secno">4.5. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-></code></span><a class="self-link" href="#take_while_view"></a></h3>
   <h4 class="heading settled" data-level="4.5.1" id="motivation③"><span class="secno">4.5.1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation③"></a></h4>
   <p>P0789 introduces <code class="highlight"><c- n>take_view</c-></code>, which rangifies the iterator pair <code class="highlight"><c- p>{</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>ranges</c-><c- o>::</c-><c- n>next</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>r</c-><c- p>),</c-> <c- n>n</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>r</c-><c- p>))}</c-></code>. As an example:</p>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>vector</c-><c- p>{</c-><c- mi>0</c-><c- p>,</c-> <c- mi>1</c-><c- p>,</c-> <c- mi>2</c-><c- p>,</c-> <c- mi>3</c-><c- p>,</c-> <c- mi>4</c-><c- p>,</c-> <c- mi>5</c-><c- p>};</c->
<c- n>cout</c-> <c- o>&lt;&lt;</c-> <c- n>distance</c-><c- p>(</c-><c- n>v</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>take</c-><c- p>(</c-><c- mi>3</c-><c- p>))</c-> <c- o>&lt;&lt;</c-> <c- sc>'\n'</c-><c- p>;</c-> <c- c1>// prints 3</c->
<c- n>copy</c-><c- p>(</c-><c- n>v</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>take</c-><c- p>(</c-><c- mi>3</c-><c- p>),</c-> <c- n>ostream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>cout</c-><c- p>,</c-> <c- s>" "</c-><c- p>));</c-> <c- c1>// prints 0 1 2</c->
<c- n>copy</c-><c- p>(</c-><c- n>v</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>take</c-><c- p>(</c-><c- n>distance</c-><c- p>(</c-><c- n>v</c-><c- p>)),</c-> <c- n>ostream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>cout</c-><c- p>,</c-> <c- s>" "</c-><c- p>));</c-> <c- c1>// prints 0 1 2 3 4 5</c->
</pre>
   <p><code class="highlight"><c- n>take_while_view</c-></code> will provide slightly different functionality, akin to having a sentinel that
checks if a certain predicate is satisfied.</p>
   <table>
    <tbody>
     <tr>
      <th>Current
      <th>Proposed
     <tr>
      <td>
<pre class="highlight"><c- k>namespace</c-> <c- n>ranges</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>experimental</c-><c- o>::</c-><c- n>ranges</c-><c- p>;</c->

<c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Integral</c-> <c- n>I</c-><c- o>></c->
<c- k>constexpr</c-> <c- b>bool</c-> <c- n>is_odd</c-><c- p>(</c-><c- n>I</c-> <c- k>const</c-> <c- n>i</c-><c- p>)</c-> <c- k>noexcept</c->
<c- p>{</c->
   <c- k>return</c-> <c- n>i</c-> <c- o>%</c-> <c- mi>2</c-><c- p>;</c->
<c- p>}</c->

<c- k>struct</c-> <c- n>is_odd_sentinel</c-> <c- p>{</c->
   <c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Iterator</c-> <c- n>I</c-><c- o>></c->
   <c- k>constexpr</c-> <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>I</c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>a</c-><c- p>,</c->
      <c- n>is_odd_sentinel</c-><c- p>)</c-> <c- k>noexcept</c->
   <c- p>{</c->
      <c- k>return</c-> <c- n>is_odd</c-><c- p>(</c-><c- o>*</c-><c- n>a</c-><c- p>);</c->
   <c- p>}</c->

   <c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Iterator</c-> <c- n>I</c-><c- o>></c->
   <c- k>constexpr</c-> <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- n>is_odd_sentinel</c-> <c- k>const</c-> <c- n>a</c-><c- p>,</c->
      <c- n>I</c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>b</c-><c- p>)</c-> <c- k>noexcept</c->
   <c- p>{</c->
      <c- k>return</c-> <c- n>b</c-> <c- o>==</c-> <c- n>a</c-><c- p>;</c->
   <c- p>}</c->

   <c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Iterator</c-> <c- n>I</c-><c- o>></c->
   <c- k>constexpr</c-> <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>I</c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>a</c-><c- p>,</c->
      <c- n>is_odd_sentinel</c-> <c- k>const</c-> <c- n>b</c-><c- p>)</c-> <c- k>noexcept</c->
   <c- p>{</c->
      <c- k>return</c-> <c- n>not</c-> <c- p>(</c-><c- n>a</c-> <c- o>==</c-> <c- n>b</c-><c- p>);</c->
   <c- p>}</c->

   <c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Iterator</c-> <c- n>I</c-><c- o>></c->
   <c- k>constexpr</c-> <c- k>friend</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- n>is_odd_sentinel</c-> <c- k>const</c-> <c- n>a</c-><c- p>,</c->
      <c- n>I</c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>b</c-><c- p>)</c-> <c- k>noexcept</c->
   <c- p>{</c->
      <c- k>return</c-> <c- n>not</c-> <c- p>(</c-><c- n>b</c-> <c- o>==</c-> <c- n>a</c-><c- p>);</c->
   <c- p>}</c->
<c- p>};</c->

<c- b>int</c-> <c- nf>main</c-><c- p>()</c->
<c- p>{</c->
   <c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>vector</c-><c- p>{</c-><c- mi>0</c-><c- p>,</c-> <c- mi>6</c-><c- p>,</c-> <c- mi>8</c-><c- p>,</c-> <c- mi>9</c-><c- p>,</c-> <c- mi>10</c-><c- p>,</c-> <c- mi>16</c-><c- p>};</c->
   <c- n>ranges</c-><c- o>::</c-><c- n>copy</c-><c- p>(</c->
     <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>v</c-><c- p>),</c->
     <c- n>is_odd_sentinel</c-><c- p>{},</c->
     <c- n>ranges</c-><c- o>::</c-><c- n>ostream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>cout</c-><c- p>,</c-> <c- s>"</c-><c- se>\n</c-><c- s>"</c-><c- p>));</c->
<c- p>}</c->
</pre>
      <td>
<pre class="highlight"><c- k>namespace</c-> <c- n>ranges</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>experimental</c-><c- o>::</c-><c- n>ranges</c-><c- p>;</c->

<c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Integral</c-> <c- n>I</c-><c- o>></c->
<c- k>constexpr</c-> <c- b>bool</c-> <c- n>is_odd</c-><c- p>(</c-><c- n>I</c-> <c- k>const</c-> <c- n>i</c-><c- p>)</c-> <c- k>noexcept</c->
<c- p>{</c->
   <c- k>return</c-> <c- n>i</c-> <c- o>%</c-> <c- mi>2</c-><c- p>;</c->
<c- p>}</c->

<c- k>template</c-> <c- o>&lt;</c-><c- n>ranges</c-><c- o>::</c-><c- n>Integral</c-> <c- n>I</c-><c- o>></c->
<c- k>constexpr</c-> <c- b>bool</c-> <c- n>is_even</c-><c- p>(</c-><c- n>I</c-> <c- k>const</c-> <c- n>i</c-><c- p>)</c-> <c- k>noexcept</c->
<c- p>{</c->
   <c- k>return</c-> <c- n>not</c-> <c- n>is_odd</c-><c- p>(</c-><c- n>i</c-><c- p>);</c->
<c- p>}</c->

<c- b>int</c-> <c- n>main</c-><c- p>()</c->
<c- p>{</c->
   <c- k>namespace</c-> <c- n>view</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>view</c-><c- p>;</c->
   <c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>vector</c-><c- p>{</c-><c- mi>0</c-><c- p>,</c-> <c- mi>6</c-><c- p>,</c-> <c- mi>8</c-><c- p>,</c-> <c- mi>9</c-><c- p>,</c-> <c- mi>10</c-><c- p>,</c-> <c- mi>16</c-><c- p>};</c->
   <c- n>ranges</c-><c- o>::</c-><c- n>copy</c-><c- p>(</c->
      <c- n>v</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>take_while</c-><c- p>(</c-><c- n>is_even</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>),</c->
      <c- n>ranges</c-><c- o>::</c-><c- n>ostream_iterator</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>cout</c-><c- p>,</c-> <c- s>"</c-><c- se>\n</c-><c- s>"</c-><c- p>));</c->
<c- p>}</c->
</pre>
     <tr>
      <td><a href="https://wandbox.org/permlink/7UXazMHnbxfOfODQ">Wandbox demo</a>
      <td><a href="https://wandbox.org/permlink/2nS3bzVuQX1DR0yJ">Wandbox demo</a>
   </table>
   <p>The former requires that a user define their own sentinel type: something that while not
expert-friendly, is yet to be established as a widespread idiom in C++, and providing a
range adaptor for this purpose will help programmers determine when a sentinel is _not_
necessary.</p>
   <h4 class="heading settled" data-level="4.5.2" id="notes"><span class="secno">4.5.2. </span><span class="content">Notes</span><a class="self-link" href="#notes"></a></h4>
   <ul>
    <li data-md>
     <p>There is a slight programmer overhead in the naming: the author felt that both <code class="highlight"><c- n>is_odd_sentinel</c-></code> and <code class="highlight"><c- n>is_even_sentinel</c-></code> were applicable names: ultimately, the name <code class="highlight"><c- n>is_odd_sentinel</c-></code> was chosen because it describes the delimiting condition. An equally
valid reason could probably be made for <code class="highlight"><c- n>is_even_sentinel</c-></code>.</p>
    <li data-md>
     <p>A sentinel that takes a lambda may be of interest to LEWG. If there is interest in
this, a proposal could be made in the C++23 timeframe.</p>
   </ul>
   <h4 class="heading settled" data-level="4.5.3" id="interface-and-specification"><span class="secno">4.5.3. </span><span class="content">Interface and specification</span><a class="self-link" href="#interface-and-specification"></a></h4>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- n>View</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-><c- o>></c->
<c- n>requires</c->
   <c- n>InputRange</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c->
   <c- n>is_object_v</c-><c- o>&lt;</c-><c- n>Pred</c-><c- o>></c-> <c- o>&amp;&amp;</c->
   <c- n>IndirectUnaryPredicate</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c->
<c- k>class</c-> <c- nc>take_while_view</c-> <c- o>:</c-> <c- k>public</c-> <c- n>view_interface</c-><c- o>&lt;</c-><c- n>take_while_view</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>Pred</c-><c- o>>></c-> <c- p>{</c->
   <c- k>template</c-><c- o>&lt;</c-><c- b>bool</c-><c- o>></c-> <c- k>class</c-> <c- nc>__sentinel</c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- k>public</c-><c- o>:</c->
   <c- n>take_while_view</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- nf>take_while_view</c-><c- p>(</c-><c- n>R</c-> <c- n>base</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->

   <c- k>template</c-> <c- o>&lt;</c-><c- n>ViewableRange</c-> <c- n>O</c-><c- o>></c->
   <c- n>requires</c-> <c- n>constructible</c-><c- o>-</c-><c- n>from</c-><c- o>-</c-><c- n>range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
   <c- k>constexpr</c-> <c- n>take_while_view</c-><c- p>(</c-><c- n>O</c-><c- o>&amp;&amp;</c-> <c- n>o</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->

   <c- k>constexpr</c-> <c- n>R</c-> <c- nf>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>const</c-> <c- n>Pred</c-><c- o>&amp;</c-> <c- n>pred</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>);</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>);</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
<c- k>private</c-><c- o>:</c->
   <c- n>R</c-> <c- n>base_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
   <c- n>semiregular</c-><c- o>&lt;</c-><c- n>Pred</c-><c- o>></c-> <c- n>pred_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-><c- o>></c->
<c- n>take_while_view</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>Pred</c-><c- p>)</c-> <c- o>-></c-> <c- n>take_while_view</c-><c- o>&lt;</c-><c- n>all_view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- o>></c-><c- p>;</c->
</pre>
   <h5 class="heading settled" data-level="4.5.3.1" id="take_while_view-constructors"><span class="secno">4.5.3.1. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-></code> constructors</span><a class="self-link" href="#take_while_view-constructors"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>take_while_view</c-><c- p>(</c-><c- n>R</c-> <c- n>base</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>base_</c-></code> with <code class="highlight"><c- n>base</c-></code> and initialises <code class="highlight"><c- n>pred_</c-></code> with <code class="highlight"><c- n>pred</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>template</c-> <c- o>&lt;</c-><c- n>ViewableRange</c-> <c- n>O</c-><c- o>></c->
<c- n>requires</c-> <c- n>constructible</c-><c- o>-</c-><c- n>from</c-><c- o>-</c-><c- n>range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
<c- k>constexpr</c-> <c- n>take_while_view</c-><c- p>(</c-><c- n>O</c-><c- o>&amp;&amp;</c-> <c- n>o</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>base_</c-></code> with <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>all</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>(</c-><c- n>o</c-><c- p>))</c-></code> and initialises <code class="highlight"><c- n>pred_</c-></code> with <code class="highlight"><c- n>pred</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.5.3.2" id="take_while_view-conversion"><span class="secno">4.5.3.2. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-></code> conversion</span><a class="self-link" href="#take_while_view-conversion"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>R</c-> <c- nf>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- n>base_</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>const</c-> <c- n>Pred</c-><c- o>&amp;</c-> <c- n>pred</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- n>pred_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.5.3.3" id="take_while_view-range-begin"><span class="secno">4.5.3.3. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-></code> range begin</span><a class="self-link" href="#take_while_view-range-begin"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>);</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- n>begin</c-><c- p>()</c-> <c- k>const</c-> <c- n>requries</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>base_</c-><c- p>);</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.5.3.4" id="take_while_view-range-end"><span class="secno">4.5.3.4. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-></code> range end</span><a class="self-link" href="#take_while_view-range-end"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>);</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>__sentinel</c-><c- o>&lt;</c-><c- n>is_const_v</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-><c- o>>></c-><c- p>(</c-><c- o>&amp;</c-><c- n>pred</c-><c- p>());</c-></code>.</p>
   </ol>
   <h4 class="heading settled" data-level="4.5.4" id="take_while_view__sentinel"><span class="secno">4.5.4. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code></span><a class="self-link" href="#take_while_view__sentinel"></a></h4>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-><c- o>></c->
<c- k>template</c-><c- o>&lt;</c-><c- b>bool</c-> <c- n>Const</c-><c- o>></c->
<c- k>class</c-> <c- nc>take_while_view</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>Pred</c-><c- o>>::</c-><c- n>__sentinel</c-> <c- p>{</c->
   <c- k>using</c-> <c- n>Parent</c-> <c- o>=</c-> <c- n>conditional_t</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- k>const</c-> <c- n>take_while_view</c-><c- p>,</c-> <c- n>take_while_view</c-><c- o>></c-><c- p>;</c->
   <c- k>using</c-> <c- n>Base</c-> <c- o>=</c-> <c- n>conditional_t</c-><c- o>&lt;</c-><c- n>Const</c-><c- p>,</c-> <c- k>const</c-> <c- n>R</c-><c- p>,</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
   <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>></c-> <c- n>end_</c-><c- p>{};</c-> <c- c1>// exposition-only</c->
   <c- k>const</c-> <c- n>Pred</c-><c- o>*</c-> <c- n>pred_</c-><c- p>{};</c-> <c- c1>// pred</c->
<c- k>public</c-><c- o>:</c->
   <c- n>__sentinel</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>__sentinel</c-><c- p>(</c-><c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>></c-> <c- n>end</c-><c- p>,</c-> <c- k>const</c-> <c- n>Pred</c-><c- o>*</c-> <c- n>pred</c-><c- p>);</c->
   <c- k>constexpr</c-> <c- nf>__sentinel</c-><c- p>(</c-><c- n>__sentinel</c-><c- o>&lt;!</c-><c- n>Const</c-><c- o>></c-> <c- n>s</c-><c- p>)</c->
     <c- n>requires</c-> <c- n>Const</c-> <c- o>&amp;&amp;</c-> <c- n>ConvertibleTo</c-><c- o>&lt;</c-><c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>></c->

   <c- k>constexpr</c-> <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>></c-> <c- n>base</c-><c- p>()</c-> <c- k>const</c-> <c- p>{</c-> <c- k>return</c-> <c- n>end_</c-><c- p>;</c-> <c- p>}</c->

   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>y</c-><c- p>);</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>);</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>y</c-><c- p>);</c->
   <c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>);</c->
<c- p>};</c->
</pre>
   <h4 class="heading settled" data-level="4.5.5" id="take_while_view__sentinel-constructor"><span class="secno">4.5.5. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code> constructor</span><a class="self-link" href="#take_while_view__sentinel-constructor"></a></h4>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>__sentinel</c-><c- p>(</c-><c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>></c-> <c- n>end</c-><c- p>,</c-> <c- k>const</c-> <c- n>Pred</c-><c- o>*</c-> <c- n>pred</c-><c- p>);</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>end_</c-></code> with <code class="highlight"><c- n>end</c-></code>, and <code class="highlight"><c- n>pred_</c-></code> with <code class="highlight"><c- n>pred</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>__sentinel</c-><c- p>(</c-><c- n>__sentinel</c-><c- o>&lt;!</c-><c- n>Const</c-><c- o>></c-> <c- n>s</c-><c- p>)</c->
   <c- n>requires</c-> <c- n>Const</c-> <c- o>&amp;&amp;</c-> <c- n>ConvertibleTo</c-><c- o>&lt;</c-><c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>></c-><c- p>;</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Effects</i> Initialises <code class="highlight"><c- n>end_</c-></code> with <code class="highlight"><c- n>s</c-><c- p>.</c-><c- n>end_</c-></code> and <code class="highlight"><c- n>pred_</c-></code> with <code class="highlight"><c- n>s</c-><c- p>.</c-><c- n>pred_</c-></code>.</p>
   </ol>
   <h4 class="heading settled" data-level="4.5.6" id="take_while_view__sentinel-conversion"><span class="secno">4.5.6. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code> conversion</span><a class="self-link" href="#take_while_view__sentinel-conversion"></a></h4>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>sentinel_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>></c-> <c- n>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="3">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>end_</c-><c- p>;</c-></code></p>
   </ol>
   <h4 class="heading settled" data-level="4.5.7" id="take_while_view__sentinel-comparisons"><span class="secno">4.5.7. </span><span class="content"><code class="highlight"><c- n>take_while_view</c-><c- o>::</c-><c- n>__sentinel</c-></code> comparisons</span><a class="self-link" href="#take_while_view__sentinel-comparisons"></a></h4>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>y</c-><c- p>)</c->
</pre>
   <ol start="4">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>x</c-><c- p>.</c-><c- n>end_</c-> <c- o>!=</c-> <c- n>y</c-> <c- o>&amp;&amp;</c-> <c- o>!</c-><c- p>(</c-><c- o>*</c-><c- n>x</c-><c- p>.</c-><c- n>pred_</c-><c- p>)(</c-><c- o>*</c-><c- n>y</c-><c- p>);</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <ol start="5">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>y</c-> <c- o>==</c-> <c- n>x</c-><c- p>;</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <ol start="6">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- o>!</c-><c- p>(</c-><c- n>x</c-> <c- o>==</c-> <c- n>y</c-><c- p>);</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>friend</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- k>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>Base</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- k>const</c-> <c- n>__sentinel</c-><c- o>&amp;</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <ol start="7">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- o>!</c-><c- p>(</c-><c- n>y</c-> <c- o>==</c-> <c- n>x</c-><c- p>);</c-></code>.</p>
   </ol>
   <h3 class="heading settled" data-level="4.6" id="viewtake_while"><span class="secno">4.6. </span><span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>take_while</c-></code></span><a class="self-link" href="#viewtake_while"></a></h3>
   <p>The name <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>take_while</c-></code> denotes a range adaptor object. Let <code class="highlight"><c- n>E</c-></code> and <code class="highlight"><c- n>F</c-></code> be expressions such that type <code class="highlight"><c- n>T</c-></code> is <code class="highlight"><c- k>decltype</c-><c- p>((</c-><c- n>E</c-><c- p>))</c-></code>. Then, the expression <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>take_while</c-><c- p>(</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>)</c-></code>is expression-equivalent to:</p>
   <ol>
    <li data-md>
     <p><code class="highlight"><c- n>take_while_view</c-><c- p>{</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>}</c-></code> if <code class="highlight"><c- n>T</c-></code> models <code class="highlight"><c- n>InputRange</c-></code> and if <code class="highlight"><c- n>F</c-></code> is an object, and
models <code class="highlight"><c- n>IndirectUnaryPredicate</c-></code>.</p>
    <li data-md>
     <p>Otherwise <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>view</c-><c- o>::</c-><c- n>take_while</c-><c- p>(</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>)</c-></code> is ill-formed.</p>
   </ol>
   <h3 class="heading settled" data-level="4.7" id="drop_view"><span class="secno">4.7. </span><span class="content"><code class="highlight"><c- n>drop_view</c-></code></span><a class="self-link" href="#drop_view"></a></h3>
   <h4 class="heading settled" data-level="4.7.1" id="motivation④"><span class="secno">4.7.1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation④"></a></h4>
   <p><code class="highlight"><c- n>drop_view</c-></code> is the complement to <code class="highlight"><c- n>take_view</c-></code>: instead of providing the user with the
first <i>n</i> elements, it provides the user with all <i>but</i> the first <i>n</i> elements.</p>
   <table>
    <tbody>
     <tr>
      <th>Current (C++17)
      <th>Proposed (C++20)
     <tr>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>begin</c-> <c- o>=</c-> <c- n>next</c-><c- p>(</c-><c- n>begin</c-><c- p>(</c-><c- n>employees</c-><c- p>),</c-> <c- mi>5</c-><c- p>,</c-> <c- n>end</c-><c- p>(</c-><c- n>employees</c-><c- p>));</c->
<c- k>auto</c-> <c- n>result</c-> <c- o>=</c-> <c- n>find</c-><c- p>(</c-><c- n>begin</c-><c- p>,</c-> <c- n>end</c-><c- p>(</c-><c- n>employees</c-><c- p>),</c-> <c- s>"Lovelace"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>employees</c-><c- o>::</c-><c- n>surname</c-><c- p>);</c->
      
</pre>
      <td>
<pre class="highlight"><c- k>namespace</c-> <c- n>view</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>view</c-><c- p>;</c->
<c- k>auto</c-> <c- n>result</c-> <c- o>=</c-> <c- n>find</c-><c- p>(</c-><c- n>employees</c-> <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>drop</c-><c- p>(</c-><c- mi>5</c-><c- p>),</c-> <c- s>"Lovelace"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>employees</c-><c- o>::</c-><c- n>surname</c-><c- p>);</c->
      
</pre>
   </table>
   <h4 class="heading settled" data-level="4.7.2" id="interface①"><span class="secno">4.7.2. </span><span class="content">Interface</span><a class="self-link" href="#interface①"></a></h4>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>View</c-> <c- n>R</c-><c- o>></c->
<c- k>class</c-> <c- nc>drop_view</c-> <c- o>:</c-> <c- k>public</c-> <c- n>view_interface</c-><c- o>&lt;</c-><c- n>drop_view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-> <c- p>{</c->
   <c- k>using</c-> <c- n>D</c-> <c- o>=</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- k>public</c-><c- o>:</c->
   <c- n>drop_view</c-><c- p>();</c->
   <c- k>constexpr</c-> <c- nf>drop_view</c-><c- p>(</c-><c- n>R</c-> <c- n>base</c-><c- p>,</c-> <c- n>D</c-> <c- n>count</c-><c- p>)</c-> <c- p>[[</c-><c- nl>expects</c-><c- p>:</c-> <c- mi>0</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>]];</c->

   <c- k>template</c-><c- o>&lt;</c-><c- n>ViewableRange</c-> <c- n>O</c-><c- o>></c->
   <c- n>requires</c-> <c- n>constructible</c-><c- o>-</c-><c- n>from</c-><c- o>-</c-><c- n>range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
   <c- k>constexpr</c-> <c- n>drop_view</c-><c- p>(</c-><c- n>O</c-><c- o>&amp;&amp;</c-> <c- n>o</c-><c- p>,</c-> <c- n>D</c-> <c- n>count</c-><c- p>)</c-> <c- p>[[</c-><c- nl>expects</c-><c- p>:</c-> <c- mi>0</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>]];</c->

   <c- k>constexpr</c-> <c- n>R</c-> <c- nf>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- p>(</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>RandomAccessRange</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>));</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>RandomAccessRange</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>);</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c-> <c- n>SizedRange</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>;</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>SizedRange</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
<c- k>private</c-><c- o>:</c->
   <c- n>R</c-> <c- n>base_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
   <c- n>D</c-> <c- n>count_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- n>Range</c-> <c- n>R</c-><c- o>></c->
<c- n>drop_view</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>)</c-> <c- o>-></c-> <c- n>drop_view</c-><c- o>&lt;</c-><c- n>all_view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c-><c- p>;</c->
</pre>
   <h5 class="heading settled" data-level="4.7.2.1" id="drop_view-constructor"><span class="secno">4.7.2.1. </span><span class="content"><code class="highlight"><c- n>drop_view</c-></code> constructor</span><a class="self-link" href="#drop_view-constructor"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>drop_view</c-><c- p>(</c-><c- n>R</c-> <c- n>base</c-><c- p>,</c-> <c- n>D</c-> <c- n>count</c-><c- p>)</c-> <c- p>[[</c-><c- nl>expects</c-><c- p>:</c-> <c- mi>0</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>]];</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>base_</c-></code> with <code class="highlight"><c- n>base</c-></code> and <code class="highlight"><c- n>count_</c-></code> with <code class="highlight"><c- n>count</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>ViewableRange</c-> <c- n>O</c-><c- o>></c->
<c- n>requires</c-> <c- n>constructible</c-><c- o>-</c-><c- n>from</c-><c- o>-</c-><c- n>range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
<c- k>constexpr</c-> <c- n>drop_view</c-><c- p>(</c-><c- n>O</c-><c- o>&amp;&amp;</c-> <c- n>o</c-><c- p>,</c-> <c- n>D</c-> <c- n>count</c-><c- p>)</c-> <c- p>[[</c-><c- nl>expects</c-><c- p>:</c-> <c- mi>0</c-> <c- o>&lt;</c-> <c- n>count</c-><c- p>]];</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>base_</c-></code> with <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>all</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>(</c-><c- n>o</c-><c- p>))</c-></code> and <code class="highlight"><c- n>count_</c-></code> with <code class="highlight"><c- n>count</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.7.2.2" id="drop_view-conversion"><span class="secno">4.7.2.2. </span><span class="content"><code class="highlight"><c- n>drop_view</c-></code> conversion</span><a class="self-link" href="#drop_view-conversion"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>R</c-> <c- nf>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="3">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>base_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.7.2.3" id="drop_view-range-begin"><span class="secno">4.7.2.3. </span><span class="content"><code class="highlight"><c- n>drop_view</c-></code> range begin</span><a class="self-link" href="#drop_view-range-begin"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- p>(</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>RandomAccessRange</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>));</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>RandomAccessRange</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
</pre>
   <ol start="4">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>next</c-><c- p>(</c-><c- n>ranges</c-><c- o>::</c-><c- n>begin</c-><c- p>(</c-><c- n>base_</c-><c- p>),</c-> <c- n>count_</c-><c- p>,</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>base_</c-><c- p>));</c-></code>.</p>
    <li data-md>
     <p><i>Remarks</i>: In order to provide the amortized constant time complexity required by the
Range concept, the first overload caches the result within the <code class="highlight"><c- n>drop_view</c-></code> for use on
subsequent calls.</p>
   </ol>
   <h5 class="heading settled" data-level="4.7.2.4" id="drop_view-range-end"><span class="secno">4.7.2.4. </span><span class="content"><code class="highlight"><c- n>drop_view</c-></code> range end</span><a class="self-link" href="#drop_view-range-end"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>);</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>Range</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
</pre>
   <ol start="6">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>base_</c-><c- p>);</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.7.2.5" id="drop_view-size"><span class="secno">4.7.2.5. </span><span class="content"><code class="highlight"><c- n>drop_view</c-></code> size</span><a class="self-link" href="#drop_view-size"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- n>requires</c-> <c- p>(</c-><c- o>!</c-><c- n>simple</c-><c- o>-</c-><c- n>view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>)</c-> <c- o>&amp;&amp;</c-> <c- n>SizedRange</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>;</c->
<c- k>constexpr</c-> <c- k>auto</c-> <c- nf>size</c-><c- p>()</c-> <c- k>const</c-> <c- n>requires</c-> <c- n>SizedRange</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>R</c-><c- o>></c-><c- p>;</c->
</pre>
   <ol start="7">
    <li data-md>
     <p>Equivalent to:</p>
   </ol>
<pre class="language-cpp highlight"><c- k>auto</c-> <c- k>const</c-> <c- n>size</c-> <c- o>=</c-> <c- n>ranges</c-><c- o>::</c-><c- n>size</c-><c- p>(</c-><c- n>base_</c-><c- p>);</c->
<c- k>auto</c-> <c- k>const</c-> <c- n>count</c-> <c- o>=</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- n>size</c-><c- p>)</c-><c- o>></c-><c- p>(</c-><c- n>count_</c-><c- p>);</c->
<c- k>return</c-> <c- n>size</c-> <c- o>&lt;</c-> <c- n>count</c-> <c- o>?</c-> <c- mi>0</c-> <c- o>:</c-> <c- n>size</c-> <c- o>-</c-> <c- n>count</c-><c- p>;</c->
</pre>
   <h3 class="heading settled" data-level="4.8" id="viewdrop"><span class="secno">4.8. </span><span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop</c-></code></span><a class="self-link" href="#viewdrop"></a></h3>
   <p>The name <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop</c-></code> denotes a range adaptor object. Let <code class="highlight"><c- n>E</c-></code> and <code class="highlight"><c- n>F</c-></code> be expressions such that type <code class="highlight"><c- n>T</c-></code> is <code class="highlight"><c- k>decltype</c-><c- p>((</c-><c- n>E</c-><c- p>))</c-></code>. Then, the expression <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop</c-><c- p>(</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>)</c-></code>is expression-equivalent to:</p>
   <ol>
    <li data-md>
     <p><code class="highlight"><c- n>drop_view</c-><c- p>{</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>}</c-></code> if <code class="highlight"><c- n>T</c-></code> models <code class="highlight"><c- n>InputRange</c-></code> and <code class="highlight"><c- n>F</c-></code> is implicitly convertible to <code class="highlight"><c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>iterator_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>></c-></code>.</p>
    <li data-md>
     <p>Otherwise <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop</c-><c- p>(</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>)</c-></code> is ill-formed.</p>
   </ol>
   <h3 class="heading settled" data-level="4.9" id="drop_while_view"><span class="secno">4.9. </span><span class="content"><code class="highlight"><c- n>drop_while_view</c-></code></span><a class="self-link" href="#drop_while_view"></a></h3>
   <h4 class="heading settled" data-level="4.9.1" id="motivation⑤"><span class="secno">4.9.1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation⑤"></a></h4>
   <p>The motivation for <code class="highlight"><c- n>drop_while_view</c-></code> is the union of <code class="highlight"><c- n>drop_view</c-></code> and <code class="highlight"><c- n>take_while_view</c-></code>.</p>
   <table>
    <tbody>
     <tr>
      <th>Current (C++17)
      <th>Proposed (C++20) v1
     <tr>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>begin</c-> <c- o>=</c-> <c- n>find_if_not</c-><c- p>(</c-><c- n>employees</c-><c- p>,</c->
   <c- p>[](</c-><c- k>auto</c-> <c- k>const</c-> <c- n>holidays</c-><c- p>){</c-> <c- k>return</c-> <c- n>holidays</c-> <c- o>&lt;</c-> <c- mi>20</c-><c- p>;</c-> <c- p>},</c->
   <c- o>&amp;</c-><c- n>employee</c-><c- o>::</c-><c- n>holidays</c-><c- p>);</c->

<c- n>transform</c-><c- p>(</c-><c- n>begin</c-><c- p>,</c-> <c- n>end</c-><c- p>(</c-><c- n>employees</c-><c- p>),</c->
   <c- n>ostream_iterator</c-><c- o>&lt;</c-><c- n>string</c-><c- o>></c-><c- p>(</c-><c- n>cout</c-><c- p>,</c-> <c- s>"</c-><c- se>\n</c-><c- s>"</c-><c- p>),</c->
   <c- p>[](</c-><c- k>auto</c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>e</c-><c- p>)</c-> <c- p>{</c-> <c- k>return</c-> <c- n>e</c-><c- p>.</c-><c- n>given_name</c-><c- p>()</c-> <c- o>+</c-> <c- n>e</c-><c- p>.</c-><c- n>surname</c-><c- p>();</c-> <c- p>});</c->
</pre>
      <td>
<pre class="highlight"><c- k>auto</c-> <c- n>excess_holidays</c-> <c- o>=</c-> <c- n>employees</c->
                     <c- o>|</c-> <c- n>view</c-><c- o>::</c-><c- n>drop_while</c-><c- p>([](</c-><c- k>auto</c-> <c- k>const</c-> <c- n>e</c-><c- p>)</c-> <c- p>{</c-> <c- k>return</c-> <c- n>e</c-><c- p>.</c-><c- n>holidays</c-><c- p>()</c-> <c- o>&lt;</c-> <c- mi>20</c-><c- p>;</c-> <c- p>});</c->
<c- n>transform</c-><c- p>(</c-><c- n>excess_holidays</c-><c- p>,</c-> <c- n>ostream_iterator</c-><c- o>&lt;</c-><c- n>string</c-><c- o>></c-><c- p>(</c-><c- n>cout</c-><c- p>,</c-> <c- s>"</c-><c- se>\n</c-><c- s>"</c-><c- p>),</c->
   <c- p>[](</c-><c- k>auto</c-> <c- k>const</c-><c- o>&amp;</c-> <c- n>e</c-><c- p>)</c-> <c- p>{</c-> <c- k>return</c-> <c- n>e</c-><c- p>.</c-><c- n>given_name</c-><c- p>()</c-> <c- o>+</c-> <c- n>e</c-><c- p>.</c-><c- n>surname</c-><c- p>();</c-> <c- p>});</c->
</pre>
   </table>
   <h4 class="heading settled" data-level="4.9.2" id="interface②"><span class="secno">4.9.2. </span><span class="content">Interface</span><a class="self-link" href="#interface②"></a></h4>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>View</c-> <c- n>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-><c- o>></c->
<c- n>requires</c->
  <c- n>InputRange</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <c- n>is_object_v</c-><c- o>&lt;</c-><c- n>Pred</c-><c- o>></c-> <c- o>&amp;&amp;</c->
  <c- n>IndirectUnaryPredicate</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>Pred</c-><c- p>,</c-> <c- n>iterator_t</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>></c->
<c- k>class</c-> <c- nc>drop_while_view</c-> <c- o>:</c-> <c- k>public</c-> <c- n>view_interface</c-><c- o>&lt;</c-><c- n>drop_while_view</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>Pred</c-><c- o>>></c-> <c- p>{</c->
<c- k>public</c-><c- o>:</c->
   <c- n>drop_while_view</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- nf>drop_while_view</c-><c- p>(</c-><c- n>R</c-> <c- n>base</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->

   <c- k>template</c-><c- o>&lt;</c-><c- n>ViewableRange</c-> <c- n>O</c-><c- o>></c->
   <c- n>requires</c-> <c- n>constructible</c-><c- o>-</c-><c- n>from</c-><c- o>-</c-><c- n>range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
   <c- k>constexpr</c-> <c- n>drop_while_view</c-><c- p>(</c-><c- n>O</c-><c- o>&amp;&amp;</c-> <c- n>o</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->

   <c- k>constexpr</c-> <c- n>R</c-> <c- nf>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
   <c- k>constexpr</c-> <c- n>Pred</c-> <c- nf>pred</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->

   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>();</c->
   <c- k>constexpr</c-> <c- k>auto</c-> <c- nf>end</c-><c- p>();</c->
<c- k>private</c-><c- o>:</c->
   <c- n>R</c-> <c- n>base_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
   <c- n>semiregular</c-><c- o>&lt;</c-><c- n>Pred</c-><c- o>></c-> <c- n>pred_</c-><c- p>;</c-> <c- c1>// exposition-only</c->
<c- p>};</c->

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>R</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Pred</c-><c- o>></c->
<c- n>drop_while_view</c-><c- p>(</c-><c- n>R</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>Pred</c-><c- p>)</c-> <c- o>-></c-> <c- n>drop_while_view</c-><c- o>&lt;</c-><c- n>all_view</c-><c- o>&lt;</c-><c- n>R</c-><c- o>></c-><c- p>,</c-> <c- n>Pred</c-><c- o>></c-><c- p>;</c->
</pre>
   <h5 class="heading settled" data-level="4.9.2.1" id="drop_while_view-constructors"><span class="secno">4.9.2.1. </span><span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> constructors</span><a class="self-link" href="#drop_while_view-constructors"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- nf>drop_while_view</c-><c- p>(</c-><c- n>R</c-> <c- n>base</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>);</c->
</pre>
   <ol>
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>base_</c-></code> with <code class="highlight"><c- n>base</c-></code> and initialises <code class="highlight"><c- n>pred_</c-></code> with <code class="highlight"><c- n>pred</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>ViewableRange</c-> <c- n>O</c-><c- o>></c->
<c- n>requires</c-> <c- n>constructible</c-><c- o>-</c-><c- n>from</c-><c- o>-</c-><c- n>range</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
<c- k>constexpr</c-> <c- n>drop_while_view</c-><c- p>(</c-><c- n>O</c-><c- o>&amp;&amp;</c-> <c- n>o</c-><c- p>,</c-> <c- n>Pred</c-> <c- n>pred</c-><c- p>)</c->
</pre>
   <ol start="2">
    <li data-md>
     <p><i>Effects</i>: Initialises <code class="highlight"><c- n>base_</c-></code> with <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>all</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>(</c-><c- n>o</c-><c- p>))</c-></code>, and intialises <code class="highlight"><c- n>pred_</c-></code> with <code class="highlight"><c- n>pred</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.9.2.2" id="drop_while_view-conversion"><span class="secno">4.9.2.2. </span><span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> conversion</span><a class="self-link" href="#drop_while_view-conversion"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>R</c-> <c- nf>base</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="3">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- n>base_</c-></code>.</p>
   </ol>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- n>Pred</c-> <c- nf>pred</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ol start="4">
    <li data-md>
     <p><i>Returns</i>: <code class="highlight"><c- n>pred_</c-></code>.</p>
   </ol>
   <h5 class="heading settled" data-level="4.9.2.3" id="drop_while_view-begin"><span class="secno">4.9.2.3. </span><span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> begin</span><a class="self-link" href="#drop_while_view-begin"></a></h5>
<pre class="language-cpp highlight"><c- k>constexpr</c-> <c- k>auto</c-> <c- nf>begin</c-><c- p>();</c->
</pre>
   <ol start="5">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>find_if_not</c-><c- p>(</c-><c- n>base_</c-><c- p>,</c-> <c- n>std</c-><c- o>::</c-><c- n>ref</c-><c- p>(</c-><c- n>pred_</c-><c- p>));</c-></code>.</p>
    <li data-md>
     <p><i>Remarks</i>: In order to provide the amortized constant time complexity required by the <code class="highlight"><c- n>Range</c-></code> concept, the first overload caches the result within the <code class="highlight"><c- n>drop_while_view</c-></code> for use on subsequent
calls.</p>
   </ol>
   <h5 class="heading settled" data-level="4.9.2.4" id="drop_while_view-end"><span class="secno">4.9.2.4. </span><span class="content"><code class="highlight"><c- n>drop_while_view</c-></code> end</span><a class="self-link" href="#drop_while_view-end"></a></h5>
   <ol start="7">
    <li data-md>
     <p><i>Effects</i>: Equivalent to <code class="highlight"><c- k>return</c-> <c- n>ranges</c-><c- o>::</c-><c- n>end</c-><c- p>(</c-><c- n>base_</c-><c- p>);</c-></code>.</p>
   </ol>
   <h3 class="heading settled" data-level="4.10" id="viewdrop_while"><span class="secno">4.10. </span><span class="content"><code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop_while</c-></code></span><a class="self-link" href="#viewdrop_while"></a></h3>
   <p>The name <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop_while</c-></code> denotes a range adaptor object. Let <code class="highlight"><c- n>X</c-></code> and <code class="highlight"><c- n>Y</c-></code> be expressions such that
type <code class="highlight"><c- n>T</c-></code> is <code class="highlight"><c- k>decltype</c-><c- p>((</c-><c- n>X</c-><c- p>))</c-></code> and <code class="highlight"><c- n>F</c-></code> is <code class="highlight"><c- k>decltype</c-><c- p>((</c-><c- n>Y</c-><c- p>))</c-></code>. Then, the expression <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop_while</c-><c- p>(</c-><c- n>X</c-><c- p>,</c-> <c- n>Y</c-><c- p>)</c-></code>is expression-equivalent to:</p>
   <ol>
    <li data-md>
     <p><code class="highlight"><c- n>drop_while_view</c-><c- p>{</c-><c- n>X</c-><c- p>,</c-> <c- n>Y</c-><c- p>}</c-></code> if <code class="highlight"><c- n>T</c-></code> models <code class="highlight"><c- n>InputRange</c-></code>, and <code class="highlight"><c- n>Y</c-></code> is an object, and <code class="highlight"><c- n>F</c-></code>| and models <code class="highlight"><c- n>IndirectUnaryPredicate</c-></code>.</p>
    <li data-md>
     <p>Otherwise <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>drop_while</c-><c- p>(</c-><c- n>E</c-><c- p>,</c-> <c- n>F</c-><c- p>)</c-></code> is ill-formed.</p>
   </ol>
   <h3 class="heading settled" data-level="4.11" id="keys-and-values"><span class="secno">4.11. </span><span class="content"><code class="highlight"><c- n>keys</c-></code> and <code class="highlight"><c- n>values</c-></code></span><a class="self-link" href="#keys-and-values"></a></h3>
   <h4 class="heading settled" data-level="4.11.1" id="motivation⑥"><span class="secno">4.11.1. </span><span class="content">Motivation</span><a class="self-link" href="#motivation⑥"></a></h4>
   <p>It is frequent to want to iterate over the keys or the values of an associative container. There is
currently no easy way to do that. It can be approximated using <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>view</c-><c- o>::</c-><c- n>transform</c-></code>, given how
frequently such operation is needed we think their addition would make manipulation of associative
containers easier by more clearly expressing the intent.</p>
   <p>These views have been part of ranges-v3 and we also have implemented them in cmcstl2. A lot of
languages and frameworks (notably JS, Python, Qt, Java, <a data-link-type="biblio" href="#biblio-boostrange">[Boost.Range]</a>) offer methods to extract
the keys or values of an associative container, often through <code class="highlight"><c- p>.</c-><c- n>keys</c-><c- p>()</c-></code> and <code class="highlight"><c- p>.</c-><c- n>values</c-><c- p>()</c-></code> operations,
respectively.</p>
   <h4 class="heading settled" data-level="4.11.2" id="implementation"><span class="secno">4.11.2. </span><span class="content">Implementation</span><a class="self-link" href="#implementation"></a></h4>
   <p>Given an exposition-only tuple extractor (<code class="highlight"><c- n>__get_fn</c-></code>), <code class="highlight"><c- n>keys</c-></code> and <code class="highlight"><c- n>values</c-></code> need only be range
adaptor objects implemented in terms of <code class="highlight"><c- n>view</c-><c- o>::</c-><c- n>transform</c-></code>, rather than range adaptors.</p>
<pre class="highlight"><c- k>namespace</c-> <c- n>view</c-> <c- p>{</c->
   <c- k>template</c-><c- o>&lt;</c-><c- b>int</c-> <c- n>X</c-><c- o>></c->
   <c- n>requires</c-> <c- p>(</c-><c- n>X</c-> <c- o>==</c-> <c- mi>0</c-><c- p>)</c-> <c- o>||</c-> <c- p>(</c-><c- n>X</c-> <c- o>==</c-> <c- mi>1</c-><c- p>)</c->
   <c- k>struct</c-> <c- n>__get_fn</c-> <c- p>{</c->
      <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>P</c-><c- o>></c->
      <c- n>requires</c-> <c- n>pair</c-><c- o>-</c-><c- n>like</c-><c- o>&lt;</c-><c- n>P</c-><c- o>></c->
      <c- k>constexpr</c-> <c- k>decltype</c-><c- p>(</c-><c- k>auto</c-><c- p>)</c-> <c- k>operator</c-><c- p>()(</c-><c- n>P</c-><c- o>&amp;&amp;</c-> <c- n>p</c-><c- p>)</c-> <c- k>const</c->
      <c- p>{</c->
         <c- k>using</c-> <c- n>T</c-> <c- o>=</c-> <c- k>decltype</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>get</c-><c- o>&lt;</c-><c- n>X</c-><c- o>></c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>P</c-><c- o>></c-><c- p>(</c-><c- n>p</c-><c- p>)));</c->
         <c- k>return</c-> <c- n>std</c-><c- o>::</c-><c- n>get</c-><c- o>&lt;</c-><c- n>X</c-><c- o>></c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>P</c-><c- o>></c-><c- p>(</c-><c- n>p</c-><c- p>));</c->
      <c- p>}</c->
   <c- p>};</c->

   <c- kr>inline</c-> <c- k>constexpr</c-> <c- k>auto</c-> <c- n>keys</c-> <c- o>=</c-> <c- n>view</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>__get_fn</c-><c- o>&lt;</c-><c- mi>0</c-><c- o>></c-><c- p>{});</c->
   <c- kr>inline</c-> <c- k>constexpr</c-> <c- k>auto</c-> <c- n>values</c-> <c- o>=</c-> <c- n>view</c-><c- o>::</c-><c- n>transform</c-><c- p>(</c-><c- n>__get_fn</c-><c- o>&lt;</c-><c- mi>1</c-><c- o>></c-><c- p>{});</c->
<c- p>}</c-> <c- c1>// namespace view</c->
</pre>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don’t scroll to compensate for the ToC if we’re above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don’t know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn’t exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn’t standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don’t have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we’re at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can’t find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-boostrange">[Boost.Range]
   <dd><a href="https://www.boost.org/doc/libs/1_68_0/libs/range/doc/html/range/reference/adaptors/reference/map_values.html#range.reference.adaptors.reference.map_values.map_values_example">Boost.Range</a>. URL: <a href="https://www.boost.org/doc/libs/1_68_0/libs/range/doc/html/range/reference/adaptors/reference/map_values.html#range.reference.adaptors.reference.map_values.map_values_example">https://www.boost.org/doc/libs/1_68_0/libs/range/doc/html/range/reference/adaptors/reference/map_values.html#range.reference.adaptors.reference.map_values.map_values_example</a>
   <dt id="biblio-cmcstl2">[CMCSTL2]
   <dd>Casey Carter &amp; others. <a href=" https://github.com/caseycarter/cmcstl2/tree/zip_view">cmcstl2/zip_view</a>. URL: <a href=" https://github.com/caseycarter/cmcstl2/tree/zip_view"> https://github.com/caseycarter/cmcstl2/tree/zip_view</a>
   <dt id="biblio-convolution">[CONVOLUTION]
   <dd>Wikipedia. <a href="https://en.wikipedia.org/wiki/Convolution_(computer_science)">Convolution</a>. URL: <a href="https://en.wikipedia.org/wiki/Convolution_(computer_science)">https://en.wikipedia.org/wiki/Convolution_(computer_science)</a>
   <dt id="biblio-ewg43">[EWG43]
   <dd>Gabriel Dos Reis. <a href="https://cplusplus.github.io/EWG/ewg-active.html#43">[tiny] simultaneous iteration with new-style for syntax</a>. URL: <a href="https://cplusplus.github.io/EWG/ewg-active.html#43">https://cplusplus.github.io/EWG/ewg-active.html#43</a>
   <dt id="biblio-iterassoctypesvalue_type">[ITER.ASSOC.TYPES.VALUE_TYPE]
   <dd>Eric Niebler; Casey Carter. <a href="https://timsong-cpp.github.io/cppwp/ranges-ts/iterator.assoc.types.value_type">ISO/IEC TS 21425:2017 C++ Extensions for Ranges</a>. URL: <a href="https://timsong-cpp.github.io/cppwp/ranges-ts/iterator.assoc.types.value_type">https://timsong-cpp.github.io/cppwp/ranges-ts/iterator.assoc.types.value_type</a>
   <dt id="biblio-p0026">[P0026]
   <dd>Matthew McAtamney-Greenwood. <a href="https://wg21.link/p0026">multi-range-based for loops</a>. URL: <a href="https://wg21.link/p0026">https://wg21.link/p0026</a>
   <dt id="biblio-p0789">[P0789]
   <dd>Eric Niebler. <a href="https://wg21.link/p0789">Range Adaptors and Utilities</a>. URL: <a href="https://wg21.link/p0789">https://wg21.link/p0789</a>
   <dt id="biblio-p0836">[P0836]
   <dd>Gordon Brown; et al. <a href="https://wg21.link/p0836">P0836 Introduce Parallelism to the Ranges TS</a>. URL: <a href="https://wg21.link/p0836">https://wg21.link/p0836</a>
   <dt id="biblio-p1037">[P1037]
   <dd>Eric Niebler; Casey Carter. <a href="https://wg21.link/p1037">Deep Integration of the Ranges TS</a>. URL: <a href="https://wg21.link/p1037">https://wg21.link/p1037</a>
   <dt id="biblio-range-v3">[RANGE-V3]
   <dd>Eric Niebler &amp; others. <a href="https://github.com/ericniebler/range-v3">range-v3</a>. URL: <a href="https://github.com/ericniebler/range-v3">https://github.com/ericniebler/range-v3</a>
   <dt id="biblio-value_type">[VALUE_TYPE]
   <dd><a href="https://godbolt.org/z/xkcREX">static_assert(not is_same_v&lt;vector&lt;int const>::value_type, vector&lt;int const>::iterator::value_type>)</a>. URL: <a href="https://godbolt.org/z/xkcREX">https://godbolt.org/z/xkcREX</a>
  </dl>