<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>P3068R2: Allowing exception throwing in constant-evaluation</title>
<link rel="stylesheet" href="data:text/css;base64,@media (prefers-color-scheme: dark) {
	:root {
		--text-color: #BBB;
		--found-highlight: blue;
		--found-text-color: white;
		--main-background: 32,32,32;
		--header-color: white;
		--box-shadow-color: rgba(0,0,0,0.5);
		--nav-background-color: #101010;
		--code-foreground-color: white;
		--code-info-color: rgba(255,255,255,0.1);
		--code-background-color: var(--nav-background-color);
		--link-color: #8ef3ff;
		--visited-link-color: #f0ff89;
		--hover-link-color: #b3f7ff;
		--hover-visited-link-color: #c8ffb3;
		--line-color: 255,255,255;
		--header-background: 0,0,0;
		--quote-left-color: rgba(255,255,255,0.5);
	}
	::selection {
	  color: black;
	  background: lightyellow;
	}
	
}

@media (prefers-color-scheme: light) {
	:root {
		--text-color: black;
		--found-highlight: yellow;
		--found-text-color: black;
		--main-background: 255,255,255;
		--header-color: black;
		--box-shadow-color: rgba(0,0,0,0.3);
		--nav-background-color: #F5F5F5;
		--code-foreground-color: black;
		--code-info-color: rgba(0,0,0,0.1);
		--code-background-color: var(--nav-background-color);
		--link-color: #000082;
		--visited-link-color: #508d0f;
		--hover-link-color: #5757c2;
		--hover-visited-link-color: #94c560;
		--line-color: 12,43,75;
		--header-background: 0,0,0;
		--quote-left-color: rgba(0,0,0,0.5);
	}
	::selection {
	  color: black;
	  background: #a4c3f6;
	}
}

.name-of-paper {
	font-size: 28px;
	padding-top: 0.5em;
}

span.found {
	text-shadow: 0 0 10px var(--found-highlight),  0 0 10px var(--found-highlight),  0 0 10px var(--found-highlight),  0 0 10px var(--found-highlight);
	color: var(--found-text-color) !important;
}

body {
	font-family: Helvetica;
	padding: 0;
	margin: 0;
	overflow: hidden;
	color: var(--text-color);
	background-color: rgba(var(--main-background), 1);
}

body > div {
	display: flex;
	padding: 0;
	margin: 0;
}

.hide-on-narrow {
	display: inherit;
}

.hide-on-wide {
	display: none;
}

@media only screen and (max-width: 1100px) {
	body {
		overflow: inherit !important;
	}
	.hide-on-narrow {
		display: none;
	}
	.hide-on-wide {
		display: inherit;
	}
	body > div {
		display: block !important;
	}
	article {
		overflow: inherit !important;
		background-image: linear-gradient(to right, transparent,rgba(var(--main-background),0.6), rgba(var(--main-background),0.8), rgba(var(--main-background),0.6), transparent) !important;
	}
	nav, article {
		flex: initial !important;
	}
	nav {
		min-width: initial !important;
		max-width: initial !important;
		min-height: initial !important;
		max-height: initial !important;
		box-shadow: 0 10px 0 var(--box-shadow-color);
	}
	nav > div {
		overflow: inherit !important;
		position: relative !important;
		max-width: initial !important;
		max-height: initial !important;
	}
	div:has(> input[type=search]) {
		display: none;
	}
	div.quote {
		overflow-x: scroll;
	}
}

nav {
	padding: 0 0.5em;
	margin: 0;
	flex: 1 1 0;
	min-width: 350px;
	max-width: 350px;
	box-shadow: 0 0 10px var(--box-shadow-color);
	background-color: var(--nav-background-color);
}

nav > div {
	position: fixed;
	max-width: 350px;
	max-height: 100%;
	overflow: scroll;
	top: 0;
	left: 0;
	padding: 0 0.5em;
	margin: 0;
}

nav > div > div {
	padding: 0.5em;
	padding-top: 0;
	padding-bottom: 1em;
}

article {
	flex: 3 1 0;
	overflow: scroll;
	height: 100vh;
	text-align: justify;
	background-image: linear-gradient(to bottom, transparent,rgba(var(--main-background),0.6), rgba(var(--main-background),0.8), rgba(var(--main-background),0.6), transparent);
	padding: 0;
	margin: 0;
}

article > div {
	padding-right: 1.5em;
	padding-left: 1.5em;
	padding-bottom: 1em;
}

code {
	
}

div.quote {
	color: var(--code-foreground-color);
	background: var(--code-background-color);
	padding: 1em;
	border-radius: 0px 15px 15px 0px;
	border-left: 5px solid var(--quote-left-color);
	font-style: italic;
	margin: 1em;
}

code:not(pre > code) {
	color: inherit;
	background: var(--code-background-color);
	border-radius: 5px;
	padding: 0 0.2em;
	margin: 0 2px;
	outline: 2px solid var(--code-background-color);
}

pre > code {
	outline: none;
	line-height: 1.4;
	tab-size: 2;
}

pre:has(code) {
	color: var(--code-foreground-color);
	background: var(--code-background-color);
	padding: 1em;
	border-radius: 15px;
	position: relative;
	z-index: 1;
	overflow-x: scroll;
}

pre:has(code.language-carbon)::before {
	content: "Carbon";
	text-transform: uppercase;
	position: absolute;
	top: 1em;
	right: 1em;
	color: var(--code-info-color);
	font-weight: bold;
}

p, ul > li {
	text-align: justify;
	overflow-wrap: break-word;
	hyphens: auto;
}

a {
	color: var(--link-color);
	text-decoration-style: dotted;
}

a:hover {
	color: var(--hover-link-color);
	text-decoration-style: solid;
}

a:visited {
	color: var(--visited-link-color);
}

a:visited:hover {
	color: var(--hover-visited-link-color);
	text-decoration-style: solid;
}

h1, h2, h3, h4, h5 {
	margin: 0;
	margin-bottom: 10px;
	padding: 0.5em;
	padding-top: 20px;
	padding-bottom: 2px;
	z-index: 2;
	color: var(--header-color);
}

article h1, article h2, article h3, article h4, article h5 {
/*	position: sticky;
	position: -webkit-sticky;
	top: 0;*/
	
}

h1 {
	font-weight: 800;
	border-bottom: rgba(var(--line-color), 1) dotted 2px;
}

h2 {
	font-weight: 800;
	border-bottom: rgba(var(--line-color), 0.75) dotted 2px;
}

h3, h4, h5 {
	font-weight: 600;
	border-bottom: rgba(var(--line-color), 0.33) dotted 2px;
}

h1 > a, h2 > a, h3 > a, h4 > a, h5 > a {
	color: inherit !important;
	text-decoration: inherit;
}

h1:target::after, h2:target::after, h3:target::after, h4:target::after, h5:target::after {
	text-decoration: inherit;
	content: " ⚓︎";
}

h1 > a:hover, h2 > a:hover, h3 > a:hover, h4 > a:hover, h5 > a:hover {
	color: var(--hover-link-color);
}

div:has(> input[type=search]) {
	position: fixed;
	top: 0;
	right: 0;
	z-index: 1000;
	padding: 0.5em;
	background-color: var(--nav-background-color);
	box-shadow: 0 0 10px rgba(0,0,0,0.3);
	border-bottom-left-radius: 10px;
}

div > input[type=search] {
	background-color: var(--nav-background-color);
	border: 2px solid var(--text-color);
	color: var(--text-color);
	width: 300px;
}

div.paper-info {
	padding: 0;
	padding-top: 1em;
	
	.key {
		font-weight: bold;
	}
	
	div {
	}
}

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

li > ul {
	padding-left: 0.5em;
}

ul > li {
	padding-left: 0.5em;
}

code .error, code .before {
		line-height: 1.9;
}

code .error > *, code .before > * {
	background-color: #FF8888 !important;
	color: black !important;
	@media (prefers-color-scheme: dark) {
		color: white;
	}
	border: 3px solid #FF8888;
	font-weight: bold;
}

code .after > * {
	background-color: lightgreen !important;
	color: black !important;
	@media (prefers-color-scheme: dark) {
		color: white;
	}
	border: 3px solid lightgreen;
	font-weight: bold;
}

code .unchanged > * {
	background-color: lightyellow !important;
	color: black !important;
	@media (prefers-color-scheme: dark) {
		color: white;
	}
	border: 3px solid lightyellow;
	font-weight: bold;
}

code .invisible {
	visibility: hidden;
}

.changes {
	display: inline-block;
}

.wording h1, .wording h2 {
	font-size: inherit;
	text-decoration: none;
	border: none;
	padding: 0;
	margin: 0;
}

.wording p {
	padding: 0;
	padding-top: 0.5em;
	margin: 0;
}

.wording a {
	text-decoration: none;
	color: inherit;
}

.wording a:hover {
	text-decoration: underline;
	color: var(--link-color);
}

.wording code {
	background: inherit !important;
	border: none;
	outline: none;
}
	
.wording {
	font-family: "Noto Serif";
	
	padding: 0.5em 1em;
	padding-bottom: 1em;
	color: var(--code-foreground-color);
	background: var(--code-background-color);
	line-height: 1.55;
	
	border-radius: 15px;
	position: relative;
	z-index: 1;
	overflow-x: scroll;
}
	
.wording .added {
	background-color: lightgreen;
	z-index: 80;
	padding: 3px;
	@media (prefers-color-scheme: dark) {
		color: black;
	}
}
	
.wording .removed {
	background-color: #FF8888;
	z-index: 50;
	padding: 3px;
	@media (prefers-color-scheme: dark) {
		color: black;
	}
}
	
.wording .note {
	font-size: 0.8em;
}
	
.wording	+ .wording {
	margin-top: 0.5em;
}
	
.wording pre:has(code) {
	border: 1px solid var(--code-info-color);
	border-radius: 0;
	padding: 0em;
	z-index: 1;
	overflow-x: scroll;
}
	
.wording	code .addeded span {
	color: black !important;
}

">
<link rel="stylesheet" href="data:text/css;base64,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">
<link href="https://fonts.googleapis.com/css?family=Noto+Serif" rel='stylesheet'>
<script src="data:text/javascript;base64,/*!
  Highlight.js v11.9.0 (git: b7ec4bfafc)
  (c) 2006-2024 undefined and other contributors
  License: BSD-3-Clause
 */
var hljs=function(){"use strict";function e(t){
return t instanceof Map?t.clear=t.delete=t.set=()=>{
throw Error("map is read-only")}:t instanceof Set&&(t.add=t.clear=t.delete=()=>{
throw Error("set is read-only")
}),Object.freeze(t),Object.getOwnPropertyNames(t).forEach((n=>{
const i=t[n],s=typeof i;"object"!==s&&"function"!==s||Object.isFrozen(i)||e(i)
})),t}class t{constructor(e){
void 0===e.data&&(e.data={}),this.data=e.data,this.isMatchIgnored=!1}
ignoreMatch(){this.isMatchIgnored=!0}}function n(e){
return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;")
}function i(e,...t){const n=Object.create(null);for(const t in e)n[t]=e[t]
;return t.forEach((e=>{for(const t in e)n[t]=e[t]})),n}const s=e=>!!e.scope
;class o{constructor(e,t){
this.buffer="",this.classPrefix=t.classPrefix,e.walk(this)}addText(e){
this.buffer+=n(e)}openNode(e){if(!s(e))return;const t=((e,{prefix:t})=>{
if(e.startsWith("language:"))return e.replace("language:","language-")
;if(e.includes(".")){const n=e.split(".")
;return[`${t}${n.shift()}`,...n.map(((e,t)=>`${e}${"_".repeat(t+1)}`))].join(" ")
}return`${t}${e}`})(e.scope,{prefix:this.classPrefix});this.span(t)}
closeNode(e){s(e)&&(this.buffer+="</span>")}value(){return this.buffer}span(e){
this.buffer+=`<span class="${e}">`}}const r=(e={})=>{const t={children:[]}
;return Object.assign(t,e),t};class a{constructor(){
this.rootNode=r(),this.stack=[this.rootNode]}get top(){
return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(e){
this.top.children.push(e)}openNode(e){const t=r({scope:e})
;this.add(t),this.stack.push(t)}closeNode(){
if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){
for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}
walk(e){return this.constructor._walk(e,this.rootNode)}static _walk(e,t){
return"string"==typeof t?e.addText(t):t.children&&(e.openNode(t),
t.children.forEach((t=>this._walk(e,t))),e.closeNode(t)),e}static _collapse(e){
"string"!=typeof e&&e.children&&(e.children.every((e=>"string"==typeof e))?e.children=[e.children.join("")]:e.children.forEach((e=>{
a._collapse(e)})))}}class c extends a{constructor(e){super(),this.options=e}
addText(e){""!==e&&this.add(e)}startScope(e){this.openNode(e)}endScope(){
this.closeNode()}__addSublanguage(e,t){const n=e.root
;t&&(n.scope="language:"+t),this.add(n)}toHTML(){
return new o(this,this.options).value()}finalize(){
return this.closeAllNodes(),!0}}function l(e){
return e?"string"==typeof e?e:e.source:null}function g(e){return h("(?=",e,")")}
function u(e){return h("(?:",e,")*")}function d(e){return h("(?:",e,")?")}
function h(...e){return e.map((e=>l(e))).join("")}function f(...e){const t=(e=>{
const t=e[e.length-1]
;return"object"==typeof t&&t.constructor===Object?(e.splice(e.length-1,1),t):{}
})(e);return"("+(t.capture?"":"?:")+e.map((e=>l(e))).join("|")+")"}
function p(e){return RegExp(e.toString()+"|").exec("").length-1}
const b=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
;function m(e,{joinWith:t}){let n=0;return e.map((e=>{n+=1;const t=n
;let i=l(e),s="";for(;i.length>0;){const e=b.exec(i);if(!e){s+=i;break}
s+=i.substring(0,e.index),
i=i.substring(e.index+e[0].length),"\\"===e[0][0]&&e[1]?s+="\\"+(Number(e[1])+t):(s+=e[0],
"("===e[0]&&n++)}return s})).map((e=>`(${e})`)).join(t)}
const E="[a-zA-Z]\\w*",x="[a-zA-Z_]\\w*",w="\\b\\d+(\\.\\d+)?",y="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",_="\\b(0b[01]+)",O={
begin:"\\\\[\\s\\S]",relevance:0},v={scope:"string",begin:"'",end:"'",
illegal:"\\n",contains:[O]},k={scope:"string",begin:'"',end:'"',illegal:"\\n",
contains:[O]},N=(e,t,n={})=>{const s=i({scope:"comment",begin:e,end:t,
contains:[]},n);s.contains.push({scope:"doctag",
begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0})
;const o=f("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/)
;return s.contains.push({begin:h(/[ ]+/,"(",o,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),s
},S=N("//","$"),M=N("/\\*","\\*/"),R=N("#","$");var j=Object.freeze({
__proto__:null,APOS_STRING_MODE:v,BACKSLASH_ESCAPE:O,BINARY_NUMBER_MODE:{
scope:"number",begin:_,relevance:0},BINARY_NUMBER_RE:_,COMMENT:N,
C_BLOCK_COMMENT_MODE:M,C_LINE_COMMENT_MODE:S,C_NUMBER_MODE:{scope:"number",
begin:y,relevance:0},C_NUMBER_RE:y,END_SAME_AS_BEGIN:e=>Object.assign(e,{
"on:begin":(e,t)=>{t.data._beginMatch=e[1]},"on:end":(e,t)=>{
t.data._beginMatch!==e[1]&&t.ignoreMatch()}}),HASH_COMMENT_MODE:R,IDENT_RE:E,
MATCH_NOTHING_RE:/\b\B/,METHOD_GUARD:{begin:"\\.\\s*"+x,relevance:0},
NUMBER_MODE:{scope:"number",begin:w,relevance:0},NUMBER_RE:w,
PHRASAL_WORDS_MODE:{
begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
},QUOTE_STRING_MODE:k,REGEXP_MODE:{scope:"regexp",begin:/\/(?=[^/\n]*\/)/,
end:/\/[gimuy]*/,contains:[O,{begin:/\[/,end:/\]/,relevance:0,contains:[O]}]},
RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
SHEBANG:(e={})=>{const t=/^#![ ]*\//
;return e.binary&&(e.begin=h(t,/.*\b/,e.binary,/\b.*/)),i({scope:"meta",begin:t,
end:/$/,relevance:0,"on:begin":(e,t)=>{0!==e.index&&t.ignoreMatch()}},e)},
TITLE_MODE:{scope:"title",begin:E,relevance:0},UNDERSCORE_IDENT_RE:x,
UNDERSCORE_TITLE_MODE:{scope:"title",begin:x,relevance:0}});function A(e,t){
"."===e.input[e.index-1]&&t.ignoreMatch()}function I(e,t){
void 0!==e.className&&(e.scope=e.className,delete e.className)}function T(e,t){
t&&e.beginKeywords&&(e.begin="\\b("+e.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",
e.__beforeBegin=A,e.keywords=e.keywords||e.beginKeywords,delete e.beginKeywords,
void 0===e.relevance&&(e.relevance=0))}function L(e,t){
Array.isArray(e.illegal)&&(e.illegal=f(...e.illegal))}function B(e,t){
if(e.match){
if(e.begin||e.end)throw Error("begin & end are not supported with match")
;e.begin=e.match,delete e.match}}function P(e,t){
void 0===e.relevance&&(e.relevance=1)}const D=(e,t)=>{if(!e.beforeMatch)return
;if(e.starts)throw Error("beforeMatch cannot be used with starts")
;const n=Object.assign({},e);Object.keys(e).forEach((t=>{delete e[t]
})),e.keywords=n.keywords,e.begin=h(n.beforeMatch,g(n.begin)),e.starts={
relevance:0,contains:[Object.assign(n,{endsParent:!0})]
},e.relevance=0,delete n.beforeMatch
},H=["of","and","for","in","not","or","if","then","parent","list","value"],C="keyword"
;function $(e,t,n=C){const i=Object.create(null)
;return"string"==typeof e?s(n,e.split(" ")):Array.isArray(e)?s(n,e):Object.keys(e).forEach((n=>{
Object.assign(i,$(e[n],t,n))})),i;function s(e,n){
t&&(n=n.map((e=>e.toLowerCase()))),n.forEach((t=>{const n=t.split("|")
;i[n[0]]=[e,U(n[0],n[1])]}))}}function U(e,t){
return t?Number(t):(e=>H.includes(e.toLowerCase()))(e)?0:1}const z={},W=e=>{
console.error(e)},X=(e,...t)=>{console.log("WARN: "+e,...t)},G=(e,t)=>{
z[`${e}/${t}`]||(console.log(`Deprecated as of ${e}. ${t}`),z[`${e}/${t}`]=!0)
},K=Error();function F(e,t,{key:n}){let i=0;const s=e[n],o={},r={}
;for(let e=1;e<=t.length;e++)r[e+i]=s[e],o[e+i]=!0,i+=p(t[e-1])
;e[n]=r,e[n]._emit=o,e[n]._multi=!0}function Z(e){(e=>{
e.scope&&"object"==typeof e.scope&&null!==e.scope&&(e.beginScope=e.scope,
delete e.scope)})(e),"string"==typeof e.beginScope&&(e.beginScope={
_wrap:e.beginScope}),"string"==typeof e.endScope&&(e.endScope={_wrap:e.endScope
}),(e=>{if(Array.isArray(e.begin)){
if(e.skip||e.excludeBegin||e.returnBegin)throw W("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
K
;if("object"!=typeof e.beginScope||null===e.beginScope)throw W("beginScope must be object"),
K;F(e,e.begin,{key:"beginScope"}),e.begin=m(e.begin,{joinWith:""})}})(e),(e=>{
if(Array.isArray(e.end)){
if(e.skip||e.excludeEnd||e.returnEnd)throw W("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
K
;if("object"!=typeof e.endScope||null===e.endScope)throw W("endScope must be object"),
K;F(e,e.end,{key:"endScope"}),e.end=m(e.end,{joinWith:""})}})(e)}function V(e){
function t(t,n){
return RegExp(l(t),"m"+(e.case_insensitive?"i":"")+(e.unicodeRegex?"u":"")+(n?"g":""))
}class n{constructor(){
this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}
addRule(e,t){
t.position=this.position++,this.matchIndexes[this.matchAt]=t,this.regexes.push([t,e]),
this.matchAt+=p(e)+1}compile(){0===this.regexes.length&&(this.exec=()=>null)
;const e=this.regexes.map((e=>e[1]));this.matcherRe=t(m(e,{joinWith:"|"
}),!0),this.lastIndex=0}exec(e){this.matcherRe.lastIndex=this.lastIndex
;const t=this.matcherRe.exec(e);if(!t)return null
;const n=t.findIndex(((e,t)=>t>0&&void 0!==e)),i=this.matchIndexes[n]
;return t.splice(0,n),Object.assign(t,i)}}class s{constructor(){
this.rules=[],this.multiRegexes=[],
this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(e){
if(this.multiRegexes[e])return this.multiRegexes[e];const t=new n
;return this.rules.slice(e).forEach((([e,n])=>t.addRule(e,n))),
t.compile(),this.multiRegexes[e]=t,t}resumingScanAtSamePosition(){
return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(e,t){
this.rules.push([e,t]),"begin"===t.type&&this.count++}exec(e){
const t=this.getMatcher(this.regexIndex);t.lastIndex=this.lastIndex
;let n=t.exec(e)
;if(this.resumingScanAtSamePosition())if(n&&n.index===this.lastIndex);else{
const t=this.getMatcher(0);t.lastIndex=this.lastIndex+1,n=t.exec(e)}
return n&&(this.regexIndex+=n.position+1,
this.regexIndex===this.count&&this.considerAll()),n}}
if(e.compilerExtensions||(e.compilerExtensions=[]),
e.contains&&e.contains.includes("self"))throw Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.")
;return e.classNameAliases=i(e.classNameAliases||{}),function n(o,r){const a=o
;if(o.isCompiled)return a
;[I,B,Z,D].forEach((e=>e(o,r))),e.compilerExtensions.forEach((e=>e(o,r))),
o.__beforeBegin=null,[T,L,P].forEach((e=>e(o,r))),o.isCompiled=!0;let c=null
;return"object"==typeof o.keywords&&o.keywords.$pattern&&(o.keywords=Object.assign({},o.keywords),
c=o.keywords.$pattern,
delete o.keywords.$pattern),c=c||/\w+/,o.keywords&&(o.keywords=$(o.keywords,e.case_insensitive)),
a.keywordPatternRe=t(c,!0),
r&&(o.begin||(o.begin=/\B|\b/),a.beginRe=t(a.begin),o.end||o.endsWithParent||(o.end=/\B|\b/),
o.end&&(a.endRe=t(a.end)),
a.terminatorEnd=l(a.end)||"",o.endsWithParent&&r.terminatorEnd&&(a.terminatorEnd+=(o.end?"|":"")+r.terminatorEnd)),
o.illegal&&(a.illegalRe=t(o.illegal)),
o.contains||(o.contains=[]),o.contains=[].concat(...o.contains.map((e=>(e=>(e.variants&&!e.cachedVariants&&(e.cachedVariants=e.variants.map((t=>i(e,{
variants:null},t)))),e.cachedVariants?e.cachedVariants:q(e)?i(e,{
starts:e.starts?i(e.starts):null
}):Object.isFrozen(e)?i(e):e))("self"===e?o:e)))),o.contains.forEach((e=>{n(e,a)
})),o.starts&&n(o.starts,r),a.matcher=(e=>{const t=new s
;return e.contains.forEach((e=>t.addRule(e.begin,{rule:e,type:"begin"
}))),e.terminatorEnd&&t.addRule(e.terminatorEnd,{type:"end"
}),e.illegal&&t.addRule(e.illegal,{type:"illegal"}),t})(a),a}(e)}function q(e){
return!!e&&(e.endsWithParent||q(e.starts))}class J extends Error{
constructor(e,t){super(e),this.name="HTMLInjectionError",this.html=t}}
const Y=n,Q=i,ee=Symbol("nomatch"),te=n=>{
const i=Object.create(null),s=Object.create(null),o=[];let r=!0
;const a="Could not find the language '{}', did you forget to load/include a language module?",l={
disableAutodetect:!0,name:"Plain text",contains:[]};let p={
ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,
languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",
cssSelector:"pre code",languages:null,__emitter:c};function b(e){
return p.noHighlightRe.test(e)}function m(e,t,n){let i="",s=""
;"object"==typeof t?(i=e,
n=t.ignoreIllegals,s=t.language):(G("10.7.0","highlight(lang, code, ...args) has been deprecated."),
G("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
s=e,i=t),void 0===n&&(n=!0);const o={code:i,language:s};N("before:highlight",o)
;const r=o.result?o.result:E(o.language,o.code,n)
;return r.code=o.code,N("after:highlight",r),r}function E(e,n,s,o){
const c=Object.create(null);function l(){if(!N.keywords)return void M.addText(R)
;let e=0;N.keywordPatternRe.lastIndex=0;let t=N.keywordPatternRe.exec(R),n=""
;for(;t;){n+=R.substring(e,t.index)
;const s=_.case_insensitive?t[0].toLowerCase():t[0],o=(i=s,N.keywords[i]);if(o){
const[e,i]=o
;if(M.addText(n),n="",c[s]=(c[s]||0)+1,c[s]<=7&&(j+=i),e.startsWith("_"))n+=t[0];else{
const n=_.classNameAliases[e]||e;u(t[0],n)}}else n+=t[0]
;e=N.keywordPatternRe.lastIndex,t=N.keywordPatternRe.exec(R)}var i
;n+=R.substring(e),M.addText(n)}function g(){null!=N.subLanguage?(()=>{
if(""===R)return;let e=null;if("string"==typeof N.subLanguage){
if(!i[N.subLanguage])return void M.addText(R)
;e=E(N.subLanguage,R,!0,S[N.subLanguage]),S[N.subLanguage]=e._top
}else e=x(R,N.subLanguage.length?N.subLanguage:null)
;N.relevance>0&&(j+=e.relevance),M.__addSublanguage(e._emitter,e.language)
})():l(),R=""}function u(e,t){
""!==e&&(M.startScope(t),M.addText(e),M.endScope())}function d(e,t){let n=1
;const i=t.length-1;for(;n<=i;){if(!e._emit[n]){n++;continue}
const i=_.classNameAliases[e[n]]||e[n],s=t[n];i?u(s,i):(R=s,l(),R=""),n++}}
function h(e,t){
return e.scope&&"string"==typeof e.scope&&M.openNode(_.classNameAliases[e.scope]||e.scope),
e.beginScope&&(e.beginScope._wrap?(u(R,_.classNameAliases[e.beginScope._wrap]||e.beginScope._wrap),
R=""):e.beginScope._multi&&(d(e.beginScope,t),R="")),N=Object.create(e,{parent:{
value:N}}),N}function f(e,n,i){let s=((e,t)=>{const n=e&&e.exec(t)
;return n&&0===n.index})(e.endRe,i);if(s){if(e["on:end"]){const i=new t(e)
;e["on:end"](n,i),i.isMatchIgnored&&(s=!1)}if(s){
for(;e.endsParent&&e.parent;)e=e.parent;return e}}
if(e.endsWithParent)return f(e.parent,n,i)}function b(e){
return 0===N.matcher.regexIndex?(R+=e[0],1):(T=!0,0)}function m(e){
const t=e[0],i=n.substring(e.index),s=f(N,e,i);if(!s)return ee;const o=N
;N.endScope&&N.endScope._wrap?(g(),
u(t,N.endScope._wrap)):N.endScope&&N.endScope._multi?(g(),
d(N.endScope,e)):o.skip?R+=t:(o.returnEnd||o.excludeEnd||(R+=t),
g(),o.excludeEnd&&(R=t));do{
N.scope&&M.closeNode(),N.skip||N.subLanguage||(j+=N.relevance),N=N.parent
}while(N!==s.parent);return s.starts&&h(s.starts,e),o.returnEnd?0:t.length}
let w={};function y(i,o){const a=o&&o[0];if(R+=i,null==a)return g(),0
;if("begin"===w.type&&"end"===o.type&&w.index===o.index&&""===a){
if(R+=n.slice(o.index,o.index+1),!r){const t=Error(`0 width match regex (${e})`)
;throw t.languageName=e,t.badRule=w.rule,t}return 1}
if(w=o,"begin"===o.type)return(e=>{
const n=e[0],i=e.rule,s=new t(i),o=[i.__beforeBegin,i["on:begin"]]
;for(const t of o)if(t&&(t(e,s),s.isMatchIgnored))return b(n)
;return i.skip?R+=n:(i.excludeBegin&&(R+=n),
g(),i.returnBegin||i.excludeBegin||(R=n)),h(i,e),i.returnBegin?0:n.length})(o)
;if("illegal"===o.type&&!s){
const e=Error('Illegal lexeme "'+a+'" for mode "'+(N.scope||"<unnamed>")+'"')
;throw e.mode=N,e}if("end"===o.type){const e=m(o);if(e!==ee)return e}
if("illegal"===o.type&&""===a)return 1
;if(I>1e5&&I>3*o.index)throw Error("potential infinite loop, way more iterations than matches")
;return R+=a,a.length}const _=O(e)
;if(!_)throw W(a.replace("{}",e)),Error('Unknown language: "'+e+'"')
;const v=V(_);let k="",N=o||v;const S={},M=new p.__emitter(p);(()=>{const e=[]
;for(let t=N;t!==_;t=t.parent)t.scope&&e.unshift(t.scope)
;e.forEach((e=>M.openNode(e)))})();let R="",j=0,A=0,I=0,T=!1;try{
if(_.__emitTokens)_.__emitTokens(n,M);else{for(N.matcher.considerAll();;){
I++,T?T=!1:N.matcher.considerAll(),N.matcher.lastIndex=A
;const e=N.matcher.exec(n);if(!e)break;const t=y(n.substring(A,e.index),e)
;A=e.index+t}y(n.substring(A))}return M.finalize(),k=M.toHTML(),{language:e,
value:k,relevance:j,illegal:!1,_emitter:M,_top:N}}catch(t){
if(t.message&&t.message.includes("Illegal"))return{language:e,value:Y(n),
illegal:!0,relevance:0,_illegalBy:{message:t.message,index:A,
context:n.slice(A-100,A+100),mode:t.mode,resultSoFar:k},_emitter:M};if(r)return{
language:e,value:Y(n),illegal:!1,relevance:0,errorRaised:t,_emitter:M,_top:N}
;throw t}}function x(e,t){t=t||p.languages||Object.keys(i);const n=(e=>{
const t={value:Y(e),illegal:!1,relevance:0,_top:l,_emitter:new p.__emitter(p)}
;return t._emitter.addText(e),t})(e),s=t.filter(O).filter(k).map((t=>E(t,e,!1)))
;s.unshift(n);const o=s.sort(((e,t)=>{
if(e.relevance!==t.relevance)return t.relevance-e.relevance
;if(e.language&&t.language){if(O(e.language).supersetOf===t.language)return 1
;if(O(t.language).supersetOf===e.language)return-1}return 0})),[r,a]=o,c=r
;return c.secondBest=a,c}function w(e){let t=null;const n=(e=>{
let t=e.className+" ";t+=e.parentNode?e.parentNode.className:""
;const n=p.languageDetectRe.exec(t);if(n){const t=O(n[1])
;return t||(X(a.replace("{}",n[1])),
X("Falling back to no-highlight mode for this block.",e)),t?n[1]:"no-highlight"}
return t.split(/\s+/).find((e=>b(e)||O(e)))})(e);if(b(n))return
;if(N("before:highlightElement",{el:e,language:n
}),e.dataset.highlighted)return void console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",e)
;if(e.children.length>0&&(p.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),
console.warn("The element with unescaped HTML:"),
console.warn(e)),p.throwUnescapedHTML))throw new J("One of your code blocks includes unescaped HTML.",e.innerHTML)
;t=e;const i=t.textContent,o=n?m(i,{language:n,ignoreIllegals:!0}):x(i)
;e.innerHTML=o.value,e.dataset.highlighted="yes",((e,t,n)=>{const i=t&&s[t]||n
;e.classList.add("hljs"),e.classList.add("language-"+i)
})(e,n,o.language),e.result={language:o.language,re:o.relevance,
relevance:o.relevance},o.secondBest&&(e.secondBest={
language:o.secondBest.language,relevance:o.secondBest.relevance
}),N("after:highlightElement",{el:e,result:o,text:i})}let y=!1;function _(){
"loading"!==document.readyState?document.querySelectorAll(p.cssSelector).forEach(w):y=!0
}function O(e){return e=(e||"").toLowerCase(),i[e]||i[s[e]]}
function v(e,{languageName:t}){"string"==typeof e&&(e=[e]),e.forEach((e=>{
s[e.toLowerCase()]=t}))}function k(e){const t=O(e)
;return t&&!t.disableAutodetect}function N(e,t){const n=e;o.forEach((e=>{
e[n]&&e[n](t)}))}
"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(()=>{
y&&_()}),!1),Object.assign(n,{highlight:m,highlightAuto:x,highlightAll:_,
highlightElement:w,
highlightBlock:e=>(G("10.7.0","highlightBlock will be removed entirely in v12.0"),
G("10.7.0","Please use highlightElement now."),w(e)),configure:e=>{p=Q(p,e)},
initHighlighting:()=>{
_(),G("10.6.0","initHighlighting() deprecated.  Use highlightAll() now.")},
initHighlightingOnLoad:()=>{
_(),G("10.6.0","initHighlightingOnLoad() deprecated.  Use highlightAll() now.")
},registerLanguage:(e,t)=>{let s=null;try{s=t(n)}catch(t){
if(W("Language definition for '{}' could not be registered.".replace("{}",e)),
!r)throw t;W(t),s=l}
s.name||(s.name=e),i[e]=s,s.rawDefinition=t.bind(null,n),s.aliases&&v(s.aliases,{
languageName:e})},unregisterLanguage:e=>{delete i[e]
;for(const t of Object.keys(s))s[t]===e&&delete s[t]},
listLanguages:()=>Object.keys(i),getLanguage:O,registerAliases:v,
autoDetection:k,inherit:Q,addPlugin:e=>{(e=>{
e["before:highlightBlock"]&&!e["before:highlightElement"]&&(e["before:highlightElement"]=t=>{
e["before:highlightBlock"](Object.assign({block:t.el},t))
}),e["after:highlightBlock"]&&!e["after:highlightElement"]&&(e["after:highlightElement"]=t=>{
e["after:highlightBlock"](Object.assign({block:t.el},t))})})(e),o.push(e)},
removePlugin:e=>{const t=o.indexOf(e);-1!==t&&o.splice(t,1)}}),n.debugMode=()=>{
r=!1},n.safeMode=()=>{r=!0},n.versionString="11.9.0",n.regex={concat:h,
lookahead:g,either:f,optional:d,anyNumberOfTimes:u}
;for(const t in j)"object"==typeof j[t]&&e(j[t]);return Object.assign(n,j),n
},ne=te({});return ne.newInstance=()=>te({}),ne}()
;"object"==typeof exports&&"undefined"!=typeof module&&(module.exports=hljs);/*! `cpp` grammar compiled for Highlight.js 11.9.0 */
(()=>{var e=(()=>{"use strict";return e=>{const t=e.regex,a=e.COMMENT("//","$",{
contains:[{begin:/\\\n/}]
}),n="decltype\\(auto\\)",r="[a-zA-Z_]\\w*::",i="(?!struct)("+n+"|"+t.optional(r)+"[a-zA-Z_]\\w*"+t.optional("<[^<>]+>")+")",s={
className:"type",begin:"\\b[a-z\\d_]*_t\\b"},c={className:"string",variants:[{
begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{
begin:"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
end:"'",illegal:"."},e.END_SAME_AS_BEGIN({
begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},o={
className:"number",variants:[{
begin:"[+-]?(?:(?:[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?|\\.[0-9](?:'?[0-9])*)(?:[Ee][+-]?[0-9](?:'?[0-9])*)?|[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*|0[Xx](?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*(?:\\.(?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)?)?|\\.[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)[Pp][+-]?[0-9](?:'?[0-9])*)(?:[Ff](?:16|32|64|128)?|(BF|bf)16|[Ll]|)"
},{
begin:"[+-]?\\b(?:0[Bb][01](?:'?[01])*|0[Xx][0-9A-Fa-f](?:'?[0-9A-Fa-f])*|0(?:'?[0-7])*|[1-9](?:'?[0-9])*)(?:[Uu](?:LL?|ll?)|[Uu][Zz]?|(?:LL?|ll?)[Uu]?|[Zz][Uu]|)"
}],relevance:0},l={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{
keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"
},contains:[{begin:/\\\n/,relevance:0},e.inherit(c,{className:"string"}),{
className:"string",begin:/<.*?>/},a,e.C_BLOCK_COMMENT_MODE]},u={
className:"title",begin:t.optional(r)+e.IDENT_RE,relevance:0
},d=t.optional(r)+e.IDENT_RE+"\\s*\\(",p={
type:["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],
keyword:["alignas","alignof","and","and_eq","asm","atomic_cancel","atomic_commit","atomic_noexcept","auto","bitand","bitor","break","case","catch","class","co_await","co_return","co_yield","compl","concept","const_cast|10","consteval","constexpr","constinit","continue","decltype","default","delete","do","dynamic_cast|10","else","enum","explicit","export","extern","false","final","for","friend","goto","if","import","inline","module","mutable","namespace","new","noexcept","not","not_eq","nullptr","operator","or","or_eq","override","private","protected","public","reflexpr","register","reinterpret_cast|10","requires","return","sizeof","static_assert","static_cast|10","struct","switch","synchronized","template","this","thread_local","throw","transaction_safe","transaction_safe_dynamic","true","try","typedef","typeid","typename","union","using","virtual","volatile","while","xor","xor_eq"],
literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],
_type_hints:["any","auto_ptr","barrier","binary_semaphore","bitset","complex","condition_variable","condition_variable_any","counting_semaphore","deque","false_type","future","imaginary","initializer_list","istringstream","jthread","latch","lock_guard","multimap","multiset","mutex","optional","ostringstream","packaged_task","pair","promise","priority_queue","queue","recursive_mutex","recursive_timed_mutex","scoped_lock","set","shared_future","shared_lock","shared_mutex","shared_timed_mutex","shared_ptr","stack","string_view","stringstream","timed_mutex","thread","true_type","tuple","unique_lock","unique_ptr","unordered_map","unordered_multimap","unordered_multiset","unordered_set","variant","vector","weak_ptr","wstring","wstring_view"]
},_={className:"function.dispatch",relevance:0,keywords:{
_hint:["abort","abs","acos","apply","as_const","asin","atan","atan2","calloc","ceil","cerr","cin","clog","cos","cosh","cout","declval","endl","exchange","exit","exp","fabs","floor","fmod","forward","fprintf","fputs","free","frexp","fscanf","future","invoke","isalnum","isalpha","iscntrl","isdigit","isgraph","islower","isprint","ispunct","isspace","isupper","isxdigit","labs","launder","ldexp","log","log10","make_pair","make_shared","make_shared_for_overwrite","make_tuple","make_unique","malloc","memchr","memcmp","memcpy","memset","modf","move","pow","printf","putchar","puts","realloc","scanf","sin","sinh","snprintf","sprintf","sqrt","sscanf","std","stderr","stdin","stdout","strcat","strchr","strcmp","strcpy","strcspn","strlen","strncat","strncmp","strncpy","strpbrk","strrchr","strspn","strstr","swap","tan","tanh","terminate","to_underlying","tolower","toupper","vfprintf","visit","vprintf","vsprintf"]
},
begin:t.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,e.IDENT_RE,t.lookahead(/(<[^<>]+>|)\s*\(/))
},m=[_,l,s,a,e.C_BLOCK_COMMENT_MODE,o,c],f={variants:[{begin:/=/,end:/;/},{
begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],
keywords:p,contains:m.concat([{begin:/\(/,end:/\)/,keywords:p,
contains:m.concat(["self"]),relevance:0}]),relevance:0},g={className:"function",
begin:"("+i+"[\\*&\\s]+)+"+d,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,
keywords:p,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:n,keywords:p,relevance:0},{
begin:d,returnBegin:!0,contains:[u],relevance:0},{begin:/::/,relevance:0},{
begin:/:/,endsWithParent:!0,contains:[c,o]},{relevance:0,match:/,/},{
className:"params",begin:/\(/,end:/\)/,keywords:p,relevance:0,
contains:[a,e.C_BLOCK_COMMENT_MODE,c,o,s,{begin:/\(/,end:/\)/,keywords:p,
relevance:0,contains:["self",a,e.C_BLOCK_COMMENT_MODE,c,o,s]}]
},s,a,e.C_BLOCK_COMMENT_MODE,l]};return{name:"C++",
aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:p,illegal:"</",
classNameAliases:{"function.dispatch":"built_in"},
contains:[].concat(f,g,_,m,[l,{
begin:"\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)",
end:">",keywords:p,contains:["self",s]},{begin:e.IDENT_RE+"::",keywords:p},{
match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],
className:{1:"keyword",3:"title.class"}}])}}})();hljs.registerLanguage("cpp",e)
})();"></script>
<script src="data:text/javascript;base64,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"></script>
</head>
<body><div>
<nav><div><div>
<h1 class="hide-on-wide name-of-paper">Allowing exception throwing in constant-evaluation</h1>
<div class="paper-info">
	<div><span class="key">Number:</span> P3068R2</div>
	<div><span class="key">Date:</span> <time>2024-05-21</time></div>
	<div><span class="key">Audience:</span> EWG &amp; LEWG</div>
	<div><span class="key">Reply-to:</span> <a href="mailto:cpp@hanicka.net">Hana Dusíková</a></div>
</div>

<h2 id="table-of-contents"><a href="#table-of-contents">Table of contents</a></h2>
<ul>
	<li><a href="#introduction">Introduction</a></li>
	<li><a href="#changes">Changes</a></li>
	<li><a href="#hello-constexpr-exceptions-world">Motivational example</a></li>
	
	<li><a href="#wording">Proposed changes to wording</a>
		<ul>
			<li><a href="#library-wording">Library wording</a></li>
		</ul>
	</li>
	<li><a href="#implementation-experience">Implementation experience</a></li>
	<li><a href="#impact-on-existing-code">Impact on existing code</a></li>
	<li><a href="#examples">Examples</a>
		<ul>
			<li><a href="#parsing-date">Parsing a date</a></li>
			<li><a href="#non-transient-exceptions">Non-transient exceptions</a></li>
			<li><a href="#exceptions-must-be-caught">Exceptions must be caught</a></li>
			<li><a href="#constant-evaluation-violation-behavior-wont-be-changed">Constant evaluation violation behavior won't be changed</a></li>
			<li><a href="#lifetime-of-exception-object-must-stay-inside-constant-evaluation">Lifetime of exception object must stay inside constant evaluation</a></li>
		</ul>
	</li>
	<li><a href="#special-thanks">Special thanks</a></li>
</ul>
</div></div></nav>
<article>
<div><div>
	<h1 class="hide-on-narrow name-of-paper">Allowing exception throwing in constant-evaluation</h1>
	<h2 id="introduction"><a href="#introduction">Introduction</a></h2>
<p>Since adding the <code>constexpr</code> keyword in C++11, WG21 has gradually expanded the scope of language features  for use in constant-evaluated code. At first, users couldn't even use <code>if</code>, <code>else</code>, or loops. C++14 added support for them. C++17 added support for constexpr lambdas. C++20 finally added the ability to use allocation, <code>std::vector</code> and <code>std::string</code>. These improvements have been widely appreciated, and lead to simpler code that doesn't need to work around differences between normal and constexpr C++.</p>
<p>The last major language feature from C++ still not present in constexpr code is the ability to throw an exception. This absence forces library authors to use more intrusive error reporting mechanisms. One example would be the use of <code>std::expected</code> and <code>std::optional</code>. Another one is the complete omission of error handling. This leaves users with long and confusing errors generated by the compiler.</p>
<p>Throwing exceptions in constant evaluated code is the preferred way of error reporting in the proposal adding <em><a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2996r2.html">Static Reflection for C++26</a></em>. Some meta-functions can fail, and allowing them to throw will significantly simplify reflection code.</p>

<h2 id="changes"><a href="#changes">Changes</a></h2>
<ul>
	<li><a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3068r1.pdf">R1</a>&#x2005;→&#x2005;R2: Added library wording, new examples, implementation description, and updated impact of changes.</li>
	<li><a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3068r0.pdf">R0</a>&#x2005;→&#x2005;<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3068r1.pdf">R1</a>: Changed wording after consultation with Jens, added example to show exception can't leak via <code>std::exception_ptr</code></li>
</ul>

<h2 id="hello-constexpr-exceptions-world"><a href="#hello-constexpr-exceptions-world">Motivational example</a></h2>
<pre><code class="language-cpp">consteval auto hello(std::string_view input) {
	if (input.empty()) {
		throw invalid_argument{"empty name provided"}; <span class="before">// BEFORE: compile-time error at throw expression site when reached</span>
	}
	
	return concat_into_a_fixed_string("hello ",input);
}</code></pre>

<pre><code class="language-cpp">const auto a = hello(""); <span class="unchanged">// AFTER: compile-time error at call site "empty name provided"</span>
const auto b = hello("Hana");

try {
	const auto c = hello(""); <span class="after">// AFTER: this exception is caught</span>
} catch (const validation_error &) {
	// everything is fine
}

const auto d = hello("Adolph Blaine Charles David Earl Frederick Gerald Hubert Irvin John Kenneth Lloyd Martin Nero Oliver Paul Quincy Randolph Sherman Thomas Uncas Victor William Xerxes Yancy Zeus Wolfeschlegelsteinhausen­bergerdorff­welche­vor­altern­waren­gewissenhaft­schafers­wessen­schafe­waren­wohl­gepflege­und­sorgfaltigkeit­beschutzen­von­angreifen­durch­ihr­raubgierig­feinde­welche­vor­altern­zwolf­tausend­jahres­voran­die­erscheinen­van­der­erste­erdemensch­der­raumschiff­gebrauch­licht­als­sein­ursprung­von­kraft­gestart­sein­lange­fahrt­hinzwischen­sternartig­raum­auf­der­suchen­ach­die­stern­welche­gehabt­bewohnbar­planeten­kreise­drehen­sich­und­wohin­der­neu­rasse­von­verstandig­menschlichkeit­konnte­fortpflanzen­und­sich­erfreuen­an­lebenslanglich­freude­und­ruhe­mit­nicht­ein­furcht­vor­angreifen­von­anderer­intelligent­geschopfs­von­hinzwischen­sternartig­raum."); <span class="before">// BEFORE: compile-time error at throw expression site deep in the concat function</span>
<span class="invisible">const auto d = hello("Adolph Blaine Charles David Earl Frederick Gerald Hubert Irvin John Kenneth Lloyd Martin Nero Oliver Paul Quincy Randolph Sherman Thomas Uncas Victor William Xerxes Yancy Zeus Wolfeschlegelsteinhausen­bergerdorff­welche­vor­altern­waren­gewissenhaft­schafers­wessen­schafe­waren­wohl­gepflege­und­sorgfaltigkeit­beschutzen­von­angreifen­durch­ihr­raubgierig­feinde­welche­vor­altern­zwolf­tausend­jahres­voran­die­erscheinen­van­der­erste­erdemensch­der­raumschiff­gebrauch­licht­als­sein­ursprung­von­kraft­gestart­sein­lange­fahrt­hinzwischen­sternartig­raum­auf­der­suchen­ach­die­stern­welche­gehabt­bewohnbar­planeten­kreise­drehen­sich­und­wohin­der­neu­rasse­von­verstandig­menschlichkeit­konnte­fortpflanzen­und­sich­erfreuen­an­lebenslanglich­freude­und­ruhe­mit­nicht­ein­furcht­vor­angreifen­von­anderer­intelligent­geschopfs­von­hinzwischen­sternartig­raum."); </span><span class="unchanged">// AFTER: compile-time error at call site "<a href="https://en.wikipedia.org/wiki/Hubert_Blaine_Wolfeschlegelsteinhausenbergerdorff_Sr.">too long name provided</a>"</span></code></pre>

<h2 id="wording"><a href="#wording">Proposed changes to wording</a></h2>
<div class="wording">
<h2><a href="https://eel.is/c++draft/expr.const">7.7 Constant expressions [expr.const]</a></h2>
<p>(<a href="https://eel.is/c++draft/expr.const#5.25">5.25</a>) a throw-expression ([expr.throw])<span class="removed">;</span><span class="added">, unless the lifetimes of the exception object and any implicit copies of exception object created by calls to <code>std::current_exception()</code> or <code>std::rethrow_exception()</code> end within the evaluation of <code>E</code></span></p>
<p class="note"><span class="added"><em>Recommended practice:</em> Where possible, implementations should use the thrown exception's member function named <code>what</code> to produce helpful diagnostics. If no such member function is available, then the implementation should emit a diagnostic containing the type and value of the thrown object. Diagnostics emitted due to an uncaught exception should include the source location of the outer-most caller, and include the source location from where the exception was thrown.]</span></p>
</div>

<h3 id="library-wording"><a href="#library-wording">Library wording</a></h3>
<p><em>Note:</em> This paper doesn't contain wording for any <code>&lt;stdexcept&gt;</code> changes as these are proposed already in <em><a href="https://isocpp.org/files/papers/P3295R0.html">P3295R0: Freestanding constexpr containers and constexpr exception types</a></em></p>

<div class="wording">

<h2><a href="https://eel.is/c++draft/exception.syn">17.9.2 Header &lt;exception&gt; synopsis [exception.syn]</a></h2>
<pre class="language-cpp"><code>// all freestanding
namespace std {
  class exception;
  class bad_exception;
  class nested_exception;

  using terminate_handler = void (*)();
  terminate_handler get_terminate() noexcept;
  terminate_handler set_terminate(terminate_handler f) noexcept;
  [[noreturn]] void terminate() noexcept;

  <span class="added">constexpr </span>int uncaught_exceptions() noexcept;

  using exception_ptr = <em>unspecified</em>;

  <span class="added">constexpr </span>exception_ptr current_exception() noexcept;
  [[noreturn]] <span class="added">constexpr </span>void rethrow_exception(exception_ptr p);
  template&lt;class E&gt; <span class="added">constexpr </span>exception_ptr make_exception_ptr(E e) noexcept;

  template&lt;class T&gt; <span class="added">constexpr </span>[[noreturn]] void throw_with_nested(T&& t);
  template&lt;class E&gt; <span class="added">constexpr </span>void rethrow_if_nested(const E& e);
}</code></pre>
<h2><a href="https://eel.is/c++draft/exception">17.9.3 Class exception [exception]</a></h2>
<pre class="language-cpp"><code>namespace std {
  class exception {
  public:
    <span class="added">constexpr </span>exception() noexcept;
    <span class="added">constexpr </span>exception(const exception&) noexcept;
    <span class="added">constexpr </span>exception& operator=(const exception&) noexcept;
    <span class="added">constexpr </span>virtual ~exception();
    <span class="added">constexpr </span>virtual const char* what() const noexcept;
  };
}</code></pre>
<pre class="language-cpp"><code><span class="added">constexpr </span>exception(const exception& rhs) noexcept;
<span class="added">constexpr </span>exception& operator=(const exception& rhs) noexcept;</code></pre>
<pre class="language-cpp"><code>virtual <span class="added">constexpr </span>~exception();</code></pre>
<pre class="language-cpp"><code>virtual <span class="added">constexpr </span>const char* what() const noexcept;</code></pre>
<h2><a href="https://eel.is/c++draft/bad.exception">17.9.4 Class bad_exception [bad.exception]</a></h2>
<pre class="language-cpp"><code>namespace std {namespace std {
  class bad_exception : public exception {
  public:
    // see [exception] for the specification of the special member functions
    <span class="added">constexpr </span>const char* what() const noexcept override;
  };
}</code></pre>
<pre class="language-cpp"><code>virtual <span class="added">constexpr </span>const char* what() const noexcept override;</code></pre>
<h2><a href="https://eel.is/c++draft/uncaught.exceptions">17.9.6 uncaught_exceptions [uncaught.exceptions]</a></h2>
<pre class="language-cpp"><code><span class="added">constexpr </span>int uncaught_exceptions() noexcept;</code></pre>
<h2><a href="https://eel.is/c++draft/propagation">17.9.7 Exception propagation [propagation]</a></h2>
<pre class="language-cpp"><code>using exception_ptr = <em>unspecified</em>;</code></pre>
<p><span class="added">(8) All member functions are marked constexpr.</span></p>

<pre class="language-cpp"><code><span class="added">constexpr </span>exception_ptr current_exception() noexcept;</code></pre>

<pre class="language-cpp"><code>[[noreturn]] <span class="added">constexpr </span>void rethrow_exception(exception_ptr p);</code></pre>

<pre class="language-cpp"><code>template&lt;class E&gt; exception_ptr <span class="added">constexpr </span>make_exception_ptr(E e) noexcept;</code></pre>

<h2><a href="https://eel.is/c++draft/except.nested">17.9.8 nested_exception [except.nested]</a></h2>
<pre class="language-cpp"><code>namespace std {
  class nested_exception {
  public:
    <span class="added">constexpr </span>nested_exception() noexcept;
    <span class="added">constexpr </span>nested_exception(const nested_exception&) noexcept = default;
    <span class="added">constexpr </span>nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual <span class="added">constexpr </span>~nested_exception() = default;

    // access functions
    [[noreturn]] <span class="added">constexpr </span>void rethrow_nested() const;
    <span class="added">constexpr </span>exception_ptr nested_ptr() const noexcept;
  };

  template&lt;class T&gt; [[noreturn]] <span class="added">constexpr </span>void throw_with_nested(T&& t);
  template&lt;class E&gt; <span class="added">constexpr </span>void rethrow_if_nested(const E& e);
}</code></pre>
<pre class="language-cpp"><code><span class="added">constexpr </span>nested_exception() noexcept;</code></pre>
<pre class="language-cpp"><code>[[noreturn]] <span class="added">constexpr </span>void rethrow_nested() const;</code></pre>
<pre class="language-cpp"><code><span class="added">constexpr </span>exception_ptr nested_ptr() const noexcept;</code></pre>
<pre class="language-cpp"><code>template&lt;class T&gt; [[noreturn]] <span class="added">constexpr </span>void throw_with_nested(T&& t);</code></pre>
<pre class="language-cpp"><code>template&lt;class E&gt; void <span class="added">constexpr </span>rethrow_if_nested(const E& e);</code></pre>



</div>
<h2 id="implementation-experience"><a href="#implementation-experience">Implementation experience</a></h2>
<p>A partial implementation in Clang is available on <a href="https://compiler-explorer.com/z/h1Tff5d3P">compiler-explorer.com</a>. I expect it to be feature complete in time for the presentation at the St. Louis meeting.</p>
<p>The implementation approach is an <em>exception</em> slot to for <code>throw</code>-statements to store it in the same way as <code>return</code>-statements do. Every <code>try</code> block creates a new <em>exception</em> slot and try to match the appropriate <code>catch</code> block.</p>
<p>Library support is implemented via a set of new compiler builtins.</p>
<p>Three other compiler vendors were consulted and raised no implementability concerns.</p>


<h2 id="impact-on-existing-code"><a href="#impact-on-existing-code">Impact on existing code</a></h2>
<p>This change doesn't break any existing code as throwing exceptions without catching them is already an error and is used by various libraries (<a href="https://github.com/fmtlib/fmt/blob/8.1.1/include/fmt/format.h#L1619">fmt</a>, <a href="https://github.com/hanickadot/cthash/commit/46c8b6db59217827bf4ac0a53e8b13ca03861089#diff-67bca1e9849772f871bd9d89e6ad975ce3aacc061e77ddd80d84c1d8de6e1fc3R18">CTHASH</a>) to improve compile-time errors.</p>
<p>This proposal can make previously non-compiling code which reached a <code>throw</code>-statement compile by catching the thrown exception.</p>
<p>The intent is to keep this useful mechanism intact. The proposed wording change will only modify behavior in cases where a <code>try</code>/<code>catch</code> block is present.</p>

<h2 id="examples"><a href="#examples">Examples</a></h2>
<h3 id="parsing-date">Parsing date</h3>
<pre><code class="language-cpp">constexpr date parse_date(std::string_view input) {
	auto [correct, year, month, day] = ctre::match&lt;"([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})"&gt;(input);
	
	if (!correct) {
		throw incorrect_date{input};
	}
	
	return build_date(year, month, day);
}

constexpr auto birthday = parse_date("1991-07-21"); // fine
constexpr auto wrong_day = parse_date("1-2-3"); <span class="error">// COMPILE-TIME ERROR: provided incorrect date "1-2-3"</span>
constexpr auto weird_day = parse_date("2023-03-29"); <span class="error">// COMPILE-TIME ERROR: year 2023 doesn't have a leap day</span>
</code></pre>
<h3 id="non-transient-exceptions"><a href="#non-transient-exceptions">Non-transient exceptions</a></h3>
<p>The current wording matches pre-<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3032r2.html">P3032</a> wording and treats an exception basically as an allocation, and such allocation can't escape any <code>constexpr</code> variable initialization.</p>
<pre><code class="language-cpp">constexpr auto just_error() { 
	throw my_exception{};
}

constexpr void foo() {
	try {
		auto v = just_error(); // OK
	} catch (my_exception) {
		// do nothing
	}
	try {
		constexpr auto v = just_error(); <span class="error">// COMPILE-TIME ERROR: uncaught exception of type "my_exception"</span>
	} catch (my_exception) { }
}</code></pre>

<h3 id="exceptions-must-be-caught"><a href="#exceptions-must-be-caught">Exceptions must be caught</a></h3>
<pre><code class="language-cpp">constexpr unsigned divide(unsigned n, unsigned d) {
	if (d == 0u) {
		throw invalid_argument{"division by zero"};
	}
	return n / d;
}

constexpr auto b = divide(5, 0); <span class="before">// BEFORE: compilation error due reaching a throw expression</span>
<span class="invisible">constexpr auto b = divide(5, 0); </span><span class="unchanged">// AFTER: still a compilation error but due the uncaught exception</span>

constexpr std::optional&lt;unsigned&gt; checked_divide(unsigned n, unsigned d) {
	try {
		return divide(n, d);
	} catch (...) {
		return std::nullopt;
	}
}

constexpr auto a = checked_divide(5, 0); <span class="before">// BEFORE: compilation error</span>
<span class="invisible">constexpr auto a = checked_divide(5, 0); </span><span class="after">// AFTER: std::nullopt value</span>
</code></pre>
<h3 id="constant-evaluation-violation-behavior-wont-be-changed"><a href="#constant-evaluation-violation-behavior-wont-be-changed">Constant evaluation violation behavior won't be changed</a></h3>
<p>This paper <b>doesn't propose</b> throwing an exception for any other constant evaluation error.</p>
<pre><code class="language-cpp">constexpr unsigned read_pointer(const unsigned* p) {
	return *p;
}

constexpr unsigned try_to_ignore_ub() {
	try {
		return read_pointer(nullptr);
	} catch (...) {
		return 0;
	}
}

constexpr auto v = try_to_ignore_ub(); <span class="unchanged">// UNCHANGED: error due reaching UB by dereferencing the NULL pointer (no exception is involved)</span>
</code></pre>
<h3 id="lifetime-of-exception-object-must-stay-inside-constant-evaluation"><a href="#lifetime-of-exception-object-must-stay-inside-constant-evaluation">Lifetime of exception object must stay inside constant evaluation</a></h3>
<p>Exception objects thrown at compile-time must be caught before leaving their respective constant-evaluated scope, and can't be stored for run-time access. This is similar to constexpr allocations, which must be deallocated before leaving their respective scopes, and any memory that's reserved at compile-time is inaccessible to run-time evaluations.</p>
<pre><code class="language-cpp">consteval auto fail() -&gt; std::exception_ptr{
	try {
		throw failure{};
	} catch (...) {
		return std::current_exception();
	}
}

constexpr auto stored_exception = fail(); <span class="error">// NOT ALLOWED to store std::exception_ptr in a constexpr variable</span>
</code></pre>
<h2 id="special-thanks"><a href="#special-thanks">Special thanks</a></h2>
To Richard&nbsp;Smith, Barry&nbsp;Revzin, Daveed&nbsp;Vandevoorde, Jana&nbsp;Machutová, Christopher&nbsp;Di&nbsp;Bella, Jens&nbsp;Maurer, Robert&nbsp;C.&nbsp;Seacord, Lewis&nbsp;Baker, David&nbsp;Sankel, and Guy&nbsp;Davidson.

</div></div></article>
</div><script>
	hljs.addPlugin(mergeHTMLPlugin);
	hljs.highlightAll();
</script>
</body>
</html>
