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

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

	body {
		counter-reset: example figure issue;

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	p {
		margin: 1em 0;
	}

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

  /* Do something nice. */

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

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

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

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

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

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

	img {
		border-style: none;
	}

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

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

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

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

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

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

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

	blockquote {
		border-color: silver;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/*
Alternate table alignment rules

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

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

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

Possible extra rowspan handling

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

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

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


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

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

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

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

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

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

		.toc li {
			clear: both;
		}

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

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

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


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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

.del, del, del *, span.del, span.del * {
  background-color: rgb(250, 200, 200);
  color: rgb(255, 0, 0);
  text-decoration: line-through;
  text-decoration-color: rgb(255, 0, 0);
}
</style>
<style>/* style-md-lists */

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

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

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

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

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

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

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

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

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

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

[data-link-type=biblio] {
    white-space: pre;
}</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1099R5<br>Using Enum</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2019-07-16">2019-07-16</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://github.com/atomgalaxy/using-enum/using-enum.bs">https://github.com/atomgalaxy/using-enum/using-enum.bs</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><span class="p-name fn">Gašper Ažman &lt;gasper.azman@gmail.com></span>
     <dd>
      <dd class="editor p-author h-card vcard"><span class="p-name fn">Jonathan Müller &lt;jonathan.mueller@foonathan.net></span>
     <dt>Audience:
     <dd>CWG
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>Class enums are restricted namespaces. Let’s extend the using declaration to them.</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="#status"><span class="secno">2</span> <span class="content">Status of this paper</span></a>
    <li><a href="#motivation"><span class="secno">3</span> <span class="content">Motivation</span></a>
    <li>
     <a href="#rationale"><span class="secno">4</span> <span class="content">Rationale</span></a>
     <ol class="toc">
      <li><a href="#consistency"><span class="secno">4.1</span> <span class="content">Consistency</span></a>
      <li><a href="#betterids"><span class="secno">4.2</span> <span class="content">Better Identifiers</span></a>
      <li><a href="#need"><span class="secno">4.3</span> <span class="content">Evidence of Need</span></a>
     </ol>
    <li>
     <a href="#proposal"><span class="secno">5</span> <span class="content">Proposal</span></a>
     <ol class="toc">
      <li><a href="#using-id"><span class="secno">5.1</span> <span class="content">Syntax: <code class="highlight"><c- k>using</c-> <c- n>ENUM_ID</c-><c- o>::</c-><c- n>IDENTIFIER</c-></code></span></a>
      <li><a href="#using-enum-id"><span class="secno">5.2</span> <span class="content">Syntax: <code class="highlight"><c- k>using</c-> <c- k>enum</c-> <c- n>IDENTIFIER</c-></code></span></a>
     </ol>
    <li>
     <a href="#examples"><span class="secno">6</span> <span class="content">Examples</span></a>
     <ol class="toc">
      <li><a href="#strong-enums-global-ids"><span class="secno">6.1</span> <span class="content">Strongly typed enums with global identifiers</span></a>
      <li><a href="#no-prefix-switches"><span class="secno">6.2</span> <span class="content">Switching with no syntax overhead</span></a>
      <li><a href="#adding-adl-only-functions-to-enumerations"><span class="secno">6.3</span> <span class="content">Adding ADL-only Functions to Enumerations:</span></a>
     </ol>
    <li>
     <a href="#faq"><span class="secno">7</span> <span class="content">Frequently Asked Questions</span></a>
     <ol class="toc">
      <li><a href="#faq-impl"><span class="secno">7.1</span> <span class="content">Has this been implemented?</span></a>
      <li><a href="#faq-old-enum"><span class="secno">7.2</span> <span class="content">Can I do this with unscoped enums?</span></a>
      <li><a href="#faq-ns-alias"><span class="secno">7.3</span> <span class="content">Are you proposing mirroring the namespace alias syntax as well?</span></a>
      <li><a href="#faq-using-enum-struct"><span class="secno">7.4</span> <span class="content">Why not allow <code class="highlight"><c- k>using</c-> <c- k>enum</c-> <c- k>struct</c-><c- o>/</c-><c- k>class</c-> <c- nc>ENUM_ID</c-><c- p>;</c-></code>?</span></a>
      <li><a href="#faq-using-decl-why"><span class="secno">7.5</span> <span class="content">Why propose <code class="highlight"><c- k>using</c-> <c- n>ENUM_ID</c-><c- o>::</c-><c- n>IDENTIFIER</c-></code> at all?</span></a>
     </ol>
    <li>
     <a href="#clarifications-for-special-cases"><span class="secno">8</span> <span class="content">Clarifications for Special Cases</span></a>
     <ol class="toc">
      <li><a href="#namespaceudecl-p3"><span class="secno">8.1</span> <span class="content">[namespace.udecl] p3</span></a>
      <li><a href="#namespaceudecl-p8"><span class="secno">8.2</span> <span class="content">[namespace.udecl] p8</span></a>
      <li><a href="#commas-in-the-using-declaration"><span class="secno">8.3</span> <span class="content">Commas in the using declaration</span></a>
      <li><a href="#commas-in-the-using-enum-declaration"><span class="secno">8.4</span> <span class="content">Commas in the <i>using-enum-declaration</i></span></a>
      <li><a href="#names-using-enum-declaration-introduces"><span class="secno">8.5</span> <span class="content">Names <em>using-enum-declaration</em> introduces</span></a>
     </ol>
    <li>
     <a href="#wording"><span class="secno">9</span> <span class="content">Proposed Wording</span></a>
     <ol class="toc">
      <li><a href="#wording-preface"><span class="secno">9.1</span> <span class="content">Preface</span></a>
      <li><a href="#wording-changes"><span class="secno">9.2</span> <span class="content">Changes</span></a>
     </ol>
    <li><a href="#ack"><span class="secno">10</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="#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>
   <ul>
    <li data-md>
     <p>r1: Typos. Changed target from LEWG to EWG.</p>
    <li data-md>
     <p>r2: Added FAQ and wording, and extended to regular enums.</p>
    <li data-md>
     <p>r3: Added examples. Nothing of substance changed.</p>
    <li data-md>
     <p>r4: Clarified that <code class="highlight"><c- k>using</c-> <c- k>enum</c-> <c- n>enum_name</c-></code> is supposed to have semantics as if the names were declared in the local scope as opposed to the way <em>using-directive</em> does it, as per EWG poll. Added Eric Niebler’s example for using this feature to enable ADL-only functions on exposed enumerators (to support <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>begin</c-></code> being a CPO). Added editorial notes for renaming the current Using Directive to Using Namespace Directive on Richard Smith’s request.</p>
    <li data-md>
     <p>r5: Applied fixes from Jens Maurer: added feature test macro, a number of technical wording fixes, added example, renamed from <em>using-enum-directive</em> to <em>using-enum-declaration</em>. Removed editorial notes for renaming <em>using-namespace-directive</em> since they are now not needed.</p>
     <ul>
      <li data-md>
       <p>r5, post round 1 of CWG review: added clashing example, added "completely specified" wording to [dcl.enum], added wording that named enum is completely-specified.</p>
      <li data-md>
       <p>r5, post round 1.5 of CWG review: used wording from CWG, split example in [enum.udecl].</p>
      <li data-md>
       <p>r5, post round 2 of CWG review: added example in namespace.udir.</p>
      <li data-md>
       <p>r5, morning: fixed reference to N4800, added <a class="property" data-link-type="propdesc">Example</a> to second example in note.</p>
      <li data-md>
       <p>r5, post round 3 of CWG review: removed full stops at end of code comments in examples, 'orange, apple' -> 'orange and apple', added [Example: --end example] to both examples in the 2nd note to make it clear where they begin and end, 'are in conflict' -> <a class="property" data-link-type="propdesc">conflict</a>.</p>
      <li data-md>
       <p>r5: Approved by CWG.</p>
     </ul>
   </ul>
   <h2 class="heading settled" data-level="2" id="status"><span class="secno">2. </span><span class="content">Status of this paper</span><a class="self-link" href="#status"></a></h2>
   <p>This paper has been approved by CWG in Cologne 2019 for C++20 after being approved by EWG in Kona 2019 (ship vehicle C++20).</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>
   <blockquote>
    <p>The single biggest deterrent to use of scoped enumerations is the inability to associate them with a <em>using directive</em>.</p>
    <p>    — Dan Saks</p>
   </blockquote>
   <p>Consider an enum class:</p>
<pre class="language-cpp highlight"><c- k>enum</c-> <c- k>class</c-> <c- nc>rgba_color_channel</c-> <c- p>{</c-> <c- n>red</c-><c- p>,</c-> <c- n>green</c-><c- p>,</c-> <c- n>blue</c-><c- p>,</c-> <c- n>alpha</c-> <c- p>};</c->
</pre>
   <p>Currently, a switch using this enum looks as follows:</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>to_string</c-><c- p>(</c-><c- n>rgba_color_channel</c-> <c- n>channel</c-><c- p>)</c-> <c- p>{</c->
  <c- k>switch</c-> <c- p>(</c-><c- n>channel</c-><c- p>)</c-> <c- p>{</c->
    <c- k>case</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- nl>red</c-><c- p>:</c->   <c- k>return</c-> <c- s>"red"</c-><c- p>;</c->
    <c- k>case</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- nl>green</c-><c- p>:</c-> <c- k>return</c-> <c- s>"green"</c-><c- p>;</c->
    <c- k>case</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- nl>blue</c-><c- p>:</c->  <c- k>return</c-> <c- s>"blue"</c-><c- p>;</c->
    <c- k>case</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- nl>alpha</c-><c- p>:</c-> <c- k>return</c-> <c- s>"alpha"</c-><c- p>;</c->
  <c- p>}</c->
<c- p>}</c->
</pre>
   <p>The necessary repetition of the <code class="highlight"><c- k>enum</c-> <c- k>class</c-></code> name reduces legibility by introducing noise in contexts where said name is obvious.</p>
   <p>To eliminate the noise penalty for introducing long (but descriptive) <code class="highlight"><c- k>enum</c-> <c- k>class</c-></code> names, this paper proposes that the statement</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- k>enum</c-> <c- n>rgba_color_channel</c-><c- p>;</c->
</pre>
   <p>introduce the enumerator identifiers into the local scope, so they may be referred to unqualified.</p>
   <p>Furthermore, the syntax</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- n>red</c-><c- p>;</c->
</pre>
   <p>should bring the identifier <code class="highlight"><c- n>red</c-></code> into the local scope, so it may be used unqualified.</p>
   <p>The above example would then be written as</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>to_string</c-><c- p>(</c-><c- n>rgba_color_channel</c-> <c- n>channel</c-><c- p>)</c-> <c- p>{</c->
  <c- k>switch</c-> <c- p>(</c-><c- n>my_channel</c-><c- p>)</c-> <c- p>{</c->
    <c- k>using</c-> <c- k>enum</c-> <c- n>rgba_color_channel</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>red</c-><c- p>:</c->   <c- k>return</c-> <c- s>"red"</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>green</c-><c- p>:</c-> <c- k>return</c-> <c- s>"green"</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>blue</c-><c- p>:</c->  <c- k>return</c-> <c- s>"blue"</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>alpha</c-><c- p>:</c-> <c- k>return</c-> <c- s>"alpha"</c-><c- p>;</c->
  <c- p>}</c->
<c- p>}</c->
</pre>
   <h2 class="heading settled" data-level="4" id="rationale"><span class="secno">4. </span><span class="content">Rationale</span><a class="self-link" href="#rationale"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="consistency"><span class="secno">4.1. </span><span class="content">Consistency</span><a class="self-link" href="#consistency"></a></h3>
   <p><code class="highlight"><c- k>enum</c-> <c- k>class</c-></code>es and <code class="highlight"><c- k>enum</c-></code>s are not classes - they are closer to namespaces comprising <code class="highlight"><c- k>static</c-> <c- k>constexpr</c-></code> inline variables. The familiar <code class="highlight"><c- k>using</c-></code> syntax that works for namespaces should therefore apply to them as well, in some fashion. Because they are closed, small, and do not contain overload sets, we can do better than the <em>using-directive</em> does for namespaces, and actually get the identifiers into the local scope, which is what the user expects.</p>
   <h3 class="heading settled" data-level="4.2" id="betterids"><span class="secno">4.2. </span><span class="content">Better Identifiers</span><a class="self-link" href="#betterids"></a></h3>
   <p>The introduction of this feature would allow better naming of enumerations. Currently, enums are named with as short an identifier as possible, often to the point of absurdity, when they are reduced to completely nondescriptive abbreviations that only hint at their proper meaning. (Just what does <code class="highlight"><c- n>zfqc</c-><c- o>::</c-><c- n>add_op</c-></code> really mean?)</p>
   <p>With this feature, identifiers become available to unqualified lookup in local contexts where their source is obvious, giving control of lookup style back to the user of the enum, instead of baking lookup semantics into the type of the enum.</p>
   <h3 class="heading settled" data-level="4.3" id="need"><span class="secno">4.3. </span><span class="content">Evidence of Need</span><a class="self-link" href="#need"></a></h3>
   <p>At a casual search, we were able to locate this <a href="https://stackoverflow.com/questions/9450338/equivalent-of-using-namespace-x-for-scoped-enumerations">thread on stackoverflow</a>.</p>
   <p>Anecdotally, 100% of people the authors have shown this to (~30) at CppCon have displayed a very enthusiastic response, with frequent comments of "I’d use enum classes but they are too verbose, this solves my problem!"</p>
   <h2 class="heading settled" data-level="5" id="proposal"><span class="secno">5. </span><span class="content">Proposal</span><a class="self-link" href="#proposal"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="using-id"><span class="secno">5.1. </span><span class="content">Syntax: <code class="highlight"><c- k>using</c-> <c- n>ENUM_ID</c-><c- o>::</c-><c- n>IDENTIFIER</c-></code></span><a class="self-link" href="#using-id"></a></h3>
   <p>We propose to allow the syntax of</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- n>ENUM_ID</c-><c- o>::</c-><c- n>IDENTIFIER</c->
</pre>
   <p>to introduce the <code class="highlight"><c- n>IDENTIFIER</c-></code> into the local namespace, aliasing <code class="highlight"><c- n>ENUM_ID</c-><c- o>::</c-><c- n>IDENTIFIER</c-></code>.</p>
   <p>This would mirror the current syntax for introducing namespaced names into the current scope.</p>
   <p class="note" role="note"><span>Note:</span> this does not conflict with <a data-link-type="biblio" href="#biblio-p0945r0">[P0945R0]</a>, because that paper only deals with the syntax <code class="highlight"><c- k>using</c-> <c- n>name</c-> <c- o>=</c-> <c- n>id</c-><c- o>-</c-><c- n>expression</c-></code>, which duplicates the enumerator name.</p>
   <h3 class="heading settled" data-level="5.2" id="using-enum-id"><span class="secno">5.2. </span><span class="content">Syntax: <code class="highlight"><c- k>using</c-> <c- k>enum</c-> <c- n>IDENTIFIER</c-></code></span><a class="self-link" href="#using-enum-id"></a></h3>
   <p>We propose the addition of a new <code class="highlight"><c- k>using</c-> <c- k>enum</c-></code> statement:</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- k>enum</c-> <c- n>IDENTIFIER</c-><c- p>;</c->
</pre>
   <p>This makes all the enumerators of the enum available for lookup in the local scope. It’s almost as if it expanded to a series of <code class="highlight"><c- k>using</c-> <c- n>ENUM</c-><c- o>::</c-><c- n>ENUMERATOR</c-></code> statements for every enumerator in the enum, but doesn’t actually introduce any declarations into the local scope.</p>
   <p>(Note: this was changed from "works as a using-directive" to the current way with a strong direction poll from EWG.)</p>
   <h2 class="heading settled" data-level="6" id="examples"><span class="secno">6. </span><span class="content">Examples</span><a class="self-link" href="#examples"></a></h2>
   <h3 class="heading settled" data-level="6.1" id="strong-enums-global-ids"><span class="secno">6.1. </span><span class="content">Strongly typed enums with global identifiers</span><a class="self-link" href="#strong-enums-global-ids"></a></h3>
   <p>This proposal lets you make strongly-typed enums still export their identifiers to namespace scope, therefore behaving like the old enums in that respect:</p>
<pre class="highlight"><c- k>namespace</c-> <c- n>my_lib</c-> <c- p>{</c->

<c- k>enum</c-> <c- k>class</c-> <c- nc>errcode</c-> <c- p>{</c->
  <c- n>SUCCESS</c-> <c- o>=</c-> <c- mi>0</c-><c- p>,</c->
  <c- n>ENOMEM</c-> <c- o>=</c-> <c- mi>1</c-><c- p>,</c->
  <c- n>EAGAIN</c-> <c- o>=</c-> <c- mi>2</c-><c- p>,</c->
  <c- n>ETOOSLOW</c-> <c- o>=</c-> <c- mi>3</c->
<c- p>};</c->
<c- k>using</c-> <c- k>enum</c-> <c- n>errcode</c-><c- p>;</c-> <c- c1>// import enumerators into namespace</c->

<c- p>}</c->

<c- k>namespace</c-> <c- n>NS</c-> <c- p>{</c->

<c- n>my_lib</c-><c- o>::</c-><c- n>errcode</c-> <c- n>get_widget</c-><c- p>()</c-> <c- p>{</c->
  <c- k>using</c-> <c- k>namespace</c-> <c- n>my_lib</c-><c- p>;</c->
  <c- k>return</c-> <c- n>ETOOSLOW</c-><c- p>;</c-> <c- c1>// works, and conversions to int don’t.</c->
<c- p>}</c->

<c- p>}</c->
</pre>
   <h3 class="heading settled" data-level="6.2" id="no-prefix-switches"><span class="secno">6.2. </span><span class="content">Switching with no syntax overhead</span><a class="self-link" href="#no-prefix-switches"></a></h3>
   <p>The proposal allows for importing enums inside the switch body, which is a scope, and using them for labels:</p>
<pre class="language-cpp highlight"><c- k>enum</c-> <c- k>class</c-> <c- nc>rgba_color_channel</c-> <c- p>{</c-> <c- n>red</c-><c- p>,</c-> <c- n>green</c-><c- p>,</c-> <c- n>blue</c-><c- p>,</c-> <c- n>alpha</c-><c- p>};</c->

<c- n>std</c-><c- o>::</c-><c- n>string_view</c-> <c- n>to_string</c-><c- p>(</c-><c- n>rgba_color_channel</c-> <c- n>channel</c-><c- p>)</c-> <c- p>{</c->
  <c- k>switch</c-> <c- p>(</c-><c- n>my_channel</c-><c- p>)</c-> <c- p>{</c->
    <c- k>using</c-> <c- k>enum</c-> <c- n>rgba_color_channel</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>red</c-><c- p>:</c->   <c- k>return</c-> <c- s>"red"</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>green</c-><c- p>:</c-> <c- k>return</c-> <c- s>"green"</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>blue</c-><c- p>:</c->  <c- k>return</c-> <c- s>"blue"</c-><c- p>;</c->
    <c- k>case</c-> <c- nl>alpha</c-><c- p>:</c-> <c- k>return</c-> <c- s>"alpha"</c-><c- p>;</c->
  <c- p>}</c->
<c- p>}</c->
</pre>
   <h3 class="heading settled" data-level="6.3" id="adding-adl-only-functions-to-enumerations"><span class="secno">6.3. </span><span class="content">Adding ADL-only Functions to Enumerations:</span><a class="self-link" href="#adding-adl-only-functions-to-enumerations"></a></h3>
   <p>The proposal allows for adding ADL-only functions to enumerations without enumerators (supported now) and enumerators (currently not supported):</p>
<pre class="language-cpp highlight"><c- k>namespace</c-> <c- n>ns</c-> <c- p>{</c->
  <c- k>struct</c-> <c- n>E_detail</c-> <c- p>{</c->
    <c- k>enum</c-> <c- n>E</c-> <c- p>{</c->
      <c- n>e1</c-> 
    <c- p>};</c->
    <c- k>friend</c-> <c- b>void</c-> <c- nf>swap</c-><c- p>(</c-><c- n>E</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>&amp;</c-><c- p>);</c->  <c- c1>// adl-only swap in the only associated scope of the enum</c->
  <c- p>};</c->
  <c- k>using</c-> <c- n>E</c-> <c- o>=</c-> <c- n>E_detail</c-><c- o>::</c-><c- n>E</c-><c- p>;</c->  <c- c1>// import E into ns</c->
  <c- k>using</c-> <c- k>enum</c-> <c- n>E</c-><c- p>;</c->           <c- c1>// expose the enumerators of E in ns. Also note the direct reference to E.</c->
<c- p>}</c->

<c- b>int</c-> <c- n>main</c-><c- p>()</c-> <c- p>{</c->
  <c- k>auto</c-> <c- n>x</c-> <c- o>=</c-> <c- n>ns</c-><c- o>::</c-><c- n>e1</c-><c- p>;</c->
  <c- k>auto</c-> <c- n>y</c-> <c- o>=</c-> <c- n>ns</c-><c- o>::</c-><c- n>e2</c-><c- p>;</c->
  <c- n>swap</c-><c- p>(</c-><c- n>x</c-><c- p>,</c-> <c- n>y</c-><c- p>);</c-> <c- c1>// finds the swap in the associated struct</c->
<c- p>}</c->
</pre>
   <p>This example was slightly modified from Eric Niebler’s on the <i>lib</i> mailing list when trying to find a way to make <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>begin</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>end</c-></code> CPOs in a backwards-compatible fashion.</p>
   <h2 class="heading settled" data-level="7" id="faq"><span class="secno">7. </span><span class="content">Frequently Asked Questions</span><a class="self-link" href="#faq"></a></h2>
   <h3 class="heading settled" data-level="7.1" id="faq-impl"><span class="secno">7.1. </span><span class="content">Has this been implemented?</span><a class="self-link" href="#faq-impl"></a></h3>
   <p>Yes. The author has an implementation in clang. It has not been reviewed or released yet, however. There do not seem to be major issues with implementation. In particular, the <code class="highlight"><c- k>using</c-> <c- n>ENUM</c-><c- o>::</c-><c- n>IDENTIFIER</c-></code> syntax literally entailed removing a condition from an if-statement, and that was it.</p>
   <h3 class="heading settled" data-level="7.2" id="faq-old-enum"><span class="secno">7.2. </span><span class="content">Can I do this with unscoped enums?</span><a class="self-link" href="#faq-old-enum"></a></h3>
   <p>Yes. The motivation for that is the pattern</p>
<pre class="language-cpp highlight"><c- k>class</c-> <c- nc>foo</c-> <c- p>{</c->
   <c- k>enum</c-> <c- n>bar</c-> <c- p>{</c->
     <c- n>A</c-><c- p>,</c->
     <c- n>B</c-><c- p>,</c->
     <c- n>C</c->
   <c- p>};</c->
<c- p>};</c->
</pre>
   <p>which was superceeded by scoped enums. With the feature this paper proposes one can bring <code class="highlight"><c- n>A</c-></code>, <code class="highlight"><c- n>B</c-></code> and <code class="highlight"><c- n>C</c-></code> into the local scope by invoking:</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- k>enum</c-> <c- o>::</c-><c- n>foo</c-><c- o>::</c-><c- n>bar</c-><c- p>;</c->
</pre>
   <h3 class="heading settled" data-level="7.3" id="faq-ns-alias"><span class="secno">7.3. </span><span class="content">Are you proposing mirroring the namespace alias syntax as well?</span><a class="self-link" href="#faq-ns-alias"></a></h3>
   <p>No. We already have a way to do that, and it looks like this:</p>
<pre class="language-cpp highlight"><c- k>using</c-> <c- n>my_alias</c-> <c- o>=</c-> <c- n>my</c-><c- o>::</c-><c- n>name_space</c-><c- o>::</c-><c- n>enum_name</c-><c- p>;</c->
</pre>
   <p>In addition, <a data-link-type="biblio" href="#biblio-p0945r0">[P0945R0]</a> proposes deprecating namespace aliases in favor of generalized <code class="highlight"><c- k>using</c-> <c- n>name</c-> <c- o>=</c-> <c- n>id_expression</c-></code>, so doing this would go counter the current movement of the standard.</p>
   <h3 class="heading settled" data-level="7.4" id="faq-using-enum-struct"><span class="secno">7.4. </span><span class="content">Why not allow <code class="highlight"><c- k>using</c-> <c- k>enum</c-> <c- k>struct</c-><c- o>/</c-><c- k>class</c-> <c- nc>ENUM_ID</c-><c- p>;</c-></code>?</span><a class="self-link" href="#faq-using-enum-struct"></a></h3>
   <p>Because would have been a needless complication and would introduce another layer of "<code class="highlight"><c- k>struct</c-></code> and <code class="highlight"><c- k>class</c-></code> don’t match" linter errors that current <code class="highlight"><c- k>class</c-></code>es and <code class="highlight"><c- k>struct</c-></code>s already have with forward declarations.</p>
   <h3 class="heading settled" data-level="7.5" id="faq-using-decl-why"><span class="secno">7.5. </span><span class="content">Why propose <code class="highlight"><c- k>using</c-> <c- n>ENUM_ID</c-><c- o>::</c-><c- n>IDENTIFIER</c-></code> at all?</span><a class="self-link" href="#faq-using-decl-why"></a></h3>
   <p>... given that the following already works:</p>
<pre class="language-cpp highlight">  <c- k>constexpr</c-> <c- k>auto</c-> <c- n>red</c-> <c- o>=</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- n>red</c-><c- p>;</c->
</pre>
   <p>and that, given <a data-link-type="biblio" href="#biblio-p0945r0">[P0945R0]</a>, this will work:</p>
<pre class="language-cpp highlight">  <c- k>using</c-> <c- n>red</c-> <c- o>=</c-> <c- n>rgba_color_channel</c-><c- o>::</c-><c- n>red</c-><c- p>;</c->
</pre>
   <p>The reason is "DRY" - don’t repeat yourself - one is forced to repeat the name of the enumerator. That said, the authors are perfectly willing to throw this part of the paper out if the <code class="highlight"><c- k>using</c-> <c- k>enum</c-> <c- n>ENUM_ID</c-></code> piece gets consensus and this is the stumbling block.</p>
   <h2 class="heading settled" data-level="8" id="clarifications-for-special-cases"><span class="secno">8. </span><span class="content">Clarifications for Special Cases</span><a class="self-link" href="#clarifications-for-special-cases"></a></h2>
   <p>This section lists additional clarifications that may help inform the the wording.</p>
   <h3 class="heading settled" data-level="8.1" id="namespaceudecl-p3"><span class="secno">8.1. </span><span class="content">[namespace.udecl] p3</span><a class="self-link" href="#namespaceudecl-p3"></a></h3>
   <p>Interplays with [namespace.udecl] p10:</p>
<pre class="language-cpp highlight"><c- k>enum</c-> <c- n>E</c-> <c- p>{</c-> <c- n>x</c-> <c- p>};</c->
<c- k>struct</c-> <c- n>S</c-> <c- p>{</c->
    <c- k>enum</c-> <c- n>H</c-> <c- p>{</c-> <c- n>y</c-> <c- p>};</c->
    <c- k>enum</c-> <c- k>class</c-> <c- nc>K</c-> <c- p>{</c-> <c- n>z</c-> <c- p>};</c->
    <c- k>using</c-> <c- n>E</c-><c- o>::</c-><c- n>x</c-><c- p>;</c-> <c- c1>// OK, introduces x into S</c->
    <c- k>using</c-> <c- n>E</c-><c- o>::</c-><c- n>x</c-><c- p>;</c-> <c- c1>// error, redeclaration in class scope</c->
    <c- k>using</c-> <c- n>H</c-><c- o>::</c-><c- n>y</c-><c- p>;</c-> <c- c1>// error, redeclaration in class scope</c->
    <c- k>using</c-> <c- n>K</c-><c- o>::</c-><c- n>z</c-><c- p>;</c-> <c- c1>// OK, introduces z into S</c->
<c- p>};</c->
</pre>
   <p>In declarative regions which do allow multiple declarations, however:</p>
<pre class="language-cpp highlight"><c- k>enum</c-> <c- n>E</c-> <c- p>{</c-> <c- n>x</c-> <c- p>};</c->
<c- k>namespace</c-> <c- n>NS</c-> <c- p>{</c->
    <c- k>enum</c-> <c- n>H</c-> <c- p>{</c-> <c- n>y</c-> <c- p>};</c->
    <c- k>enum</c-> <c- k>class</c-> <c- nc>K</c-> <c- p>{</c-> <c- n>z</c-> <c- p>};</c->
    <c- k>using</c-> <c- n>E</c-><c- o>::</c-><c- n>x</c-><c- p>;</c-> <c- c1>// OK, introduces x into NS</c->
    <c- k>using</c-> <c- n>E</c-><c- o>::</c-><c- n>x</c-><c- p>;</c-> <c- c1>// OK, just a redeclaration of the same entity</c->
    <c- k>using</c-> <c- n>H</c-><c- o>::</c-><c- n>y</c-><c- p>;</c-> <c- c1>// OK, redeclaration of the same entity</c->
    <c- k>using</c-> <c- n>K</c-><c- o>::</c-><c- n>z</c-><c- p>;</c-> <c- c1>// OK, introduces z into NS</c->
<c- p>};</c->
</pre>
   <h3 class="heading settled" data-level="8.2" id="namespaceudecl-p8"><span class="secno">8.2. </span><span class="content">[namespace.udecl] p8</span><a class="self-link" href="#namespaceudecl-p8"></a></h3>
   <p>This change is meant to allow the introduction of class members that are enumerators into non-class scope. Consider this example:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- n>S</c-> <c- p>{</c->
    <c- k>enum</c-> <c- n>E</c-> <c- p>{</c-> <c- n>x</c-> <c- p>};</c->
    <c- k>enum</c-> <c- k>class</c-> <c- nc>EC</c-> <c- p>{</c-> <c- n>y</c-> <c- p>};</c->
    <c- k>using</c-> <c- n>EC</c-><c- o>::</c-><c- n>y</c-><c- p>;</c->
<c- p>};</c->

<c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
    <c- k>using</c-> <c- n>S</c-><c- o>::</c-><c- n>x</c-><c- p>;</c-> <c- c1>// OK</c->
    <c- n>x</c-><c- p>;</c-> <c- c1>// resolves to S::E::x;</c->
    <c- k>using</c-> <c- n>S</c-><c- o>::</c-><c- n>y</c-><c- p>;</c-> <c- c1>// OK</c->
    <c- n>y</c-><c- p>;</c-> <c- c1>// resolves to S::EC::y;</c->
<c- p>}</c->
</pre>
   <h3 class="heading settled" data-level="8.3" id="commas-in-the-using-declaration"><span class="secno">8.3. </span><span class="content">Commas in the using declaration</span><a class="self-link" href="#commas-in-the-using-declaration"></a></h3>
   <p>Since the grammar of the using declaration is not changed, it is valid to import multiple enumerators at the same time:</p>
<pre class="language-cpp highlight"><c- k>enum</c-> <c- k>class</c-> <c- nc>E</c-> <c- p>{</c-> <c- n>a</c-><c- p>,</c-> <c- n>b</c-><c- p>,</c-> <c- n>c</c-> <c- p>};</c->
<c- k>using</c-> <c- n>E</c-><c- o>::</c-><c- n>a</c-><c- p>,</c-> <c- n>E</c-><c- o>::</c-><c- n>b</c-><c- p>,</c-> <c- n>E</c-><c- o>::</c-><c- n>c</c-><c- p>;</c-> <c- c1>// OK, imports all three</c->
</pre>
   <h3 class="heading settled" data-level="8.4" id="commas-in-the-using-enum-declaration"><span class="secno">8.4. </span><span class="content">Commas in the <i>using-enum-declaration</i></span><a class="self-link" href="#commas-in-the-using-enum-declaration"></a></h3>
   <p>Since "using namespace" does not allow them, this paper did not propose allowing the listing of several enumeration names in the <em>using-enum-declaration</em>.</p>
   <h3 class="heading settled" data-level="8.5" id="names-using-enum-declaration-introduces"><span class="secno">8.5. </span><span class="content">Names <em>using-enum-declaration</em> introduces</span><a class="self-link" href="#names-using-enum-declaration-introduces"></a></h3>
   <p>The <em>using-enum-declaration</em> only introduces the names of the enumerators into the declarative region where it appears. It does not introduce the name of the enumeration it names.</p>
   <p>Example:</p>
<pre class="highlight"><c- k>struct</c-> <c- n>B</c-> <c- p>{</c->
    <c- k>enum</c-> <c- k>class</c-> <c- nc>E</c-> <c- p>{</c-> <c- n>x</c-> <c- p>};</c->
<c- p>};</c->
<c- k>enum</c-> <c- k>class</c-> <c- nc>H</c-> <c- p>{</c-> <c- n>y</c-> <c- p>};</c->
<c- k>struct</c-> <c- nl>C</c-> <c- p>:</c-> <c- n>B</c-> <c- p>{</c->
    <c- k>using</c-> <c- k>enum</c-> <c- n>B</c-><c- o>::</c-><c- n>E</c-><c- p>;</c-> <c- c1>// OK, introduces E::x into C</c->
    <c- k>using</c-> <c- k>enum</c-> <c- n>H</c-><c- p>;</c-> <c- c1>// OK, introduces y into C. Does not introduce H</c->
<c- p>};</c->
</pre>
   <h2 class="heading settled" data-level="9" id="wording"><span class="secno">9. </span><span class="content">Proposed Wording</span><a class="self-link" href="#wording"></a></h2>
   <h3 class="heading settled" data-level="9.1" id="wording-preface"><span class="secno">9.1. </span><span class="content">Preface</span><a class="self-link" href="#wording-preface"></a></h3>
   <p>The idea is that the identifiers appear as if they were declared in the declarative region where the <em>using-enum-declaration</em> appears, and not model the using-directive’s "enclosing namespace" wording.</p>
   <p>All wording is relative to the working draft of the ISO/IEC IS 14882: N4765, though, as it is almost entirely additive, it is also a valid diff to N4800.</p>
   <h3 class="heading settled" data-level="9.2" id="wording-changes"><span class="secno">9.2. </span><span class="content">Changes</span><a class="self-link" href="#wording-changes"></a></h3>
   <p>Under [namespace.udecl]:</p>
   <ol start="3">
    <li data-md>
     <p>
      In a <i>using-declaration</i> used as a <i>member-declaration</i>, each <i>using-declarator</i>
      <del>'s</del>
      <ins>shall either name an enumerator or have a</ins>
       <i>nested-name-specifier</i> 
      <del>shall name</del>
      <ins>naming</ins>
       a base class of the class being defined. 
      <ins>[<em>Example:</em></ins>
     </p>
     <div class="ins">
      <p></p>
<pre class="highlight"><c- k>enum</c-> <c- k>class</c-> <c- nc>button</c-> <c- p>{</c-> <c- n>up</c-><c- p>,</c-> <c- n>down</c-> <c- p>};</c->
<c- k>struct</c-> <c- n>S</c-> <c- p>{</c->
   <c- k>using</c-> <c- n>button</c-><c- o>::</c-><c- n>up</c-><c- p>;</c->
   <c- n>button</c-> <c- n>b</c-> <c- o>=</c-> <c- n>up</c-><c- p>;</c-> <c- c1>// OK</c->
<c- p>};</c->
</pre>
      <em>-- end example</em>] 
     </div>
   </ol>
   <del>7. A <i>using-declaration</i> shall not name a scoped enumerator.</del>
   <ol start="8">
    <li data-md>
     <p>
      A <i>using-declaration</i> that names a class member 
      <ins>other than an enumerator</ins>
       shall be a <i>member-declaration</i>.
     </p>
   </ol>
   <p>Under [dcl.dcl], in [dcl.enum], add subclause titled "Using Enum Declaration", with the stable reference "[enum.udecl]".</p>
   <div class="ins">
     <i>using-enum-declaration:</i><br>     
    <tt>using </tt>
    <i>elaborated-enum-specifier</i> ; 
    <ol>
     <li data-md>
      <p>The <i>elaborated-enum-specifier</i> shall not name a dependent type and the type shall have a reachable <i>enum-specifier</i>.</p>
     <li data-md>
      <p>A <i>using-enum-declaration</i> introduces the enumerator names of the named enumeration as if by a <i>using-declaration</i> for each enumerator.</p>
    </ol>
    <p>[<em>Note</em>: A <i>using-enum-declaration</i> in class scope adds the enumerators of the named enumeration as members to the scope. This means they are accessible for member lookup.
[<em>Example</em>:</p>
<pre class="highlight"><c- k>enum</c-> <c- k>class</c-> <c- nc>fruit</c-> <c- p>{</c-> <c- n>orange</c-><c- p>,</c-> <c- n>apple</c-> <c- p>};</c->
<c- k>struct</c-> <c- n>S</c-> <c- p>{</c->
  <c- k>using</c-> <c- k>enum</c-> <c- n>fruit</c-><c- p>;</c-> <c- c1>// OK, introduces orange and apple into S</c->
<c- p>};</c->
<c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
  <c- n>S</c-> <c- n>s</c-><c- p>;</c->
  <c- n>s</c-><c- p>.</c-><c- n>orange</c-><c- p>;</c-> <c- c1>// OK, names fruit::orange</c->
  <c- n>S</c-><c- o>::</c-><c- n>orange</c-><c- p>;</c-> <c- c1>// OK, names fruit::orange</c->
<c- p>}</c->
</pre>
    <em>-- end example</em>] 
    <p>Two <i>using-enum-declaration</i>s that introduce two enumerators of the same name conflict.
[<em>Example:</em></p>
<pre class="highlight"><c- k>enum</c-> <c- k>class</c-> <c- nc>fruit</c-> <c- p>{</c-> <c- n>orange</c-><c- p>,</c-> <c- n>apple</c-> <c- p>};</c->
<c- k>enum</c-> <c- k>class</c-> <c- nc>color</c-> <c- p>{</c-> <c- n>red</c-><c- p>,</c-> <c- n>orange</c-> <c- p>};</c->
<c- b>void</c-> <c- nf>f</c-><c- p>()</c-> <c- p>{</c->
  <c- k>using</c-> <c- k>enum</c-> <c- n>fruit</c-><c- p>;</c-> <c- c1>// OK</c->
  <c- k>using</c-> <c- k>enum</c-> <c- n>color</c-><c- p>;</c-> <c- c1>// error, color::orange and fruit::orange conflict</c->
<c- p>}</c->
</pre>
    <em>-- end example</em>] <em>-- end note</em>] 
   </div>
   <p>Under [basic.def], add (just after <i>using-directive</i>)  (and renumber section):</p>
   <div class="ins"> 2.17. — it is a <i>using-enum-declaration</i> </div>
   <p>In [dcl.dcl], under <i>block-declaration</i>:</p>
   <p>
    <i>block-declaration</i><br>     [...]<br>     <i>using-declaration</i><br>     
    <ins><i>using-enum-declaration</i></ins>
    <br>
   </p>
   <p>In [class.mem], under <i>member-declaration</i>:</p>
   <p>
    <i>member-declaration</i><br>     [...]<br>     <i>using-declaration</i><br>     
    <ins><i>using-enum-declaration</i></ins>
    <br>
   </p>
   <p>In [dcl.type.elab]:</p>
   <p>
    <i>elaborated-type-specifier:</i><br>     [...]<br>     
    <del>
     <tt>enum</tt>
      <i>nested-name-specifier<sub>opt</sub> identifier</i>
    </del>
    <br>     
    <ins><i>elaborated-enum-specifier</i></ins>
   </p>
   <p>
    <i class="ins">elaborated-enum-specifier:</i><br>     
    <ins>
     <tt>enum</tt>
      <i>nested-name-specifier<sub>opt</sub> identifier</i>
    </ins>
    <br>
   </p>
   <p>To table 17 (Feature-test macros), add the feature test macro:</p>
   <table>
    <tbody>
     <tr>
      <th>Name
      <th>Value
     <tr>
      <td>
       <ins><code class="highlight"><c- n>__cpp_using_enum</c-></code></ins>
      <td>
       <ins>PLACEHOLDER DATE</ins>
   </table>
   <p>The PLACEHOLDER DATE should be replaced with the appropriate integral constant of type long.</p>
   <h2 class="heading settled" data-level="10" id="ack"><span class="secno">10. </span><span class="content">Acknowledgements</span><a class="self-link" href="#ack"></a></h2>
   <p>(Alphabetically, by first name)</p>
   <ul>
    <li data-md>
     <p>Barry Revzin: feedback on R0</p>
    <li data-md>
     <p>BSI C++ WG: feedback throughout the life of the process</p>
    <li data-md>
     <p>Casey Carter: realization that this proposal allows adding adl-only functions to enumerations, typography feedback.</p>
    <li data-md>
     <p>CWG for their help with wording</p>
    <li data-md>
     <p>Dan Saks: early feedback, encouragement, quotation at start</p>
    <li data-md>
     <p>Eric Niebler: for the example of adl-only functions for enumerations.</p>
    <li data-md>
     <p>Graham Haynes: feedback on R0, and suggesting examples</p>
    <li data-md>
     <p>Jeff Snyder: feedback, championing with EWG</p>
    <li data-md>
     <p>Jens Maurer: wording feedback, the change to <em>using-enum-declaration</em>, and the encouragement to add the feature-test macro and split out the <em>elaborated-enum-specifier</em> from the other <em>elaborated-type-specifier</em>s, edge cases.</p>
    <li data-md>
     <p>Lisa Lippincott: early feedback on preprint.</p>
    <li data-md>
     <p>Marcel Ebmer: early feedback on preprint.</p>
    <li data-md>
     <p>Richard Smith: change design to direct injection of names, why enum names must not be dependent types, and a lot of help with wording. The initial wording without Richard’s involvement would have been much, much worse.</p>
    <li data-md>
     <p>Roger Orr: championing with CWG, and the button example in namespace.udir</p>
    <li data-md>
     <p>Tomas Puverle: encouragement to extend to regular <code class="highlight"><c- k>enum</c-></code>s, and other feedback</p>
   </ul>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

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

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

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

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

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

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


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

    tocNav.appendChild(toggle);
  }

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

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

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

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-p0945r0">[P0945R0]
   <dd>Richard Smith. <a href="https://wg21.link/p0945r0">Generalizing alias declarations</a>. 10 February 2018. URL: <a href="https://wg21.link/p0945r0">https://wg21.link/p0945r0</a>
  </dl>