﻿<html>
<head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    <meta charset="utf-8">
    <!-- TITLE -->
    <title>A friendlier tuple get</title>
    <style name="main.css">
        @import url(https://fonts.googleapis.com/css?family=Muli:400,300);
        @import url(https://fonts.googleapis.com/css?family=Share:400,700);
        /* ============================== */
        /* BODY */
        /* ============================== */
        body {
            font-family: 'Muli',arial,sans-serif;
            background-color: #FEFEFE;
            margin: 0;
            padding: 0;
            font-size: 0.875em;
            color: #616161;
        }

        h1, h2, h3, h4, h5, h6 {
            margin-bottom: 0.5em;
            font-family: 'Share';
        }

        .title {
            border-bottom: solid 2px #f5aa10;
        }

        #container {
            margin: 0 auto;
            width: 60%;
            min-width: 640px;
            overflow: auto;
        }

        #main {
            width: 100%;
        }

        a {
            color: #3C6EB4;
            cursor: pointer;
            text-decoration: none;
        }

            a:hover {
                text-decoration: underline;
            }
        /* ============================== */
        /* HEADER */
        /* ============================== */
        #head {
            overflow: auto;
            margin: 40px 0;
        }

            #head div.top {
                font-size: 2.4em;
                margin-right: 80px;
            }

            #head div.bottom {
                height: 38px;
                margin-right: 80px;
            }

            #head .logo {
                vertical-align: bottom;
            }

            #head a.name {
                text-decoration: none;
                color: #555;
                font-weight: bold;
                overflow: auto;
            }

            #head span.slogan {
                color: #CCC;
            }
        /* ============================== */
        /* POST VIEW*/
        /* ============================== */
        article.post {
            margin-bottom: 60px;
            clear: both;
            overflow: auto;
        }

            article.post header.post {
                margin-bottom: 10px;
            }

                article.post header.post h1.title {
                    font-weight: bold;
                    margin: 0;
                }

                    article.post header.post h1.title a {
                        color: inherit;
                        text-decoration: none;
                    }

                article.post header.post div.date {
                    font-size: 0.9em;
                    font-weight: bold;
                    text-align: right;
                    text-transform: uppercase;
                    color: #999;
                }

            article.post .body {
                font-size: 1.2em;
            }

            article.post .console {
                background: url("img/console.png") no-repeat scroll 10px center #F1F1F1;
                display: block;
                line-height: 50px;
                margin: 5px 0;
                padding-left: 60px;
            }

            article.post img:not(.captcha) {
                max-width: 100%;
            }

            article.post blockquote {
                font-size: 1em;
                width: 80%;
                margin-left: 2em;
                padding-left: 0.5em;
                border-left: 2px solid #C3C3C3;
            }

            article.post footer.post {
                clear: both;
                margin-top: 20px;
                text-align: center;
            }

        article pre {
            border: 1px dashed #ccc;
            padding: 1em;
            background: #f4f4f4;
        }

        article.pre, article.code {
            font-family: monospace;
            font-size: 1em;
        }
        /* ============================== */
        /* TABLES */
        /* ============================== */
        table {
            border: 1px solid #999;
        }

            table th, table td {
                background: #f4f4f4;
                padding: 5px 15px;
            }

            table thead {
                border-bottom: 1px solid #999;
            }

            table th {
                font-weight: bold;
                background: #eaeaea;
            }

            table td, table th {
                border-right: 1px solid #999;
            }
    </style>
    <!-- SyntaxHighlighter -->
    <style name="normalize.css">
        article, aside, details, figcaption, figure, footer, header, hgroup, nav, section, summary {
            display: block;
        }

        audio, canvas, video {
            display: inline-block;
        }

            audio:not([controls]) {
                display: none;
                height: 0;
            }

        [hidden] {
            display: none;
        }

        html {
            font-family: sans-serif;
            -webkit-text-size-adjust: 100%;
            -ms-text-size-adjust: 100%;
        }

        a:focus {
            outline: thin dotted;
        }

        a:active, a:hover {
            outline: 0;
        }

        h1 {
            font-size: 2em;
        }

        abbr[title] {
            border-bottom: 1px dotted;
        }

        b, strong {
            font-weight: 700;
        }

        dfn {
            font-style: italic;
        }

        mark {
            background: #ff0;
            color: #000;
        }

        code, kbd, pre, samp {
            font-family: monospace, serif;
            font-size: 1em;
        }

        pre {
            white-space: pre-wrap;
            word-wrap: break-word;
        }

        q {
            quotes: \201C \201D \2018 \2019;
        }

        small {
            font-size: 80%;
        }

        sub, sup {
            font-size: 75%;
            line-height: 0;
            position: relative;
            vertical-align: baseline;
        }

        sup {
            top: -.5em;
        }

        sub {
            bottom: -.25em;
        }

        img {
            border: 0;
        }

        svg:not(:root) {
            overflow: hidden;
        }

        fieldset {
            border: 1px solid silver;
            margin: 0 2px;
            padding: .35em .625em .75em;
        }

        button, input, select, textarea {
            font-family: inherit;
            font-size: 100%;
            margin: 0;
        }

        button, input {
            line-height: normal;
        }

            button, html input[type=button], /* 1 */
            input[type=reset], input[type=submit] {
                -webkit-appearance: button;
                cursor: pointer;
            }

                button[disabled], input[disabled] {
                    cursor: default;
                }

            input[type=checkbox], input[type=radio] {
                box-sizing: border-box;
                padding: 0;
            }

            input[type=search] {
                -webkit-appearance: textfield;
                -moz-box-sizing: content-box;
                -webkit-box-sizing: content-box;
                box-sizing: content-box;
            }

                input[type=search]::-webkit-search-cancel-button, input[type=search]::-webkit-search-decoration {
                    -webkit-appearance: none;
                }

        textarea {
            overflow: auto;
            vertical-align: top;
        }

        table {
            border-collapse: collapse;
            border-spacing: 0;
        }

        body, figure {
            margin: 0;
        }

        legend, button::-moz-focus-inner, input::-moz-focus-inner {
            border: 0;
            padding: 0;
        }
    </style>
    <style name="shCore.css">
        .syntaxhighlighter a,
        .syntaxhighlighter div,
        .syntaxhighlighter code,
        .syntaxhighlighter table,
        .syntaxhighlighter table td,
        .syntaxhighlighter table tr,
        .syntaxhighlighter table tbody,
        .syntaxhighlighter table thead,
        .syntaxhighlighter table caption,
        .syntaxhighlighter textarea {
            -moz-border-radius: 0 0 0 0 !important;
            -webkit-border-radius: 0 0 0 0 !important;
            background: none !important;
            border: 0 !important;
            bottom: auto !important;
            float: none !important;
            height: auto !important;
            left: auto !important;
            line-height: 1.1em !important;
            margin: 0 !important;
            outline: 0 !important;
            overflow: visible !important;
            padding: 0 !important;
            position: static !important;
            right: auto !important;
            text-align: left !important;
            top: auto !important;
            vertical-align: baseline !important;
            width: auto !important;
            box-sizing: content-box !important;
            font-family: monospace !important;
            font-weight: normal !important;
            font-style: normal !important;
            font-size: 1em !important;
            min-height: inherit !important;
            min-height: auto !important;
        }

        .syntaxhighlighter {
            margin: 1em 0 1em 0 !important;
            overflow: auto !important;
            font-size: 1em !important;
        }

            .syntaxhighlighter.source {
                overflow: hidden !important;
            }

            .syntaxhighlighter .bold {
                font-weight: bold !important;
            }

            .syntaxhighlighter .italic {
                font-style: italic !important;
            }

            .syntaxhighlighter .line {
                white-space: pre !important;
            }

            .syntaxhighlighter table {
                width: 100% !important;
            }

                .syntaxhighlighter table caption {
                    text-align: left !important;
                    padding: .5em 0 0.5em 1em !important;
                }

                .syntaxhighlighter table td.code {
                    width: 100% !important;
                }

                    .syntaxhighlighter table td.code .container {
                        position: relative !important;
                    }

                        .syntaxhighlighter table td.code .container textarea {
                            box-sizing: border-box !important;
                            position: absolute !important;
                            left: 0 !important;
                            top: 0 !important;
                            width: 100% !important;
                            height: 100% !important;
                            border: none !important;
                            background: white !important;
                            padding-left: 1em !important;
                            overflow: hidden !important;
                            white-space: pre !important;
                        }

                .syntaxhighlighter table td.gutter .line {
                    text-align: right !important;
                    padding: 0 0.5em 0 1em !important;
                }

                .syntaxhighlighter table td.code .line {
                    padding: 0 1em !important;
                }

            .syntaxhighlighter.nogutter td.code .container textarea, .syntaxhighlighter.nogutter td.code .line {
                padding-left: 0em !important;
            }

            .syntaxhighlighter.show {
                display: block !important;
            }

            .syntaxhighlighter.collapsed table {
                display: none !important;
            }

            .syntaxhighlighter.collapsed .toolbar {
                padding: 0.1em 0.8em 0em 0.8em !important;
                font-size: 1em !important;
                position: static !important;
                width: auto !important;
                height: auto !important;
            }

                .syntaxhighlighter.collapsed .toolbar span {
                    display: inline !important;
                    margin-right: 1em !important;
                }

                    .syntaxhighlighter.collapsed .toolbar span a {
                        padding: 0 !important;
                        display: none !important;
                    }

                        .syntaxhighlighter.collapsed .toolbar span a.expandSource {
                            display: inline !important;
                        }

            .syntaxhighlighter .toolbar {
                position: absolute !important;
                right: 1px !important;
                top: 1px !important;
                width: 11px !important;
                height: 11px !important;
                font-size: 10px !important;
                z-index: 10 !important;
            }

                .syntaxhighlighter .toolbar span.title {
                    display: inline !important;
                }

                .syntaxhighlighter .toolbar a {
                    display: block !important;
                    text-align: center !important;
                    text-decoration: none !important;
                    padding-top: 1px !important;
                }

                    .syntaxhighlighter .toolbar a.expandSource {
                        display: none !important;
                    }

            .syntaxhighlighter.ie {
                font-size: .9em !important;
                padding: 1px 0 1px 0 !important;
            }

                .syntaxhighlighter.ie .toolbar {
                    line-height: 8px !important;
                }

                    .syntaxhighlighter.ie .toolbar a {
                        padding-top: 0px !important;
                    }

            .syntaxhighlighter.printing .line.alt1 .content,
            .syntaxhighlighter.printing .line.alt2 .content,
            .syntaxhighlighter.printing .line.highlighted .number,
            .syntaxhighlighter.printing .line.highlighted.alt1 .content,
            .syntaxhighlighter.printing .line.highlighted.alt2 .content {
                background: none !important;
            }

            .syntaxhighlighter.printing .line .number {
                color: #bbbbbb !important;
            }

            .syntaxhighlighter.printing .line .content {
                color: black !important;
            }

            .syntaxhighlighter.printing .toolbar {
                display: none !important;
            }

            .syntaxhighlighter.printing a {
                text-decoration: none !important;
            }

            .syntaxhighlighter.printing .plain, .syntaxhighlighter.printing .plain a {
                color: black !important;
            }

            .syntaxhighlighter.printing .comments, .syntaxhighlighter.printing .comments a {
                color: #008200 !important;
            }

            .syntaxhighlighter.printing .string, .syntaxhighlighter.printing .string a {
                color: blue !important;
            }

            .syntaxhighlighter.printing .keyword {
                color: #006699 !important;
                font-weight: bold !important;
            }

            .syntaxhighlighter.printing .preprocessor {
                color: gray !important;
            }

            .syntaxhighlighter.printing .variable {
                color: #aa7700 !important;
            }

            .syntaxhighlighter.printing .value {
                color: #009900 !important;
            }

            .syntaxhighlighter.printing .functions {
                color: #ff1493 !important;
            }

            .syntaxhighlighter.printing .constants {
                color: #0066cc !important;
            }

            .syntaxhighlighter.printing .script {
                font-weight: bold !important;
            }

            .syntaxhighlighter.printing .color1, .syntaxhighlighter.printing .color1 a {
                color: gray !important;
            }

            .syntaxhighlighter.printing .color2, .syntaxhighlighter.printing .color2 a {
                color: #ff1493 !important;
            }

            .syntaxhighlighter.printing .color3, .syntaxhighlighter.printing .color3 a {
                color: red !important;
            }

            .syntaxhighlighter.printing .break, .syntaxhighlighter.printing .break a {
                color: black !important;
            }
    </style>
    <style name="shThemeDefault.css">
        .syntaxhighlighter {
            background-color: #f4f4f4 !important;
            border: 1px dashed #ccc;
            padding: 1em;
        }

            .syntaxhighlighter .line.alt1 {
                background-color: #f4f4f4 !important;
            }

            .syntaxhighlighter .line.alt2 {
                background-color: #f4f4f4 !important;
            }

            .syntaxhighlighter .line.highlighted.alt1, .syntaxhighlighter .line.highlighted.alt2 {
                background-color: #e0e0e0 !important;
            }

            .syntaxhighlighter .line.highlighted.number {
                color: black !important;
            }

            .syntaxhighlighter table caption {
                color: black !important;
            }

            .syntaxhighlighter .gutter {
                color: #afafaf !important;
            }

                .syntaxhighlighter .gutter .line {
                    border-right: 3px solid #6ce26c !important;
                }

                    .syntaxhighlighter .gutter .line.highlighted {
                        background-color: #6ce26c !important;
                        color: white !important;
                    }

            .syntaxhighlighter.printing .line .content {
                border: none !important;
            }

            .syntaxhighlighter.collapsed {
                overflow: visible !important;
            }

                .syntaxhighlighter.collapsed .toolbar {
                    color: blue !important;
                    background: #f4f4f4 !important;
                    border: 1px solid #6ce26c !important;
                }

                    .syntaxhighlighter.collapsed .toolbar a {
                        color: blue !important;
                    }

                        .syntaxhighlighter.collapsed .toolbar a:hover {
                            color: red !important;
                        }

            .syntaxhighlighter .toolbar {
                color: #f4f4f4 !important;
                background: #6ce26c !important;
                border: none !important;
            }

                .syntaxhighlighter .toolbar a {
                    color: #f4f4f4 !important;
                }

                    .syntaxhighlighter .toolbar a:hover {
                        color: black !important;
                    }

            .syntaxhighlighter .plain, .syntaxhighlighter .plain a {
                color: black !important;
            }

            .syntaxhighlighter .comments, .syntaxhighlighter .comments a {
                color: #008200 !important;
            }

            .syntaxhighlighter .string, .syntaxhighlighter .string a {
                color: blue !important;
            }

            .syntaxhighlighter .keyword {
                color: #006699 !important;
            }

            .syntaxhighlighter .preprocessor {
                color: gray !important;
            }

            .syntaxhighlighter .variable {
                color: #aa7700 !important;
            }

            .syntaxhighlighter .value {
                color: #009900 !important;
            }

            .syntaxhighlighter .functions {
                color: #ff1493 !important;
            }

            .syntaxhighlighter .constants {
                color: #0066cc !important;
            }

            .syntaxhighlighter .script {
                font-weight: bold !important;
                color: #006699 !important;
                background-color: none !important;
            }

            .syntaxhighlighter .color1, .syntaxhighlighter .color1 a {
                color: gray !important;
            }

            .syntaxhighlighter .color2, .syntaxhighlighter .color2 a {
                color: #ff1493 !important;
            }

            .syntaxhighlighter .color3, .syntaxhighlighter .color3 a {
                color: red !important;
            }

            .syntaxhighlighter .keyword {
                font-weight: bold !important;
            }
    </style>
</head>
<body>
    <div id="container">
        <section id="main">
            <article class="post">
                <p>
                    Document number: P0825R1<br>
                    Date: 2018-2-10<br>
                    Project: Programming Language C++, Library Evolution Working Group<br>
                    Reply-to: Agustín Bergé <a href="mailto:agustinberge@gmail.com">agustinberge@gmail.com</a>
                </p>

                <a name="a-friendlier-tuple-`get`" href="#a-friendlier-tuple-`get`"><h1>A friendlier tuple <code>get</code></h1></a>

                <a name="0.-history" href="#0.-history"><h2>0. History</h2></a>

                <p>Changes from P0825R0:</p>

                <ul>
                    <li>Add proposed wording.</li>
                    <li>Move alternative designs discussion to appendix.</li>
                </ul>

                <a name="1.-introduction" href="#1.-introduction"><h2>1. Introduction</h2></a>

                <p>This paper proposes changing <code>std::get</code> overloads to behave gracefully in the presence of user defined <code>get</code> overloads.</p>

                <a name="2.-motivation" href="#2.-motivation"><h2>2. Motivation</h2></a>

                <p>Consider the following example, presented on <em>Cpplang</em> at Slack:</p>

                <div>
                    <div id="highlighter_964663" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp keyword bold">typename</code><code class="cpp plain">... Ts&gt;</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp keyword bold">struct</code> <code class="cpp plain">WeirdTuple : </code><code class="cpp keyword bold">private</code> <code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt; {</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">using</code> <code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;::tuple;</code></div>
                                            <div class="line number4 index3 alt1"><code class="cpp plain">};</code></div>
                                            <div class="line number5 index4 alt2">&nbsp;</div>
                                            <div class="line number6 index5 alt1"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">typename</code><code class="cpp plain">... Ts&gt;</code></div>
                                            <div class="line number7 index6 alt2"><code class="cpp keyword bold">auto</code> <code class="cpp plain">get(WeirdTuple&lt;Ts...&gt;&amp; t) { </code><code class="cpp keyword bold">return</code> <code class="cpp plain">I + 10; }</code></div>
                                            <div class="line number8 index7 alt1">&nbsp;</div>
                                            <div class="line number9 index8 alt2"><code class="cpp color1 bold">int</code> <code class="cpp plain">main() {</code></div>
                                            <div class="line number10 index9 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp plain">WeirdTuple&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt; wt(1);</code></div>
                                            <div class="line number11 index10 alt2">&nbsp;</div>
                                            <div class="line number12 index11 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp plain">get&lt;0&gt;(wt); </code><code class="cpp comments">// changing this 0 to anything else will break</code></div>
                                            <div class="line number13 index12 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// theoretically, that should still work -</code></div>
                                            <div class="line number14 index13 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// we're obviously using the WeirdTuple overload of get&lt;&gt;(),</code></div>
                                            <div class="line number15 index14 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// but the compiler fails when trying to compile </code><code class="cpp comments bold">every</code><code class="cpp comments"> possible overload!</code></div>
                                            <div class="line number16 index15 alt1"><code class="cpp plain">}</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p>After the alluded change, the result is:</p>

                <div>
                    <div id="highlighter_872575" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp plain">get&lt;1&gt;(wt); </code><code class="cpp comments">// error: static assertion failed: tuple index is in range</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// in instantiation of 'std::tuple_element&lt;1, std::tuple&lt;int&gt;&gt;'</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// required by substitution of</code></div>
                                            <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; constexpr std::tuple_element_t&lt;I, std::tuple&lt;Ts...&gt;&gt;&amp;</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(std::tuple&lt;Ts...&gt;&amp;)</code></div>
                                            <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; [with I = 1; Ts = {int}]</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p>The confusion arises from a disagreement between the programmer and the implementation on the "obviousness" of the intented target. A sufficiently advanced implementation might realize that no <code>std::get</code> overload would possibly be a better match than the <code>WeirdTuple</code> overload and thus skip substitution altogether, but it is not required to do so. During that substitution process the <code>std::get</code> overloads render the program ill-formed, effectively poisoning the overload set.</p>

                <a name="3.-discussion" href="#3.-discussion"><h2>3. Discussion</h2></a>

                <p>LEWG discussion in Albuquerque favored a solution based on conditionally deleting <code>std::get</code> overloads for out-of-bounds calls (see <a href="#a.-alternative-designs" title="Alternative Designs">Alternative Designs</a>):</p>

                <blockquote>
                    <p>APPROVAL VOTE:</p>

                    <ul>
                        <li>Option #1: SFINAE-friendly       2</li>
                        <li>Option #2: Conditionally Deleted 8</li>
                        <li>Option #3: Deduced Return Type   4</li>
                    </ul>
                </blockquote>

                <p>Conditionally deleted <code>get</code> overloads solve the issue by deferring the effect of making the program ill-formed to the point in which the overload is actually used, rather than when forming the candidate overload set:</p>

                <div>
                    <div id="highlighter_446717" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp plain">WeirdTuple&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt; wt(1);</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp plain">get&lt;0&gt;(wt); </code><code class="cpp comments">// ok, returns 10</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp plain">get&lt;1&gt;(wt); </code><code class="cpp comments">// ok too, returns 11</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p>Another consequence of this deferred effect is that it makes the calls SFINAE-friendly, since the invalid expression happens in an immediate context, and as such they can be used in expression constraints:</p>

                <div>
                    <div id="highlighter_930379" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">Tuple&gt;</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp keyword bold">concept</code> <code class="cpp plain">has_get = </code><code class="cpp keyword bold">requires</code><code class="cpp plain">(Tuple&amp; t) { get&lt;I&gt;(t); };</code></div>
                                            <div class="line number3 index2 alt2">&nbsp;</div>
                                            <div class="line number4 index3 alt1"><code class="cpp keyword bold">static_assert</code><code class="cpp plain">(has_get&lt;0, </code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt;&gt; == </code><code class="cpp keyword bold">true</code><code class="cpp plain">, </code><code class="cpp string">"elem 0: int"</code><code class="cpp plain">);</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp keyword bold">static_assert</code><code class="cpp plain">(has_get&lt;1, </code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt;&gt; == </code><code class="cpp keyword bold">false</code><code class="cpp plain">, </code><code class="cpp string">"out-of-bounds"</code><code class="cpp plain">);</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p>Given that deleted overloads do participate in overload resolution, even out-of-bounds calls to <code>get</code> will prefer a (deleted) <code>std::get</code> overload to any other user defined viable overload —Murphy, not Machiavelli— when the argument is one of the standard library types:</p>

                <div>
                    <div id="highlighter_239190" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">namespace</code> <code class="cpp plain">ud {</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">struct</code> <code class="cpp plain">foo { </code><code class="cpp comments">/*...*/</code> <code class="cpp plain">};</code></div>
                                            <div class="line number3 index2 alt2">&nbsp;</div>
                                            <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I&gt;</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">void</code> <code class="cpp plain">get(</code><code class="cpp color1 bold">std::any</code><code class="cpp plain"> thing) { </code><code class="cpp comments">/*gotten*/</code> <code class="cpp plain">}</code></div>
                                            <div class="line number6 index5 alt1"><code class="cpp plain">}</code></div>
                                            <div class="line number7 index6 alt2">&nbsp;</div>
                                            <div class="line number8 index7 alt1"><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;ud::foo&gt; t;</code></div>
                                            <div class="line number9 index8 alt2"><code class="cpp plain">get&lt;0&gt;(t); </code><code class="cpp comments">// ok</code></div>
                                            <div class="line number10 index9 alt1"><code class="cpp plain">get&lt;1&gt;(t); </code><code class="cpp comments">// error: call to deleted function 'get'</code></div>
                                            <div class="line number11 index10 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// note: declared here</code></div>
                                            <div class="line number12 index11 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(std::tuple&lt;Ts...&gt;&amp;) = delete;</code></div>
                                            <div class="line number13 index12 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; [with I = 1; Ts = {ud::foo}]</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p>As an additional side effect, since the error happens only after overload resolution has finished its job, the resulting diagnostics for an out-of-bounds call will only mention the selected (deleted) overload.</p>

                <a name="4.-proposed-wording" href="#4.-proposed-wording"><h2>4. Proposed Wording</h2></a>

                <p>This wording is relative to <strong>[N4713]</strong>.</p>

                <p>Change 23.2.1 [utility.syn], Header <code>&lt;utility&gt;</code> synopsis, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_416762" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp comments">// 23.4.4, tuple-like access to pair</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T&gt; </code><code class="cpp keyword bold">class</code> <code class="cpp plain">tuple_size;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T&gt; </code><code class="cpp keyword bold">class</code> <code class="cpp plain">tuple_element;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code>&nbsp;</div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt; </code><code class="cpp keyword bold">struct</code> <code class="cpp plain">tuple_size&lt;pair&lt;T1, T2&gt;&gt;;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt; </code><code class="cpp keyword bold">struct</code> <code class="cpp plain">tuple_element&lt;I, pair&lt;T1, T2&gt;&gt;;</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code>&nbsp;</div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number9 index8 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp; get(pair&lt;T1, T2&gt;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number10 index9 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number11 index10 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number12 index11 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number13 index12 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number14 index13 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number15 index14 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number16 index15 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number17 index16 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T1&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number18 index17 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number19 index18 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T1&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number20 index19 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number21 index20 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T1&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number22 index21 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number23 index22 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T1&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number24 index23 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number25 index24 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T2&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number26 index25 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number27 index26 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T2&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number28 index27 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number29 index28 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T2&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number30 index29 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number31 index30 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T2&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code></del></div>
                                                <div class="line number32 index31 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number33 index32 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></ins></div>
                                                <div class="line number34 index33 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number35 index34 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></ins></div>
                                                <div class="line number36 index35 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number37 index36 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></ins></div>
                                                <div class="line number38 index37 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number39 index38 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code></ins></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>
                </blockquote>

                <p>Change 23.4.4 [pair.astuple], Tuple-like access to <code>pair</code>, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_286485" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">struct</code> <code class="cpp plain">tuple_size&lt;pair&lt;T1, T2&gt;&gt; : integral_constant&lt;</code><code class="cpp color1 bold">size_t</code><code class="cpp plain">, 2&gt; { };</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code>&nbsp;</div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp plain">tuple_element&lt;I, pair&lt;T1, T2&gt;&gt;::type</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p>-1- <em>Requires</em>: <code>I &lt; 2</code>. The program is ill-formed if <code>I</code> is out of bounds.</p>

                    <p>-2- <em>Value</em>: The type <code>T1</code> if <code>I == 0</code>, otherwise the type <code>T2</code>.</p>

                    <div>
                        <div id="highlighter_928476" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p>-3- <em>Returns</em>: If <code>I == 0</code> returns a reference to <code>p.first</code>; if <code>I == 1</code> returns a reference to <code>p.second</code><del style="background-color: #FFA0A0;">; otherwise the program is ill-formed</del>.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: If <code>I &lt; 2</code> the type <code>V</code> is <code>tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;</code>. Otherwise this function is defined as deleted, and <code>V</code> is an unspecified referenceable type.</ins></p>

                    <div>
                        <div id="highlighter_644664" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><del style="background-color: #FFA0A0;"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number2 index1 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T1&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number3 index2 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number4 index3 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T1&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number5 index4 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number6 index5 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T1&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number7 index6 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></del></div>
                                                <div class="line number8 index7 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T1&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-4- <em>Requires</em>: <code>T1</code> and <code>T2</code> are distinct types. Otherwise, the program is ill-formed.</del></p>

                    <p><del style="background-color: #FFA0A0;">-5- <em>Returns</em>: A reference to <code>p.first</code>.</del></p>

                    <div>
                        <div id="highlighter_634859" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><del style="background-color: #FFA0A0;"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number2 index1 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T2&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number3 index2 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number4 index3 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T2&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number5 index4 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number6 index5 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T2&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                                <div class="line number7 index6 alt2"><del style="background-color: #FFA0A0;"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1&gt;</code></del></div>
                                                <div class="line number8 index7 alt1"><del style="background-color: #FFA0A0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T2&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></del></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-6- <em>Requires</em>: <code>T1</code> and <code>T2</code> are distinct types. Otherwise, the program is ill-formed.</del></p>

                    <p><del style="background-color: #FFA0A0;">-7- <em>Returns</em>: A reference to <code>p.second</code>.</del></p>

                    <div>
                        <div id="highlighter_166040" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number2 index1 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></ins></div>
                                                <div class="line number3 index2 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number4 index3 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></ins></div>
                                                <div class="line number5 index4 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number6 index5 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></ins></div>
                                                <div class="line number7 index6 alt2"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T1, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T2&gt;</code></ins></div>
                                                <div class="line number8 index7 alt1"><ins style="background-color: #A0FFA0;"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">pair&lt;T1, T2&gt;&amp;&amp; p) </code><code class="cpp keyword bold">noexcept</code></ins></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Returns</em>: If <code>is_same_v&lt;T, T1&gt;</code> is <code>true</code> returns a reference to <code>p.first</code>; if <code>is_same_v&lt;T, T2&gt;</code> is <code>true</code> returns a reference to <code>p.second</code>.</ins></p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: This function is defined as deleted unless <code>T1</code> and <code>T2</code> are distinct types, and <code>T</code> is either <code>T1</code> or <code>T2</code>.</ins></p>
                </blockquote>

                <p>Change 23.5.2 [tuple.syn], Header <code>&lt;tuple&gt;</code> synopsis, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_502108" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp comments">// 23.5.3.7, element access</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp; get(tuple&lt;Types...&gt;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number9 index8 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number10 index9 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number11 index10 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(tuple&lt;Types...&gt;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number12 index11 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number13 index12 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number14 index13 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number15 index14 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number16 index15 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number17 index16 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>
                </blockquote>

                <p>Change 23.5.3.7 [tuple.elem], Element access, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_604098" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get(tuple&lt;Types...&gt;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;&amp;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get(tuple&lt;Types...&gt;&amp;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">; </code><code class="cpp comments">// Note A</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;</code></div>
                                                <div class="line number9 index8 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">; </code><code class="cpp comments">// Note B</code></div>
                                                <div class="line number10 index9 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number11 index10 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-1- <em>Requires</em>: <code>I &lt; sizeof...(Types)</code>. The program is ill-formed if <code>I</code> is out of bounds.</del></p>

                    <p>-2- <em>Returns</em>: A reference to the <code>I</code>th element of <code>t</code>, where indexing is zero-based.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: If <code>I &lt; sizeof...(Types)</code> the type <code>V</code> is <code>tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;</code>. Otherwise this function is defined as deleted, and <code>V</code> is an unspecified referenceable type.</ins></p>

                    <p>-3- <em>[Note A:</em> If a <code>T</code> in <code>Types</code> is some reference type <code>X&amp;</code>, the return type is <code>X&amp;</code>, not <code>X&amp;&amp;</code>. However, if the element type is a non-reference type <code>T</code>, the return type is <code>T&amp;&amp;</code>. <em>-end note]</em></p>

                    <p>-4- <em>[Note B:</em> Constness is shallow. If a <code>T</code> in <code>Types</code> is some reference type <code>X&amp;</code>, the return type is <code>X&amp;</code>, not <code>const X&amp;</code>. However, if the element type is a non-reference type <code>T</code>, the return type is const <code>T&amp;</code>. This is consistent with how constness is defined to work for member variables of reference type. <em>-end note]</em></p>

                    <div>
                        <div id="highlighter_857450" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(tuple&lt;Types...&gt;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;Types...&gt;&amp;&amp; t) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-5- <em>Requires</em>: The type <code>T</code> occurs exactly once in <code>Types...</code>. Otherwise, the program is ill-formed.</del></p>

                    <p>-6- <em>Returns</em>: A reference to the element of <code>t</code> corresponding to the type <code>T</code> in <code>Types...</code>.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: This function is defined as deleted unless the type <code>T</code> occurs exactly once in <code>Types...</code>.</ins></p>

                    <p>-7- <em>[Example:</em></p>

                    <div>
                        <div id="highlighter_387959" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">const</code> <code class="cpp plain">tuple&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">, </code><code class="cpp keyword bold">const</code> <code class="cpp color1 bold">int</code><code class="cpp plain">, </code><code class="cpp color1 bold">double</code><code class="cpp plain">, </code><code class="cpp color1 bold">double</code><code class="cpp plain">&gt; t(1, 2, 3.4, 5.6);</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">const</code> <code class="cpp color1 bold">int</code><code class="cpp plain">&amp; i1 = get&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt;(t); </code><code class="cpp comments">// OK. Not ambiguous. i1 == 1</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">const</code> <code class="cpp color1 bold">int</code><code class="cpp plain">&amp; i2 = get&lt;</code><code class="cpp keyword bold">const</code> <code class="cpp color1 bold">int</code><code class="cpp plain">&gt;(t); </code><code class="cpp comments">// OK. Not ambiguous. i2 == 2</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">const</code> <code class="cpp color1 bold">double</code><code class="cpp plain">&amp; d = get&lt;</code><code class="cpp color1 bold">double</code><code class="cpp plain">&gt;(t); </code><code class="cpp comments">// ERROR. <del style="background-color: #FFA0A0;">ill-formed</del><ins style="background-color: #A0FFA0;">deleted</ins></code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><em>-end example]</em></p>

                    <p>-8- <em>[Note:</em> The reason <code>get</code> is a non-member function is that if this functionality had been provided as a member function, code where the type depended on a template parameter would have required using the <code>template</code> keyword. <em>-end note]</em></p>
                </blockquote>

                <p>Change 26.3.7.6 [utility.syn], Tuple interface to class template <code>array</code>, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_776887" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">N&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">struct</code> <code class="cpp plain">tuple_size&lt;array&lt;T, N&gt;&gt; : integral_constant&lt;</code><code class="cpp color1 bold">size_t</code><code class="cpp plain">, N&gt; { };</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code>&nbsp;</div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp plain">tuple_element&lt;I, array&lt;T, N&gt;&gt;::type</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p>-1- <em>Requires</em>: <code>I &lt; N</code>. The program is ill-formed if <code>I</code> is out of bounds.</p>

                    <p>-2- <em>Value</em>: The type <code>T</code>.</p>

                    <div>
                        <div id="highlighter_174321" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">N&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(array&lt;T, N&gt;&amp; a) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">N&gt;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(array&lt;T, N&gt;&amp;&amp; a) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">N&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">array&lt;T, N&gt;&amp; a) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">N&gt;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">array&lt;T, N&gt;&amp;&amp; a) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-3- <em>Requires</em>: <code>I &lt; N</code>. The program is ill-formed if <code>I</code> is out of bounds.</del></p>

                    <p>-4- <em>Returns</em>: A reference to the <code>I</code>th element of <code>a</code>, where indexing is zero-based.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: This function is defined as deleted unless <code>I &lt; N</code>.</ins></p>
                </blockquote>

                <p>Change 23.7.2 [variant.syn], Header <code>&lt;variant&gt;</code> synopsis, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_591821" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp comments">// 23.7.5, value access</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp color1 bold">bool</code> <code class="cpp plain">holds_alternative(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code>&nbsp;</div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp; get(variant&lt;Types...&gt;&amp;);</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp;&amp; get(variant&lt;Types...&gt;&amp;&amp;);</code></div>
                                                <div class="line number9 index8 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number10 index9 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;);</code></div>
                                                <div class="line number11 index10 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number12 index11 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;&amp;);</code></div>
                                                <div class="line number13 index12 alt2"><code class="cpp spaces"></code>&nbsp;</div>
                                                <div class="line number14 index13 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number15 index14 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(variant&lt;Types...&gt;&amp;);</code></div>
                                                <div class="line number16 index15 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number17 index16 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(variant&lt;Types...&gt;&amp;&amp;);</code></div>
                                                <div class="line number18 index17 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number19 index18 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;);</code></div>
                                                <div class="line number20 index19 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number21 index20 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;&amp;);</code></div>
                                                <div class="line number22 index21 alt1"><code class="cpp spaces"></code>&nbsp;</div>
                                                <div class="line number23 index22 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number24 index23 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;<del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&gt;</code></div>
                                                <div class="line number25 index24 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(variant&lt;Types...&gt;*) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number26 index25 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number27 index26 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;</code><code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;"><em>see below</em></ins>&gt;</code></div>
                                                <div class="line number28 index27 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;*) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number29 index28 alt2"><code class="cpp spaces"></code>&nbsp;</div>
                                                <div class="line number30 index29 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number31 index30 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;T&gt;</code></div>
                                                <div class="line number32 index31 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(variant&lt;Types...&gt;*) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number33 index32 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number34 index33 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;</code><code class="cpp keyword bold">const</code> <code class="cpp plain">T&gt;</code></div>
                                                <div class="line number35 index34 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;*) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>
                </blockquote>

                <p>Change 23.7.5 [variant.get], Value access, as indicated:</p>

                <blockquote>
                    <div>
                        <div id="highlighter_302588" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp color1 bold">bool</code> <code class="cpp plain">holds_alternative(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp; v) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p>-1- <em>Requires</em>: The type <code>T</code> occurs exactly once in <code>Types...</code>. Otherwise, the program is ill-formed.</p>

                    <p>-2- <em>Returns</em>: <code>true</code> if <code>index()</code> is equal to the zero-based index of <code>T</code> in <code>Types...</code>.</p>

                    <div>
                        <div id="highlighter_831168" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp; get(variant&lt;Types...&gt;&amp; v);</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;&amp; get(variant&lt;Types...&gt;&amp;&amp; v);</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp; v);</code></div>
                                                <div class="line number7 index6 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number8 index7 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;&amp; v);</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-3- <em>Requires</em>: <code>I &lt; sizeof...(Types)</code>. Otherwise the program is ill-formed.</del></p>

                    <p>-4- <em>Effects</em>: If <code>v.index()</code> is <code>I</code>, returns a reference to the object stored in the <code>variant</code>. Otherwise, throws an exception of type <code>bad_variant_access</code>.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: If <code>I &lt; sizeof...(Types)</code> the type <code>V</code> is <code>variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</code>. Otherwise this function is defined as deleted, and <code>V</code> is an unspecified referenceable type.</ins></p>

                    <div>
                        <div id="highlighter_692187" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt; </code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp; get(variant&lt;Types...&gt;&amp; v);</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt; </code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">T&amp;&amp; get(variant&lt;Types...&gt;&amp;&amp; v);</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt; </code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp; v);</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt; </code><code class="cpp keyword bold">constexpr</code> <code class="cpp keyword bold">const</code> <code class="cpp plain">T&amp;&amp; get(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;&amp;&amp; v);</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-5- <em>Requires</em>: The type <code>T</code> occurs exactly once in <code>Types...</code>. Otherwise, the program is ill-formed.</del></p>

                    <p>-6- <em>Effects</em>: If v holds a value of type T, returns a reference to that value. Otherwise, throws an exception of type <code>bad_variant_access</code>.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: This function is defined as deleted unless the type <code>T</code> occurs exactly once in <code>Types...</code>.</ins></p>

                    <div>
                        <div id="highlighter_717254" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;<del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&gt;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(variant&lt;Types...&gt;* v) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;</code><code class="cpp keyword bold">const</code> <code class="cpp plain"><del style="background-color: #FFA0A0;">variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</del><ins style="background-color: #A0FFA0;">V</ins>&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;* v) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-7- <em>Requires</em>: <code>I &lt; sizeof...(Types)</code>. Otherwise the program is ill-formed.</del></p>

                    <p>-8- <em>Returns</em>: A pointer to the value stored in the variant, if <code>v != nullptr</code> and <code>v-&gt;index() == I</code>. Otherwise, returns <code>nullptr</code>.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: If <code>I &lt; sizeof...(Types)</code> the type <code>V</code> is <code>variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;</code>. Otherwise this function is defined as deleted, and <code>V</code> is an unspecified referenceable type.</ins></p>

                    <div>
                        <div id="highlighter_63183" class="syntaxhighlighter nogutter  cpp">
                            <table border="0" cellspacing="0" cellpadding="0">
                                <tbody>
                                    <tr>
                                        <td class="code">
                                            <div class="container">
                                                <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;T&gt;</code></div>
                                                <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(variant&lt;Types...&gt;* v) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                                <div class="line number4 index3 alt1"><code class="cpp spaces"></code><code class="cpp keyword bold">template</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">class</code> <code class="cpp plain">T, </code><code class="cpp keyword bold">class</code><code class="cpp plain">... Types&gt;</code></div>
                                                <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">constexpr</code> <code class="cpp plain">add_pointer_t&lt;</code><code class="cpp keyword bold">const</code> <code class="cpp plain">T&gt;</code></div>
                                                <div class="line number6 index5 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp plain">get_if(</code><code class="cpp keyword bold">const</code> <code class="cpp plain">variant&lt;Types...&gt;* v) </code><code class="cpp keyword bold">noexcept</code><code class="cpp plain">;</code></div>
                                            </div>
                                        </td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <p><del style="background-color: #FFA0A0;">-9- <em>Requires</em>: The type <code>T</code> occurs exactly once in <code>Types...</code>. Otherwise, the program is ill-formed.</del></p>

                    <p>-10- <em>Effects</em>: Equivalent to: <code>return get_if&lt;i&gt;(v)</code>; with <em>i</em> being the zero-based index of <code>T</code> in <code>Types...</code>.</p>

                    <p><ins style="background-color: #A0FFA0;">-?- <em>Remarks</em>: This function is defined as deleted unless the type <code>T</code> occurs exactly once in <code>Types...</code>.</ins></p>
                </blockquote>

                <a name="5.-references" href="#5.-references"><h2>5. References</h2></a>

                <ul>
                    <li>
                        <p>
                            <strong>[N4687]</strong> ISO/IEC JTC1 SC22 WG21, Programming Languages - C++, working draft, July 2017<br>
                            <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4687.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4687.pdf</a>
                        </p>
                    </li>
                    <li>
                        <p>
                            <strong>[LWG2974]</strong> Diagnose out of bounds <code>tuple_element</code>/<code>variant_alternative</code> - Agustín Bergé<br>
                            <a href="http://cplusplus.github.io/LWG/lwg-defects.html#2974">http://cplusplus.github.io/LWG/lwg-defects.html#2974</a>
                        </p>
                    </li>
                </ul>

                <a name="a.-alternative-designs" href="#a.-alternative-designs"><h2>A. Alternative Designs</h2></a>

                <a name="a.1-sfinae-friendly" href="#a.1-sfinae-friendly"><h3>A.1 SFINAE-friendly</h3></a>

                <p>A traditional SFINAE-friendly implementation will get out of the user's way when used with an out-of-bounds index. The main disadvantage of this approach is that by not participating in overload resolution, it opens the door for user defined overloads even when called on a standard library tuple-like type; that is, given <code>t</code> of type <code>std::tuple&lt;UDT&gt;</code>, <code>get&lt;1&gt;(t)</code> might silently fall back to a <code>get</code> overload in an associated namespace of <code>UDT</code>. This regresses key functionality in the current <code>std::get</code> design, which mandates a diagnostic for out-of-bounds calls.</p>

                <div>
                    <div id="highlighter_551014" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">typename</code> <code class="cpp plain">...Ts,</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">typename</code> <code class="cpp plain">Enable = </code><code class="cpp color1 bold">std::enable_if_t</code><code class="cpp plain">&lt;I &lt; </code><code class="cpp keyword bold">sizeof</code><code class="cpp plain">...(Ts)&gt;&gt;</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp color1 bold">std::tuple_element_t</code><code class="cpp plain">&lt;I, </code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&gt;&amp;</code></div>
                                            <div class="line number4 index3 alt1"><code class="cpp plain">get(</code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&amp; t) {</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">return</code> <code class="cpp comments">/*...*/</code><code class="cpp plain">;</code></div>
                                            <div class="line number6 index5 alt1"><code class="cpp plain">}</code></div>
                                            <div class="line number7 index6 alt2">&nbsp;</div>
                                            <div class="line number8 index7 alt1"><code class="cpp comments">// Out-of-bounds calls:</code></div>
                                            <div class="line number9 index8 alt2"><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt; t;</code></div>
                                            <div class="line number10 index9 alt1"><code class="cpp color1 bold">std::get</code><code class="cpp plain">&lt;1&gt;(t); </code><code class="cpp comments">// error: no matching function for call to 'get&lt;1&gt;(std::tuple&lt;int&gt;&amp;)'</code></div>
                                            <div class="line number11 index10 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// note: candidate template ignored:</code></div>
                                            <div class="line number12 index11 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(array&lt;Ts...&gt;&amp;)</code></div>
                                            <div class="line number13 index12 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; could not match 'array' against 'tuple'</code></div>
                                            <div class="line number14 index13 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// note: candidate template ignored:</code></div>
                                            <div class="line number15 index14 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(pair&lt;Ts...&gt;&amp;)</code></div>
                                            <div class="line number16 index15 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; could not match 'pair' against 'tuple'</code></div>
                                            <div class="line number17 index16 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// note: candidate template ignored:</code></div>
                                            <div class="line number18 index17 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(variant&lt;Ts...&gt;&amp;)</code></div>
                                            <div class="line number19 index18 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; could not match 'variant' against 'tuple'</code></div>
                                            <div class="line number20 index19 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// note: candidate template ignored:</code></div>
                                            <div class="line number21 index20 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(std::tuple&lt;Ts...&gt;&amp;)</code></div>
                                            <div class="line number22 index21 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; [with I = 1; Ts = {int}]</code></div>
                                            <div class="line number23 index22 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; requirement 'I &lt; sizeof...(Ts)' was not satisfied</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p>Making <code>std::tuple_element</code> SFINAE-friendly would have the same effect, while leaving existing <code>std::get</code> by-index overloads unchanged.</p>

                <a name="a-note-on-concepts" href="#a-note-on-concepts"><h4>A note on Concepts</h4></a>

                <p>A traditional Concept-based implementation is essentially equivalent to a traditional SFINAE-friendly implementation, and so it shares the same disadvantages. That includes the diagnostics generated for an out-of-bounds calls (for currently available implementations).</p>

                <div>
                    <div id="highlighter_30121" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">typename</code> <code class="cpp plain">...Ts&gt;</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">requires</code> <code class="cpp plain">I &lt; </code><code class="cpp keyword bold">sizeof</code><code class="cpp plain">...(Ts)</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp color1 bold">std::tuple_element_t</code><code class="cpp plain">&lt;I, </code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&gt;&amp;</code></div>
                                            <div class="line number4 index3 alt1"><code class="cpp plain">get(</code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&amp; t) {</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">return</code> <code class="cpp comments">/*...*/</code><code class="cpp plain">;</code></div>
                                            <div class="line number6 index5 alt1"><code class="cpp plain">}</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <p><em>[Note:</em> The current specification unintentionally requires <code>std::tuple_element_t&lt;I, std::tuple&lt;Ts...&gt;&gt;</code> be instantiated <strong>before</strong> checking that the associated constraints are satisfied, resulting in an ill-formed program for out-of-bounds calls. The results presented here circumvent this issue, under the assumption that it will be rectified. <a href="http://lists.isocpp.org/core/2017/10/3016.php">CWG-issue-pending-publication</a>. <em>]</em></p>

                <a name="a.2-conditionally-deleted" href="#a.2-conditionally-deleted"><h3>A.2 Conditionally Deleted</h3></a>

                <p>A conditionally deleted implementation prevents the unintended fall back behavior of the traditional SFINAE-friendly approach, while still remaining SFINAE-friendly. As a bonus, diagnostics on out-of-bounds calls tend to be concise.</p>

                <div>
                    <div id="highlighter_101291" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">typename</code> <code class="cpp plain">...Ts,</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">typename</code> <code class="cpp plain">Enable = </code><code class="cpp color1 bold">std::enable_if_t</code><code class="cpp plain">&lt;I &lt; </code><code class="cpp keyword bold">sizeof</code><code class="cpp plain">...(Ts)&gt;&gt;</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp color1 bold">std::tuple_element_t</code><code class="cpp plain">&lt;I, </code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&gt;&amp;</code></div>
                                            <div class="line number4 index3 alt1"><code class="cpp plain">get(</code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&amp; t) {</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">return</code> <code class="cpp comments">/*...*/</code><code class="cpp plain">;</code></div>
                                            <div class="line number6 index5 alt1"><code class="cpp plain">}</code></div>
                                            <div class="line number7 index6 alt2">&nbsp;</div>
                                            <div class="line number8 index7 alt1"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">typename</code> <code class="cpp plain">...Ts&gt;</code></div>
                                            <div class="line number9 index8 alt2"><code class="cpp color1 bold">std::enable_if_t</code><code class="cpp plain">&lt;</code><code class="cpp keyword bold">sizeof</code><code class="cpp plain">...(Ts) &lt;= I&gt;</code></div>
                                            <div class="line number10 index9 alt1"><code class="cpp plain">get(</code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&amp; t) = </code><code class="cpp keyword bold">delete</code><code class="cpp plain">;</code></div>
                                            <div class="line number11 index10 alt2">&nbsp;</div>
                                            <div class="line number12 index11 alt1"><code class="cpp comments">// Out-of-bounds calls:</code></div>
                                            <div class="line number13 index12 alt2"><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt; t;</code></div>
                                            <div class="line number14 index13 alt1"><code class="cpp color1 bold">std::get</code><code class="cpp plain">&lt;1&gt;(t); </code><code class="cpp comments">// error: call to deleted function 'get'</code></div>
                                            <div class="line number15 index14 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// note: declared here</code></div>
                                            <div class="line number16 index15 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(std::tuple&lt;Ts...&gt;&amp;) = delete;</code></div>
                                            <div class="line number17 index16 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; [with I = 1; Ts = {int}]</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>

                <a name="a.3-deduced-return-type" href="#a.3-deduced-return-type"><h3>A.3 Deduced Return Type</h3></a>

                <p>An implementation that uses deduced return types can defer the required diagnostic until the definition is instantiated. The main disadvantage is that such definition may need to be instantiated earlier/more often than an explicitly typed alternative, and that the result is SFINAE-unfriendly in those contexts. On the other side, diagnostics on out-of-bounds calls tend to be concise and could include a custom tailored message.</p>

                <div>
                    <div id="highlighter_940668" class="syntaxhighlighter nogutter  cpp">
                        <table border="0" cellspacing="0" cellpadding="0">
                            <tbody>
                                <tr>
                                    <td class="code">
                                        <div class="container">
                                            <div class="line number1 index0 alt2"><code class="cpp keyword bold">template</code> <code class="cpp plain">&lt;</code><code class="cpp color1 bold">std::size_t</code> <code class="cpp plain">I, </code><code class="cpp keyword bold">typename</code> <code class="cpp plain">...Ts&gt;</code></div>
                                            <div class="line number2 index1 alt1"><code class="cpp keyword bold">decltype</code><code class="cpp plain">(</code><code class="cpp keyword bold">auto</code><code class="cpp plain">) get(</code><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;Ts...&gt;&amp; t) {</code></div>
                                            <div class="line number3 index2 alt2"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">static_assert</code><code class="cpp plain">(I &lt; </code><code class="cpp keyword bold">sizeof</code><code class="cpp plain">...(Ts), </code><code class="cpp string">"tuple index is in range"</code><code class="cpp plain">);</code></div>
                                            <div class="line number4 index3 alt1"><code class="cpp spaces">&nbsp;&nbsp;</code><code class="cpp keyword bold">return</code> <code class="cpp comments">/*...*/</code><code class="cpp plain">;</code></div>
                                            <div class="line number5 index4 alt2"><code class="cpp plain">}</code></div>
                                            <div class="line number6 index5 alt1">&nbsp;</div>
                                            <div class="line number7 index6 alt2"><code class="cpp comments">// Out-of-bounds calls:</code></div>
                                            <div class="line number8 index7 alt1"><code class="cpp color1 bold">std::tuple</code><code class="cpp plain">&lt;</code><code class="cpp color1 bold">int</code><code class="cpp plain">&gt; t;</code></div>
                                            <div class="line number9 index8 alt2"><code class="cpp color1 bold">std::get</code><code class="cpp plain">&lt;1&gt;(t); </code><code class="cpp comments">// error: static assertion failed: tuple index is in range</code></div>
                                            <div class="line number10 index9 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">// in instantiation of</code></div>
                                            <div class="line number11 index10 alt2"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; std::get(std::tuple&lt;Ts...&gt;&amp;)</code></div>
                                            <div class="line number12 index11 alt1"><code class="cpp spaces">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><code class="cpp comments">//&nbsp;&nbsp; [with I = 1; Ts = {int}]</code></div>
                                        </div>
                                    </td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>
            </article>
        </section>
</body>
</html>