<!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>P3568R0: break label; and continue label;</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
 *     -> ins/del.c### for candidate and proposed changes (amendments)
 *
 * 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)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *   - .correction for "candidate corrections"       (div, aside, details, section)
 *   - .addition   for "candidate additions"         (div, aside, details, section)
 *   - .correction.proposed for "proposed corrections" (div, aside, details, section)
 *   - .addition.proposed   for "proposed additions"   (div, aside, details, section)
 *
 * 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
 *
 * Outdated warning for old specs
 *
 * 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)
 *
 ******************************************************************************/

/* color variables included separately for reliability */

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

	html {
	}

	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;

		color: black;
		color: var(--text);
		background: white top left fixed no-repeat;
		background: var(--bg) 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: solid var(--logo-bg);
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		background: var(--logo-bg);
		color: white;
		color: var(--logo-text);
		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;
		background: var(--logo-active-bg);
		border-color: #c00;
		border-color: var(--logo-active-bg);
	}

	/* 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: 3;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

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

			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;

			color: #707070;
			color: var(--tocnav-normal-text);
			background: white;
			background: var(--tocnav-normal-bg);
		}
		#toc-nav > a:hover,
		#toc-nav > a:focus {
			color: black;
			color: var(--tocnav-hover-text);
			background: #f8f8f8;
			background: var(--tocnav-hover-bg);
		}
		#toc-nav > a:active {
			color: #c00;
			color: var(--tocnav-active-text);
			background: white;
			background: var(--tocnav-active-bg);
		}

		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		/* 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 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);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) 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);
			color: var(--tocsidebar-heading-text);
		}
		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);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) 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);
			color: var(--tocsidebar-heading-text);
		}

		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;
		color: var(--heading-text);
	}

	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,
	#profile-and-date {
		/* #profile-and-date 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) > :not(.head) + hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		color: black;
		color: var(--hr-text);
		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;
	border-left: 0.5em solid var(--algo-border);
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	 padding: .5em;
	 border: thin solid #ddd;
	 border: thin solid var(--algo-border);
	 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: inherit;
	}
	dfn var {
		font-style: normal;
	}

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

	del {
		color: #aa0000;
		color: var(--del-text);
		background: transparent;
		background: var(--del-bg);
		text-decoration: line-through;
	}
	ins {
		color: #006100;
		color: var(--ins-text);
		background: transparent;
		background: var(--ins-bg);
		text-decoration: underline;
	}

	/* for amendments (candidate/proposed changes) */

	.amendment ins, .correction ins, .addition ins,
	ins[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment del, .correction del, .addition del,
	del[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment.proposed ins, .correction.proposed ins, .addition.proposed ins,
	ins[class^=c].proposed {
		text-decoration-style: double;
	}
	.amendment.proposed del, .correction.proposed del, .addition.proposed del,
	del[class^=c].proposed {
		text-decoration-style: double;
	}

/** 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;
		hyphens: none;
		text-transform: none;
		text-align: left;
		text-align: start;
		font-variant: normal;
		orphans: 3;
		widows: 3;
		page-break-before: avoid;
	}
	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;
		color: var(--a-normal-text);
		text-decoration: underline #707070;
		text-decoration: underline var(--a-normal-underline);
		text-decoration-skip-ink: none;
	}
	a:visited {
		color: #034575;
		color: var(--a-visited-text);
		text-decoration-color: #bbb;
		text-decoration-color: var(--a-visited-underline);
	}

	/* Indicate interaction with the link */
	a[href]:focus,
	a[href]:hover {
		text-decoration-thickness: 2px;
	}
	a[href]:active {
		color: #c00;
		color: var(--a-active-text);
		text-decoration-color: #c00;
		text-decoration-color: var(--a-active-underline);
	}

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

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

	img {
		border-style: none;
	}

	img, svg {
		/* Intentionally not color-scheme aware. */
		background: white;
	}

	/* 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;
		height: 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,
	.amendment, .correction, .addition {
		margin: 1em auto;
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	blockquote > :first-child,
	.note  > p:first-child,
	.issue > p:first-child,
	.amendment > p:first-child,
	.correction > p:first-child,
	.addition > p:first-child {
		margin-top: 0;
	}
	blockquote > :last-child,
	.note  > p:last-child,
	.issue > p:last-child,
	.amendment > p:last-child,
	.correction > p:last-child,
	.addition > p:last-child {
		margin-bottom: 0;
	}


	.issue::before, .issue > .marker,
	.example::before, .example > .marker,
	.note::before, .note > .marker,
	details.note > summary > .marker,
	.amendment::before, .amendment > .marker,
	details.amendment > summary > .marker,
	.addition::before, .addition > .marker,
	addition.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	correction.amendment > summary > .marker
	{
		text-transform: uppercase;
		padding-right: 1em;
	}

	.example::before, .example > .marker {
		display: block;
		padding-right: 0em;
	}

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

	blockquote {
		border-color: silver;
		border-color: var(--blockquote-border);
		background: transparent;
		background: var(--blockquote-bg);
		color: currentcolor;
		color: var(--blockquote-text);
	}

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

	.issue {
		border-color: #e05252;
		border-color: var(--issue-border);
		background: #fbe9e9;
		background: var(--issue-bg);
		color: black;
		color: var(--issue-text);
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		color: #831616;
		color: var(--issueheading-text);
	}
	/* 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;
		border-color: var(--example-border);
		background: #fcfaee;
		background: var(--example-bg);
		color: black;
		color: var(--example-text);
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		color: #574b0f;
		color: var(--exampleheading-text);
	}
	/* 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;
		border-color: var(--note-border);
		background: #e9fbe9;
		background: var(--note-bg);
		color: black;
		color: var(--note-text);
		overflow: auto;
	}

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

	details.note[open] > summary {
		border-bottom: 1px silver solid;
		border-bottom: 1px var(--notesummary-underline) solid;
	}

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

	.assertion {
		border-color: #AAA;
		border-color: var(--assertion-border);
		background: #EEE;
		background: var(--assertion-bg);
		color: black;
		color: var(--assertion-text);
	}

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

	.advisement {
		border-color: orange;
		border-color: var(--advisement-border);
		border-style: none solid;
		background: #fec;
		background: var(--advisement-bg);
		color: black;
		color: var(--advisement-text);
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement::before, .advisement > .marker {
		color: #b35f00;
		color: var(--advisementheading-text);
	}

/** Amendment Box *************************************************************/

	.amendment, .correction, .addition {
		border-color: #330099;
		border-color: var(--amendment-border);
		background: #F5F0FF;
		background: var(--amendment-bg);
		color: black;
		color: var(--amendment-text);
	}
	.amendment.proposed, .correction.proposed, .addition.proposed {
		border-style: solid;
		border-block-width: 0.25em;
	}
	.amendment::before, .amendment > .marker,
	details.amendment > summary::before, details.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	details.correction > summary::before, details.correction > summary > .marker,
	.addition::before, .addition > .marker,
	details.addition > summary::before, details.addition > summary > .marker {
		color: #220066;
		color: var(--amendmentheading-text);
	}
	.amendment.proposed::before, .amendment.proposed > .marker,
	details.amendment.proposed > summary::before, details.amendment.proposed > summary > .marker,
	.correction.proposed::before, .correction.proposed > .marker,
	details.correction.proposed > summary::before, details.correction.proposed > summary > .marker,
	.addition.proposed::before, .addition.proposed > .marker,
	details.addition.proposed > summary::before, details.addition.proposed > summary > .marker {
		font-weight: bold;
	}

/** 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: hsla(40,100%,50%,0.95);
		background: var(--warning-bg);
		color: black;
		color: var(--warning-text);
		padding: .75em 1em;
		border: red;
		border: var(--warning-border);
		border-style: solid none;
		box-shadow: 0 2px 8px black;
		text-align: center;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

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

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

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

	.def {
		padding: .5em 1em;
		background: #def;
		background: var(--def-bg);
		margin: 1.2em 0;
		border-left: 0.5em solid #8ccbf2;
		border-left: 0.5em solid var(--def-border);
		color: black;
		color: var(--def-text);
	}

/******************************************************************************/
/*                                    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;
		border-bottom: 1px solid var(--defrow-border);
	}

	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-color: var(--datacell-border);
		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;
		border-top: 1px solid var(--datacell-border);
		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;
		border: 1px solid var(--datacell-border);
		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: 0.1rem 1px 0;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Switch to using border-bottom for underlines */
		text-decoration: none;
		border-bottom: 1px solid;
		/* Reverse color scheme */
		color: black;
		color: var(--toclink-text);
		border-color: #3980b5;
		border-color: var(--toclink-underline);
	}
	.toc a:visited {
		color: black;
		color: var(--toclink-visited-text);
		border-color: #054572;
		border-color: var(--toclink-visited-underline);
	}
	.toc a:focus,
	.toc a:hover {
		background: rgba(75%, 75%, 75%, .25);
		background: var(--a-hover-bg);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	.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;
	}
	.toc {
		line-height: 1.1em;
	}

	/* 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 li { font-size:   85%;	}

	/* @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 li li li .secno { font-size: 85%; }
		.toc > li li li li li .secno { font-size: 100%; }

		.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; }
		}
		/* Loosen it on wide screens */
		@media screen and (min-width: 78em) {
			body:not(.toc-inline) :not(li) > .toc			 { margin-left:  4rem; }
			body:not(.toc-inline) .toc .secno				 { margin-left: -4rem; }
			body:not(.toc-inline) .toc > li li li			 { margin-left:  1rem; }
			body:not(.toc-inline) .toc > li li li .secno	  { margin-left: -5rem; }
			body:not(.toc-inline) .toc > li li li li .secno	{ margin-left: -6rem; }
			body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
	}
	/* } */

	@supports (display:grid) and (display:contents) {
		/* 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;
			border-bottom: 3px solid transparent;
			margin-bottom: -3px;
		}
		#toc .content:hover,
		#toc .content:focus {
			background: rgba(75%, 75%, 75%, .25);
			background: var(--a-hover-bg);
			border-bottom-color: #054572;
			border-bottom-color: var(--toclink-underline);
		}
		#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 a + span {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
			color: var(--indexinfo-text);
		}
	}

/** 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]) {
		color: black;
		color: var(--indextable-hover-text);
		background: #f7f8f9;
		background: var(--indextable-hover-bg);
	}

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

/** Outdated warning **********************************************************/

.outdated-spec {
	color: black;
	color: var(--outdatedspec-text);
	background-color: rgba(0,0,0,0.5);
	background-color: var(--outdatedspec-bg);
}

.outdated-warning {
	position: fixed;
	bottom: 50%;
	left: 0;
	right: 0;
	margin: 0 auto;
	width: 50%;
	background: maroon;
	background: var(--outdated-bg);
	color: white;
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	position: absolute;
	top: 0;
	right:0;
	margin: 0;
	border: 0;
	padding: 0.25em 0.5em;
	background: transparent;
	color: white;
	color: var(--outdated-text);
	font:1em sans-serif;
	text-align:center;
}

.outdated-warning span {
	display: block;
}

.outdated-collapsed {
	bottom: 0;
	border-radius: 0;
	width: 100%;
	padding: 0;
}

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

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

		.outdated-warning {
			position: absolute;
			border-style: solid;
			border-color: red;
		}

		.outdated-warning input {
			display: none;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}



/******************************************************************************/
/*                             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 {
		/* Magic to create good item positioning:
		  "content column" is 50ems wide at max; less on smaller screens.
		  Extra space (after ToC + content) is empty on the right.

		  1. When item < content column, centers item in column.
		  2. When content < item < available, left-aligns.
		  3. When item > available, fills available + scroll bar.
		*/
		display: grid;
		grid-template-columns: minmax(0, 50em);
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			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-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-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>
    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;
    }

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version 4416b18d5, updated Tue Jan 2 15:52:39 2024 -0800" name="generator">
  <link href="https://eisenwave.github.io/cpp-proposals/break-continue-label.html" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="148066ed82024e154050ccff7164cff8d30d9573" name="revision">
<style>
table, th, td {
    border-color: rgba(0, 0, 0, 0.5);
}

@media (prefers-color-scheme: dark) {
table, th, td {
    border-color: rgba(255, 255, 255, 0.5);
}
}

.indent {
    padding-left: 2em;
}

svg {
    background: none;
    vertical-align: middle;
}

ins {
    background: rgba(136, 255, 93, 0.2);
    color: inherit;
}
ins::not(.ins-block) {
    text-decoration: underlined;
}

.ins-block, .ins-block * {
    text-decoration: none !important;
}
.ins-block {
    background: rgba(136, 255, 93, 0.2) !important;
}

del {
    background: rgba(255, 93, 93, 0.2);
    color: inherit;
    text-decoration: strikethrough;
}
</style>
<style>/* Boilerplate: style-autolinks */
.css.css, .property.property, .descriptor.descriptor {
    color: var(--a-normal-text);
    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;
}

@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}
</style>
<style>/* Boilerplate: style-colors */
/* Any --*-text not paired with a --*-bg is assumed to have a transparent bg */
:root {
    color-scheme: light dark;

    --text: black;
    --bg: white;

    --unofficial-watermark: url(https://www.w3.org/StyleSheets/TR/2016/logos/UD-watermark);

    --logo-bg: #1a5e9a;
    --logo-active-bg: #c00;
    --logo-text: white;

    --tocnav-normal-text: #707070;
    --tocnav-normal-bg: var(--bg);
    --tocnav-hover-text: var(--tocnav-normal-text);
    --tocnav-hover-bg: #f8f8f8;
    --tocnav-active-text: #c00;
    --tocnav-active-bg: var(--tocnav-normal-bg);

    --tocsidebar-text: var(--text);
    --tocsidebar-bg: #f7f8f9;
    --tocsidebar-shadow: rgba(0,0,0,.1);
    --tocsidebar-heading-text: hsla(203,20%,40%,.7);

    --toclink-text: var(--text);
    --toclink-underline: #3980b5;
    --toclink-visited-text: var(--toclink-text);
    --toclink-visited-underline: #054572;

    --heading-text: #005a9c;

    --hr-text: var(--text);

    --algo-border: #def;

    --del-text: red;
    --del-bg: transparent;
    --ins-text: #080;
    --ins-bg: transparent;

    --a-normal-text: #034575;
    --a-normal-underline: #bbb;
    --a-visited-text: var(--a-normal-text);
    --a-visited-underline: #707070;
    --a-hover-bg: rgba(75%, 75%, 75%, .25);
    --a-active-text: #c00;
    --a-active-underline: #c00;

    --blockquote-border: silver;
    --blockquote-bg: transparent;
    --blockquote-text: currentcolor;

    --issue-border: #e05252;
    --issue-bg: #fbe9e9;
    --issue-text: var(--text);
    --issueheading-text: #831616;

    --example-border: #e0cb52;
    --example-bg: #fcfaee;
    --example-text: var(--text);
    --exampleheading-text: #574b0f;

    --note-border: #52e052;
    --note-bg: #e9fbe9;
    --note-text: var(--text);
    --noteheading-text: hsl(120, 70%, 30%);
    --notesummary-underline: silver;

    --assertion-border: #aaa;
    --assertion-bg: #eee;
    --assertion-text: black;

    --advisement-border: orange;
    --advisement-bg: #fec;
    --advisement-text: var(--text);
    --advisementheading-text: #b35f00;

    --warning-border: red;
    --warning-bg: hsla(40,100%,50%,0.95);
    --warning-text: var(--text);

    --amendment-border: #330099;
    --amendment-bg: #F5F0FF;
    --amendment-text: var(--text);
    --amendmentheading-text: #220066;

    --def-border: #8ccbf2;
    --def-bg: #def;
    --def-text: var(--text);
    --defrow-border: #bbd7e9;

    --datacell-border: silver;

    --indexinfo-text: #707070;

    --indextable-hover-text: black;
    --indextable-hover-bg: #f7f8f9;

    --outdatedspec-bg: rgba(0, 0, 0, .5);
    --outdatedspec-text: black;
    --outdated-bg: maroon;
    --outdated-text: white;
    --outdated-shadow: red;

    --editedrec-bg: darkorange;
}

@media (prefers-color-scheme: dark) {
    :root {
        --text: #ddd;
        --bg: black;

        --unofficial-watermark: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cg fill='%23100808' transform='translate(200 200) rotate(-45) translate(-200 -200)' stroke='%23100808' stroke-width='3'%3E%3Ctext x='50%25' y='220' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EUNOFFICIAL%3C/text%3E%3Ctext x='50%25' y='305' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EDRAFT%3C/text%3E%3C/g%3E%3C/svg%3E");

        --logo-bg: #1a5e9a;
        --logo-active-bg: #c00;
        --logo-text: white;

        --tocnav-normal-text: #999;
        --tocnav-normal-bg: var(--bg);
        --tocnav-hover-text: var(--tocnav-normal-text);
        --tocnav-hover-bg: #080808;
        --tocnav-active-text: #f44;
        --tocnav-active-bg: var(--tocnav-normal-bg);

        --tocsidebar-text: var(--text);
        --tocsidebar-bg: #080808;
        --tocsidebar-shadow: rgba(255,255,255,.1);
        --tocsidebar-heading-text: hsla(203,20%,40%,.7);

        --toclink-text: var(--text);
        --toclink-underline: #6af;
        --toclink-visited-text: var(--toclink-text);
        --toclink-visited-underline: #054572;

        --heading-text: #8af;

        --hr-text: var(--text);

        --algo-border: #456;

        --del-text: #f44;
        --del-bg: transparent;
        --ins-text: #4a4;
        --ins-bg: transparent;

        --a-normal-text: #6af;
        --a-normal-underline: #555;
        --a-visited-text: var(--a-normal-text);
        --a-visited-underline: var(--a-normal-underline);
        --a-hover-bg: rgba(25%, 25%, 25%, .2);
        --a-active-text: #f44;
        --a-active-underline: var(--a-active-text);

        --borderedblock-bg: rgba(255, 255, 255, .05);

        --blockquote-border: silver;
        --blockquote-bg: var(--borderedblock-bg);
        --blockquote-text: currentcolor;

        --issue-border: #e05252;
        --issue-bg: var(--borderedblock-bg);
        --issue-text: var(--text);
        --issueheading-text: hsl(0deg, 70%, 70%);

        --example-border: hsl(50deg, 90%, 60%);
        --example-bg: var(--borderedblock-bg);
        --example-text: var(--text);
        --exampleheading-text: hsl(50deg, 70%, 70%);

        --note-border: hsl(120deg, 100%, 35%);
        --note-bg: var(--borderedblock-bg);
        --note-text: var(--text);
        --noteheading-text: hsl(120, 70%, 70%);
        --notesummary-underline: silver;

        --assertion-border: #444;
        --assertion-bg: var(--borderedblock-bg);
        --assertion-text: var(--text);

        --advisement-border: orange;
        --advisement-bg: #222218;
        --advisement-text: var(--text);
        --advisementheading-text: #f84;

        --warning-border: red;
        --warning-bg: hsla(40,100%,20%,0.95);
        --warning-text: var(--text);

        --amendment-border: #330099;
        --amendment-bg: #080010;
        --amendment-text: var(--text);
        --amendmentheading-text: #cc00ff;

        --def-border: #8ccbf2;
        --def-bg: #080818;
        --def-text: var(--text);
        --defrow-border: #136;

        --datacell-border: silver;

        --indexinfo-text: #aaa;

        --indextable-hover-text: var(--text);
        --indextable-hover-bg: #181818;

        --outdatedspec-bg: rgba(255, 255, 255, .5);
        --outdatedspec-text: black;
        --outdated-bg: maroon;
        --outdated-text: white;
        --outdated-shadow: red;

        --editedrec-bg: darkorange;
    }
    /* In case a transparent-bg image doesn't expect to be on a dark bg,
       which is quite common in practice... */
    img { background: white; }
}
</style>
<style>/* Boilerplate: 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>/* Boilerplate: style-issues */
a[href].issue-return {
    float: right;
    float: inline-end;
    color: var(--issueheading-text);
    font-weight: bold;
    text-decoration: none;
}
</style>
<style>/* Boilerplate: 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>/* Boilerplate: style-selflinks */
:root {
    --selflink-text: white;
    --selflink-bg: gray;
    --selflink-hover-text: black;
}
.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%;
}
.example > a.self-link,
.note > a.self-link,
.issue > a.self-link {
    /* These blocks are overflow:auto, so positioning outside
       doesn't work. */
    left: auto;
    right: 0;
}
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: var(--selflink-bg);
    color: var(--selflink-text);
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: var(--selflink-hover-text);
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }
</style>
<style>/* Boilerplate: style-syntax-highlighting */
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }

.highlight:not(.idl) { background: rgba(0, 0, 0, .03); }
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 */

@media (prefers-color-scheme: dark) {
    .highlight:not(.idl) { background: rgba(255, 255, 255, .05); }

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P3568R0<br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code></h1>
   <h2 class="no-num no-toc no-ref heading settled" id="profile-and-date"><span class="content">Published Proposal, <time class="dt-updated" datetime="2025-01-12">2025-01-12</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://eisenwave.github.io/cpp-proposals/break-continue-label.html">https://eisenwave.github.io/cpp-proposals/break-continue-label.html</a>
     <dt class="editor">Authors:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:janschultke@gmail.com">Jan Schultke</a>
     <dd class="editor p-author h-card vcard"><span class="p-name fn">Sarah Quiñones</span>
     <dt>Audience:
     <dd>SG22, SG17
     <dt>Project:
     <dd>ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
     <dt>Source:
     <dd><a href="https://github.com/Eisenwave/cpp-proposals/blob/master/src/break-continue-label.bs">eisenwave/cpp-proposals</a>
    </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>Introduce <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> to <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> out of nested loops and <code class="highlight"><c- k>switch</c-></code>es as accepted into C2y,
and relax label restrictions.</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="#history"><span class="secno">1</span> <span class="content">Revision history</span></a>
    <li>
     <a href="#introduction"><span class="secno">2</span> <span class="content">Introduction</span></a>
     <ol class="toc">
      <li><a href="#changes-since-2014"><span class="secno">2.1</span> <span class="content">What has changed since 2014</span></a>
     </ol>
    <li>
     <a href="#motivation"><span class="secno">3</span> <span class="content">Motivation</span></a>
     <ol class="toc">
      <li>
       <a href="#no-good-alternatives"><span class="secno">3.1</span> <span class="content">No good alternative</span></a>
       <ol class="toc">
        <li><a href="#alternative-goto"><span class="secno">3.1.1</span> <span class="content"><code class="highlight"><c- k>goto</c-></code></span></a>
        <li><a href="#alternative-iile"><span class="secno">3.1.2</span> <span class="content">Immediately invoked lambda expression (IILE)</span></a>
        <li><a href="#alternative-bool-state"><span class="secno">3.1.3</span> <span class="content">Mutable <code class="highlight"><c- b>bool</c-></code> state</span></a>
       </ol>
      <li>
       <a href="#argumentum-ad-populum"><span class="secno">3.2</span> <span class="content">Argumentum ad populum</span></a>
       <ol class="toc">
        <li><a href="#poll"><span class="secno">3.2.1</span> <span class="content">Poll</span></a>
        <li><a href="#how-common-is-break-continue-label"><span class="secno">3.2.2</span> <span class="content">How common is <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> with labels?</span></a>
       </ol>
      <li><a href="#c2y-compatibility"><span class="secno">3.3</span> <span class="content">C2y compatibility</span></a>
     </ol>
    <li>
     <a href="#design-considerations"><span class="secno">4</span> <span class="content">Design Considerations</span></a>
     <ol class="toc">
      <li>
       <a href="#alternative-break-continue-forms"><span class="secno">4.1</span> <span class="content">Alternative <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> forms</span></a>
       <ol class="toc">
        <li><a href="#why-not-break-n"><span class="secno">4.1.1</span> <span class="content"><code class="highlight"><c- k>break</c-> <c- n>N</c-></code></span></a>
        <li><a href="#why-not-break-while"><span class="secno">4.1.2</span> <span class="content"><code class="highlight"><c- k>break</c-> <c- k>while</c-></code> et al.</span></a>
        <li><a href="#why-not-break-statement"><span class="secno">4.1.3</span> <span class="content"><code class="highlight"><c- k>break</c-> <c- n>statement</c-></code></span></a>
       </ol>
      <li><a href="#break-block-statement"><span class="secno">4.2</span> <span class="content">What about <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> for block statements etc.?</span></a>
      <li><a href="#constexpr-break-continue"><span class="secno">4.3</span> <span class="content">Should there be <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code> in constant expressions?</span></a>
      <li>
       <a href="#syntax"><span class="secno">4.4</span> <span class="content">What about syntax?</span></a>
       <ol class="toc">
        <li><a href="#n3377-labels-dont-imply-target"><span class="secno">4.4.1</span> <span class="content">Labels don’t properly imply the target</span></a>
        <li>
         <a href="#n3377-label-disambiguation"><span class="secno">4.4.2</span> <span class="content">Two sets of labels for disambiguation</span></a>
         <ol class="toc">
          <li><a href="#n3377-naming-convention-workaround"><span class="secno">4.4.2.1</span> <span class="content">Naming conventions as a workaround</span></a>
         </ol>
        <li>
         <a href="#opposition-to-n3377"><span class="secno">4.4.3</span> <span class="content">Strong opposition to N3377</span></a>
         <ol class="toc">
          <li><a href="#against-n3377-breaking-precedent"><span class="secno">4.4.3.1</span> <span class="content">Breaking precedent of most prior art</span></a>
          <li><a href="#against-n3377-teachability"><span class="secno">4.4.3.2</span> <span class="content">Teachability, Simplicity, Elegance</span></a>
          <li><a href="#against-n3377-multi-language"><span class="secno">4.4.3.3</span> <span class="content">Reusable syntax in multi-language systems</span></a>
          <li><a href="#against-n3377-instant-tooling-integration"><span class="secno">4.4.3.4</span> <span class="content">Instant tooling integration</span></a>
          <li><a href="#against-n3777-do-while"><span class="secno">4.4.3.5</span> <span class="content"><code class="highlight"><c- k>do</c-></code> ... <code class="highlight"><c- k>while</c-></code></span></a>
          <li><a href="#against-n3377-pronunciation"><span class="secno">4.4.3.6</span> <span class="content">Code pronunciation</span></a>
          <li><a href="#against-n3377-repetition"><span class="secno">4.4.3.7</span> <span class="content">Repetition</span></a>
          <li><a href="#against-n3377-extendability"><span class="secno">4.4.3.8</span> <span class="content">Extendability</span></a>
          <li><a href="#against-n3377-keywords"><span class="secno">4.4.3.9</span> <span class="content">Blocking contextual keywords</span></a>
          <li><a href="#against-n3377-macro-loops"><span class="secno">4.4.3.10</span> <span class="content">Labeling loops expanded from macros</span></a>
         </ol>
       </ol>
      <li>
       <a href="#changes-to-labels"><span class="secno">4.5</span> <span class="content">Changes to labels</span></a>
       <ol class="toc">
        <li><a href="#new-labels-goto"><span class="secno">4.5.1</span> <span class="content">New labels - <code class="highlight"><c- k>goto</c-></code> issues</span></a>
        <li><a href="#new-labels-nesting"><span class="secno">4.5.2</span> <span class="content">New labels - what about nesting?</span></a>
        <li><a href="#new-labels-duplicates"><span class="secno">4.5.3</span> <span class="content">New labels - what about direct duplicates?</span></a>
        <li><a href="#new-labels-break-label-multiple"><span class="secno">4.5.4</span> <span class="content">New labels - what about <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> for loops with more than one label?</span></a>
       </ol>
     </ol>
    <li><a href="#impact-on-existing-code"><span class="secno">5</span> <span class="content">Impact on existing code</span></a>
    <li><a href="#implementation-experience"><span class="secno">6</span> <span class="content">Implementation experience</span></a>
    <li><a href="#proposed-wording"><span class="secno">7</span> <span class="content">Proposed wording</span></a>
    <li><a href="#acknowledgements"><span class="secno">8</span> <span class="content">Acknowledgements</span></a>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#normative"><span class="secno"></span> <span class="content">Normative References</span></a>
      <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="history"><span class="secno">1. </span><span class="content">Revision history</span><a class="self-link" href="#history"></a></h2>
   <p>This is the first revision.</p>
   <h2 class="heading settled" data-level="2" id="introduction"><span class="secno">2. </span><span class="content">Introduction</span><a class="self-link" href="#introduction"></a></h2>
   <p>While C++ already has a broad selection of control flow constructs,
one construct commonly found in other languages is notably absent:
the ability to apply <code class="highlight"><c- k>break</c-></code> or <code class="highlight"><c- k>continue</c-></code> to a loop or <code class="highlight"><c- k>switch</c-></code> when
this isn’t the innermost enclosing statement.
This feature is popular, simple, and quite useful:</p>
   <p>Specifically, we propose the following functionality:</p>
<pre class="language-cpp highlight"><c- nl>outer</c-><c- p>:</c-> <c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>x</c-> <c- o>:</c-> <c- n>xs</c-><c- p>)</c-> <c- p>{</c->
    <c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>y</c-> <c- o>:</c-> <c- n>ys</c-><c- p>)</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
            <c- k>continue</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// OK, continue applies to outer for loop</c->
            <c- k>break</c-> <c- n>outer</c-><c- p>;</c->    <c- c1>// OK, break applies to outer for loop  </c->
        <c- p>}</c->
    <c- p>}</c->
<c- p>}</c->

<c- nl>switch_label</c-><c- p>:</c-> <c- k>switch</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- k>default</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- d>/* ...*/</c-><c- p>)</c-> <c- p>{</c->
            <c- k>break</c-> <c- n>switch_label</c-><c- p>;</c-> <c- c1>// OK, break applies to switch, not to while loop</c->
        <c- p>}</c->
    <c- p>}</c->
<c- p>}</c->

<c- k>break</c-> <c- n>outer</c-><c- p>;</c->       <c- c1>// error: cannot break loop from the outside</c->
<c- k>goto</c-> <c- n>outer</c-><c- p>;</c->        <c- c1>// OK, used to be OK, and is unaffected by this proposal</c->

<c- nl>switch_label</c-><c- p>:;</c->     <c- c1>// OK, labels can be reused</c->
<c- k>goto</c-> <c- n>switch_label</c-><c- p>;</c-> <c- c1>// error: jump target is ambiguous</c->
</pre>
   <p>The <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> syntax is identical to that in <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> and has been accepted into C2y (see working draft at <a data-link-type="biblio" href="#biblio-n3435" title="ISO/IEC 9899:202y (en) — n3435 working draft">[N3435]</a>).
We bring that syntax into C++ and relax restrictions on labels to
make it more powerful,
and to address concerns in a rival proposal <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>.</p>
   <p>Note that <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> with labels have been proposed in <a data-link-type="biblio" href="#biblio-n3879" title="Explicit Flow Control: break label, goto case and explicit switch">[N3879]</a> and rejected at Rapperswil 2014 (<a data-link-type="biblio" href="#biblio-n4327" title="C++ Standard Evolution Closed Issues List (Revision R10)">[N4327]</a>):</p>
   <blockquote>
    <p>Straw poll, proposal as a whole:</p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>1
       <td>1
       <td>1
       <td>13
       <td>10
    </table>
    <p>"break label;" + "continue label;"</p>
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>3
       <td>8
       <td>4
       <td>9
       <td>3
    </table>
   </blockquote>
   <p>Ten years later, circumstances have changed and we should re-examine this feature.</p>
   <h3 class="heading settled" data-level="2.1" id="changes-since-2014"><span class="secno">2.1. </span><span class="content">What has changed since 2014</span><a class="self-link" href="#changes-since-2014"></a></h3>
   <p>The acceptance of the feature into C2y justifies re-examination in itself.</p>
   <p>Furthermore, use of <code class="highlight"><c- k>constexpr</c-></code> has become tremendously more common,
and <code class="highlight"><c- k>goto</c-></code> may not be used in constant expressions.
Where <code class="highlight"><c- k>goto</c-></code> is used to break out of nested loops, <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> makes it easy to migrate code:</p>
   <div class="example" id="example-5c2cd862">
    <a class="self-link" href="#example-5c2cd862"></a> Uses of <code class="highlight"><c- k>goto</c-></code> to break out of nested loops can be replaced with <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> as follows: 
<pre class="highlight"><code><ins><c- k>constexpr</c-></ins> <c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <ins><c- nl>outer</c-><c- p>:</c-> </ins><c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
            <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
                <del><c- k>goto</c-> <c- n>after_loop</c-><c- p>;</c-></del>
                <ins><c- k>break</c-> <c- n>outer</c-><c- p>;</c-></ins>
            <c- p>}</c->
        <c- p>}</c->
    <c- p>}</c->
    <del><c- nl>after_loop</c-><c- p>:;</c-></del>
<c- p>}</c->
</code></pre>
   </div>
   <p>Last but not least, <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> have seen an increase
in popularity over the last ten years.
The feature has seen increased adoption in older languages such as JavaScript,
and newer languages have been popularized which support this construct,
such as Rust and Kotlin.</p>
   <p>Nowadays, it seems almost unthinkable not to have such control statements in a new language.
A recent example of this is <a data-link-type="biblio" href="#biblio-cpp2" title="Cpp2 documentation - Loop names, break, and continue">[Cpp2]</a> (cppfront), which has <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>.</p>
   <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><code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> are largely motivated by the ability to control nested loops.
This is a highly popular feature in other languages,
and C++ could use it too, since it has no good alternative.</p>
   <p>To be fair, a conditional <code class="highlight"><c- k>return</c-></code> in the loop sometimes bypasses the need to terminate it.
However, this is not always allowed; such practice is outlawed by
MISRA-C++:2008 Rule 6-6-5 "A function shall have a single point of exit at the end of the function"
(<a data-link-type="biblio" href="#biblio-misra-c" title="MISRA C++:2023">[MISRA-C++]</a>).
Even if it is permitted, there are many cases where an early <code class="highlight"><c- k>return</c-></code> does not obsolete <code class="highlight"><c- k>break</c-></code>, and it generally does not obsolete <code class="highlight"><c- k>continue</c-></code>.</p>
   <h3 class="heading settled" data-level="3.1" id="no-good-alternatives"><span class="secno">3.1. </span><span class="content">No good alternative</span><a class="self-link" href="#no-good-alternatives"></a></h3>
   <p>Let’s examine a motivating example which uses our new construct:</p>
   <div class="example" id="example-d03f000b">
    <a class="self-link" href="#example-d03f000b"></a> 
<pre class="language-cpp highlight"><c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- nl>process_files</c-><c- p>:</c-> <c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
        <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
            <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
                <c- k>continue</c-> <c- n>process_files</c-><c- p>;</c->
            <c- p>}</c->
            <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
        <c- p>}</c->
        <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- p>}</c->
    <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
<c- p>}</c->
</pre>
    <p><code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> is very useful in this scenario,
and expresses our intent with unparalleled clarity.
We want to continue processing other files, so we <code class="highlight"><c- k>continue</c-> <c- n>process_files</c-></code>.</p>
    <p>A plain <code class="highlight"><c- k>break</c-></code> cannot be used here because it would result in executing the
following <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>println</c-></code> statement, but this should only be done upon success.</p>
   </div>
   <p>There are alternative ways to write this, but all of them have various issues.</p>
   <h4 class="heading settled" data-level="3.1.1" id="alternative-goto"><span class="secno">3.1.1. </span><span class="content"><code class="highlight"><c- k>goto</c-></code></span><a class="self-link" href="#alternative-goto"></a></h4>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
    <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
            <c- k>goto</c-> <c- n>done_with_file</c-><c- p>;</c->
        <c- p>}</c->
        <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
    <c- p>}</c->
    <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- nl>done_with_file</c-><c- p>:</c->
<c- p>}</c->
<c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
</pre>
   <p><code class="highlight"><c- k>goto</c-></code> is similar in complexity and even readability here, however there are some issues:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- k>goto</c-></code> cannot cross (non-vacuous) initialization,
which would be an issue if some variable was initialized prior to <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>println</c-></code>.
This can be addressed by surrounding the outer loop contents with another set of braces,
but this solution isn’t obvious and takes away from the elegance of <code class="highlight"><c- k>goto</c-></code> here.</p>
    <li data-md>
     <p><code class="highlight"><c- k>goto</c-></code> cannot be used in constant expressions.
For processing text files like in the example, this doesn’t matter,
but nested loops are desirable in a <code class="highlight"><c- k>constexpr</c-></code> context as well.</p>
    <li data-md>
     <p>Many style guides ban or discourage the use of <code class="highlight"><c- k>goto</c-></code>.
See <a data-link-type="biblio" href="#biblio-misra-c" title="MISRA C++:2023">[MISRA-C++]</a>, <a data-link-type="biblio" href="#biblio-cppcoreguidelineses76" title="CppCoreGuidelines/ES.76: Avoid goto">[CppCoreGuidelinesES76]</a>, etc.
This discouragement dates all the way back to 1968 (see <a data-link-type="biblio" href="#biblio-gotoconsideredharmful" title="Go To Statement Considered Harmful">[GotoConsideredHarmful]</a>),
and 66 years of teaching not to use <code class="highlight"><c- k>goto</c-></code> won’t be undone.</p>
    <li data-md>
     <p>Even in the cases where <code class="highlight"><c- k>goto</c-></code> isn’t discouraged,
those cases are always special, like "only <code class="highlight"><c- k>goto</c-></code> forwards",
"only <code class="highlight"><c- k>goto</c-></code> to break out of loops", etc..
This issue has been debated for decades,
and there is still no consensus on when, actually, <code class="highlight"><c- k>goto</c-></code> is okay to use.</p>
    <li data-md>
     <p><code class="highlight"><c- k>goto</c-></code> is innately more difficult to use because to understand its purpose,
the user has to know where the jump target is located.
A <code class="highlight"><c- k>goto</c-> <c- n>past_the_loop</c-></code> behaves radically differently compared to a <code class="highlight"><c- k>goto</c-> <c- n>before_the_loop</c-></code>.
Moving the jump target or the <code class="highlight"><c- k>goto</c-></code> statement relative to each other can also completely
change these semantics.
By comparison, <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> always jump forwards,
past a surrounding loop, or to the end of a surrounding loop respectively.
This makes them much easier to reason about, and much less error-prone.</p>
    <li data-md>
     <p>The "local readability" of <code class="highlight"><c- k>goto</c-></code> relies heavily on high-quality naming for the label.
A <code class="highlight"><c- k>goto</c-> <c- n>end</c-></code> could mean to the end of a loop, to after the loop, to the end of a function, etc.
Since <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> are much more limited,
they do not require such good label naming.
A <code class="highlight"><c- k>break</c-> <c- n>loop</c-></code> has bad name, but the user <em>generally</em> understands its purpose.</p>
   </ul>
   <p class="note" role="note"><span class="marker">Note:</span> Previous discussion on the <a data-link-type="biblio" href="#biblio-isocpp-core" title="Discussion regarding continue vs. goto in constant expressions">[isocpp-core]</a> reflector has addressed the idea
of just adding <code class="highlight"><c- k>constexpr</c-> <c- k>goto</c-></code>,
but doing so is alleged to be more complicated than more limited <code class="highlight"><c- k>constexpr</c-></code> control flow
structures which can only "jump forwards", such as <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code>.</p>
   <p>In conclusion, there are too many issues with <code class="highlight"><c- k>goto</c-></code>, some of which may never be resolved. <a data-link-type="biblio" href="#biblio-std-proposals" title="Bringing break/continue with label to C++">[std-proposals]</a> discussion prior to the publication of this proposal has shown once again
that <code class="highlight"><c- k>goto</c-></code> is a controversial and divisive.</p>
   <h4 class="heading settled" data-level="3.1.2" id="alternative-iile"><span class="secno">3.1.2. </span><span class="content">Immediately invoked lambda expression (IILE)</span><a class="self-link" href="#alternative-iile"></a></h4>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
    <c- p>[</c-><c- o>&amp;</c-><c- p>]</c-> <c- p>{</c->
        <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
            <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
                <c- k>return</c-><c- p>;</c->
            <c- p>}</c->
            <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
        <c- p>}</c->
        <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- p>}();</c->
<c- p>}</c->
<c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
</pre>
   <p>While this solution works in constant expressions,
we may be painting ourselves into a corner with this design.
We cannot also <code class="highlight"><c- k>break</c-></code> the surrounding loop from within the IILE,
and we cannot return from the surrounding function.
If this is needed at some point, we will have to put substantial effort into refactoring.</p>
   <p>Furthermore, this solution isn’t exactly elegant:</p>
   <ul>
    <li data-md>
     <p>The level of indentation has unnecessarily increased through the extra scope.</p>
    <li data-md>
     <p>The call stack will be one level deeper during debugging.
This may be relevant to debug build performance.</p>
    <li data-md>
     <p>The fact that the lambda is immediately invoked isn’t obvious until reading up to <code class="highlight"><c- p>()</c-></code>.</p>
    <li data-md>
     <p>The word <code class="highlight"><c- k>return</c-></code> does not express the overall intent well, which is merely to
continue the outer loop.
This can be considered a teachability downside.</p>
   </ul>
   <p>It is also possible to use an additional function instead of an IILE in this place.
However, this is arguably increasing the degree of complexity even more,
and it scatters the code across multiple functions without any substantial benefit.</p>
   <h4 class="heading settled" data-level="3.1.3" id="alternative-bool-state"><span class="secno">3.1.3. </span><span class="content">Mutable <code class="highlight"><c- b>bool</c-></code> state</span><a class="self-link" href="#alternative-bool-state"></a></h4>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>const</c-> <c- n>File</c-><c- o>&amp;</c-> <c- n>text_file</c-> <c- o>:</c-> <c- n>files</c-><c- p>)</c-> <c- p>{</c->
    <c- b>bool</c-> <c- n>success</c-> <c- o>=</c-> true<c- p>;</c->
    <c- k>for</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>line</c-> <c- o>:</c-> <c- n>text_file</c-><c- p>.</c-><c- n>lines</c-><c- p>())</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- n>makes_me_angry</c-><c- p>(</c-><c- n>line</c-><c- p>))</c-> <c- p>{</c->
            <c- n>success</c-> <c- o>=</c-> false<c- p>;</c->
            <c- k>break</c-><c- p>;</c->
        <c- p>}</c->
        <c- n>consume</c-><c- p>(</c-><c- n>line</c-><c- p>);</c->
    <c- p>}</c->
    <c- k>if</c-> <c- p>(</c-><c- n>success</c-><c- p>)</c-> <c- p>{</c->
        <c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed {}"</c-><c- p>,</c-> <c- n>text_file</c-><c- p>.</c-><c- n>path</c-><c- p>());</c->
    <c- p>}</c->
<c- p>}</c->
<c- n>std</c-><c- o>::</c-><c- n>println</c-><c- p>(</c-><c- s>"Processed all files"</c-><c- p>);</c->
</pre>
   <p>This solution substantially increase complexity.
Instead of introducing extra scope and call stack depth,
we add more mutable state to our function.
The original intent of "go process the next file" is also lost.</p>
   <p>Such a solution also needs additional state for each nested loop,
i.e. two <code class="highlight"><c- b>bool</c-></code>s are needed to <code class="highlight"><c- k>continue</c-></code> from a loop "two levels up".</p>
   <h3 class="heading settled" data-level="3.2" id="argumentum-ad-populum"><span class="secno">3.2. </span><span class="content">Argumentum ad populum</span><a class="self-link" href="#argumentum-ad-populum"></a></h3>
   <p>Another reason to have <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> is simply that it’s a
popular construct, available in other languages.
When Java, JavaScript, Rust, or Kotlin developers pick up C++,
they may expect that C++ can <code class="highlight"><c- k>break</c-></code> out of nested loops as well,
but will find themselves disappointed.</p>
   <p><a data-link-type="biblio" href="#biblio-stackoverflow" title="Can I use break to exit multiple nested &apos;for&apos; loops?">[StackOverflow]</a> <i>"Can I use break to exit multiple nested <code class="highlight"><c- k>for</c-></code> loops?"</i> shows that there is interest in this feature (393K views at the time of writing).</p>
   <p>A draft of the proposal was posted on <a data-link-type="biblio" href="#biblio-reddit" title="&quot;break label;&quot; and &quot;continue label;&quot; in C++">[Reddit]</a> and received overwhelmingly positive feedback
(70K views, 143 upvotes with, 94% upvote rate at the time of writing).</p>
   <h4 class="heading settled" data-level="3.2.1" id="poll"><span class="secno">3.2.1. </span><span class="content">Poll</span><a class="self-link" href="#poll"></a></h4>
   <p>Another way to measure interest is to simply ask C++ users.
The following is a committee-style poll (source: <a data-link-type="biblio" href="#biblio-tccpp" title="Poll at Together C &amp; C++ (discord.gg/tccpp)">[TCCPP]</a>) from the Discord server <a href="https://discord.gg/tccpp">Together C &amp; C++</a>,
which is the largest server in terms of C++-focused message activity:</p>
   <blockquote>
     Should C++ have "break label" and "continue label" statements
to apply break/continue to nested loops or switches? 
    <table>
     <tbody>
      <tr>
       <td>SF
       <td>F
       <td>N
       <td>A
       <td>SA
      <tr>
       <td>21
       <td>21
       <td>12
       <td>6
       <td>4
    </table>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> 64 users in total voted, and the poll was active for one week.</p>
   <h4 class="heading settled" data-level="3.2.2" id="how-common-is-break-continue-label"><span class="secno">3.2.2. </span><span class="content">How common is <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> with labels?</span><a class="self-link" href="#how-common-is-break-continue-label"></a></h4>
   <p>To further quantify the popularity, we can use GitHub code search for various
languages which already support this feature.
The following table counts only control statements with a label, <em>not</em> plain <code class="highlight"><c- k>break</c-><c- p>;</c-></code>, <code class="highlight"><c- k>continue</c-><c- p>;</c-></code>, etc.</p>
   <table>
    <tbody>
     <tr>
      <td>Language
      <td>Syntax
      <td>Labeled<br><code class="highlight"><c- k>break</c-></code>s
      <td>Labeled<br><code class="highlight"><c- k>continue</c-></code>s
      <td>Σ <code class="highlight"><c- k>break</c-></code> <code class="highlight"><c- k>continue</c-></code>
      <td><code class="highlight"><c- k>goto</c-></code>s
     <tr>
      <td>Java
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AJava+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">424K files</a>
      <td><a href="https://github.com/search?q=language%3AJava+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">152K files</a>
      <td>576K files
      <td>N/A
     <tr>
      <td>JavaScript
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AJavaScript+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">53.8K files</a>
      <td><a href="https://github.com/search?q=language%3AJavaScript+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">68.7K files</a>
      <td>122.5K files
      <td>N/A
     <tr>
      <td>Perl
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- n>last</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- n>next</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3APerl+%2F%28%3F-i%29last+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">34.9K files</a>
      <td><a href="https://github.com/search?q=language%3APerl+%2F%28%3F-i%29next+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">31.7K files</a>
      <td>66.6K files
      <td><a href="https://github.com/search?q=language%3APerl+%2F%28%3F-i%29goto+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">16.9K files</a>
     <tr>
      <td>Rust
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> '<c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> '<c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3ARust+%2F%28%3F-i%29break+%3F%27%5Ba-zA-Z0-9%5D%2B%3B%2F&amp;type=code">30.6K files</a>
      <td><a href="https://github.com/search?q=language%3ARust+%2F%28%3F-i%29continue+%3F%27%5Ba-zA-Z0-9%5D%2B%3B%2F&amp;type=code">29.1K files</a>
      <td>59.7K files
      <td>N/A
     <tr>
      <td>TypeScript
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3ATypeScript+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">11.6K files</a>
      <td><a href="https://github.com/search?q=language%3ATypeScript+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">9K files</a>
      <td>20.6K files
      <td>N/A
     <tr>
      <td>Swift
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-></code>
      <td><a href="https://github.com/search?q=language%3ASwift+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%5Cn%2F&amp;type=code">12.6K files</a>
      <td><a href="https://github.com/search?q=language%3ASwift+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%5Cn%2F&amp;type=code">5.6K files</a>
      <td>18.2K files
      <td>N/A
     <tr>
      <td>Kotlin
      <td><code class="highlight"><c- n>label</c->@ <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c->@<c- n>label</c-></code><br><code class="highlight"><c- k>continue</c->@<c- n>label</c-></code>
      <td><a href="https://github.com/search?q=language%3AKotlin+%2F%28%3F-i%29break%40%5B_a-zA-Z0-9%5D%2B%2F&amp;type=code">8.7K files</a>
      <td><a href="https://github.com/search?q=language%3AKotlin+%2F%28%3F-i%29continue%40%5B_a-zA-Z0-9%5D%2B%2F&amp;type=code">7.6K files</a>
      <td>16.3K files
      <td>N/A
     <tr>
      <td>D
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AD+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">3.5K files</a>
      <td><a href="https://github.com/search?q=language%3AD+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">2.6K files</a>
      <td>6.1K files
      <td><a href="https://github.com/search?q=language%3AD+%2F%28%3F-i%29goto+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">12.3K files</a>
     <tr>
      <td>Go
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td><a href="https://github.com/search?q=language%3AGo+%2F%28%3F-i%29break+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">270 files</a>
      <td><a href="https://github.com/search?q=language%3AGo+%2F%28%3F-i%29continue+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">252 files</a>
      <td>522
      <td><a href="https://github.com/search?q=language%3AD+%2F%28%3F-i%29goto+%5Ba-zA-Z0-9%5D%2B%3B%2F&amp;type=code">1.5K files</a>
     <tr>
      <td>Cpp2 (cppfront)
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>...</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
      <td>N/A
     <tr>
      <td>C
      <td><code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- k>for</c-> <c- p>(...)</c-></code><br><code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code><br><code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>
      <td>N/A
      <td>N/A
      <td>N/A
      <td><a href="https://github.com/search?q=language%3AC+%2F%28%3F-i%29goto+%5B_a-zA-Z0-9%5D%2B%3B%2F&amp;type=code">7.8M files</a>
   </table>
   <p>Based on this, we can reasonably estimate that there are at least one million files
in the world which use labeled <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> (or an equivalent construct).</p>
   <p class="note" role="note"><span class="marker">Note:</span> The <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> columns also count equivalent constructs, such as Perl’s <code class="highlight"><c- n>last</c-></code>.</p>
   <p class="note" role="note"><span class="marker">Note:</span> This language list is not exhaustive and the search only includes open-source code bases on GitHub.</p>
   <p class="note" role="note"><span class="marker">Note:</span> The D <code class="highlight"><c- k>goto</c-></code> count is inflated by <code class="highlight"><c- k>goto</c-> <c- k>case</c->;</code> and <code class="highlight"><c- k>goto</c-> <c- k>default</c-><c- p>;</c-></code> which perform <code class="highlight"><c- k>switch</c-></code> fallthrough.</p>
   <p class="note" role="note"><span class="marker">Note:</span> Fun fact: <code class="highlight"><c- k>continue</c-></code> occurs in <a href="https://github.com/search?q=language%3AC+%2F%28%3F-i%29continue%3B%2F&amp;type=code">5.8M C files</a>,
meaning that <code class="highlight"><c- k>goto</c-></code> is more common.</p>
   <h3 class="heading settled" data-level="3.3" id="c2y-compatibility"><span class="secno">3.3. </span><span class="content">C2y compatibility</span><a class="self-link" href="#c2y-compatibility"></a></h3>
   <p>Last but not least, C++ should have <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> to increase the amount of code that has a direct equivalent in C.
Such compatibility is desirable for two reasons:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- kr>inline</c-></code> functions or macros used in C/C++ interoperable headers could use the same syntax.</p>
    <li data-md>
     <p>C2y code is much easier to port to C++ (and vice-versa) if both languages support the same
control flow constructs.</p>
   </ul>
   <p>Furthermore, the adoption of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> saves EWG a substantial amount of time
when it comes to debating the syntax; the C++ syntax should certainly be C-compatible.</p>
   <p class="note" role="note"><span class="marker">Note:</span> The <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax is still subject to discussion; see <a href="#syntax">§ 4.4 What about syntax?</a>.</p>
   <h2 class="heading settled" data-level="4" id="design-considerations"><span class="secno">4. </span><span class="content">Design Considerations</span><a class="self-link" href="#design-considerations"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="alternative-break-continue-forms"><span class="secno">4.1. </span><span class="content">Alternative <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> forms</span><a class="self-link" href="#alternative-break-continue-forms"></a></h3>
   <p>There are some alternative forms of <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> from various proposals/discussions,
not just <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code>.
None of these are proposed by <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> or <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>,
which is reason enough to reject them.
We discuss these regardless for the sake of completion.</p>
   <h4 class="heading settled" data-level="4.1.1" id="why-not-break-n"><span class="secno">4.1.1. </span><span class="content"><code class="highlight"><c- k>break</c-> <c- n>N</c-></code></span><a class="self-link" href="#why-not-break-n"></a></h4>
   <p>A possible alternative to <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> would be a <code class="highlight"><c- k>break</c-> <c- n>N</c-><c- p>;</c-></code> syntax
(analogous for <code class="highlight"><c- k>continue</c-></code>),
where <code class="highlight"><c- n>N</c-></code> is an <em>integer-literal</em> or <em>constant-expression</em> which specifies
how many levels should be broken.
For example:</p>
<pre class="language-cpp highlight"><c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c->
    <c- k>while</c-> <c- p>(</c-><c- d>/* ...*/</c-><c- p>)</c->
        <c- k>break</c-> <c- mi>2</c-><c- p>;</c-> <c- c1>// breaks both loops</c->
</pre>
   <p>We don’t propose this syntax for multiple reasons.
Firstly, <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> points out readability concerns, concerns when using <code class="highlight"><c- k>break</c-> <c- n>N</c-><c- p>;</c-></code> in a macro,
and these are valid concerns in C++ as well.</p>
   <p>Secondly, <code class="highlight"><c- k>break</c-> <c- n>N</c-></code> is more challenging to read because the developer has to investigate what scopes
surround the statement (where e.g. <code class="highlight"><c- k>if</c-></code> doesn’t count, but <code class="highlight"><c- k>switch</c-></code> and <code class="highlight"><c- k>for</c-></code> count),
and conclude from this where <code class="highlight"><c- k>break</c-></code> applies.
The greater <code class="highlight"><c- n>N</c-></code> is, the ore challenging this task becomes.
By comparison, <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> obviously breaks out of the loop labeled <code class="highlight"><c- nl>label</c-><c- p>:</c-></code>.</p>
   <p>Thirdly, this construct is an obscure idea (not entirely novel, seen before in PHP).
In our experience, obscure control flow ideas are unpopular and not worth pursuing.
An extreme negative reaction to obscure control flow ideas was seen for
the <code class="highlight"><c- k>goto</c-> <c- k>default</c-><c- p>;</c-></code> and <code class="highlight"><c- k>goto</c-> <c- k>case</c-> <c- no>X</c->;</code> statements proposed in <a data-link-type="biblio" href="#biblio-n3879" title="Explicit Flow Control: break label, goto case and explicit switch">[N3879]</a>.
By comparison, <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> is completely mainstream;
such code has likely been written a million times or more already
(based on numbers in <a href="#how-common-is-break-continue-label">§ 3.2.2 How common is break/continue with labels?</a>).</p>
   <h4 class="heading settled" data-level="4.1.2" id="why-not-break-while"><span class="secno">4.1.2. </span><span class="content"><code class="highlight"><c- k>break</c-> <c- k>while</c-></code> et al.</span><a class="self-link" href="#why-not-break-while"></a></h4>
   <p>Yet another novel idea has been suggested at <a data-link-type="biblio" href="#biblio-std-proposals-2" title="Improving break &amp; continue">[std-proposals-2]</a>:</p>
<pre class="language-cpp highlight"><c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
 <c- k>for</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
   <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
     <c- k>break</c-> <c- k>while</c-><c- p>;</c-> <c- c1>// break the while loop, not the for loop</c->
     <c- c1>// break for while; // identical in functioning to the above version</c->
    <c- p>}</c->
  <c- p>}</c->
<c- p>}</c->
</pre>
   <p>This idea has been received negatively, and we strongly oppose it.
It is not as obvious what the targeted statement is, as with <code class="highlight"><c- k>break</c-> <c- n>N</c-><c- p>;</c-></code>,
and code can easily be broken by relocating the <code class="highlight"><c- k>break</c-> <c- k>for</c-> <c- k>while</c-> <c- k>for</c-><c- p>;</c-></code> or whatever statement somewhere else.</p>
   <h4 class="heading settled" data-level="4.1.3" id="why-not-break-statement"><span class="secno">4.1.3. </span><span class="content"><code class="highlight"><c- k>break</c-> <c- n>statement</c-></code></span><a class="self-link" href="#why-not-break-statement"></a></h4>
   <p>Perhaps the most exotic proposal is found in <code class="highlight"><c- k>break</c-> <i><c- n>statement</c-></i><c- p>;</c-></code> proposed in <a data-link-type="biblio" href="#biblio-p2635r0" title="Enhancing the break statement">[P2635R0]</a>.
Such a statement would execute <code class="highlight"><i><c- n>statement</c-></i></code> in the scope that has been entered by <code class="highlight"><c- k>break</c-></code> or <code class="highlight"><c- k>continue</c-></code>:</p>
<pre class="language-cpp highlight"><c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>i</c-> <c- o>:</c-> <c- n>range_i</c-><c- p>)</c-> <c- p>{</c->
    <c- k>for</c-> <c- p>(</c-><c- k>auto</c-> <c- n>j</c-> <c- o>:</c-> <c- n>range_j</c-><c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- k>continue</c-><c- p>;</c-> <c- c1>// breaks the inner loop, and continues the outer loop</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   <p>The author has seemingly abandoned that proposal,
but even if they didn’t, this idea is quite flawed.</p>
   <div class="example" id="example-628520dd">
    <a class="self-link" href="#example-628520dd"></a> <code class="highlight"><c- k>break</c-> <c- k>return</c-> <c- n>i</c-><c- p>;</c-></code> could be used to <code class="highlight"><c- k>return</c-></code> a shadowed entity <code class="highlight"><c- n>i</c-></code> because name lookup
of the <code class="highlight"><i><c- n>statement</c-></i></code> takes place in the jumped-to scope: 
<pre class="language-cpp highlight"><c- b>float</c-> <c- n>i</c-><c- p>;</c->
<c- k>for</c-> <c- p>(</c-><c- b>int</c-> <c- n>i</c-> <c- o>=</c-> <c- mi>0</c-><c- p>;</c-> <c- n>i</c-> <c- o>&lt;</c-> <c- mi>10</c-><c- p>;</c-> <c- o>++</c-><c- n>i</c-><c- p>)</c-> <c- p>{</c->
    <c- k>break</c-> <c- k>return</c-> <c- n>i</c-><c- p>;</c-> <c- c1>// returns float i</c->
<c- p>}</c->
</pre>
   </div>
   <p>The overarching issue is that statements
don’t always "belong" to the scope in which they appear syntactically;
this is difficult to reason about, even if we don’t add name lookup confusion like in the example.</p>
   <h3 class="heading settled" data-level="4.2" id="break-block-statement"><span class="secno">4.2. </span><span class="content">What about <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> for block statements etc.?</span><a class="self-link" href="#break-block-statement"></a></h3>
   <p>The following is <em>not</em> proposed:</p>
<pre class="language-cpp highlight"><c- nl>label</c-><c- p>:</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>label</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>Being able to apply <code class="highlight"><c- k>break</c-></code> or <code class="highlight"><c- k>continue</c-></code> to additional constructs in C++ would be a
controversial and novel idea.
We simply want to apply <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> to the same things you can already apply it to,
but also state <em>which</em> construct they apply to, if need be.</p>
   <p>However, the syntax we propose allows for such a construct to be added in the (distant) future;
see <a href="#against-n3377-extendability">§ 4.4.3.8 Extendability</a>.</p>
   <h3 class="heading settled" data-level="4.3" id="constexpr-break-continue"><span class="secno">4.3. </span><span class="content">Should there be <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> and <code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code> in constant expressions?</span><a class="self-link" href="#constexpr-break-continue"></a></h3>
   <p>Yes, absolutely!
This is a major benefit over <code class="highlight"><c- k>goto</c-></code>, and it’s part of the motivation for this proposal.</p>
   <p>An implementation is also quite feasible, and <em>basically</em> already exists in every compiler.
For constant evaluation, <code class="highlight"><c- k>break</c-></code> already needs to be able to exit
out of arbitrarily deeply nested scopes:</p>
<pre class="language-cpp highlight"><c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- p>{</c-> <c- p>{</c-> <c- p>{</c-> <c- p>{</c-> <c- p>{</c-> <c- k>break</c-><c- p>;</c-> <c- p>}</c-> <c- p>}</c-> <c- p>}</c-> <c- p>}</c-> <c- p>}</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   <p>The only novelty offered by <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> is that additional surrounding scopes can be "skipped",
which is simple to implement, both for constant expressions and regular code.</p>
   <h3 class="heading settled" data-level="4.4" id="syntax"><span class="secno">4.4. </span><span class="content">What about syntax?</span><a class="self-link" href="#syntax"></a></h3>
   <p>We strongly support the currently accepted syntax of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a>.
This syntax is</p>
   <ul>
    <li data-md>
     <p>simple and intuitive,</p>
    <li data-md>
     <p>has been used in a variety of other languages, and</p>
    <li data-md>
     <p>is easy to implement, considering that labels already exist in that form.</p>
   </ul>
   <p>It should be noted that there is a new competing proposal <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> for C2y,
which instead proposes:</p>
<pre class="language-cpp highlight"><c- k>for</c-> <c- n>outer</c-> <c- p>(</c-><c- d>/* ...*/</c-><c- p>)</c-> <c- p>{</c->
    <c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- k>break</c-> <c- n>outer</c-><c- p>;</c->
    <c- k>while</c-> <c- n>outer</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- c1>// OK, applies to the enclosing while loop</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   <p>In summary, the competing syntax has the technical benefit that
it doesn’t require each <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> to be unique within a function.
This allows the developer to expand function-style macros containing labeled loops
multiple times, and lets them repurpose simple names like <code class="highlight"><c- n>outer</c-></code> and <code class="highlight"><c- n>inner</c-></code> within the same function.
We address these technical issues in <a href="#changes-to-labels">§ 4.5 Changes to labels</a>, however,
not with the <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax.</p>
   <p><a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> also makes largely more subjective claims
as to why the <code class="highlight"><c- k>for</c-> <c- n>label</c-></code> syntax is a better fit for C,
which we discuss below.</p>
   <h4 class="heading settled" data-level="4.4.1" id="n3377-labels-dont-imply-target"><span class="secno">4.4.1. </span><span class="content">Labels don’t properly imply the target</span><a class="self-link" href="#n3377-labels-dont-imply-target"></a></h4>
   <p>One claim made by <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> is that labels don’t properly imply a target and are their own
declaration.
This is actually true and based on the fact that a <em>compound-statement</em> consists of <em>block-item</em>s, and one of these can simply be a <em>label</em> with no <em>statement</em>.</p>
   <p>However, these grammatical implementation details are easily changed and don’t matter all that much
to the mental model of a programmer.
The quintessential example of this is the preference of many C++ programmers for <code class="highlight"><c- b>int</c-><c- o>*</c-> <c- n>x</c-></code>,
closely associating <code class="highlight"><c- o>*</c-></code> with the <code class="highlight"><c- b>int</c-></code> specifier, despite <code class="highlight"><c- o>*</c-><c- n>x</c-></code> forming a <em>declarator</em> and
thus being "more correct".</p>
   <p>Similarly, <code class="highlight"><c- nl>l</c-><c- p>:</c-></code> is intuitively meant to attach to
something else (based on the name "label" and on its syntax),
even though the language grammar no longer mandates that.
Whether <code class="highlight"><c- nl>l</c-><c- p>:</c-> <c- k>for</c-></code> is a good syntax should depend on whether it expresses the idea of attaching
a label to a <code class="highlight"><c- k>for</c-></code> loop well, not on whether it is a perfect fit for the current
grammar implementation details, which are subject to change anyway.</p>
   <h4 class="heading settled" data-level="4.4.2" id="n3377-label-disambiguation"><span class="secno">4.4.2. </span><span class="content">Two sets of labels for disambiguation</span><a class="self-link" href="#n3377-label-disambiguation"></a></h4>
   <p>Another benefit is that <code class="highlight"><c- k>goto</c-></code> jump targets and loop names don’t share syntax, and this
disambiguates code (with <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax):</p>
   <ul>
    <li data-md>
     <p>When a developer sees <code class="highlight"><c- nl>label</c-><c- p>:</c-></code>, they know that this label is a jump target for <code class="highlight"><c- k>goto</c-></code>.</p>
    <li data-md>
     <p>When a developer sees <code class="highlight"><c- k>for</c-> <c- n>name</c-></code>, they know that this <code class="highlight"><c- n>name</c-></code> is a target for <code class="highlight"><c- k>break</c-></code> or <code class="highlight"><c- k>continue</c-></code>, and cannot be jumped to with <code class="highlight"><c- k>goto</c-></code>.</p>
   </ul>
   <p>For C, this is not a negligible concern. <code class="highlight"><c- k>goto</c-></code> is slightly more common than <code class="highlight"><c- k>continue</c-><c- p>;</c-></code> in C code on GitHub (source: <a href="#how-common-is-break-continue-label">§ 3.2.2 How common is break/continue with labels?</a>),
but approx. half as common as <code class="highlight"><c- k>break</c-><c- p>;</c-></code>.
This means that for any <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> with the <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax in C,
there is a decent chance that there are <code class="highlight"><c- k>goto</c-></code>s nearby.</p>
   <p>However, this problem is easy to overstate.
Firstly, this ambiguity <em>only</em> exists for labeled loops,
since arbitrary statements cannot be targeted by <code class="highlight"><c- k>break</c-></code> or <code class="highlight"><c- k>continue</c-></code>.
For example, <code class="highlight"><c- nl>label</c-><c- p>:</c-> <c- n>free</c-><c- p>(</c-><c- n>pointer</c-><c- p>)</c-></code> is obviously a <code class="highlight"><c- k>goto</c-></code> target.</p>
   <p>Secondly, we can make an educated guess about the purpose of a label in many situations:</p>
   <ul>
    <li data-md>
     <p>Labels towards the end of a function are likely targets for prior <code class="highlight"><c- k>goto</c-></code>s
which jump to cleanup/error handling code.</p>
    <li data-md>
     <p>Labels inside of loops are less likely to be <code class="highlight"><c- k>goto</c-></code> targets because jumping into the middle of
a is quite surprising, and may be illegal due to crossing initialization
of a loop variable.</p>
    <li data-md>
     <p>Labels such as <code class="highlight"><c- nl>end</c-><c- p>:</c-></code>, <code class="highlight"><c- nl>stop</c-><c- p>:</c-></code>, <code class="highlight"><c- nl>done</c-><c- p>:</c-></code>, <code class="highlight"><c- nl>success</c-><c- p>:</c-></code>, <code class="highlight"><c- nl>cleanup</c-><c- p>:</c-></code>, <code class="highlight"><c- nl>error</c-><c- p>:</c-></code>, etc.
heavily imply that earlier code uses <code class="highlight"><c- k>goto</c-></code> to get there.</p>
    <li data-md>
     <p>Labels such as <code class="highlight"><c- nl>loop</c-><c- p>:</c-></code>, <code class="highlight"><c- nl>outer</c-><c- p>:</c-></code>, etc.
heavily imply that code inside the loop uses <code class="highlight"><c- k>break</c-> <c- n>label</c-><c- p>;</c-></code> or <code class="highlight"><c- k>continue</c-> <c- n>label</c-><c- p>;</c-></code>.</p>
   </ul>
   <h5 class="heading settled" data-level="4.4.2.1" id="n3377-naming-convention-workaround"><span class="secno">4.4.2.1. </span><span class="content">Naming conventions as a workaround</span><a class="self-link" href="#n3377-naming-convention-workaround"></a></h5>
   <p>Furthermore, disambiguation of <code class="highlight"><c- k>goto</c-></code> targets and <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- k>continue</c-></code> targets
is possible through naming conventions for labels.
For example, <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> targets can be named <code class="highlight"><c- n>xzy_loop</c-></code>,
and such names can be avoided for <code class="highlight"><c- k>goto</c-></code> jump targets.</p>
   <p>Virtually every programming community already uses naming conventions for disambiguation.
For example, method names conventionally use <code class="highlight"><c- n>camelCase</c-></code> in Kotlin,
and class names conventionally use <code class="highlight"><c- n>PascalCase</c-></code>.
This effectively disambiguates constructor calls from regular function calls for <code class="highlight"><c- n>F</c-><c- p>()</c-></code>.</p>
   <p>Naming conventions seem like a reasonable solution for disambiguating <code class="highlight"><c- k>goto</c-></code> targets from <code class="highlight"><c- k>break</c-></code> targets.
We don’t need to create two distinct label syntaxes to accomplish this.
We can let people choose for themselves whether they want such disambiguation or not,
which is much more in line with C and C++ design philosophy.</p>
   <h4 class="heading settled" data-level="4.4.3" id="opposition-to-n3377"><span class="secno">4.4.3. </span><span class="content">Strong opposition to N3377</span><a class="self-link" href="#opposition-to-n3377"></a></h4>
   <p>We strongly oppose the N3377 syntax for multiple reasons, listed below.</p>
   <h5 class="heading settled" data-level="4.4.3.1" id="against-n3377-breaking-precedent"><span class="secno">4.4.3.1. </span><span class="content">Breaking precedent of most prior art</span><a class="self-link" href="#against-n3377-breaking-precedent"></a></h5>
   <p>Most languages that supports both labeled loop control
and <code class="highlight"><c- k>goto</c-></code> statements have a single label syntax. <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> breaks this pattern.</p>
   <div class="example" id="example-6338a82e">
    <a class="self-link" href="#example-6338a82e"></a> Perl supports <code class="highlight"><c- k>goto</c-> <c- n>LABEL</c-></code>, <code class="highlight"><c- n>last</c-> <c- n>LABEL</c-></code>, and <code class="highlight"><c- n>next</c-> <c- n>LABEL</c-></code>, with shared label syntax: 
<pre class="language-perl highlight">goto <c- n>LINE</c-><c- p>;</c->
<c- n>LINE:</c-> <c- k>while</c-> <c- p>(</c-><c- n>true</c-><c- p>)</c-> <c- p>{</c->
    <c- k>last</c-> <c- n>LINE</c-><c- p>;</c->  <c- c1># like our proposed break LINE</c->
<c- p>}</c->
</pre>
   </div>
   <div class="example" id="example-3ceef6d8">
    <a class="self-link" href="#example-3ceef6d8"></a> Go supports <code class="highlight"><c- k>goto</c-> <c- n>Label</c-></code>, <code class="highlight"><c- k>break</c-> <c- n>Label</c-></code>, and <code class="highlight"><c- k>continue</c-> <c- n>Label</c-></code>, with shared label syntax: 
<pre class="language-go highlight"><c- k>goto</c-> OuterLoop
OuterLoop<c- p>:</c-> <c- k>for</c-> <c- p>{</c->
    <c- k>break</c-> OuterLoop
<c- p>}</c->
</pre>
   </div>
   <div class="example" id="example-13d02915">
    <a class="self-link" href="#example-13d02915"></a> D supports <code class="highlight"><c- k>goto</c-> <c- n>label</c-></code>, <code class="highlight"><c- k>break</c-> <c- n>label</c-></code>, and <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code>, with shared label syntax: 
<pre class="language-d highlight"><c- k>goto</c-> <c- n>outer</c-><c- p>;</c->
<c- n>outer</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c-><c- kc>true</c-><c- p>)</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>outer</c-><c- p>;</c->
<c- p>}</c->
</pre>
   </div>
   <p>The fact that none of these languages require separate syntax
for <code class="highlight"><c- k>goto</c-></code> targets and <code class="highlight"><c- k>break</c-></code> targets proves that the syntax proposed by <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> is unnecessary, from a technical viewpoint.
C is not so different from D or Go that this argument doesn’t apply.</p>
   <p>Such separate syntax would also be very surprising to Go, Perl, and D developers coming to C++
because they could reasonably expect <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> to work for any kind of jump.</p>
   <p>To be fair, opposite precedent also exists:</p>
   <div class="example" id="example-cc9da832">
    <a class="self-link" href="#example-cc9da832"></a> Ada supports <code class="highlight"><c- k>goto</c-> <c- n>Label</c-></code> with <code class="highlight"><c- o>&lt;&lt;</c-><c- n>Label</c-><c- o>>></c-></code>, and <code class="highlight"><c- n>exit</c-> <c- n>label</c-></code> with <code class="highlight"><c- nl>Label</c-><c- p>:</c-></code>: 
<pre class="language-ada highlight"><c- kr>goto</c-> <c- n>Target</c-><c- p>;</c->
<c- nl>&lt;&lt;Target>></c->
<c- nl>Outer</c-><c- p>:</c-> <c- kr>loop</c->
    <c- kr>exit</c-> <c- n>Outer</c-><c- p>;</c-> <c- c1>-- like our proposed break Outer</c->
<c- kr>end</c-> <c- kr>loop</c-> <c- nf>Outer</c-><c- p>;</c->
</pre>
   </div>
   <h5 class="heading settled" data-level="4.4.3.2" id="against-n3377-teachability"><span class="secno">4.4.3.2. </span><span class="content">Teachability, Simplicity, Elegance</span><a class="self-link" href="#against-n3377-teachability"></a></h5>
   <p>C and C++ have had the <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> syntax for labeling statements
for multiple decades now.
It is extremely well understood, and has been replicated by other C-esque languages, such as
Java, Rust, JavaScript, Kotlin, and more.
Based on the numbers in <a href="#how-common-is-break-continue-label">§ 3.2.2 How common is break/continue with labels?</a>, we can assume that <code class="highlight"><c- nl>label</c-><c- p>:</c-></code>-like
syntax has been used in over a million files already.</p>
   <p>Now, decades after the fact, and a million files later,
we need to invent our own, novel syntax <em>just</em> for labeling loops and <code class="highlight"><c- k>switch</c-></code>es?
No, we don’t!
Go, Perl, and D didn’t need to either.</p>
   <p>The <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax can be intuitively understood at first glance,
either through intuition from <code class="highlight"><c- k>goto</c-></code> labels,
or from prior experience with other languages.
On the contrary, given the precedent set by <code class="highlight"><c- k>if</c-> <c- k>constexpr</c-></code>, the <code class="highlight"><c- k>for</c-> <c- n>outer</c-></code> syntax
could mislead a user into believing that <code class="highlight"><c- n>outer</c-></code> is some kind of contextual keyword.
These first experiences matter.</p>
   <h5 class="heading settled" data-level="4.4.3.3" id="against-n3377-multi-language"><span class="secno">4.4.3.3. </span><span class="content">Reusable syntax in multi-language systems</span><a class="self-link" href="#against-n3377-multi-language"></a></h5>
   <p>C and C++ do not exist in a vacuum.
They are often being used to implement lower-level details of a larger system,
written in another language (e.g. NumPy, which combines Python, C, and C++).</p>
   <p>In such a multi-language system,
it is highly beneficial to have common syntax because developers don’t have to learn
two entirely different languages, but rather, one and a half.
With <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a>, C and C++ could have identical label syntax to JavaScript, Java,
and other languages with which they are paired. <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> wastes this opportunity.</p>
   <h5 class="heading settled" data-level="4.4.3.4" id="against-n3377-instant-tooling-integration"><span class="secno">4.4.3.4. </span><span class="content">Instant tooling integration</span><a class="self-link" href="#against-n3377-instant-tooling-integration"></a></h5>
   <p>Since the <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax reuses existing <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> syntax,
it is immediately compatible with existing tooling, such as syntax highlighters,
auto-formatters, and more.</p>
   <h5 class="heading settled" data-level="4.4.3.5" id="against-n3777-do-while"><span class="secno">4.4.3.5. </span><span class="content"><code class="highlight"><c- k>do</c-></code> ... <code class="highlight"><c- k>while</c-></code></span><a class="self-link" href="#against-n3777-do-while"></a></h5>
   <div class="example" id="example-4f8cfce9">
    <a class="self-link" href="#example-4f8cfce9"></a> <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> proposes the following syntax for <code class="highlight"><c- k>do</c-></code> ... <code class="highlight"><c- k>while</c-></code> loops: 
<pre class="language-cpp highlight"><c- k>do</c-> <c- p>{</c->
    <c- c1>// ...</c->
    <c- k>break</c-> <c- n>name</c-><c- p>;</c->
    <c- c1>// ...</c->
<c- p>}</c-> <c- k>while</c-> <c- n>name</c-><c- p>(</c-><c- d>/* ... */</c-><c- p>);</c->
</pre>
   </div>
   <p>This is consistent with <code class="highlight"><c- k>while</c-></code> loops because the <em>block-name</em> is always placed after the <code class="highlight"><c- k>while</c-></code> keyword.
However, it also means that <code class="highlight"><c- k>break</c-></code> and <code class="highlight"><c- k>continue</c-></code> can apply to a <em>block-name</em> which has not yet appeared in the code.
This is a readability issue; with the exception of <code class="highlight"><c- k>goto</c-></code> and labels,
function bodies can be understood by reading them from top to bottom.</p>
   <p class="note" role="note"><span class="marker">Note:</span> Of course, there are also entities that can be outside the function body,
like other called (member) functions, types, etc.
However, control flow and use of local entities generally follow a top-to-bottom
structure.</p>
   <div class="example" id="example-04538084">
    <a class="self-link" href="#example-04538084"></a> In larger functions, this can also be incredibly disorienting: 
<pre class="language-cpp highlight"><c- k>while</c-> <c- d>/* outer? */</c-><c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- c1>// ...</c->
    <c- c1>// ...</c->
    <c- c1>// ...</c->
    <c- k>do</c-> <c- p>{</c->
        <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
            <c- c1>// ...</c->
            <c- k>if</c-> <c- p>(</c-><c- n>condition</c-><c- p>)</c->
                <c- k>break</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// &lt;&lt;&lt; you are here</c->
            <c- c1>// ...</c->
        <c- p>}</c->
        <c- c1>// ...</c->
        <c- c1>// ...</c->
        <c- c1>// ...</c->
    <c- p>}</c-> <c- k>while</c-> <c- d>/* outer? */</c-><c- p>(</c->true<c- p>);</c->
<c- p>}</c->
</pre>
    <p>When starting to read this code from the middle
(perhaps after jumping to a specific line in there),
the reader doesn’t even know whether they should look further up, or further down when
searching for the loop labeled <code class="highlight"><c- n>outer</c-></code>.</p>
   </div>
   <p>To be fair, <code class="highlight"><c- k>do</c-></code> ... <code class="highlight"><c- k>while</c-></code> loops are relatively rare, so assuming that the <em>block-name</em> can be found above is usually correct.
However, it is not always correct, and that makes this syntax less ergonomic.</p>
   <div class="example" id="example-89bec1a9">
    <a class="self-link" href="#example-89bec1a9"></a> On the contrary, the <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> (and our) syntax <em>never</em> have <code class="highlight"><c- k>break</c-></code> apply to a name
which appears later: 
<pre class="language-cpp highlight"><c- nl>name</c-><c- p>:</c-> <c- k>do</c-> <c- p>{</c->
    <c- c1>// ...</c->
    <c- k>break</c-> <c- n>name</c-><c- p>;</c->
    <c- c1>// ...    </c->
<c- p>}</c-> <c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c->
</pre>
   </div>
   <p>The <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax could be adjusted to place the <em>block-name</em> after <code class="highlight"><c- k>do</c-></code>,
but every way to proceed has downsides:</p>
   <ul>
    <li data-md>
     <p>Either <code class="highlight"><c- k>break</c-></code> can refer to a <em>block-name</em> which appears arbitrarily far below, or</p>
    <li data-md>
     <p>the <em>block-name</em> is not always placed after <code class="highlight"><c- k>while</c-></code>, which may be hard to teach and remember, or</p>
    <li data-md>
     <p>the <em>block-name</em> can be placed both after <code class="highlight"><c- k>while</c-></code> and after <code class="highlight"><c- k>do</c-></code>, which creates to competing
styles for the same construct.</p>
   </ul>
   <p>On the contrary, <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> has no such issues.</p>
   <h5 class="heading settled" data-level="4.4.3.6" id="against-n3377-pronunciation"><span class="secno">4.4.3.6. </span><span class="content">Code pronunciation</span><a class="self-link" href="#against-n3377-pronunciation"></a></h5>
   <div class="example" id="example-511f5994">
    <a class="self-link" href="#example-511f5994"></a> The <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax interferes with how code is pronounced, from left to right: 
<pre class="language-cpp highlight"><c- c1>// "(loop named outer) While x is greater or equal to zero:" </c->
<c- nl>outer</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c-><c- n>x</c-> <c- o>>=</c-> <c- mi>0</c-><c- p>)</c-> <c- p>{</c-> <c- d>/* ... */</c-> <c- p>}</c->

<c- c1>// "While (loop named outer) x is greater or equal to zero:"</c->
<c- k>while</c-> <c- n>outer</c-><c- p>(</c-><c- n>x</c-> <c- o>>=</c-> <c- mi>0</c-><c- p>)</c-> <c- p>{</c-> <c- d>/* ... */</c-> <c- p>}</c->
</pre>
   </div>
   <p>Putting the loop name between the conjunction <code class="highlight"><c- k>while</c-></code> and the dependent clause <code class="highlight"><c- n>x</c-> <c- o>>=</c-> <c- mi>0</c-></code> is not
easily compatible with the English language.
A preceding label is less intrusive and doesn’t need to be (mentally) pronounced,
like a leading attribute, line number, paragraph number, etc.</p>
   <p>This is not just a stylistic argument; it’s an accessibility argument.
C++ developers who rely on screen readers cannot "skip over" or "blend out" the <code class="highlight"><c- n>outer</c-></code> like a sighted developer,
and benefit from code that is more naturally pronounceable.</p>
   <h5 class="heading settled" data-level="4.4.3.7" id="against-n3377-repetition"><span class="secno">4.4.3.7. </span><span class="content">Repetition</span><a class="self-link" href="#against-n3377-repetition"></a></h5>
   <p>In the event that a user wants to be <code class="highlight"><c- k>break</c-></code> out of a loop and <code class="highlight"><c- k>goto</c-></code> it,
in the same function, repetition is needed:</p>
<pre class="language-cpp highlight"><c- k>goto</c-> <c- n>outer</c-><c- p>;</c->
<c- c1>// ...</c->
<c- nl>outer</c-><c- p>:</c-> <c- k>while</c-> <c- n>outer</c-><c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- k>while</c-><c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>outer</c-><c- p>;</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   <p>Since traditional labels are entirely separate from the loop names,
we need to specify the <code class="highlight"><c- n>outer</c-></code> name twice here.
Some people may consider it a benefit to keep loop names strictly separate from jump targets,
however, we see it as detrimental:</p>
   <ul>
    <li data-md>
     <p>If the label is the same as the loop name, we repeat ourselves.</p>
    <li data-md>
     <p>Otherwise, we refer to the same statement using two different names,
which feels disorienting.
If we have a good, meaningful label for a loop, such as <code class="highlight"><c- nl>main_event_loop</c-><c- p>:</c-></code>,
why shouldn’t we also write <code class="highlight"><c- k>while</c-> <c- n>main_event_loop</c-></code>?</p>
   </ul>
   <h5 class="heading settled" data-level="4.4.3.8" id="against-n3377-extendability"><span class="secno">4.4.3.8. </span><span class="content">Extendability</span><a class="self-link" href="#against-n3377-extendability"></a></h5>
   <p>Consider the following (not proposed) construct:</p>
<pre class="language-cpp highlight"><c- nl>label</c-><c- p>:</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>label</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p class="note" role="note"><span class="marker">Note:</span> C++ allows you to emulate such <code class="highlight"><c- k>break</c-></code>s with <code class="highlight"><c- k>goto</c-> <c- n>past_the_block</c-><c- p>;</c-></code>,
but see <a href="#alternative-goto">§ 3.1.1 goto</a>.</p>
   <p>Other mainstream languages already have such a feature:</p>
   <ul>
    <li data-md>
     <p>That code above is valid Java, JavaScript, and TypeScript.</p>
    <li data-md>
     <p>When replacing <code class="highlight"><c- n>label</c-></code> with <code class="highlight">'<c- n>label</c-></code>, the code is valid Rust.</p>
    <li data-md>
     <p>Scala has <a href="https://www.scala-lang.org/api/current/scala/util/control/Breaks.html"><code class="highlight"><c- n>breakable</c-></code> blocks</a> in which <code class="highlight"><c- k>break</c-><c- p>()</c-></code> can be used the same way.</p>
   </ul>
   <p>Breaking a <em>block-statement</em> is currently <em>not</em> proposed, however:</p>
   <ul>
    <li data-md>
     <p>What if someone wants to propose <code class="highlight"><c- k>break</c-></code>ing block statements in the future?
There is no obvious <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>-like syntax for adding an identifier to a <em>block-statement</em>.
Are we really certain that we will never want to do this, in the next 50 years?</p>
    <li data-md>
     <p>What if someone wants to add such <code class="highlight"><c- k>break</c-></code>s as a compiler extension right now?
With the <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax, this wouldn’t make sense,
considering that "<code class="highlight"><c- k>goto</c-></code> labels" cannot be addressed by <code class="highlight"><c- k>break</c-></code> at all.</p>
    <li data-md>
     <p>What about new statement that we want to be <code class="highlight"><c- k>break</c-></code>able?
Every new statement would need some unique way of adding a name,
instead of us being able to use <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> in every case.</p>
   </ul>
   <p>On the contrary, the <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax makes no such problematic commitments,
and is easily compatible with</p>
   <ul>
    <li data-md>
     <p>existing language extensions like "GCC computed <code class="highlight"><c- k>goto</c-></code>",</p>
    <li data-md>
     <p>every new statement in the future, and</p>
    <li data-md>
     <p>new language extensions, like <code class="highlight"><c- k>break</c-></code> for block-statements.</p>
   </ul>
   <p>It should be noted that <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> also floats the idea of an alternative Rust-like syntax,
such as <code class="highlight">'<c- n>label</c-><c- o>:</c-> <c- k>for</c-></code>.
This would no longer interfere with future standardization,
but we don’t believe that this is worth pursuing because it creates two extremely similar label syntaxes.
It is almost impossible to justify why the language needs two almost identical label syntaxes
when other languages (e.g. D, Go, Perl) have shown that this is technically unnecessary.</p>
   <p>Such a strategy would also turn the prior example in <a href="#against-n3377-repetition">§ 4.4.3.7 Repetition</a> into <code class="highlight"><c- nl>outer</c-><c- p>:</c-> '<c- n>outer</c-><c- o>:</c-> <c- k>for</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-></code>,
which looks even worse.</p>
   <h5 class="heading settled" data-level="4.4.3.9" id="against-n3377-keywords"><span class="secno">4.4.3.9. </span><span class="content">Blocking contextual keywords</span><a class="self-link" href="#against-n3377-keywords"></a></h5>
   <p>Considering that the user is able to add arbitrary identifiers after <code class="highlight"><c- k>while</c-></code> and <code class="highlight"><c- k>for</c-></code>,
this makes it impossible to add future contextual keywords in that place without
potentially breaking code:</p>
<pre class="language-cpp highlight"><c- k>while</c-> <c- n>parallel</c-><c- p>(</c-><c- d>/* ... */</c-><c- p>)</c->
</pre>
   <p>If <code class="highlight"><c- n>parallel</c-></code> was used as a label here, that may be broken by "parallel while loops" in the future.
There is precedent for such changes in C++, in the form if <code class="highlight"><c- k>if</c-> <c- k>constexpr</c-></code>.
To be fair, <code class="highlight"><c- k>constexpr</c-></code> is a true keyword, so the addition of <code class="highlight"><c- k>constexpr</c-></code> after <code class="highlight"><c- k>if</c-></code> wouldn’t have been blocked by <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax either (if <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> was part of C++ at the time).</p>
   <p>Nonetheless, it is substantial commitment to block contextual keywords with the <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax,
and we don’t see that commitment as justified.</p>
   <p>To be fair, <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> also floats the idea of a syntax such as:</p>
<pre class="language-cpp highlight"><c- nl>while</c-> <c- p>:</c-><c- n>outer</c-><c- o>:</c-><c- p>(</c-><c- d>/* ... */</c-><c- p>)</c->
</pre>
   <p>The addition of special characters into the <em>block-name</em> no longer blocks future contextual keywords.
However, if we are requiring this, it seems strictly better to have a syntax such as</p>
<pre class="language-cpp highlight"><c- o>:</c-><c- n>outer</c-><c- o>:</c-> <c- k>while</c->
</pre>
   <p>The only other language (to my knowledge) with two syntaxes is Ada (<code class="highlight"><c- o>&lt;&lt;</c-><c- n>Label</c-><c- o>>></c-></code> and <code class="highlight"><c- nl>Label</c-><c- p>:</c-></code>),
but even that language puts the labels <em>before</em> the statement to which they apply, not somewhere
in the middle, let alone at the end (in the case of <code class="highlight"><c- k>do</c-> <c- k>while</c-></code>).</p>
   <p>A preceding syntax simply works better when considering <em>block-statement</em>s (<a href="#against-n3377-extendability">§ 4.4.3.8 Extendability</a>)
and <code class="highlight"><c- k>do</c-> <c- k>while</c-></code> loops (<a href="#against-n3377-instant-tooling-integration">§ 4.4.3.4 Instant tooling integration</a>).
However, once again, this unnecessarily gives us two almost identical label syntaxes.</p>
   <h5 class="heading settled" data-level="4.4.3.10" id="against-n3377-macro-loops"><span class="secno">4.4.3.10. </span><span class="content">Labeling loops expanded from macros</span><a class="self-link" href="#against-n3377-macro-loops"></a></h5>
   <p>Because <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> loop labels are prepended to the loop, they can also be applied to loops
expanded from macros.
Such macro-expanded loops are relatively common in C.</p>
   <div class="example" id="example-87b59d33">
    <a class="self-link" href="#example-87b59d33"></a> The <code class="highlight"><c- n>HASH_ITER</c-></code> macro from uthash expands to a for loop;
see <a data-link-type="biblio" href="#biblio-uthashdocs" title="uthash User Guide: Deletion-safe iteration">[UthashDocs]</a>. 
<pre class="language-cpp highlight"><c- cp>#define HASH_ITER(hh,head,el,tmp)                                                              \</c->
<c- cp>for(((el)=(head)), ((*(char**)(&amp;(tmp)))=(char*)((head!=NULL)?(head)->hh.next:NULL));           \</c->
<c- cp>  (el) != NULL; ((el)=(tmp)), ((*(char**)(&amp;(tmp)))=(char*)((tmp!=NULL)?(tmp)->hh.next:NULL)))</c->
</pre>
    <p>The <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax lets the user <code class="highlight"><c- k>break</c-></code> out of a <code class="highlight"><c- n>HASH_ITER</c-></code> loop as follows:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>my_struct</c-> <c- o>*</c-><c- n>current_user</c-><c- p>,</c-> <c- o>*</c-><c- n>tmp</c-><c- p>;</c->

<c- nl>outer</c-><c- p>:</c-> <c- n>HASH_ITER</c-><c- p>(</c-><c- n>hh</c-><c- p>,</c-> <c- n>users</c-><c- p>,</c-> <c- n>current_user</c-><c- p>,</c-> <c- n>tmp</c-><c- p>)</c-> <c- p>{</c->
    <c- k>for</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- k>if</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- k>break</c-> <c- n>outer</c-><c- p>;</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   </div>
   <p>The <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax makes it impossible to apply labels to existing such loop macros.
To add a <em>block-name</em>, cooperation from the library author is needed.</p>
   <p class="note" role="note"><span class="marker">Note:</span> This argument is not so important to C++ because such loops would idiomatically be written
as a function template containing a loop;
instead, this argument is targeted towards C developers, who cannot use templates.</p>
   <h3 class="heading settled" data-level="4.5" id="changes-to-labels"><span class="secno">4.5. </span><span class="content">Changes to labels</span><a class="self-link" href="#changes-to-labels"></a></h3>
   <p><a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> points out legitimate issues with reusing the <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> syntax (see <a href="#syntax">§ 4.4 What about syntax?</a>).
However, as stated, we strongly oppose the proposed <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a> syntax,
and we propose to make changes to label semantics instead.
These changes keep the syntax the same as <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a>.</p>
   <p>First and foremost, we permit the same <code class="highlight"><c- nl>label</c-><c- p>:</c-></code> multiple times within the same function,
see <a href="#changes-to-labels">§ 4.5 Changes to labels</a>.</p>
   <div class="example" id="example-e8240f6f">
    <a class="self-link" href="#example-e8240f6f"></a> 
<pre class="language-cpp highlight"><c- nl>outer</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- nl>inner</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// breaks enclosing outer while loop</c->
    <c- p>}</c->
<c- p>}</c->

<c- nl>outer</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c-> <c- c1>// OK, reusing label is permitted</c->
    <c- nl>inner</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// breaks enclosing outer while loop</c->
    <c- p>}</c->
<c- p>}</c->

<c- k>goto</c-> <c- n>outer</c-><c- p>;</c-> <c- c1>// error: ambiguous jump target</c->
</pre>
   </div>
   <p class="note" role="note"><span class="marker">Note:</span> This code is well-formed Java and JavaScript.
When using the labels <code class="highlight">'<c- n>outer</c-></code> and <code class="highlight">'<c- n>inner</c-></code> instead, this code is also well-formed Rust.</p>
   <p>In other words, we are doubling down on the <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> syntax and changing labels to behave
more like other mainstream languages.</p>
   <h4 class="heading settled" data-level="4.5.1" id="new-labels-goto"><span class="secno">4.5.1. </span><span class="content">New labels - <code class="highlight"><c- k>goto</c-></code> issues</span><a class="self-link" href="#new-labels-goto"></a></h4>
   <p>The label changes have some implications for <code class="highlight"><c- k>goto</c-></code>:</p>
<pre class="language-cpp highlight"><c- nl>x</c-><c- p>:</c-> <c- n>f</c-><c- p>();</c->
<c- nl>x</c-><c- p>:</c-> <c- n>g</c-><c- p>();</c->
<c- k>goto</c-> <c- n>x</c-><c- p>;</c-> <c- c1>// error: jump is ambiguous</c->
</pre>
   <p>Labeling multiple statements with <code class="highlight"><c- nl>x</c-><c- p>:</c-></code> would now be permitted.
Even though this is essentially useless considering that <code class="highlight"><c- n>f</c-><c- p>()</c-></code> and <code class="highlight"><c- n>g</c-><c- p>()</c-></code> are not loops,
it makes the rules easier to teach, and easier to understand;
there are no special rules for loops.</p>
   <p><code class="highlight"><c- k>goto</c-> <c- n>x</c-><c- p>;</c-></code> is ill-formed because it is ambiguous which <code class="highlight"><c- nl>x</c-><c- p>:</c-></code> label it is meant to jump to.
This change doesn’t break any existing code because existing code cannot have such ambiguities.</p>
   <h4 class="heading settled" data-level="4.5.2" id="new-labels-nesting"><span class="secno">4.5.2. </span><span class="content">New labels - what about nesting?</span><a class="self-link" href="#new-labels-nesting"></a></h4>
   <p>Another case to consider is the following:</p>
<pre class="language-cpp highlight"><c- nl>l</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- nl>l</c-><c- p>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
        <c- k>break</c-> <c- n>l</c-><c- p>;</c->
    <c- p>}</c->
<c- p>}</c->
</pre>
   <p class="note" role="note"><span class="marker">Note:</span> This code is not valid Java or JavaScript, but is valid Rust when using the label <code class="highlight">'<c- n>l</c-></code>.</p>
   <p>We believe that this code should be well-formed.
Developers may run into this case when nesting pairs of <code class="highlight"><c- nl>outer</c-><c- p>:</c-></code>/<code class="highlight"><c- nl>inner</c-><c- p>:</c-></code> loops in each other "manually",
or when a <code class="highlight"><c- nl>l</c-><c- p>:</c-></code> labeled loop in a macro is expanded into a surrounding loop that also uses <code class="highlight"><c- nl>l</c-><c- p>:</c-></code>.</p>
   <p>Such cases are the motivation for <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>, and should be addressed. <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> does not currently permit such nesting,
and that fact will have to be resolved somehow,
either by significant syntax changes through <a data-link-type="biblio" href="#biblio-n3377" title="N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355">[N3377]</a>,
or through relaxation of label rules.</p>
   <h4 class="heading settled" data-level="4.5.3" id="new-labels-duplicates"><span class="secno">4.5.3. </span><span class="content">New labels - what about direct duplicates?</span><a class="self-link" href="#new-labels-duplicates"></a></h4>
   <p>A more extreme form of the scenario above is:</p>
<pre class="language-cpp highlight"><c- nl>l</c-><c- p>:</c-> <c- n>l</c-><c- o>:</c-> <c- n>l</c-><c- o>:</c-> <c- n>l</c-><c- o>:</c-> <c- n>f</c-><c- p>();</c->
</pre>
   <p>We also believe that this code should be well-formed because it’s not harmful,
and may be useful in certain, rare situations.</p>
   <div class="example" id="example-9e2df0e2">
    <a class="self-link" href="#example-9e2df0e2"></a> A somewhat common C idiom is to expand loops from macros;
see also <a href="#against-n3377-macro-loops">§ 4.4.3.10 Labeling loops expanded from macros</a>. 
<pre class="language-cpp highlight"><c- nl>outer</c-><c- p>:</c-> <c- n>MY_LOOP_MACRO</c-><c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>outer</c-><c- p>;</c->
<c- p>}</c->
</pre>
    <p>If <code class="highlight"><c- n>MY_LOOP_MACRO</c-></code> already uses an <code class="highlight"><c- nl>outer</c-><c- p>:</c-></code> label internally,
perhaps because it expands to two nested loops and uses <code class="highlight"><c- k>continue</c-> <c- n>outer</c-><c- p>;</c-></code> itself,
then the macro effectively expands to <code class="highlight"><c- nl>outer</c-><c- p>:</c-> <c- n>outer</c-><c- o>:</c-></code>.</p>
    <p>This forces the user to come up with a new label now, for a seemingly arbitrary reason.</p>
   </div>
   <p>Permitting this case has the benefit that <em>no code at all</em> can become ill-formed through
applying labels.
This rule is simple, teachable, and easy to implement.</p>
   <h4 class="heading settled" data-level="4.5.4" id="new-labels-break-label-multiple"><span class="secno">4.5.4. </span><span class="content">New labels - what about <code class="highlight"><c- k>break</c-> <c- n>label</c-></code> for loops with more than one label?</span><a class="self-link" href="#new-labels-break-label-multiple"></a></h4>
   <p>Another case to consider is this:</p>
<pre class="language-cpp highlight"><c- nl>x</c-><c- p>:</c-> <c- n>y</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c->true<c- p>)</c-> <c- p>{</c->
    <c- k>break</c-> <c- n>x</c-><c- p>;</c->
<c- p>}</c->
</pre>
   <p>Grammatically, <code class="highlight"><c- nl>x</c-><c- p>:</c-> <c- n>y</c-><c- o>:</c-> <c- p>...</c-></code> is a <em>labeled-statement</em>,
where the <em>statement</em> is another <em>labeled-statement</em> <code class="highlight"><c- nl>y</c-><c- p>:</c-> <c- p>...</c-></code>,
with a <em>label</em> <code class="highlight"><c- n>y</c-></code> and a <em>statement</em> <code class="highlight"><c- k>while</c-> <c- p>...</c-></code>.
In other words, <code class="highlight"><c- nl>x</c-><c- p>:</c-></code> doesn’t even apply directly to the loop.</p>
   <p><a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> makes wording changes specifically to address this, and to make this well-formed.
So are we; this code should well-formed if only for the sake of C2y compatibility.</p>
   <h2 class="heading settled" data-level="5" id="impact-on-existing-code"><span class="secno">5. </span><span class="content">Impact on existing code</span><a class="self-link" href="#impact-on-existing-code"></a></h2>
   <p>No existing code becomes ill-formed or has its meaning altered.
This proposal merely permits code which was previously ill-formed,
and relaxes restrictions on the placement of labels.</p>
   <h2 class="heading settled" data-level="6" id="implementation-experience"><span class="secno">6. </span><span class="content">Implementation experience</span><a class="self-link" href="#implementation-experience"></a></h2>
   <p>An LLVM implementation is W.I.P.</p>
   <p>A GCC implementation of <a data-link-type="biblio" href="#biblio-n3355" title="N3355: Named loops, v3">[N3355]</a> has also been committed at <a data-link-type="biblio" href="#biblio-gcc" title="c: Implement C2Y N3355 - Named Loops [PR117022]">[GCC]</a>.</p>
   <h2 class="heading settled" data-level="7" id="proposed-wording"><span class="secno">7. </span><span class="content">Proposed wording</span><a class="self-link" href="#proposed-wording"></a></h2>
   <p>The wording is relative to <a data-link-type="biblio" href="#biblio-n5001" title="Working Draft, Programming Languages — C++">[N5001]</a>.</p>
   <p>Update <a href="https://eel.is/c++draft/stmt.label">[stmt.label]</a> paragraph 1 as follows:</p>
   <blockquote>
     A label can be added to a statement or used anywhere in a <em>compound-statement</em>. 
    <div class="indent">
      <em>label</em>:<br> 
     <div class="indent"> <em>attribute-specifier-seq</em><sub>opt</sub> <em>identifier</em> <code class="highlight"><c- o>:</c-></code><br> <em>attribute-specifier-seq</em><sub>opt</sub> <code class="highlight"><c- k>case</c-></code> <em>constant-expression</em> <code class="highlight"><c- o>:</c-></code><br> <em>attribute-specifier-seq</em><sub>opt</sub> <code class="highlight"><c- k>default</c-></code> <code class="highlight"><c- o>:</c-></code> </div>
      <em>labeled-statement</em>:<br> 
     <div class="indent"> <em>label</em> <em>statement</em> </div>
    </div>
     The optional <em>attribute-specifier-seq</em> appertains to the label. 
    <del>The only use of a label with an <em>identifier</em> is as the target of a <code class="highlight"><c- k>goto</c-></code>.
No two labels in a function shall have the same identifier.</del>
     A label can be used in a <code class="highlight"><c- k>goto</c-></code> statement 
    <ins>([stmt.goto])</ins>
     before its introduction.
    <ins><br><br> [ <em>Note</em>: Multiple identical labels within the same function are permitted,
    but such duplicate labels cannot be used in a <code class="highlight"><c- k>goto</c-></code> statement. — <em>end note</em> ] </ins>
   </blockquote>
   <p>In <a href="https://eel.is/c++draft/stmt.label">[stmt.label]</a> insert a new paragraph after paragraph 1:</p>
   <blockquote>
    <ins>
     A label <strong>L</strong> of the form <em>attribute-specifier-seq</em><sub>opt</sub> <em>identifier</em> <code class="highlight"><c- o>:</c-></code> <em>labels</em> a <em>statement</em> <strong>S</strong> if 
     <ul>
      <li><strong>L</strong> is the <em>label</em> and <strong>S</strong> is the <em>statement</em> of a <em>labeled-statement</em> <strong>X</strong>, or
      <li><strong>L</strong> labels <strong>X</strong> (recursively).
     </ul>
    </ins>
    <div class="ins-block">
      [ <em>Example</em>: 
<pre class="highlight"><c- nl>a</c-><c- p>:</c-> <c- n>b</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c-><c- mi>0</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->            <c- c1>// both a: and b: label the loop</c->
<c- nl>c</c-><c- p>:</c-> <c- p>{</c-> <c- n>d</c-><c- o>:</c-> <c- k>switch</c-> <c- p>(</c-><c- mi>0</c-><c- p>)</c-> <c- p>{</c->           <c- c1>// unlike c:, d: labels the switch statement</c->
    <c- k>default</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c-><c- mi>0</c-><c- p>)</c-> <c- p>{</c-> <c- p>}</c->     <c- c1>// default: labels nothing</c->
<c- p>}</c-> <c- p>}</c->
</pre>
     — <em>end example</em> ]
    </div>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> This defines the term <em>(to) label</em>, which is used extensively below.
We also don’t want <code class="highlight"><c- k>case</c-></code> or <code class="highlight"><c- k>default</c-></code> labels to label statements, since this would inadvertently
permit <code class="highlight"><c- k>break</c-> <c- n>i</c-></code> given <code class="highlight"><c- k>case</c-> <c- no>i</c-><c- p>:</c-></code>, considering how we word [stmt.break].</p>
   <p>Update <a href="https://eel.is/c++draft/stmt.label">[stmt.label]</a> paragraph 3 as follows:</p>
   <blockquote>
     A <em>control-flow-limited statement</em> is a statement <strong>S</strong> for which: 
    <ul>
     <li> a <code class="highlight"><c- k>case</c-></code> or <code class="highlight"><c- k>default</c-></code> label appearing within <strong>S</strong> shall be associated with a <code class="highlight"><c- k>switch</c-></code> statement ([stmt.switch]) within <strong>S</strong>, and 
     <li>
       a label declared in <strong>S</strong> shall only be
        referred to by a statement 
      <del>([stmt.goto])</del>
       in <strong>S</strong>. 
    </ul>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> While the restriction still primarily applies to <code class="highlight"><c- k>goto</c-></code> (preventing the user from e.g. jumping into an <code class="highlight"><c- k>if</c-> <c- k>constexpr</c-></code> statement),
if other statements can also refer to labels, it is misleading to say
"statement ([stmt.goto])" as if <code class="highlight"><c- k>goto</c-></code> was the only relevant statement.</p>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.jump.general">[stmt.jump.general]</a> paragraph 1 as follows:</p>
   <blockquote>
     Jump statements unconditionally transfer control. 
    <div class="indent">
      <em>jump-statement</em>: 
     <div class="indent">
      <ins><code class="highlight"><c- k>goto</c-></code> <em>identifier</em> <code class="highlight"><c- p>;</c-></code></ins>
      <br> <code class="highlight"><c- k>break</c-></code> 
      <ins><em>identifier</em><sub>opt</sub></ins>
       <code class="highlight"><c- p>;</c-></code><br> <code class="highlight"><c- k>continue</c-></code> 
      <ins><em>identifier</em><sub>opt</sub></ins>
       <code class="highlight"><c- p>;</c-></code><br> <code class="highlight"><c- k>return</c-></code> <em>expr-or-braced-init-list</em><sub>opt</sub> <code class="highlight"><c- p>;</c-></code><br> 
      <del><code class="highlight"><c- k>goto</c-></code> <em>identifier</em> <code class="highlight"><c- p>;</c-></code></del>
      <br> 
     </div>
    </div>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> <code class="highlight"><c- k>goto</c-></code> is being relocated to the top so that all the jump statements with an <em>identifier</em> are grouped together.
Of these three, <code class="highlight"><c- k>goto</c-></code> is being listed first because it models the concept of
"jumping somewhere" most literally; every following statement is more sophisticated or even
defined as equivalent to <code class="highlight"><c- k>goto</c-></code> (in the case of <code class="highlight"><c- k>continue</c-></code>).</p>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.break">[stmt.break]</a> paragraph 1 as follows:</p>
   <blockquote>
    <ins>A <em>breakable statement</em> is
an <em>iteration-statement</em> ([stmt.iter]) or a <code class="highlight"><c- k>switch</c-></code> statement ([stmt.switch]).</ins>
     A <code class="highlight"><c- k>break</c-></code> statement shall be enclosed by ([stmt.pre]) 
    <ins>a breakable statement</ins>
    <del>an <em>iteration-statement</em> ([stmt.iter]) or a <code class="highlight"><c- k>switch</c-></code> statement ([stmt.switch])</del>
    . 
    <ins>If present, the <em>identifier</em> shall be part of a label <strong>L</strong> which labels ([stmt.label]) an enclosing breakable statement.</ins>
     The <code class="highlight"><c- k>break</c-></code> statement causes termination of
    <ins>:</ins>
    <del>the smallest such enclosing statement;</del>
    <ul>
     <li>
      <ins>if an <em>identifier</em> is present, the smallest enclosing breakable statement labeled by <strong>L</strong>,</ins>
     <li>
      <ins>otherwise, the smallest enclosing breakable statement.</ins>
    </ul>
    <del>control</del>
    <ins>Control</ins>
     passes to the statement following the terminated statement, if any. <br><br> 
    <div class="ins-block">
      [ <em>Example</em>: 
<pre class="highlight"><c- nl>a</c-><c- p>:</c-> <c- n>b</c-><c- o>:</c-> <c- k>while</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
    <c- nl>a</c-><c- p>:</c-> <c- n>a</c-><c- o>:</c-> <c- n>c</c-><c- o>:</c-> <c- k>for</c-> <c- p>(</c-><c- d>/* ... */</c-><c- p>)</c-> <c- p>{</c->
        <c- k>break</c-><c- p>;</c->              <c- c1>// OK, terminates enclosing for loop</c->
        <c- k>break</c-> <c- n>a</c-><c- p>;</c->            <c- c1>// OK, same</c->
        <c- k>break</c-> <c- n>b</c-><c- p>;</c->            <c- c1>// OK, terminates enclosing while loop</c->
        <c- nl>y</c-><c- p>:</c-> <c- p>{</c-> <c- k>break</c-> <c- n>y</c-><c- p>;</c-> <c- p>}</c->     <c- c1>// error: break does not refer to a breakable statement</c->
    <c- p>}</c->
    <c- k>break</c-> <c- n>c</c-><c- p>;</c->                <c- c1>// error: break does not refer to an enclosing statement</c->
<c- p>}</c->
<c- k>break</c-><c- p>;</c->                      <c- c1>// error: break must be enclosed by a breakable statement</c->
</pre>
     — <em>end example</em> ]
    </div>
   </blockquote>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.cont">[stmt.cont]</a> paragraph 1 as follows:</p>
   <blockquote>
     A <code class="highlight"><c- k>continue</c-></code> statement shall be enclosed by ([stmt.pre]) an <em>iteration-statement</em> ([stmt.iter]). 
    <ins>If present, the <em>identifier</em> shall be part of a label <strong>L</strong> which labels ([stmt.label]) an enclosing <em>iteration-statement</em>.</ins>
     The <code class="highlight"><c- k>continue</c-></code> statement causes control to pass to the loop-continuation portion of
    <ins>:</ins>
    <del>the smallest such enclosing statement, that is, to the end of the loop.</del>
    <ul>
     <li>
      <ins>if an <em>identifier</em> is present, the smallest enclosing <em>iteration-statement</em> labeled by <strong>L</strong>,</ins>
     <li>
      <ins>otherwise, the smallest enclosing <em>iteration-statement</em>.</ins>
    </ul>
     More precisely, in each of the statements 
<pre class="highlight"><ins><c- nl>label</c-><c- p>:</c-> </ins><c- k>while</c-> <c- p>(</c-><c- n>foo</c-><c- p>)</c-> <c- p>{</c->
  <c- p>{</c->
    <c- c1>// ...</c->
  <c- p>}</c->
<c- nl>contin</c-><c- p>:</c-> <c- p>;</c->
<c- p>}</c->

<ins><c- nl>label</c-><c- p>:</c-> </ins><c- k>do</c-> <c- p>{</c->
  <c- p>{</c->
    <c- c1>// ...</c->
  <c- p>}</c->
<c- nl>contin</c-><c- p>:</c-> <c- p>;</c->
<c- p>}</c-> <c- k>while</c-> <c- p>(</c-><c- n>foo</c-><c- p>);</c->

<ins><c- nl>label</c-><c- p>:</c-> </ins><c- k>for</c-> <c- p>(;;)</c-> <c- p>{</c->
  <c- p>{</c->
    <c- c1>// ...</c->
  <c- p>}</c->
<c- nl>contin</c-><c- p>:</c-> <c- p>;</c->
<c- p>}</c->
</pre>
    <del>a <code class="highlight"><c- k>continue</c-></code> not contained in an an enclosed iteration statement is equivalent to <code class="highlight"><c- k>goto</c-> <c- n>contin</c-></code>.</del>
    <ins>
     the following are equivalent to <code class="highlight"><c- k>goto</c-> <c- n>contin</c-></code>: 
     <ul>
      <li>A <code class="highlight"><c- k>continue</c-></code> not contained in an an enclosed iteration statement.
      <li>A <code class="highlight"><c- k>continue</c-> <c- n>label</c-></code> not contained in an enclosed iteration statement labeled <code class="highlight"><c- nl>label</c-><c- p>:</c-></code>.
     </ul>
    </ins>
   </blockquote>
   <p class="note" role="note"><span class="marker">Note:</span> The clarification "that is, to the end of the loop"
was dropped entirely based on community feedback.
"the end of the loop" is not all that much clearer either, and the whole <code class="highlight"><c- k>goto</c-></code> equivalence portion
should make it clear enough what the behavior is.</p>
   <hr>
   <p>Update <a href="https://eel.is/c++draft/stmt.goto">[stmt.goto]</a> paragraph 1 as follows:</p>
   <blockquote>
     The <code class="highlight"><c- k>goto</c-></code> statement unconditionally transfers control to 
    <del>the</del>
    <ins>a</ins>
     statement
labeled 
    <ins>([stmt.label])</ins>
     by 
    <del>the identifier</del>
    <ins>a label in the current function containing <em>identifier</em>, but not to a <code class="highlight"><c- k>case</c-></code> label</ins>
    . 
    <del>The identifier shall be a label located in the current function.</del>
    <ins>There shall be exactly one such label.</ins>
   </blockquote>
   <div class="note" role="note">
     <span class="marker">Note:</span> This wording has always been defective and our proposal fixes this.
The term "to label" was never defined,
and the requirement that an identifier shall be a label is impossible to satisfy because
a label ends with a <code class="highlight"><c- o>:</c-></code>, and an <em>identifier</em> in itself would never match the <em>label</em> rule. 
    <p>The previous wording may have also allowed for <code class="highlight"><c- k>goto</c-> <c- n>x</c-><c- p>;</c-></code> to jump between two different functions
both containing <code class="highlight"><c- nl>x</c-><c- p>:</c-></code> because while there has to be some label <code class="highlight"><c- nl>x</c-><c- p>:</c-></code> in the current function,
we don’t say that we jump to the <code class="highlight"><c- nl>x</c-><c- p>:</c-></code> in the current function specifically.</p>
   </div>
   <h2 class="heading settled" data-level="8" id="acknowledgements"><span class="secno">8. </span><span class="content">Acknowledgements</span><a class="self-link" href="#acknowledgements"></a></h2>
   <p>I thank Sebastian Wittmeier for providing a list of languages that support both <code class="highlight"><c- k>goto</c-></code> and <code class="highlight"><c- k>break</c-></code>/<code class="highlight"><c- n>last</c-></code> with the same label syntax.
This has been helpful for writing <a href="#against-n3377-breaking-precedent">§ 4.4.3.1 Breaking precedent of most prior art</a>.</p>
   <p>I think Arthur O’Dwyer and Jens Maurer for providing wording feedback and improvement suggestions.</p>
   <p>I thank the <a href="https://discord.gg/tccpp">Together C &amp; C++</a> community for responding to my poll; see <a data-link-type="biblio" href="#biblio-tccpp" title="Poll at Together C &amp; C++ (discord.gg/tccpp)">[TCCPP]</a>.</p>
  </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="normative"><span class="content">Normative References</span><a class="self-link" href="#normative"></a></h3>
  <dl>
   <dt id="biblio-n5001">[N5001]
   <dd>Thomas Köppe. <a href="https://wg21.link/n5001"><cite>Working Draft, Programming Languages — C++</cite></a>. 17 December 2024. URL: <a href="https://wg21.link/n5001">https://wg21.link/n5001</a>
  </dl>
  <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-cpp2">[Cpp2]
   <dd>Herb Sutter. <a href="https://hsutter.github.io/cppfront/cpp2/functions/#loop-names-break-and-continue"><cite>Cpp2 documentation - Loop names, break, and continue</cite></a>. URL: <a href="https://hsutter.github.io/cppfront/cpp2/functions/#loop-names-break-and-continue">https://hsutter.github.io/cppfront/cpp2/functions/#loop-names-break-and-continue</a>
   <dt id="biblio-cppcoreguidelineses76">[CppCoreGuidelinesES76]
   <dd>CppCoreGuidelines contributors. <a href="https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-goto"><cite>CppCoreGuidelines/ES.76: Avoid goto</cite></a>. URL: <a href="https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-goto">https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-goto</a>
   <dt id="biblio-gcc">[GCC]
   <dd>Jakub Jelinek. <a href="https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=50f27896adb272b40ab03a56fd192e74789bef97"><cite>c: Implement C2Y N3355 - Named Loops [PR117022]</cite></a>. URL: <a href="https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=50f27896adb272b40ab03a56fd192e74789bef97">https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git;h=50f27896adb272b40ab03a56fd192e74789bef97</a>
   <dt id="biblio-gotoconsideredharmful">[GotoConsideredHarmful]
   <dd>Edgar Dijkstra. <a href="https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf"><cite>Go To Statement Considered Harmful</cite></a>. 1968. URL: <a href="https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf">https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf</a>
   <dt id="biblio-isocpp-core">[ISOCPP-CORE]
   <dd>CWG. <a href="https://lists.isocpp.org/core/2023/05/14228.php"><cite>Discussion regarding continue vs. goto in constant expressions</cite></a>. URL: <a href="https://lists.isocpp.org/core/2023/05/14228.php">https://lists.isocpp.org/core/2023/05/14228.php</a>
   <dt id="biblio-misra-c">[MISRA-C++]
   <dd>MISRA Consortium Limited. <a href="https://misra.org.uk/product/misra-cpp2023/"><cite>MISRA C++:2023</cite></a>. URL: <a href="https://misra.org.uk/product/misra-cpp2023/">https://misra.org.uk/product/misra-cpp2023/</a>
   <dt id="biblio-n3355">[N3355]
   <dd>Alex Celeste. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm"><cite>N3355: Named loops, v3</cite></a>. 2024-09-18. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm</a>
   <dt id="biblio-n3377">[N3377]
   <dd>Erich Keane. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3377.pdf"><cite>N3377: Named Loops Should Name Their Loops: An Improved Syntax For N3355</cite></a>. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3377.pdf">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3377.pdf</a>
   <dt id="biblio-n3435">[N3435]
   <dd>JeanHeyd Meneide; Freek Wiedijk. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3435.pdf"><cite>ISO/IEC 9899:202y (en) — n3435 working draft</cite></a>. URL: <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3435.pdf">https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3435.pdf</a>
   <dt id="biblio-n3879">[N3879]
   <dd>Andrew Tomazos. <a href="https://wg21.link/n3879"><cite>Explicit Flow Control: break label, goto case and explicit switch</cite></a>. 16 January 2014. URL: <a href="https://wg21.link/n3879">https://wg21.link/n3879</a>
   <dt id="biblio-n4327">[N4327]
   <dd>Ville Voutilanen. <a href="https://wg21.link/n4327"><cite>C++ Standard Evolution Closed Issues List (Revision R10)</cite></a>. 21 November 2014. URL: <a href="https://wg21.link/n4327">https://wg21.link/n4327</a>
   <dt id="biblio-p2635r0">[P2635R0]
   <dd>Justin Cooke. <a href="https://wg21.link/p2635r0"><cite>Enhancing the break statement</cite></a>. 21 August 2022. URL: <a href="https://wg21.link/p2635r0">https://wg21.link/p2635r0</a>
   <dt id="biblio-reddit">[Reddit]
   <dd>Jan Schultke. <a href="https://www.reddit.com/r/cpp/comments/1hwdskt/break_label_and_continue_label_in_c/"><cite>"break label;" and "continue label;" in C++</cite></a>. URL: <a href="https://www.reddit.com/r/cpp/comments/1hwdskt/break_label_and_continue_label_in_c/">https://www.reddit.com/r/cpp/comments/1hwdskt/break_label_and_continue_label_in_c/</a>
   <dt id="biblio-stackoverflow">[StackOverflow]
   <dd>Faken. <a href="https://stackoverflow.com/q/1257744/5740428"><cite>Can I use break to exit multiple nested 'for' loops?</cite></a>. 10 Aug 2009. URL: <a href="https://stackoverflow.com/q/1257744/5740428">https://stackoverflow.com/q/1257744/5740428</a>
   <dt id="biblio-std-proposals">[STD-PROPOSALS]
   <dd>Jan Schultke. <a href="https://lists.isocpp.org/std-proposals/2024/12/11838.php"><cite>Bringing break/continue with label to C++</cite></a>. URL: <a href="https://lists.isocpp.org/std-proposals/2024/12/11838.php">https://lists.isocpp.org/std-proposals/2024/12/11838.php</a>
   <dt id="biblio-std-proposals-2">[STD-PROPOSALS-2]
   <dd>Filip. <a href="https://lists.isocpp.org/std-proposals/2024/11/11585.php"><cite>Improving break &amp; continue</cite></a>. URL: <a href="https://lists.isocpp.org/std-proposals/2024/11/11585.php">https://lists.isocpp.org/std-proposals/2024/11/11585.php</a>
   <dt id="biblio-tccpp">[TCCPP]
   <dd><a href="https://discord.com/channels/331718482485837825/851121440425639956/1318965556128383029"><cite>Poll at Together C &amp; C++ (discord.gg/tccpp)</cite></a>. URL: <a href="https://discord.com/channels/331718482485837825/851121440425639956/1318965556128383029">https://discord.com/channels/331718482485837825/851121440425639956/1318965556128383029</a>
   <dt id="biblio-uthashdocs">[UthashDocs]
   <dd>Troy D. Hanson; Arthur O'Dwyer. <a href="https://troydhanson.github.io/uthash/userguide.html#deletesafe"><cite>uthash User Guide: Deletion-safe iteration</cite></a>. URL: <a href="https://troydhanson.github.io/uthash/userguide.html#deletesafe">https://troydhanson.github.io/uthash/userguide.html#deletesafe</a>
  </dl>