<!DOCTYPE html>

<html lang="en">

<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <meta name="mobile-web-app-capable" content="yes">
    <title>
        Beyond operator(): NTTP callables in type-erased call wrappers - HackMD
    </title>
    <link rel="icon" type="image/png" href="https://hackmd.io/favicon.png">
    <link rel="apple-touch-icon" href="https://hackmd.io/apple-touch-icon.png">

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha256-916EbMg70RQy9LHiGkXzG8hSg9EdNy97GazNG/aiY1w=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" integrity="sha256-eZrrJcwDc/3uDhsdt61sL2oOBY362qM3lon1gyExkL0=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/ionicons/2.0.1/css/ionicons.min.css" integrity="sha256-3iu9jgsy9TpTwXKb7bNQzqWekRX7pPK+2OLj3R922fo=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/octicons/3.5.0/octicons.min.css" integrity="sha256-QiWfLIsCT02Sdwkogf6YMiQlj4NE84MKkzEMkZnMGdg=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.5.1/themes/prism.min.css" integrity="sha256-vtR0hSWRc3Tb26iuN2oZHt3KRUomwTufNIf5/4oeCyg=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/css/basic/emojify.min.css" integrity="sha256-UOrvMOsSDSrW6szVLe8ZDZezBxh5IoIfgTwdNDgTjiU=" crossorigin="anonymous" />
    <style>
        @import url(https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,500,500i|Source+Code+Pro:300,400,500|Source+Sans+Pro:300,300i,400,400i,600,600i|Source+Serif+Pro&subset=latin-ext);.hljs{display:block;background:#fff;padding:.5em;color:#333;overflow-x:auto}.hljs-comment,.hljs-meta{color:#969896}.hljs-emphasis,.hljs-quote,.hljs-string,.hljs-strong,.hljs-template-variable,.hljs-variable{color:#df5000}.hljs-keyword,.hljs-selector-tag,.hljs-type{color:#a71d5d}.hljs-attribute,.hljs-bullet,.hljs-literal,.hljs-number,.hljs-symbol{color:#0086b3}.hljs-built_in,.hljs-builtin-name{color:#005cc5}.hljs-name,.hljs-section{color:#63a35c}.hljs-tag{color:#333}.hljs-attr,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-selector-pseudo,.hljs-title{color:#795da3}.hljs-addition{color:#55a532;background-color:#eaffea}.hljs-deletion{color:#bd2c00;background-color:#ffecec}.hljs-link{text-decoration:underline}.markdown-body{font-size:16px;line-height:1.5;word-wrap:break-word}.markdown-body:after,.markdown-body:before{display:table;content:""}.markdown-body:after{clear:both}.markdown-body>:first-child{margin-top:0!important}.markdown-body>:last-child{margin-bottom:0!important}.markdown-body a:not([href]){color:inherit;text-decoration:none}.markdown-body .absent{color:#c00}.markdown-body .anchor{float:left;padding-right:4px;margin-left:-20px;line-height:1}.markdown-body .anchor:focus{outline:none}.markdown-body blockquote,.markdown-body dl,.markdown-body ol,.markdown-body p,.markdown-body pre,.markdown-body table,.markdown-body ul{margin-top:0;margin-bottom:16px}.markdown-body hr{height:.25em;padding:0;margin:24px 0;background-color:#e7e7e7;border:0}.markdown-body blockquote{font-size:16px;padding:0 1em;color:#777;border-left:.25em solid #ddd}.markdown-body blockquote>:first-child{margin-top:0}.markdown-body blockquote>:last-child{margin-bottom:0}.markdown-body kbd,.popover kbd{display:inline-block;padding:3px 5px;font-size:11px;line-height:10px;color:#555;vertical-align:middle;background-color:#fcfcfc;border:1px solid #ccc;border-bottom-color:#bbb;border-radius:3px;box-shadow:inset 0 -1px 0 #bbb}.markdown-body .loweralpha{list-style-type:lower-alpha}.markdown-body h1,.markdown-body h2,.markdown-body h3,.markdown-body h4,.markdown-body h5,.markdown-body h6{margin-top:24px;margin-bottom:16px;font-weight:600;line-height:1.25}.markdown-body h1 .octicon-link,.markdown-body h2 .octicon-link,.markdown-body h3 .octicon-link,.markdown-body h4 .octicon-link,.markdown-body h5 .octicon-link,.markdown-body h6 .octicon-link{color:#000;vertical-align:middle;visibility:hidden}.markdown-body h1:hover .anchor,.markdown-body h2:hover .anchor,.markdown-body h3:hover .anchor,.markdown-body h4:hover .anchor,.markdown-body h5:hover .anchor,.markdown-body h6:hover .anchor{text-decoration:none}.markdown-body h1:hover .anchor .octicon-link,.markdown-body h2:hover .anchor .octicon-link,.markdown-body h3:hover .anchor .octicon-link,.markdown-body h4:hover .anchor .octicon-link,.markdown-body h5:hover .anchor .octicon-link,.markdown-body h6:hover .anchor .octicon-link{visibility:visible}.markdown-body h1 code,.markdown-body h1 tt,.markdown-body h2 code,.markdown-body h2 tt,.markdown-body h3 code,.markdown-body h3 tt,.markdown-body h4 code,.markdown-body h4 tt,.markdown-body h5 code,.markdown-body h5 tt,.markdown-body h6 code,.markdown-body h6 tt{font-size:inherit}.markdown-body h1{font-size:2em}.markdown-body h1,.markdown-body h2{padding-bottom:.3em;border-bottom:1px solid #eee}.markdown-body h2{font-size:1.5em}.markdown-body h3{font-size:1.25em}.markdown-body h4{font-size:1em}.markdown-body h5{font-size:.875em}.markdown-body h6{font-size:.85em;color:#777}.markdown-body ol,.markdown-body ul{padding-left:2em}.markdown-body ol.no-list,.markdown-body ul.no-list{padding:0;list-style-type:none}.markdown-body ol ol,.markdown-body ol ul,.markdown-body ul ol,.markdown-body ul ul{margin-top:0;margin-bottom:0}.markdown-body li>p{margin-top:16px}.markdown-body li+li{padding-top:.25em}.markdown-body dl{padding:0}.markdown-body dl dt{padding:0;margin-top:16px;font-size:1em;font-style:italic;font-weight:700}.markdown-body dl dd{padding:0 16px;margin-bottom:16px}.markdown-body table{display:block;width:100%;overflow:auto;word-break:normal;word-break:keep-all}.markdown-body table th{font-weight:700}.markdown-body table td,.markdown-body table th{padding:6px 13px;border:1px solid #ddd}.markdown-body table tr{background-color:#fff;border-top:1px solid #ccc}.markdown-body table tr:nth-child(2n){background-color:#f8f8f8}.markdown-body img{max-width:100%;box-sizing:content-box;background-color:#fff}.markdown-body img[align=right]{padding-left:20px}.markdown-body img[align=left]{padding-right:20px}.markdown-body .emoji{max-width:none;vertical-align:text-top;background-color:transparent}.markdown-body span.frame{display:block;overflow:hidden}.markdown-body span.frame>span{display:block;float:left;width:auto;padding:7px;margin:13px 0 0;overflow:hidden;border:1px solid #ddd}.markdown-body span.frame span img{display:block;float:left}.markdown-body span.frame span span{display:block;padding:5px 0 0;clear:both;color:#333}.markdown-body span.align-center{display:block;overflow:hidden;clear:both}.markdown-body span.align-center>span{display:block;margin:13px auto 0;overflow:hidden;text-align:center}.markdown-body span.align-center span img{margin:0 auto;text-align:center}.markdown-body span.align-right{display:block;overflow:hidden;clear:both}.markdown-body span.align-right>span{display:block;margin:13px 0 0;overflow:hidden;text-align:right}.markdown-body span.align-right span img{margin:0;text-align:right}.markdown-body span.float-left{display:block;float:left;margin-right:13px;overflow:hidden}.markdown-body span.float-left span{margin:13px 0 0}.markdown-body span.float-right{display:block;float:right;margin-left:13px;overflow:hidden}.markdown-body span.float-right>span{display:block;margin:13px auto 0;overflow:hidden;text-align:right}.markdown-body code,.markdown-body tt{padding:0;padding-top:.2em;padding-bottom:.2em;margin:0;font-size:85%;background-color:rgba(0,0,0,.04);border-radius:3px}.markdown-body code:after,.markdown-body code:before,.markdown-body tt:after,.markdown-body tt:before{letter-spacing:-.2em;content:"\00a0"}.markdown-body code br,.markdown-body tt br{display:none}.markdown-body del code{text-decoration:inherit}.markdown-body pre{word-wrap:normal}.markdown-body pre>code{padding:0;margin:0;font-size:100%;word-break:normal;white-space:pre;background:transparent;border:0}.markdown-body .highlight{margin-bottom:16px}.markdown-body .highlight pre{margin-bottom:0;word-break:normal}.markdown-body .highlight pre,.markdown-body pre{padding:16px;overflow:auto;font-size:85%;line-height:1.45;background-color:#f7f7f7;border-radius:3px}.markdown-body pre code,.markdown-body pre tt{display:inline;max-width:auto;padding:0;margin:0;overflow:visible;line-height:inherit;word-wrap:normal;background-color:transparent;border:0}.markdown-body pre code:after,.markdown-body pre code:before,.markdown-body pre tt:after,.markdown-body pre tt:before{content:normal}.markdown-body .csv-data td,.markdown-body .csv-data th{padding:5px;overflow:hidden;font-size:12px;line-height:1;text-align:left;white-space:nowrap}.markdown-body .csv-data .blob-line-num{padding:10px 8px 9px;text-align:right;background:#fff;border:0}.markdown-body .csv-data tr{border-top:0}.markdown-body .csv-data th{font-weight:700;background:#f8f8f8;border-top:0}.news .alert .markdown-body blockquote{padding:0 0 0 40px;border:0 none}.activity-tab .news .alert .commits,.activity-tab .news .markdown-body blockquote{padding-left:0}.task-list-item{list-style-type:none}.task-list-item label{font-weight:400}.task-list-item.enabled label{cursor:pointer}.task-list-item+.task-list-item{margin-top:3px}.task-list-item-checkbox{float:left;margin:.31em 0 .2em -1.3em!important;vertical-align:middle;cursor:default!important}.markdown-body{padding-top:40px;padding-bottom:40px;max-width:758px;overflow:visible!important;position:relative}.markdown-body .emoji{vertical-align:top}.markdown-body pre{border:inherit!important}.markdown-body code{color:inherit!important}.markdown-body pre code .wrapper{display:-moz-inline-flex;display:-ms-inline-flex;display:-o-inline-flex;display:inline-flex}.markdown-body pre code .gutter{float:left;overflow:hidden;-webkit-user-select:none;user-select:none}.markdown-body pre code .gutter.linenumber{text-align:right;position:relative;display:inline-block;cursor:default;z-index:4;padding:0 8px 0 0;min-width:20px;box-sizing:content-box;color:#afafaf!important;border-right:3px solid #6ce26c!important}.markdown-body pre code .gutter.linenumber>span:before{content:attr(data-linenumber)}.markdown-body pre code .code{float:left;margin:0 0 0 16px}.markdown-body .gist .line-numbers{border-left:none;border-top:none;border-bottom:none}.markdown-body .gist .line-data{border:none}.markdown-body .gist table{border-spacing:0;border-collapse:inherit!important}.markdown-body code[data-gist-id]{background:none;padding:0}.markdown-body code[data-gist-id]:after,.markdown-body code[data-gist-id]:before{content:""}.markdown-body code[data-gist-id] .blob-num{border:unset}.markdown-body code[data-gist-id] table{overflow:unset;margin-bottom:unset}.markdown-body code[data-gist-id] table tr{background:unset}.markdown-body[dir=rtl] pre{direction:ltr}.markdown-body[dir=rtl] code{direction:ltr;unicode-bidi:embed}.markdown-body .alert>p:last-child{margin-bottom:0}.markdown-body pre.abc,.markdown-body pre.flow-chart,.markdown-body pre.graphviz,.markdown-body pre.mermaid,.markdown-body pre.sequence-diagram,.markdown-body pre.vega{text-align:center;background-color:inherit;border-radius:0;white-space:inherit;overflow:visible}.markdown-body pre.abc>code,.markdown-body pre.flow-chart>code,.markdown-body pre.graphviz>code,.markdown-body pre.mermaid>code,.markdown-body pre.sequence-diagram>code,.markdown-body pre.vega>code{text-align:left}.markdown-body pre.abc>svg,.markdown-body pre.flow-chart>svg,.markdown-body pre.graphviz>svg,.markdown-body pre.mermaid>svg,.markdown-body pre.sequence-diagram>svg,.markdown-body pre.vega>svg{max-width:100%;height:100%}.markdown-body pre>code.wrap{white-space:pre-wrap;white-space:-moz-pre-wrap;white-space:-pre-wrap;white-space:-o-pre-wrap;word-wrap:break-word}.markdown-body .alert>p:last-child,.markdown-body .alert>ul:last-child{margin-bottom:0}.markdown-body summary{display:list-item}.markdown-body summary:focus{outline:none}.markdown-body details summary{cursor:pointer}.markdown-body details:not([open])>:not(summary){display:none}.markdown-body figure{margin:1em 40px}.markdown-body .mark,.markdown-body mark{background-color:#fff1a7}.vimeo,.youtube{cursor:pointer;display:table;text-align:center;background-position:50%;background-repeat:no-repeat;background-size:contain;background-color:#000;overflow:hidden}.vimeo,.youtube{position:relative;width:100%}.youtube{padding-bottom:56.25%}.vimeo img{width:100%;object-fit:contain;z-index:0}.youtube img{object-fit:cover;z-index:0}.vimeo iframe,.youtube iframe,.youtube img{width:100%;height:100%;position:absolute;top:0;left:0}.vimeo iframe,.youtube iframe{vertical-align:middle;z-index:1}.vimeo .icon,.youtube .icon{position:absolute;height:auto;width:auto;top:50%;left:50%;transform:translate(-50%,-50%);color:#fff;opacity:.3;transition:opacity .2s;z-index:0}.vimeo:hover .icon,.youtube:hover .icon{opacity:.6;transition:opacity .2s}.slideshare .inner,.speakerdeck .inner{position:relative;width:100%}.slideshare .inner iframe,.speakerdeck .inner iframe{position:absolute;top:0;bottom:0;left:0;right:0;width:100%;height:100%}.figma{display:table;position:relative;width:100%;padding-bottom:56.25%}.figma iframe{position:absolute;top:0;bottom:0;left:0;right:0;width:100%;height:100%;border:1px solid #eee}.markmap-container{height:300px}.markmap-container>svg{width:100%;height:100%}.MJX_Assistive_MathML{display:none}#MathJax_Message{z-index:1000!important}.ui-infobar{position:relative;z-index:2;max-width:760px;margin:25px auto -25px;color:#777}.toc .invisable-node{list-style-type:none}.ui-toc{position:fixed;bottom:20px;z-index:998}.ui-toc.both-mode{margin-left:8px}.ui-toc.both-mode .ui-toc-label{height:40px;padding:10px 4px;border-top-left-radius:0;border-bottom-left-radius:0}.ui-toc-label{background-color:#e6e6e6;border:none;color:#868686;transition:opacity .2s}.ui-toc .open .ui-toc-label{opacity:1;color:#fff;transition:opacity .2s}.ui-toc-label:focus{opacity:.3;background-color:#ccc;color:#000}.ui-toc-label:hover{opacity:1;background-color:#ccc;transition:opacity .2s}.ui-toc-dropdown{margin-top:20px;margin-bottom:20px;padding-left:10px;padding-right:10px;max-width:45vw;width:25vw;max-height:70vh;overflow:auto;text-align:inherit}.ui-toc-dropdown>.toc{max-height:calc(70vh - 100px);overflow:auto}.ui-toc-dropdown[dir=rtl] .nav{padding-right:0;letter-spacing:.0029em}.ui-toc-dropdown a{overflow:hidden;text-overflow:ellipsis;white-space:pre}.ui-toc-dropdown .nav>li>a{display:block;padding:4px 20px;font-size:13px;font-weight:500;color:#767676}.ui-toc-dropdown .nav>li:first-child:last-child>ul,.ui-toc-dropdown .toc.expand ul{display:block}.ui-toc-dropdown .nav>li>a:focus,.ui-toc-dropdown .nav>li>a:hover{padding-left:19px;color:#000;text-decoration:none;background-color:transparent;border-left:1px solid #000}.ui-toc-dropdown[dir=rtl] .nav>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav>li>a:hover{padding-right:19px;border-left:none;border-right:1px solid #000}.ui-toc-dropdown .nav>.active:focus>a,.ui-toc-dropdown .nav>.active:hover>a,.ui-toc-dropdown .nav>.active>a{padding-left:18px;font-weight:700;color:#000;background-color:transparent;border-left:2px solid #000}.ui-toc-dropdown[dir=rtl] .nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav>.active>a{padding-right:18px;border-left:none;border-right:2px solid #000}.ui-toc-dropdown .nav .nav{display:none;padding-bottom:10px}.ui-toc-dropdown .nav>.active>ul{display:block}.ui-toc-dropdown .nav .nav>li>a{padding-top:1px;padding-bottom:1px;padding-left:30px;font-size:12px;font-weight:400}.ui-toc-dropdown[dir=rtl] .nav .nav>li>a{padding-right:30px}.ui-toc-dropdown .nav .nav>li>ul>li>a{padding-top:1px;padding-bottom:1px;padding-left:40px;font-size:12px;font-weight:400}.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a{padding-right:40px}.ui-toc-dropdown .nav .nav>li>a:focus,.ui-toc-dropdown .nav .nav>li>a:hover{padding-left:29px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav .nav>li>a:hover{padding-right:29px}.ui-toc-dropdown .nav .nav>li>ul>li>a:focus,.ui-toc-dropdown .nav .nav>li>ul>li>a:hover{padding-left:39px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a:hover{padding-right:39px}.ui-toc-dropdown .nav .nav>.active:focus>a,.ui-toc-dropdown .nav .nav>.active:hover>a,.ui-toc-dropdown .nav .nav>.active>a{padding-left:28px;font-weight:500}.ui-toc-dropdown[dir=rtl] .nav .nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>a{padding-right:28px}.ui-toc-dropdown .nav .nav>.active>.nav>.active:focus>a,.ui-toc-dropdown .nav .nav>.active>.nav>.active:hover>a,.ui-toc-dropdown .nav .nav>.active>.nav>.active>a{padding-left:38px;font-weight:500}.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active>a{padding-right:38px}.markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,sans-serif}html[lang^=ja] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ\ ゴシック,sans-serif}html[lang=zh-tw] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}html .markdown-body[lang^=ja]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ\ ゴシック,sans-serif}html .markdown-body[lang=zh-tw]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html .markdown-body[lang=zh-cn]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}html[lang^=ja] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Meiryo UI,MS PGothic,ＭＳ\ Ｐゴシック,sans-serif}html[lang=zh-tw] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Microsoft JhengHei UI,微軟正黑UI,sans-serif}html[lang=zh-cn] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Microsoft YaHei UI,微软雅黑UI,sans-serif}html .ui-toc-dropdown[lang^=ja]{font-family:Source Sans Pro,Helvetica,Arial,Meiryo UI,MS PGothic,ＭＳ\ Ｐゴシック,sans-serif}html .ui-toc-dropdown[lang=zh-tw]{font-family:Source Sans Pro,Helvetica,Arial,Microsoft JhengHei UI,微軟正黑UI,sans-serif}html .ui-toc-dropdown[lang=zh-cn]{font-family:Source Sans Pro,Helvetica,Arial,Microsoft YaHei UI,微软雅黑UI,sans-serif}.ui-affix-toc{position:fixed;top:0;max-width:15vw;max-height:70vh;overflow:auto}.back-to-top,.expand-toggle,.go-to-bottom{display:block;padding:4px 10px;margin-top:10px;margin-left:10px;font-size:12px;font-weight:500;color:#999}.back-to-top:focus,.back-to-top:hover,.expand-toggle:focus,.expand-toggle:hover,.go-to-bottom:focus,.go-to-bottom:hover{color:#563d7c;text-decoration:none}.back-to-top,.go-to-bottom{margin-top:0}.ui-user-icon{width:20px;height:20px;display:block;border-radius:50%;margin-top:2px;margin-bottom:2px;margin-right:5px;background-position:50%;background-repeat:no-repeat;background-size:cover}.ui-user-icon.small{width:18px;height:18px;display:inline-block;vertical-align:middle;margin:0 0 .2em}.ui-infobar>small>span{line-height:22px}.ui-infobar>small .dropdown{display:inline-block}.ui-infobar>small .dropdown a:focus,.ui-infobar>small .dropdown a:hover{text-decoration:none}.ui-more-info{color:#888;cursor:pointer;vertical-align:middle}.ui-more-info .fa{font-size:16px}.ui-connectedGithub,.ui-published-note{color:#888}.ui-connectedGithub{line-height:23px;white-space:nowrap}.ui-connectedGithub a.file-path{color:#888;text-decoration:none;padding-left:22px}.ui-connectedGithub a.file-path:active,.ui-connectedGithub a.file-path:hover{color:#888;text-decoration:underline}.ui-connectedGithub .fa{font-size:20px}.ui-published-note .fa{font-size:20px;vertical-align:top}.unselectable{-webkit-user-select:none;-o-user-select:none;user-select:none}.selectable{-webkit-user-select:text;-o-user-select:text;user-select:text}.inline-spoiler-section{cursor:pointer}.inline-spoiler-section .spoiler-text{border-radius:2px;background-color:#333}.inline-spoiler-section .spoiler-text>*{opacity:0}.inline-spoiler-section .spoiler-img{filter:blur(10px)}.inline-spoiler-section.raw{border-radius:2px;background-color:#333}.inline-spoiler-section.raw>*{opacity:0}.inline-spoiler-section.unveil{cursor:auto}.inline-spoiler-section.unveil .spoiler-text{background-color:rgba(51,51,51,.1)}.inline-spoiler-section.unveil .spoiler-text>*{opacity:1}.inline-spoiler-section.unveil .spoiler-img{filter:none}@media print{blockquote,div,img,pre,table{page-break-inside:avoid!important}a[href]:after{font-size:12px!important}}.markdown-body.slides{position:relative;z-index:1;color:#222}.markdown-body.slides:before{content:"";display:block;position:absolute;top:0;left:0;right:0;bottom:0;z-index:-1;background-color:currentColor;box-shadow:0 0 0 50vw}.markdown-body.slides section[data-markdown]{position:relative;margin-bottom:1.5em;background-color:#fff;text-align:center}.markdown-body.slides section[data-markdown] code{text-align:left}.markdown-body.slides section[data-markdown]:before{content:"";display:block;padding-bottom:56.23%}.markdown-body.slides section[data-markdown]>div:first-child{position:absolute;top:50%;left:1em;right:1em;transform:translateY(-50%);max-height:100%;overflow:hidden}.markdown-body.slides section[data-markdown]>ul{display:inline-block}.markdown-body.slides>section>section+section:after{content:"";position:absolute;top:-1.5em;right:1em;height:1.5em;border:3px solid #777}.site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,sans-serif}html[lang^=ja] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ\ ゴシック,sans-serif}html[lang=zh-tw] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}body{font-smoothing:subpixel-antialiased!important;-webkit-font-smoothing:subpixel-antialiased!important;-moz-osx-font-smoothing:auto!important;-webkit-overflow-scrolling:touch;letter-spacing:.025em;font-family:Source Sans Pro,Helvetica,Arial,sans-serif}html[lang^=ja] body{font-family:Source Sans Pro,Helvetica,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ\ ゴシック,sans-serif}html[lang=zh-tw] body{font-family:Source Sans Pro,Helvetica,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] body{font-family:Source Sans Pro,Helvetica,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}abbr[data-original-title],abbr[title]{cursor:help}body.modal-open{overflow-y:auto;padding-right:0!important}svg{text-shadow:none}
    </style>
    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    	<script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv.min.js" integrity="sha256-3Jy/GbSLrg0o9y5Z5n1uw0qxZECH7C6OQpVBgNFYa0g=" crossorigin="anonymous"></script>
    	<script src="https://cdnjs.cloudflare.com/ajax/libs/respond.js/1.4.2/respond.min.js" integrity="sha256-g6iAfvZp+nDQ2TdTR/VVKJf3bGro4ub5fvWSWVRi2NE=" crossorigin="anonymous"></script>
		<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.5.9/es5-shim.min.js" integrity="sha256-8E4Is26QH0bD52WoQpcB+R/tcWQtpzlCojrybUd7Mxo=" crossorigin="anonymous"></script>
    <![endif]-->
</head>

<body>
    <div id="doc" class="markdown-body container-fluid comment-inner comment-enabled" data-hard-breaks="true"><style>
ins { background-color: #CCFFCC }
s { background-color: #FFCACA }
blockquote { color: inherit !important }
table.no-alt tr:nth-child(2n) { background-color: inherit }
</style><table><tbody>
<tr><th>Doc. no.:</th>    <td>P2511R2</td></tr>
<tr><th>Date:</th>        <td>2022-8-14</td></tr>
<tr><th>Audience:</th>    <td>LWG</td></tr>
<tr><th>Reply-to:</th>    <td>Zhihao Yuan &lt;zy at miator dot net&gt;</td></tr>
</tbody></table><h1 id="Beyond-operator-NTTP-callables-in-type-erased-call-wrappers" data-id="Beyond-operator-NTTP-callables-in-type-erased-call-wrappers"><a class="anchor hidden-xs" href="#Beyond-operator-NTTP-callables-in-type-erased-call-wrappers" title="Beyond-operator-NTTP-callables-in-type-erased-call-wrappers"><span class="octicon octicon-link"></span></a><span>Beyond operator(): NTTP callables in type-erased call wrappers</span></h1><h2 id="Changes-Since-R1" data-id="Changes-Since-R1"><a class="anchor hidden-xs" href="#Changes-Since-R1" title="Changes-Since-R1"><span class="octicon octicon-link"></span></a><span>Changes Since R1</span></h2><ul>
<li><span>add feature test macro</span></li>
<li><span>complete reference implementations</span></li>
</ul><h2 id="Changes-Since-R0" data-id="Changes-Since-R0"><a class="anchor hidden-xs" href="#Changes-Since-R0" title="Changes-Since-R0"><span class="octicon octicon-link"></span></a><span>Changes Since R0</span></h2><ul>
<li><span>respond to offline comments</span></li>
<li><span>simplify semantics</span></li>
<li><span>provide wording for </span><code>std::function</code></li>
</ul><h2 id="Introduction" data-id="Introduction"><a class="anchor hidden-xs" href="#Introduction" title="Introduction"><span class="octicon octicon-link"></span></a><span>Introduction</span></h2><p><span>Non-type template parameters (NTTP) can provide information for call wrappers to erase at compile-time, eliminating the need for binding objects at runtime when fulfilling a simple demand. This paper proposes tweaking type-erased call wrappers, such as </span><code>std::move_only_function</code><span>, with NTTP callable objects.</span></p><p><span>Here is an unfair Tony Table that quickly demonstrates a motivating use case:</span></p><table class="no-alt"><tbody>
<tr><td>C++11</td><td>
<pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">push</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token function">bind</span><span class="token punctuation">(</span><span class="token operator">&amp;</span>DB<span class="token double-colon punctuation">::</span>connect<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">,</span> _1<span class="token punctuation">,</span> _2<span class="token punctuation">,</span> _3<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
</td></tr>
<tr><td>C++14</td>
<td>
<pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">push</span><span class="token punctuation">(</span><span class="token punctuation">[</span>db<span class="token punctuation">{</span>std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">]</span> <span class="token punctuation">(</span><span class="token keyword">auto</span> <span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span> <span class="token keyword">mutable</span>
       <span class="token punctuation">{</span>
           <span class="token keyword">return</span> db<span class="token punctuation">.</span><span class="token function">connect</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator">&lt;</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>args<span class="token punctuation">)</span><span class="token operator">&gt;</span></span></span><span class="token punctuation">(</span>args<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
       <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
</td></tr>
<tr><td>C++20</td>
<td>
<pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">push</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token function">bind_front</span><span class="token punctuation">(</span><span class="token operator">&amp;</span>DB<span class="token double-colon punctuation">::</span>connect<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
<pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">push</span><span class="token punctuation">(</span><span class="token punctuation">[</span>db<span class="token punctuation">{</span>std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">]</span> <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>T<span class="token operator">&gt;</span><span class="token punctuation">(</span>T <span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span> <span class="token keyword">mutable</span>
       <span class="token punctuation">{</span>
           <span class="token keyword">return</span> db<span class="token punctuation">.</span><span class="token function">connect</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator">&lt;</span>T<span class="token operator">&gt;</span></span></span><span class="token punctuation">(</span>args<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
       <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
</td></tr>
<tr>
<td>
<p><mark><span>P2511</span></mark></p>
</td>
<td>
<pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">emplace</span><span class="token punctuation">(</span>nontype<span class="token operator">&lt;</span><span class="token operator">&amp;</span>DB<span class="token double-colon punctuation">::</span>connect<span class="token operator">&gt;</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
</td></tr>
</tbody></table><h2 id="Motivation" data-id="Motivation"><a class="anchor hidden-xs" href="#Motivation" title="Motivation"><span class="octicon octicon-link"></span></a><span>Motivation</span></h2><p data-original-title="" title=""><span>Not all user-defined objects have an</span>
<code>operator()</code><span>. To pass a user-defined object to a parameter of </span><code>std::move_only_function</code><span>, one must be able to use that object as</span></p><pre><code class="cpp hljs"><span class="token function">obj</span><span class="token punctuation">(</span>some<span class="token punctuation">,</span> args<span class="token punctuation">)</span>
</code></pre><p><span>But often, the object is designed to be used as</span></p><pre><code class="cpp hljs">obj<span class="token punctuation">.</span><span class="token function">send</span><span class="token punctuation">(</span>some<span class="token punctuation">,</span> args<span class="token punctuation">)</span>
</code></pre><p><span>I want to use such an object with </span><code>move_only_function</code><span> as if the type of the object aliased its </span><code>send</code><span> member function to </span><code>operator()</code><span>.</span></p><h2 id="Analysis" data-id="Analysis"><a class="anchor hidden-xs" href="#Analysis" title="Analysis"><span class="octicon octicon-link"></span></a><span>Analysis</span></h2><h3 id="Why-don’t-people-make-their-classes-callable" data-id="Why-don’t-people-make-their-classes-callable"><a class="anchor hidden-xs" href="#Why-don’t-people-make-their-classes-callable" title="Why-don’t-people-make-their-classes-callable"><span class="octicon octicon-link"></span></a><span>Why don’t people make their classes </span><em><span>callable</span></em><span>?</span></h3><p><span>Given sufficient tag types, any member functions can be expressed in one overload set, namely </span><code>operator()</code><span>. But we are not in that direction and are not working with constructors – a typical context where the entities to call are anonymous. Naming functions differently is the best way to disambiguate.</span></p><p><span>When there is no demand for disambiguation, people who design the class can still prefer naming their only member function in the interface “run,” “parse,” and even “apply,” since clearly,</span></p><pre><code class="cpp hljs">repl<span class="token punctuation">.</span><span class="token function">run</span><span class="token punctuation">(</span>line<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>delivers more information than</span></p><pre><code class="cpp hljs"><span class="token function">repl</span><span class="token punctuation">(</span>line<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><h3 id="Can-we-do-this-with-wrapping" data-id="Can-we-do-this-with-wrapping"><a class="anchor hidden-xs" href="#Can-we-do-this-with-wrapping" title="Can-we-do-this-with-wrapping"><span class="octicon octicon-link"></span></a><span>Can we do this with wrapping?</span></h3><p><span>Lambda expression is an option. We can pass a closure object instead of the original object</span></p><pre><code class="cpp hljs">pack<span class="token punctuation">.</span><span class="token function">start</span><span class="token punctuation">(</span><span class="token punctuation">[</span>obj<span class="token punctuation">{</span>std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>obj<span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">]</span> <span class="token punctuation">(</span><span class="token keyword">auto</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span> <span class="token keyword">mutable</span>
           <span class="token punctuation">{</span>
               <span class="token keyword">return</span> obj<span class="token punctuation">.</span><span class="token function">send</span><span class="token punctuation">(</span>args<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
           <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>Perfect-forwarding will need more boilerplate</span></p><pre><code class="cpp hljs">pack<span class="token punctuation">.</span><span class="token function">start</span><span class="token punctuation">(</span><span class="token punctuation">[</span>obj<span class="token punctuation">{</span>std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>obj<span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">]</span>
           <span class="token operator">&lt;</span><span class="token keyword">class</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>T<span class="token operator">&gt;</span><span class="token punctuation">(</span>T <span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span> <span class="token keyword">mutable</span>
           <span class="token punctuation">{</span>
               <span class="token keyword">return</span> obj<span class="token punctuation">.</span><span class="token function">send</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator">&lt;</span>T<span class="token operator">&gt;</span></span></span><span class="token punctuation">(</span>args<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
           <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>And don’t forget that we are using </span><code>obj</code><span> only as an lvalue in this example. A lambda’s captures are unaware of the value category of the closure object unless using </span><code>std::forward_like</code><sup class="footnote-ref"><a href="#fn1" id="fnref1">[1]</a></sup><span> together with an explicit object parameter.</span></p><p><span>Let’s just say that lambda expression is not suitable for expressing the intention of designating a differently named member function.</span></p><p><span>And it’s a part of the reason why we have </span><code>std::bind_front</code><span>. You can rewrite the example above as</span></p><pre><code class="cpp hljs">pack<span class="token punctuation">.</span><span class="token function">start</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token function">bind_front</span><span class="token punctuation">(</span><span class="token operator">&amp;</span>Cls<span class="token double-colon punctuation">::</span>send<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>obj<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>But </span><code>bind_front</code><span> incurs a cost. Sometimes, the space penalty – size of a pointer to member function, is greater than the </span><code>obj</code><span> itself. Other than that, the codegen cost is also high.</span></p><h3 id="Why-the-ask-has-to-have-something-to-do-with-type-erasure" data-id="Why-the-ask-has-to-have-something-to-do-with-type-erasure"><a class="anchor hidden-xs" href="#Why-the-ask-has-to-have-something-to-do-with-type-erasure" title="Why-the-ask-has-to-have-something-to-do-with-type-erasure"><span class="octicon octicon-link"></span></a><span>Why the ask has to have something to do with type-erasure?</span></h3><p><span>Let’s recall function pointers – the most basic form of type-erasures. You can assign different functions to the same function pointer:</span></p><pre><code class="cpp hljs"><span class="token keyword">typedef</span> <span class="token keyword">int</span> <span class="token function">cmp_t</span><span class="token punctuation">(</span><span class="token keyword">const</span> <span class="token keyword">char</span> <span class="token operator">*</span><span class="token punctuation">,</span> <span class="token keyword">const</span> <span class="token keyword">char</span> <span class="token operator">*</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
cmp_t <span class="token operator">*</span>p <span class="token operator">=</span> strcmp<span class="token punctuation">;</span>
p <span class="token operator">=</span> strcasecmp<span class="token punctuation">;</span>
</code></pre><p><span>At first glance, here we did not erase type. The turth is that we erased “nontype” compile-time information – </span><code>&amp;strcmp</code><span> and </span><code>&amp;strcasecmp</code><span>. In a hypothetical language, every function could be of different types, like what the following piece of legal C++ code shows:</span></p><pre><code class="cpp hljs">p <span class="token operator">=</span> <span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">auto</span> lhs<span class="token punctuation">,</span> <span class="token keyword">auto</span> rhs<span class="token punctuation">)</span>
    <span class="token punctuation">{</span>
        <span class="token keyword">return</span> <span class="token function">string_view</span><span class="token punctuation">(</span>lhs<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">compare</span><span class="token punctuation">(</span>rhs<span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre><p><span>There are two ways to understand this:</span></p><ol>
<li><span>The function pointer erased type </span><code>T</code><span> from the closure.</span></li>
<li><span>C++ offshored the compile-time identity of functions into nontype values.</span></li>
</ol><p><span>They are equivalent, as you may get those nontype values back into types anytime:</span></p><pre><code class="cpp hljs"><span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">auto</span> V<span class="token operator">&gt;</span> <span class="token keyword">struct</span> <span class="token class-name">nontype_t</span> <span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">static_assert</span><span class="token punctuation">(</span><span class="token operator">!</span>is_same_v<span class="token operator">&lt;</span>nontype_t<span class="token operator">&lt;</span>strcmp<span class="token operator">&gt;</span><span class="token punctuation">,</span> nontype_t<span class="token operator">&lt;</span>strcasecmp<span class="token operator">&gt;&gt;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>Type erasure is called “type erasure” because it makes code that should depend on different types, not dependent. It wouldn’t be surprising if the code supposed to be dependent were </span><em><span>value-dependent</span></em><span>. So it seems that a type-erased call wrapper is suitable for erasing the nontype information, </span><code>&amp;Cls::send</code><span>, from the expression</span></p><pre><code class="cpp hljs">obj<span class="token punctuation">.</span><span class="token function">send</span><span class="token punctuation">(</span>some<span class="token punctuation">,</span> args<span class="token punctuation">)</span>
</code></pre><p><span>to make the code that uses </span><code>obj</code><span> depends on neither </span><code>&amp;Cls::send</code><span> nor </span><code>Cls</code><span>, where the latter case is what being erased if </span><code>obj</code><span> were </span><em><span>callable</span></em><span>.</span></p><h2 id="Proposal" data-id="Proposal"><a class="anchor hidden-xs" href="#Proposal" title="Proposal"><span class="octicon octicon-link"></span></a><span>Proposal</span></h2><p><span>This proposal consists of two parts. First, it adds </span><code>nontype_t</code><span> and </span><code>nontype</code><span> to the </span><code>&lt;utility&gt;</code><span> header. They are similar to </span><code>in_place_type_t</code><span> and </span><code>in_place_type</code><span>, except each of the former two accepts a nontype template parameter with </span><code>auto</code><span> rather than type template parameters.</span></p><p><span>Second, it adds </span><code>nontype_t&lt;V&gt;</code><span> to </span><code>move_only_function</code><span>’s constructors to allow you to do the following things:</span></p><pre><code class="cpp hljs">pack<span class="token punctuation">.</span><span class="token function">start</span><span class="token punctuation">(</span><span class="token punctuation">{</span>nontype<span class="token operator">&lt;</span><span class="token operator">&amp;</span>Cls<span class="token double-colon punctuation">::</span>send<span class="token operator">&gt;</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>obj<span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// 1</span>
pack<span class="token punctuation">.</span><span class="token function">start</span><span class="token punctuation">(</span><span class="token punctuation">{</span>nontype<span class="token operator">&lt;</span><span class="token operator">&amp;</span>Cls<span class="token double-colon punctuation">::</span>send<span class="token operator">&gt;</span><span class="token punctuation">,</span> <span class="token operator">&amp;</span>obj<span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>           <span class="token comment">// 2</span>
</code></pre><p><span>In the first case, the </span><code>move_only_function</code><span> parameter owns </span><code>obj</code><span>. In the second case, the parameter holds a reference to </span><code>obj</code><span>. But this does not mean that we will dereference the pointer in the second case. It works here because the </span><em><code>INVOKE</code></em><span> protocol calls a pointer-to-member on an object pointer. If </span><code>Cls::send</code><span> were an </span><em><span>explicit object member function</span></em><sup class="footnote-ref"><a href="#fn2" id="fnref2">[2]</a></sup><span>, case 2 would stop working.</span></p><p><span>Another constructor converts a single </span><code>nontype&lt;V&gt;</code><span> to </span><code>move_only_function</code><span>. It is merely a shortcut to initialize from a callable object if we can pass it using a nontype template parameter.</span></p><pre><code class="cpp hljs">move_only_function<span class="token operator">&lt;</span>cmp_t<span class="token operator">&gt;</span> fn <span class="token operator">=</span> strcmp<span class="token punctuation">;</span>
fn <span class="token operator">=</span> nontype<span class="token operator">&lt;</span>strcasecmp<span class="token operator">&gt;</span><span class="token punctuation">;</span>  <span class="token comment">// new</span>
</code></pre><p><span>This revision proposes the one-argument and the two-argument </span><code>nontype_t</code><span> constructors for </span><code>std::function</code><span> as well. The similar change for </span><code>function_ref</code><span> has been incorporated in P0792R10</span><sup class="footnote-ref"><a href="#fn3" id="fnref3">[3]</a></sup><span>.</span></p><p><span>Third, clone </span><code>move_only_function</code><span>’s </span><code>in_place_type_t&lt;T&gt;</code><span> constructors and prepend</span>
<span>the </span><code>nontype_t&lt;V&gt;</code><span> parameters. This will give us two more constructors.</span></p><h2 id="Discussion" data-id="Discussion"><a class="anchor hidden-xs" href="#Discussion" title="Discussion"><span class="octicon octicon-link"></span></a><span>Discussion</span></h2><h3 id="How-do-other-programming-languages-solve-this-problem" data-id="How-do-other-programming-languages-solve-this-problem"><a class="anchor hidden-xs" href="#How-do-other-programming-languages-solve-this-problem" title="How-do-other-programming-languages-solve-this-problem"><span class="octicon octicon-link"></span></a><span>How do other programming languages solve this problem?</span></h3><p><span>Java® did not designate a magic method serving </span><code>operator()</code><span>'s role. Instead, any interface with a single abstract method is deemed a </span><strong><span>functional interface</span></strong><span>. When passing a lambda expression to a parameter of a functional interface, Java produces a closure object that implements this interface. So it doesn’t matter what the method’s name is; it may be </span><code>void accept(T)</code><span>, </span><code>R apply(T)</code><span>, etc. But you don’t have to use a lambda if your </span><code>obj</code><span> doesn’t implement the functional interface. Method references are a more straightforward way to produce a closure object. For example, </span><code>obj::consume</code><span> can make a closure object supporting the </span><code>accept</code><span> method.</span></p><p><span>Python designates </span><code>__call__</code><span> to be the magic method to make an object callable. If you want to call a different method to fulfill the </span><code>typing.Callable</code><span> requirement, you may pass a </span><strong><span>bound method</span></strong><span> like </span><code>obj.send</code><span>. A method in Python has a </span><code>__self__</code><span> attribute to store the class instance.</span></p><p><span>C♯, similar to Java, doesn’t support overloading the call operator. However, its </span><strong><span>delegate</span></strong><span> language facility allows quickly defining a functional interface. Unlike Java, you cannot “implement” a delegate, so you must create delegate objects using a syntax similar to Python’s bound methods.</span></p><p><span>In a parallel universe, C++ with C++0x Concepts provides </span><strong><span>concept maps</span></strong><span> as a general mechanism for adapting a de facto interface to be used in a component that expects a common, but different interface. Here, to enable type </span><code>Cls</code><span> for being used in </span><code>move_only_function</code><span>, we can specify a mapping using Richard’s generalized alias declaration</span><sup class="footnote-ref"><a href="#fn3" id="fnref3">[3]</a></sup><span>:</span></p><pre><code class="cpp hljs"><span class="token keyword">template</span><span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span>
concept_map invocable<span class="token operator">&lt;</span>Cls<span class="token punctuation">,</span> Args<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token operator">&gt;</span>
<span class="token punctuation">{</span>
    <span class="token keyword">using</span> <span class="token keyword">operator</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">=</span> Cls<span class="token double-colon punctuation">::</span>send<span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre><p data-original-title="" title=""><span>To make this adaptation local to the users’ code, they can define the </span><code>concept_map</code><span> in their own namespace.</span><sup class="footnote-ref"><a href="#fn4" id="fnref4">[4]</a></sup></p><h3 id="Why-this-proposal-is-different-from-delegates-and-other-solutions" data-id="Why-this-proposal-is-different-from-delegates-and-other-solutions"><a class="anchor hidden-xs" href="#Why-this-proposal-is-different-from-delegates-and-other-solutions" title="Why-this-proposal-is-different-from-delegates-and-other-solutions"><span class="octicon octicon-link"></span></a><span>Why this proposal is different from delegates and other solutions?</span></h3><p><span>The solution given by concept maps has the right model. But </span><em><span>invocable</span></em><span> is not only a concept. It is centralized in a programming paradigm. That might be why the other solutions widely used in practice allow forming the adaptations that are different from use to use.</span></p><p><span>The rest of the solutions, such as delegates, are all language features that work only with member functions.</span></p><p><span>However, in C++, until C++20, functional interface means </span><code>std::function</code><span>. There are also </span><code>packaged_task</code><span>, </span><code>folly::Function</code><span>, </span><code>llvm::function_ref</code><span>… There is no generic functional interface that fits all needs.</span></p><p><span>We are proposing a framework that enables designating a different </span><code>operator()</code><span> when initializing any functional interface in C++. A third-party library can also add </span><code>nontype_t&lt;V&gt;</code><span> to their type-erased call wrappers’ constructor overload sets. The </span><code>V</code><span> they accept may be more permissive or restrictive, the storage policy they chose may be adaptive or pooled, but the end-users can enjoy expressing the same idea using the same syntax.</span></p><p><span>And a C++ class’s interface consists not only of member functions. The NTTP callable, </span><code>V</code><span>, can be a pointer to explicit object member function – in other words, you can treat a free function as that member function. You can even rewrite that </span><code>obj</code><span>’s call operator with another structural object with an </span><code>operator()</code><span>:</span></p><pre><code class="cpp hljs">nontype<span class="token operator">&lt;</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>Cls<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token function">runtime_work</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span><span class="token operator">&gt;</span>
</code></pre><p><span>The proposed solution supports all these to satisfy users’ expectations for C++.</span></p><h3 id="Should-we-add-those-constructors-to-all-type-erased-call-wrappers" data-id="Should-we-add-those-constructors-to-all-type-erased-call-wrappers"><a class="anchor hidden-xs" href="#Should-we-add-those-constructors-to-all-type-erased-call-wrappers" title="Should-we-add-those-constructors-to-all-type-erased-call-wrappers"><span class="octicon octicon-link"></span></a><span>Should we add those constructors to all type-erased call wrappers?</span></h3><p data-original-title="" title=""><span>The paper proposes extensions to </span><code>std::function</code><span> since R1. The author has reviewed major standard library implementations’ code and believes the changes should not create ABI concerns.</span></p><p><span>The typical uses of </span><code>packaged_task</code><span> do not seem to value codegen high enough to justify adding the </span><code>nontype_t&lt;V&gt;</code><span> constructors.</span></p><h3 id="Should-type-passing-call-wrappers-support-NTTP-callables" data-id="Should-type-passing-call-wrappers-support-NTTP-callables"><a class="anchor hidden-xs" href="#Should-type-passing-call-wrappers-support-NTTP-callables" title="Should-type-passing-call-wrappers-support-NTTP-callables"><span class="octicon octicon-link"></span></a><span>Should type-passing call wrappers support NTTP callables?</span></h3><p><span>Strictly speaking, they are outside the scope of this paper. But some type-passing call wrappers that require factory functions have an attractive syntax when accepting NTTP callables – you can pass them in function templates’ </span><em><span>template-argument-list</span></em><span>. So let me break down the typical ones: </span><code>bind_front&lt;V&gt;</code><span>, </span><code>not_fn&lt;V&gt;()</code><span>, and </span><code>mem_fn&lt;V&gt;()</code><span>.</span></p><p><span>Supporting </span><code>bind_front&lt;&amp;Cls::send&gt;(obj)</code><span> eliminates the space penalty of </span><code>bind_front(&amp;Cls::send, obj)</code><span>. But, please be aware that if </span><code>bind_front</code><span> appears alone, the compiler has no pressure optimizing type-passing code. Hence, the new form only makes sense if a type-erasure later erases the underlying wrapper object. But a type-erased call wrapper already requires wrapping the target object. This double-wrapping downgrades the usability of those call wrappers:</span></p><ol>
<li><span>One cannot in-place constructs </span><code>obj</code><span> in an owning call wrapper bypassing </span><code>bind_front</code><span>;</span></li>
<li><span>One must write </span><code>bind_front&lt;&amp;Cls::send&gt;(std::ref(obj))</code><span> to archive reference semantics even if this expression is about to initialize a </span><code>function_ref</code><span>, defeating half of the purpose of </span><code>function_ref</code><span>.</span></li>
</ol><p><span>The need of type-erasing a predicate such as </span><code>not_fn(p)</code><span> seems rare. STL algorithms that take predicates have a type-passing interface.</span></p><p><span>The uses of </span><code>std::mem_fn</code><span> largely diminished after introducing </span><code>std::invoke</code><span>.</span></p><h3 id="Should-nontype_t-itself-be-callable" data-id="Should-nontype_t-itself-be-callable"><a class="anchor hidden-xs" href="#Should-nontype_t-itself-be-callable" title="Should-nontype_t-itself-be-callable"><span class="octicon octicon-link"></span></a><span>Should </span><code>nontype_t</code><span> itself be callable?</span></h3><p><span>Rather than overloading </span><code>mem_fn</code><span> to take NTTP callables, adding an </span><code>operator()</code><span> to </span><code>nontype_t</code><span> will have the same, or arguably better, effect:</span></p><pre><code class="cpp hljs">std<span class="token double-colon punctuation">::</span><span class="token function">transform</span><span class="token punctuation">(</span><span class="token function">begin</span><span class="token punctuation">(</span>v<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">end</span><span class="token punctuation">(</span>v<span class="token punctuation">)</span><span class="token punctuation">,</span> it<span class="token punctuation">,</span> nontype<span class="token operator">&lt;</span><span class="token operator">&amp;</span>Cls<span class="token double-colon punctuation">::</span>pmd<span class="token operator">&gt;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>And doing so can make </span><code>bind_front(nontype&lt;&amp;Cls::send&gt;, obj)</code><span> automatically benefit from better codegen in a quality implementation of </span><code>std::bind_front</code><span>. However, this raises both API and ABI concerns.</span></p><p><span>In terms of API, </span><code>nontype_t</code><span>’s meaning should be entirely up to the wrapper. I don’t see a problem if a call wrapper interprets</span></p><pre><code class="cpp hljs"><span class="token keyword">auto</span> fn <span class="token operator">=</span> C<span class="token punctuation">{</span>fp<span class="token punctuation">,</span> nontype<span class="token operator">&lt;</span>std<span class="token double-colon punctuation">::</span>fputs<span class="token operator">&gt;</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre><p><span>as binding </span><code>fp</code><span> to the last parameter.</span></p><p><span>When it comes to ABI, the return type of </span><code>bind_front</code>
<span>is opaque but not erased – it can be at</span>
<span>the ABI boundary. So if a type-passing wrapper like </span><code>bind_front</code><span> later wants to handle </span><code>nontype_t</code><span> differently as a QoI improvement,</span>
<span>it breaks ABI.</span></p><h3 id="Can-some-form-of-lambda-solve-the-problem" data-id="Can-some-form-of-lambda-solve-the-problem"><a class="anchor hidden-xs" href="#Can-some-form-of-lambda-solve-the-problem" title="Can-some-form-of-lambda-solve-the-problem"><span class="octicon octicon-link"></span></a><span>Can some form of lambda solve the problem?</span></h3><p><span>The previous discussion (</span><a href="#Why-this-proposal-is-different-from-delegates-and-other-solutions"><span>1</span></a><span>, </span><a href="#Should-type-passing-call-wrappers-support-NTTP-callables"><span>2</span></a><span>) revealed how large the design space is and how the problem ties to the library. This section will use a specific paper in the past as an example to show how these factors can affect language design.</span></p><p><span>There have been discussions about whether C++ should have expression lambda</span><sup class="footnote-ref"><a href="#fn5" id="fnref5">[5]</a></sup></p><pre><code class="cpp hljs">priority_queue <span class="token function">pq</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token number">1.</span><span class="token function">id</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">&lt;</span> <span class="token operator">&amp;</span><span class="token number">2.</span><span class="token function">id</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">]</span><span class="token punctuation">,</span> input<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>to make lambda terse. Expression lambdas aim to address the difficulty of introducing parameters.  But in our </span><a href="#Can-we-do-this-with-wrapping?"><span>motivating example</span></a><span>, we forwarded all parameters without introducing any. So expression lambda doesn’t directly respond to the problem.</span></p><p><span>So the ask will need to expand the scope of </span><em><span>lambda</span></em><span> to “anything that can produce an anonymous closure object.” It is reasonable as other languages have similar sugars. For example, Java’s method references and lambda expressions share VM mechanisms.</span><sup class="footnote-ref"><a href="#fn6" id="fnref6">[6]</a></sup></p><p><span>In that case, let’s prototype the ask: Why don’t we write the following and make everything work?</span></p><pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">push_back</span><span class="token punctuation">(</span>db<span class="token punctuation">.</span>connect<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>Recall that </span><code>q</code><span> is a container of </span><code>std::move_only_function</code><span> from </span><a href="#Introduction"><span>Introduction</span></a><span>, so the first question will be what </span><code>db.connect</code><span> means. Luckily, Andrew Sutton had an answer to that in 2016.</span><sup class="footnote-ref"><a href="#fn7" id="fnref7">[7]</a></sup><span> Here is an example from his paper:</span></p><pre><code class="cpp hljs"><span class="token keyword">struct</span> <span class="token class-name">S</span>
<span class="token punctuation">{</span>
  <span class="token keyword">void</span> <span class="token function">f</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token operator">&amp;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token keyword">void</span> <span class="token function">f</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>string<span class="token operator">&amp;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>

S s<span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span><span class="token function">transform</span><span class="token punctuation">(</span>first<span class="token punctuation">,</span> last<span class="token punctuation">,</span> s<span class="token punctuation">.</span>f<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><code>s.f</code><span> produces (applied minor corrections):</span></p><pre><code class="cpp hljs"><span class="token punctuation">[</span><span class="token operator">&amp;</span>s<span class="token punctuation">]</span> <span class="token operator">&lt;</span><span class="token keyword">class</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> Args<span class="token operator">&gt;</span><span class="token punctuation">(</span>Args<span class="token operator">&amp;&amp;</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> args<span class="token punctuation">)</span>
  <span class="token operator">-&gt;</span> <span class="token keyword">decltype</span><span class="token punctuation">(</span>s<span class="token punctuation">.</span><span class="token function">f</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator">&lt;</span>Args<span class="token operator">&gt;</span></span></span><span class="token punctuation">(</span>args<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">)</span>
<span class="token punctuation">{</span>
  <span class="token keyword">return</span> s<span class="token punctuation">.</span><span class="token function">f</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator">&lt;</span>Args<span class="token operator">&gt;</span></span></span><span class="token punctuation">(</span>args<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre><p><span>The above suggests that, in our example, </span><code>db.connect</code><span> captures </span><code>db</code><span> by reference.</span></p><p><span>But </span><code>move_only_function</code><span> is supposed have a unique copy of </span><code>db</code><span>! In the motivating example, we </span><code>std::move(db)</code><span> into an element of </span><code>q</code><span>. So maybe </span><code>s</code><span> should mean “capture by value” in </span><code>s.f</code><span>, and we write </span><code>std::move(db).connect</code><span>?</span></p><p><span>Assume it is the case. What happens if there is another function </span><code>retry</code><span> taking </span><code>function_ref</code><span>:</span></p><pre><code class="cpp hljs"><span class="token function">retry</span><span class="token punctuation">(</span>db<span class="token punctuation">.</span>connect<span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment">// a few times</span>
</code></pre><p><span>Given the modified semantics, the above should mean “capture </span><code>db</code><span> by making a copy, and pass the closure by reference using </span><code>function_ref</code><span>.” Which is, of course, not satisfying. </span><code>std::ref(db)</code><span> won’t help this time, so let’s go with</span></p><pre><code class="cpp hljs"><span class="token function">retry</span><span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token operator">&amp;</span>db<span class="token punctuation">)</span><span class="token operator">-&gt;</span>connect<span class="token punctuation">)</span><span class="token punctuation">;</span>  <span class="token comment">// a few times</span>
</code></pre><p><span>Now </span><code>db.connect</code><span> and </span><code>(&amp;db)-&gt;connect</code><span> have different meanings. This implies that if we had a pointer to </span><code>db</code><span>,</span></p><pre><code class="cpp hljs"><span class="token keyword">auto</span> p <span class="token operator">=</span> <span class="token operator">&amp;</span>db<span class="token punctuation">;</span>
</code></pre><p><code>(*p).connect</code><span> and </span><code>p-&gt;connect</code><span> will have different meanings. This goes against the common expectation on C++ (</span><a href="https://eel.is/c++draft/over.call.func#2" target="_blank" rel="noopener"><span>[over.call.func]/2</span></a><span>):</span></p><blockquote>
<p><span>[…] the construct </span><code>A-&gt;B</code><span> is generally equivalent to </span><code>(*A).B</code></p>
</blockquote><p><span>Let’s take another angle. Instead of moving </span><code>db</code><span>, what if we want to construct an object of </span><code>DB</code><span> in the new element in place?</span></p><p><span>It’s simple using a </span><code>nontype</code><span> constructor. We only need to go from</span></p><pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">emplace</span><span class="token punctuation">(</span>nontype<span class="token operator">&lt;</span><span class="token operator">&amp;</span>DB<span class="token double-colon punctuation">::</span>connect<span class="token operator">&gt;</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>to</span></p><pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">emplace</span><span class="token punctuation">(</span>nontype<span class="token operator">&lt;</span><span class="token operator">&amp;</span>DB<span class="token double-colon punctuation">::</span>connect<span class="token operator">&gt;</span><span class="token punctuation">,</span>
          std<span class="token double-colon punctuation">::</span>in_place_type<span class="token operator">&lt;</span>DB<span class="token operator">&gt;</span><span class="token punctuation">,</span> <span class="token string">"example.db"</span><span class="token punctuation">,</span> <span class="token number">100</span>ms<span class="token punctuation">,</span> <span class="token boolean">true</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>I don’t know of a solution that involves capturing. </span><code>DB("example.db", 100ms, true).connect</code><span> will result in moving a subobject along with the closure. And more importantly, it requires </span><code>DB</code><span> to be movable, which adds more to </span><code>move_only_function</code><span>’s minimal requirements.</span></p><p><span>It seems that C++ lambdas are not only verbose to introduce parameters but also tricky to capture variables. A solution that couples naming a different </span><em><code>id-expression</code></em><span> after </span><em><code>.</code></em><span> operator with captures will face problems when working with varying type-erased call wrappers.</span></p><p><span>But if expression lambda solves the problem of introducing parameters, can we replace the problems caused by capturing variables with the problem we solved?</span></p><pre><code class="cpp hljs">q<span class="token punctuation">.</span><span class="token function">emplace</span><span class="token punctuation">(</span>nontype<span class="token operator">&lt;</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token number">1</span><span class="token double-colon punctuation">::</span>connect<span class="token punctuation">]</span><span class="token operator">&gt;</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>db<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><p><span>This WORKS. A captureless lambda is of a structural type. It solves the problem of selecting a particular overload or specialization when </span><code>connect</code><span> is an overload set. In Andrew’s example,</span></p><pre><code class="cpp hljs"><span class="token keyword">struct</span> <span class="token class-name">S</span>
<span class="token punctuation">{</span>
  <span class="token keyword">void</span> <span class="token function">f</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token operator">&amp;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token keyword">void</span> <span class="token function">f</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>string<span class="token operator">&amp;</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre><p><span>Right now, to select the first overload, we have to write </span><code>nontype&lt;(void (S::*)(int&amp;))&amp;S::f&gt;</code><span>; with an expression lambda, it’s as simple as </span><code>nontype&lt;[][&amp;1.f]&gt;</code><span>.</span></p><p><span>As long as we decoupled naming from wrapping, a language design can relieve itself from making every library happy with a single type-passing language feature that does wrapping for you. In that situation, the library additions and the language additions can evolve in parallel and work together in the end.</span></p><h2 id="Prior-Art" data-id="Prior-Art"><a class="anchor hidden-xs" href="#Prior-Art" title="Prior-Art"><span class="octicon octicon-link"></span></a><span>Prior Art</span></h2><p><span>The earliest attempt to bind an object with a member function I can find is Rich Hickey’s “Callbacks in C++ Using Template Functors”</span><sup class="footnote-ref"><a href="#fn9" id="fnref9">[9]</a></sup><span> back in 1994.</span></p><p><span>Borland C++ has a language extension – the </span><code>__closure</code><span> keyword.</span><sup class="footnote-ref"><a href="#fn10" id="fnref10">[10]</a></sup><span> It is very similar to the hypothetical </span><code>__bound</code><span> keyword in Rich’s article. However, you may not </span><code>delete</code><span> a pointer to closure or initialize it with a function.</span></p><p><span>This proposal is inspired by an earlier revision of P2472</span><sup class="footnote-ref"><a href="#fn11" id="fnref11">[11]</a></sup><span>.</span></p><h2 id="Wording" data-id="Wording"><a class="anchor hidden-xs" href="#Wording" title="Wording"><span class="octicon octicon-link"></span></a><span>Wording</span></h2><p><span>The wording is relative to N4910.</span></p><h3 id="Part-1" data-id="Part-1"><a class="anchor hidden-xs" href="#Part-1" title="Part-1"><span class="octicon octicon-link"></span></a><span>Part 1.</span></h3><p><span>Add new templates to </span><a href="https://eel.is/c++draft/utility.syn" target="_blank" rel="noopener"><span>[utility.syn]</span></a><span>, header </span><code>&lt;utility&gt;</code><span> synopsis:</span></p><pre>namespace std {
  [...]

  template&lt;size_t I&gt;
    struct in_place_index_t {
      explicit in_place_index_t() = default;
    };

  template&lt;size_t I&gt; inline constexpr in_place_index_t&lt;I&gt; in_place_index{};
<ins>
  <i>// nontype argument tag</i>
  template&lt;auto V&gt;
    struct nontype_t {
      explicit nontype_t() = default;
    };

  template&lt;auto V&gt; inline constexpr nontype_t&lt;V&gt; nontype{};</ins>
}
</pre><p><span>Revise definitions in </span><a href="https://eel.is/c++draft/func.def" target="_blank" rel="noopener"><span>[func.def]</span></a><span>:</span></p><blockquote>
<p><span>[…]</span></p>
<p><span>A </span><em><span>target object</span></em><span> is the </span><s><span>callable</span></s><span> object held by a call wrapper </span><ins><span>for the purpose of calling</span></ins><span>.</span></p>
<p><span>A call wrapper type may additionally hold a sequence of objects and references that may be passed as arguments to </span><ins><span>the call expressions involving</span></ins><span> the target object. […]</span></p>
</blockquote><h3 id="Part-2" data-id="Part-2"><a class="anchor hidden-xs" href="#Part-2" title="Part-2"><span class="octicon octicon-link"></span></a><span>Part 2.</span></h3><p><span>Add new signatures to </span><a href="https://eel.is/c++draft/func.wrap.func.general" target="_blank" rel="noopener"><span>[func.wrap.func.general]</span></a><span> synopsis:</span></p><blockquote>
<p><span>[…]</span></p>
</blockquote><pre>  template&lt;class R, class... ArgTypes&gt;
  class function&lt;R(ArgTypes...)&gt; {
  public:
    using result_type = R;

    <i>// [func.wrap.func.con], construct/copy/destroy</i>
    function() noexcept;
    function(nullptr_t) noexcept;
    <ins>template&lt;auto f&gt; function(nontype_t&lt;f&gt;) noexcept;</ins>
    function(const function&amp;);
    function(function&amp;&amp;) noexcept;
    template&lt;class F&gt; function(F&amp;&amp;);
    <ins>template&lt;auto f, class T&gt; function(nontype_t&lt;f&gt;, T&amp;&amp;);</ins>
</pre><blockquote>
<p><span>[…]</span></p>
</blockquote><p><span>Insert the following to </span><a href="https://eel.is/c++draft/func.wrap.func.general" target="_blank" rel="noopener"><span>[func.wrap.func.general]</span></a><span> after paragraph 3:</span></p><blockquote>
<p><span>The </span><code>function</code><span> class template is a call wrapper </span><a href="https://eel.is/c++draft/func.def" target="_blank" rel="noopener"><span>[func.def]</span></a><span> whose call signature </span><a href="https://eel.is/c++draft/func.def" target="_blank" rel="noopener"><span>[func.def]</span></a><span> is </span><code>R(ArgTypes...)</code><span>.</span></p>
<p><ins><span>Within this subclause, </span><em><code>call-args</code></em><span> is an argument pack with elements that have types </span><code>ArgTypes&amp;&amp;...</code><span> respectively.</span></ins></p>
</blockquote><p><span>Modify </span><a href="https://eel.is/c++draft/func.wrap.func#con" target="_blank" rel="noopener"><span>[func.wrap.func.con]</span></a><span> as indicated:</span></p><blockquote>
<p><span>[…]</span></p>
</blockquote><pre><code>function(nullptr_t) noexcept;
</code></pre><blockquote>
<p><em><span>Postconditions</span></em><span>: </span><code>!*this</code><span>.</span></p>
</blockquote><pre><ins>template&lt;auto f&gt; function(nontype_t&lt;f&gt;) noexcept;</ins>
</pre><blockquote>
<p><ins><em><span>Constraints</span></em><span>: </span><code>is_invocable_r_v&lt;R, decltype(f), ArgTypes...&gt;</code><span> is </span><code>true</code><span>.</span></ins></p>
<p><ins><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has a target object. Such an object and </span><code>f</code><span> are template-argument-equivalent </span><a href="https://eel.is/c++draft/temp.type" target="_blank" rel="noopener"><span>[temp.type]</span></a><span>.</span></ins></p>
<p><ins><em><span>Remarks</span></em><span>: The stored target object leaves no type identification </span><a href="https://eel.is/c++draft/expr.typeid" target="_blank" rel="noopener"><span>[expr.typeid]</span></a><span> in </span><code>*this</code><span>.</span></ins></p>
</blockquote><pre><code>template&lt;class F&gt; function(F&amp;&amp; f);
</code></pre><blockquote>
<p><span>Let </span><code>FD</code><span> be </span><code>decay_t&lt;F&gt;</code><span>.</span></p>
<p><em><span>Constraints</span></em><span>:</span></p>
<ul>
<li><code>is_same_v&lt;remove_cvref_t&lt;F&gt;, function&gt;</code><span> is </span><code>false</code><span>, and</span></li>
<li><code>FD</code><span> is Lvalue-Callable </span><a href="https://eel.is/c++draft/func.wrap.func" target="_blank" rel="noopener"><span>[func.wrap.func]</span></a><span> for argument types </span><code>ArgTypes...</code><span> and return type </span><code>R</code><span>.</span></li>
</ul>
<p><em><span>Mandates</span></em><span>:</span></p>
<ul>
<li><code>is_copy_constructible_v&lt;FD&gt;</code><span> is </span><code>true</code><span>, and</span></li>
<li><code>is_constructible_v&lt;FD, F&gt;</code><span> is </span><code>true</code><span>.</span></li>
</ul>
<p><em><span>Preconditions</span></em><span>: </span><code>FD</code><span> meets the </span><em><span>Cpp17CopyConstructible</span></em><span> requirements.</span></p>
<p><em><span>Postconditions</span></em><span>: </span><code>!*this</code><span> is </span><code>true</code><span> if any of the following hold:</span></p>
<ul>
<li><code>f</code><span> is a null function pointer value.</span></li>
<li><code>f</code><span> is a null member pointer value.</span></li>
<li><code>remove_cvref_t&lt;F&gt;</code><span> is a specialization of the </span><code>function</code><span> class template, and </span><code>!f</code><span> is </span><code>true</code><span>.</span></li>
</ul>
<p><span>Otherwise, </span><code>*this</code><span> has a target object of type </span><code>FD</code><span> direct-non-list-initialized with </span><code>std::forward&lt;F&gt;(f)</code><span>.</span></p>
<p><em><span>Throws</span></em><span>: Nothing if </span><code>FD</code><span> is a specialization of </span><code>reference_wrapper</code><span> or a function pointer type. Otherwise, may throw </span><code>bad_alloc</code><span> or any exception thrown by the initialization of the target object.</span></p>
<p><em><span>Recommended practice</span></em><span>: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where </span><code>f</code><span> refers to an object holding only a pointer or reference to an object and a member function pointer.</span></p>
</blockquote><pre><ins>template&lt;auto f, class T&gt; function(nontype_t&lt;f&gt;, T&amp;&amp; x);</ins>
</pre><blockquote data-original-title="" title="">
<p><ins><span>Let </span><code>D</code><span> be </span><code>decay_t&lt;T&gt;</code><span>.</span></ins></p>
<p><ins><em><span>Constraints</span></em><span>: </span><code>is_invocable_r_v&lt;R, decltype(f), D&amp;, ArgTypes...&gt;</code><span> is </span><code>true</code><span>.</span></ins></p>
<p><ins><em><span>Mandates</span></em><span>:</span></ins></p>
<ul>
<li><ins><code>is_copy_constructible_v&lt;D&gt;</code><span> is </span><code>true</code><span>, and</span></ins></li>
<li><ins><code>is_constructible_v&lt;D, T&gt;</code><span> is </span><code>true</code><span>.</span></ins></li>
</ul>
<p><ins><em><span>Preconditions</span></em><span>: </span><code>D</code><span> meets the </span><em><span>Cpp17CopyConstructible</span></em><span> requirements.</span></ins></p>
<p><ins><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has a target object </span><code>d</code><span> of type </span><code>D</code><span> direct-non-list-initialized with </span><code>std::forward&lt;T&gt;(x)</code><span>. </span><code>d</code><span> is hypothetically usable in a call expression, where </span><code><span>d(</span><em><span>call-args...</span></em><span>)</span></code><span> is expression equivalent to </span><code><span>invoke(f, d, </span><em><span>call-args...</span></em><span>)</span></code></ins></p>
<p><ins><em><span>Throws</span></em><span>: Nothing if </span><code>D</code><span> is a specialization of </span><code>reference_wrapper</code><span> or a pointer type. Otherwise, may throw </span><code>bad_alloc</code><span> or any exception thrown by the initialization of the target object.</span></ins></p>
<p><ins><em><span>Recommended practice</span></em><span>: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where </span><code>f</code><span> refers to an object holding only a pointer or reference to an object.</span></ins></p>
<p><span>[…]</span></p>
</blockquote><pre><code>R operator()(ArgTypes... args) const;
</code></pre><blockquote>
<p><em><span>Returns</span></em><span>: </span><code><em><span>INVOKE</span></em><span>&lt;R&gt;(f, std::forward&lt;ArgTypes&gt;(args)...)</span></code><span> </span><a href="https://eel.is/c++draft/func.require" target="_blank" rel="noopener"><span>[func.require]</span></a><span>, where </span><code>f</code><span> is the target object </span><a href="https://eel.is/c++draft/func.def" target="_blank" rel="noopener"><span>[func.def]</span></a><span> of </span><code>*this</code><span>.</span></p>
<p><em><span>Throws</span></em><span>: </span><code>bad_function_call</code><span> if </span><code>!*this</code><span>; otherwise, any exception thrown by the target object.</span></p>
</blockquote><p><span>Modify </span><a href="https://eel.is/c++draft/func.wrap.func#targ" target="_blank" rel="noopener"><span>[func.wrap.func.targ]</span></a><span> as indicated:</span></p><pre><code>const type_info&amp; target_type() const noexcept;
</code></pre><blockquote>
<p><em><span>Returns</span></em><span>: If </span><code>*this</code><span> has a target of type </span><code>T</code><span> </span><ins><span>and the target did not waive its type identification in </span><code>*this</code></ins><span>, </span><code>typeid(T)</code><span>; otherwise, </span><code>typeid(void)</code><span>.</span></p>
</blockquote><pre data-original-title="" title=""><code>template&lt;class T&gt;       T* target() noexcept;
template&lt;class T&gt; const T* target() const noexcept;
</code></pre><blockquote data-original-title="" title="">
<p><em><span>Returns</span></em><span>: If </span><code>target_type() == typeid(T)</code><span> a pointer to the stored function target; otherwise a null pointer.</span></p>
</blockquote><h3 id="Part-3" data-id="Part-3"><a class="anchor hidden-xs" href="#Part-3" title="Part-3"><span class="octicon octicon-link"></span></a><span>Part 3.</span></h3><p><span>Add new signatures to </span><a href="https://eel.is/c++draft/func.wrap.move.class" target="_blank" rel="noopener"><span>[func.wrap.move.class]</span></a><span> synopsis:</span></p><blockquote>
<p><span>[…]</span></p>
</blockquote><pre>  template&lt;class R, class... ArgTypes&gt;
  class move_only_function&lt;R(ArgTypes...) <i>cv ref</i> noexcept(<i>noex</i>)&gt; {
  public:
    using result_type = R;

    <i>// [func.wrap.move.ctor], constructors, assignment, and destructor</i>
    move_only_function() noexcept;
    move_only_function(nullptr_t) noexcept;
    move_only_function(move_only_function&amp;&amp;) noexcept;
    <ins>template&lt;auto f&gt; move_only_function(nontype_t&lt;f&gt;) noexcept;</ins>
    template&lt;class F&gt; move_only_function(F&amp;&amp;);
    <ins>template&lt;auto f, class T&gt; move_only_function(nontype_t&lt;f&gt;, T&amp;&amp;);</ins>
    template&lt;class T, class... Args&gt;
      explicit move_only_function(in_place_type_t&lt;T&gt;, Args&amp;&amp;...);
    <ins>template&lt;auto f, class T, class... Args&gt;
      explicit move_only_function(
        nontype_t&lt;f&gt;,
        in_place_type_t&lt;T&gt;,
        Args&amp;&amp;...);</ins>
    template&lt;class T, class U, class... Args&gt;
      explicit move_only_function(in_place_type_t&lt;T&gt;, initializer_list&lt;U&gt;, Args&amp;&amp;...);
    <ins>template&lt;auto f, class T, class U, class... Args&gt;
      explicit move_only_function(
        nontype_t&lt;f&gt;,
        in_place_type_t&lt;T&gt;,
        initializer_list&lt;U&gt;,
        Args&amp;&amp;...);</ins>

    move_only_function&amp; operator=(move_only_function&amp;&amp;);
    move_only_function&amp; operator=(nullptr_t) noexcept;
    template&lt;class F&gt; move_only_function&amp; operator=(F&amp;&amp;);

    ~move_only_function();

    <i>// [func.wrap.move.inv], invocation</i>
    explicit operator bool() const noexcept;
    R operator()(ArgTypes...) <i>cv ref</i> noexcept(<i>noex</i>);

    <i>// [func.wrap.move.util], utility</i>
    void swap(move_only_function&amp;) noexcept;
    friend void swap(move_only_function&amp;, move_only_function&amp;) noexcept;
    friend bool operator==(const move_only_function&amp;, nullptr_t) noexcept;

  private:
    <ins>template&lt;class... T&gt;
      static constexpr bool <i>is-invocable-using</i> = <i>see below</i>;     <i>// exposition only</i></ins>
    template&lt;class VT&gt;
      static constexpr bool <i>is-callable-from</i> = <i>see below</i>;       <i>// exposition only</i>
    <ins>template&lt;auto f, class T&gt;
      static constexpr bool <i>is-callable-as-if-from</i> = <i>see below</i>; <i>// exposition only</i></ins>
  };
}
</pre><p><span>Insert the following to </span><a href="https://eel.is/c++draft/func.wrap.move.class" target="_blank" rel="noopener"><span>[func.wrap.move.class]</span></a><span> after paragraph 1:</span></p><blockquote>
<p><span>[…] These wrappers can store, move, and call arbitrary callable objects, given a call signature.</span></p>
<p><ins><span>Within this subclause, </span><em><code>call-args</code></em><span> is an argument pack with elements that have types </span><code>ArgTypes&amp;&amp;...</code><span> respectively.</span></ins></p>
</blockquote><p><span>Modify </span><a href="https://eel.is/c++draft/func.wrap.move.ctor" target="_blank" rel="noopener"><span>[func.wrap.move.ctor]</span></a><span> as indicated:</span></p><pre><ins>template&lt;class... T&gt;
  static constexpr bool <i>is-invocable-using</i> = <i>see below</i>;
</ins></pre><blockquote data-original-title="" title="">
<p><ins><span>If </span><em><span>noex</span></em><span> is true, </span><code><i><span>is-invocable-using</span></i><span>&lt;T...&gt;</span></code><span> is equal to:</span></ins></p>
<p><ins><span>&nbsp;&nbsp;</span><code>is_nothrow_invocable_r_v&lt;R, T..., ArgTypes...&gt;</code></ins></p>
<p><ins><span>Otherwise, </span><code><i><span>is-invocable-using</span></i><span>&lt;T...&gt;</span></code><span> is equal to:</span></ins></p>
<p><ins><span>&nbsp;&nbsp;</span><code>is_invocable_r_v&lt;R, T..., ArgTypes...&gt;</code></ins></p>
</blockquote><pre>template&lt;class VT&gt;
  static constexpr bool <i>is-callable-from</i> = <i>see below</i>;
</pre><blockquote data-original-title="" title="">
<p><s><span>If </span><em><span>noex</span></em><span> is true, </span><code><i><span>is-callable-from</span></i><span>&lt;VT&gt;</span></code><span> is equal to:</span></s></p>
<p><s><span>&nbsp;&nbsp;</span><code><span>is_nothrow_invocable_r_v&lt;R, VT </span><i><span>cv ref</span></i><span>, ArgTypes…&gt; &amp;&amp;</span></code></s><br>
<s><span>&nbsp;&nbsp;</span><code><span>is_nothrow_invocable_r_v&lt;R, VT </span><i><span>inv-quals</span></i><span>, ArgTypes…&gt;</span></code></s></p>
<p><s><span>Otherwise, &nbsp;</span></s><code><i><span>is-callable-from</span></i><span>&lt;VT&gt;</span></code><span> is equal to:</span></p>
<p><ins><span>&nbsp;&nbsp;</span><code><i><span>is-invocable-using</span></i><span>&lt;VT </span><i><span>cv ref</span></i><span>&gt; &amp;&amp;</span></code></ins><br>
<ins><span>&nbsp;&nbsp;</span><code><i><span>is-invocable-using</span></i><span>&lt;VT </span><i><span>inv-quals</span></i><span>&gt;</span></code></ins><br>
<s><span>&nbsp;&nbsp;</span><code><span>is_invocable_r_v&lt;R, VT </span><i><span>cv ref</span></i><span>, ArgTypes…&gt; &amp;&amp;</span></code></s><br>
<s><span>&nbsp;&nbsp;</span><code><span>is_invocable_r_v&lt;R, VT </span><i><span>inv-quals</span></i><span>, ArgTypes…&gt;</span></code></s></p>
</blockquote><pre><ins>template&lt;auto f, class T&gt;
  static constexpr bool <i>is-callable-as-if-from</i> = <i>see below</i>;
</ins></pre><blockquote>
<p><ins><i><span>is-callable-as-if-from</span></i><span>&lt;f, VT&gt;</span><span> is equal to:</span></ins></p>
<p><ins><span>&nbsp;&nbsp;</span><code><i><span>is-invocable-using</span></i><span>&lt;decltype(f), VT </span><i><span>inv-quals</span></i><span>&gt;</span></code></ins><br></p>
<p><span>[…]</span></p>
</blockquote><pre><ins>template&lt;auto f&gt; move_only_function(nontype_t&lt;f&gt;) noexcept;
</ins></pre><blockquote>
<p><ins><em><span>Constraints</span></em><span>: </span><code><i><span>is-invocable-using</span></i><span>&lt;decltype(f)&gt;</span></code><span> is </span><code>true</code><span>.</span></ins></p>
<p><ins><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has a target object. Such an object and </span><code>f</code><span> are template-argument-equivalent </span><a href="https://eel.is/c++draft/temp.type" target="_blank" rel="noopener"><span>[temp.type]</span></a><span>.</span></ins></p>
</blockquote><pre><code>template&lt;class F&gt; move_only_function(F&amp;&amp; f);
</code></pre><blockquote>
<p><span>Let </span><code>VT</code><span> be </span><code>decay_t&lt;F&gt;</code><span>.</span></p>
<p><em><span>Constraints</span></em><span>:</span></p>
<ul>
<li><code>remove_cvref_t&lt;F&gt;</code><span> is not the same type as </span><code>move_only_function</code><span>, and</span></li>
<li><code>remove_cvref_t&lt;F&gt;</code><span> is not a specialization of </span><code>in_place_type_t</code><span>, and</span></li>
<li><code><i><span>is-callable-from</span></i><span>&lt;VT&gt;</span></code><span> is </span><code>true</code><span>.</span></li>
</ul>
<p><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;VT, F&gt;</code><span> is </span><code>true</code><span>.</span></p>
<p><em><span>Preconditions</span></em><span>: </span><code>VT</code><span> meets the </span><em><span>Cpp17Destructible</span></em><span> requirements, and if </span><code>is_move_constructible_v&lt;VT&gt;</code><span> is </span><code>true</code><span>, </span><code>VT</code><span> meets the </span><em><span>Cpp17MoveConstructible</span></em><span> requirements.</span></p>
<p><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has no target object if any of the following hold:</span></p>
<ul>
<li><code>f</code><span> is a null function pointer value, or</span></li>
<li><code>f</code><span> is a null member pointer value, or</span></li>
<li><code>remove_cvref_t&lt;F&gt;</code><span> is a specialization of the </span><code>move_only_function</code><span> class template, and </span><code>f</code><span> has no target object.</span></li>
</ul>
<p><span>Otherwise, </span><code>*this</code><span> has a target object of type </span><code>VT</code><span> direct-non-list-initialized with </span><code>std::forward&lt;F&gt;(f)</code><span>.</span></p>
<p><em><span>Throws</span></em><span>: Any exception thrown by the initialization of the target object. May throw </span><code>bad_alloc</code><span> unless </span><code>VT</code><span> is a function pointer or a specialization of </span><code>reference_wrapper</code><span>.</span></p>
</blockquote><pre><ins>template&lt;auto f, class T&gt; move_only_function(nontype_t&lt;f&gt;, T&amp;&amp; x);
</ins></pre><blockquote>
<p><ins><span>Let </span><code>VT</code><span> be </span><code>decay_t&lt;T&gt;</code><span>.</span></ins></p>
<p><ins><em><span>Constraints</span></em><span>: </span><code><i><span>is-callable-as-if-from</span></i><span>&lt;f, VT&gt;</span></code><span> is </span><code>true</code><span>.</span></ins></p>
<p><ins><em><span>Mandates</span></em><span>: </span><code>is_constructible_v&lt;VT, T&gt;</code><span> is </span><code>true</code><span>.</span></ins></p>
<p><ins><em><span>Preconditions</span></em><span>: </span><code>VT</code><span> meets the </span><em><span>Cpp17Destructible</span></em><span> requirements, and if </span><code>is_move_constructible_v&lt;VT&gt;</code><span> is </span><code>true</code><span>, </span><code>VT</code><span> meets the </span><em><span>Cpp17MoveConstructible</span></em><span> requirements.</span></ins></p>
<p><ins><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has a target object </span><code>d</code><span> of type </span><code>VT</code><span> direct-non-list-initialized with </span><code>std::forward&lt;T&gt;(x)</code><span>. </span><code>d</code><span> is hypothetically usable in a call expression, where </span><code><span>d(</span><em><span>call-args...</span></em><span>)</span></code><span> is expression equivalent to </span><code><span>invoke(f, d, </span><em><span>call-args...</span></em><span>)</span></code></ins></p>
<p><ins><em><span>Throws</span></em><span>: Any exception thrown by the initialization of the target object. May throw </span><code>bad_alloc</code><span> unless </span><code>VT</code><span> is a pointer or a specialization of </span><code>reference_wrapper</code><span>.</span></ins></p>
</blockquote><pre>template&lt;class T, class... Args&gt;
  explicit move_only_function(in_place_type_t&lt;T&gt;, Args&amp;&amp;... args);
<ins>template&lt;auto f, class T, class... Args&gt;
  explicit move_only_function(
    nontype_t&lt;f&gt;,
    in_place_type_t&lt;T&gt;,
    Args&amp;&amp;... args);
</ins></pre><blockquote>
<p><span>Let </span><code>VT</code><span> be </span><code>decay_t&lt;T&gt;</code><span>.</span></p>
<p><em><span>Constraints</span></em><span>:</span></p>
<ul>
<li><code>is_constructible_v&lt;VT, Args...&gt;</code><span> is </span><code>true</code><span>, and</span></li>
<li><code><i><span>is-callable-from</span></i><span>&lt;VT&gt;</span></code><span> is </span><code>true</code><span> </span><ins><span>for the first form or </span><code><i><span>is-callable-as-if-from</span></i><span>&lt;f, VT&gt;</span></code><span> is </span><code>true</code><span> for the second form</span></ins><span>.</span></li>
</ul>
<p><em><span>Mandates</span></em><span>: </span><code>VT</code><span> is the same type as </span><code>T</code><span>.</span></p>
<p><em><span>Preconditions</span></em><span>: </span><code>VT</code><span> meets the </span><em><span>Cpp17Destructible</span></em><span> requirements, and if </span><code>is_move_constructible_v&lt;VT&gt;</code><span> is </span><code>true</code><span>, </span><code>VT</code><span> meets the </span><em><span>Cpp17MoveConstructible</span></em><span> requirements.</span></p>
<p><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has a target object </span><ins><code>d</code></ins><span> of type </span><code>VT</code><span> direct-non-list-initialized with </span><code>std::forward&lt;Args&gt;(args)...</code><span>. </span><ins><span>With the second form, </span><code>d</code><span> is hypothetically usable in a call expression, where </span><code><span>d(</span><em><span>call-args…</span></em><span>)</span></code><span> is expression equivalent to </span><code><span>invoke(f, d, </span><em><span>call-args…</span></em><span>)</span></code></ins></p>
<p><em><span>Throws</span></em><span>: Any exception thrown by the initialization of the target object. May throw </span><code>bad_alloc</code><span> unless </span><code>VT</code><span> is a </span><s><span>function</span></s><span> pointer or a specialization of </span><code>reference_wrapper</code><span>.</span></p>
</blockquote><pre>template&lt;class T, class U, class... Args&gt;
  explicit move_only_function(in_place_type_t&lt;T&gt;, initializer_list&lt;U&gt; ilist, Args&amp;&amp;... args);
<ins>template&lt;auto f, class T, class U, class... Args&gt;
  explicit move_only_function(
    nontype_t&lt;f&gt;,
    in_place_type_t&lt;T&gt;,
    initializer_list&lt;U&gt; ilist,
    Args&amp;&amp;... args);
</ins></pre><blockquote>
<p><span>Let </span><code>VT</code><span> be </span><code>decay_t&lt;T&gt;</code><span>.</span></p>
<p><em><span>Constraints</span></em><span>:</span></p>
<ul>
<li><code>is_constructible_v&lt;VT, initializer_list&lt;U&gt;&amp;, Args...&gt;</code><span> is </span><code>true</code><span>, and</span></li>
<li><code><i><span>is-callable-from</span></i><span>&lt;VT&gt;</span></code><span> is </span><code>true</code><span> </span><ins><span>for the first form or</span><code><i><span>is-callable-as-if-from</span></i><span>&lt;f, VT&gt;</span></code><span> is </span><code>true</code><span> for the second form</span></ins><span>.</span></li>
</ul>
<p><em><span>Mandates</span></em><span>: </span><code>VT</code><span> is the same type as </span><code>T</code><span>.</span></p>
<p><em><span>Preconditions</span></em><span>: </span><code>VT</code><span> meets the </span><em><span>Cpp17Destructible</span></em><span> requirements, and if </span><code>is_move_constructible_v&lt;VT&gt;</code><span> is </span><code>true</code><span>, </span><code>VT</code><span> meets the </span><em><span>Cpp17MoveConstructible</span></em><span> requirements.</span></p>
<p><em><span>Postconditions</span></em><span>: </span><code>*this</code><span> has a target object </span><ins><code>d</code></ins><span> of type </span><code>VT</code><span> direct-non-list-initialized with </span><code>ilist, std::forward&lt;Args&gt;(args)...</code><span>. </span><ins><span>With the second form, </span><code>d</code><span> is hypothetically usable in a call expression, where </span><code><span>d(</span><em><span>call-args…</span></em><span>)</span></code><span> is expression equivalent to </span><code><span>invoke(f, d, </span><em><span>call-args…</span></em><span>)</span></code></ins></p>
<p><em><span>Throws</span></em><span>: Any exception thrown by the initialization of the target object. May throw </span><code>bad_alloc</code><span> unless </span><code>VT</code><span> is a </span><s><span>function</span></s><span> pointer or a specialization of </span><code>reference_wrapper</code><span>.</span></p>
<p><span>[…]</span></p>
</blockquote><pre>R operator()(ArgTypes... args) <i>cv ref</i> noexcept(<i>noex</i>);
</pre><blockquote>
<p><em><span>Preconditions</span></em><span>: </span><code>*this</code><span> has a target object.</span></p>
<p><em><span>Effects</span></em><span>: Equivalent to:</span></p>
<p><span>&nbsp;&nbsp;</span><code><span>return </span><em><span>INVOKE</span></em><span>&lt;R&gt;(static_cast&lt;F </span><em><span>inv-quals</span></em><span>&gt;(f), std::forward&lt;ArgTypes&gt;(args)...);</span></code></p>
<p><span>where </span><code>f</code><span> is an lvalue designating the target object of </span><code>*this</code><span> and </span><code>F</code><span> is the type of </span><code>f</code><span>.</span></p>
</blockquote><h3 id="Feature-test-macro" data-id="Feature-test-macro"><a class="anchor hidden-xs" href="#Feature-test-macro" title="Feature-test-macro"><span class="octicon octicon-link"></span></a><span>Feature test macro</span></h3><p><span>Insert </span><code>__cpp_lib_function</code><span> to </span><a href="https://eel.is/c++draft/version.syn" target="_blank" rel="noopener"><span>[version.syn]</span></a><span>, header </span><code>&lt;version&gt;</code><span> synopsis, and update </span><code>__cpp_lib_move_only_function</code><span> to the same value:</span></p><pre><ins>#define __cpp_lib_function           20XXXXL <i>// also in &lt;functional&gt;</i></ins>
#define __cpp_lib_move_only_function <s>202110L</s><ins>20XXXXL</ins> <i>// also in &lt;functional&gt;</i>
</pre><h2 id="Implementation-Experience" data-id="Implementation-Experience"><a class="anchor hidden-xs" href="#Implementation-Experience" title="Implementation-Experience"><span class="octicon octicon-link"></span></a><span>Implementation Experience</span></h2><p><a href="https://github.com/zhihaoy/nontype_functional/tree/v1.0.0" target="_blank" rel="noopener"><span>zhihaoy/nontype_functional@v1.0.0</span></a><span> implements </span><code>std::function</code><span>, </span><code>std::move_only_function</code><span>, and </span><code>function_ref</code><span> with the </span><code>nontype_t&lt;V&gt;</code><span> constructors.</span></p><p><span>The author plans to conduct experimental changes in major standard library implementations.</span></p><h2 id="Acknowledgments" data-id="Acknowledgments"><a class="anchor hidden-xs" href="#Acknowledgments" title="Acknowledgments"><span class="octicon octicon-link"></span></a><span>Acknowledgments</span></h2><p><span>Thank Ryan McDougall and Tomasz Kamiński for providing valuable feedback to the paper.</span></p><h2 id="References" data-id="References"><a class="anchor hidden-xs" href="#References" title="References"><span class="octicon octicon-link"></span></a><span>References</span></h2><hr class="footnotes-sep"><section class="footnotes">
<ol class="footnotes-list">
<li id="fn1" class="footnote-item"><p><span>Ažman, Gašper. P2445R1 </span><em><span>std::forward_like</span></em><span>. </span><a href="http://wg21.link/p2445r1" target="_blank" rel="noopener"><span>http://wg21.link/p2445r1</span></a> <a href="#fnref1" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn2" class="footnote-item"><p><span>Ažman et al. P0847R7 </span><em><span>Deducing this</span></em><span>. </span><a href="http://wg21.link/p0847r7" target="_blank" rel="noopener"><span>http://wg21.link/p0847r7</span></a> <a href="#fnref2" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn3" class="footnote-item"><p><span>Romeo, et al. P0792R10 </span><em><span>function_ref: a type-erased callable reference</span></em><span>. </span><a href="http://wg21.link/p0792r10" target="_blank" rel="noopener"><span>http://wg21.link/p0792r10</span></a> <a href="#fnref3" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn4" class="footnote-item"><p><span>Smith, Richard. P0945R0 </span><em><span>Generalizing alias declarations</span></em><span>. </span><a href="http://wg21.link/p0945r0" target="_blank" rel="noopener"><span>http://wg21.link/p0945r0</span></a> <a href="#fnref4" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn5" class="footnote-item"><p><span>Siek, Jeremy. N2098 </span><em><span>Scoped Concept Maps</span></em><span>. </span><a href="http://wg21.link/n2098" target="_blank" rel="noopener"><span>http://wg21.link/n2098</span></a> <a href="#fnref5" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn6" class="footnote-item"><p><span>Revzin, Barry. </span><em><span>Why were abbrev. lambdas rejected?</span></em><span> </span><a href="https://brevzin.github.io/c++/2020/01/15/abbrev-lambdas/" target="_blank" rel="noopener"><span>https://brevzin.github.io/c++/2020/01/15/abbrev-lambdas/</span></a> <a href="#fnref6" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn7" class="footnote-item"><p><span>Goetz, Brian. </span><em><span>Translation of Lambda Expressions .</span></em><span> </span><a href="https://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html" target="_blank" rel="noopener"><span>https://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html</span></a> <a href="#fnref7" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn8" class="footnote-item"><p><span>Sutton, Andrew. P0119R2 </span><em><span>Overload sets as function arguments.</span></em><span> </span><a href="http://wg21.link/p0119r2" target="_blank" rel="noopener"><span>http://wg21.link/p0119r2</span></a> <a href="#fnref8" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn9" class="footnote-item"><p><span>Hickey, Rich. </span><em><span>Callbacks in C++ Using Template Functors</span></em><span>. </span><a href="http://www.tutok.sk/fastgl/callback.html" target="_blank" rel="noopener"><span>http://www.tutok.sk/fastgl/callback.html</span></a> <a href="#fnref9" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn10" class="footnote-item"><p><span>__closure. </span><em><span>Language Support for the RAD Studio Libraries (C++)</span></em><span>. </span><a href="https://docwiki.embarcadero.com/RADStudio/Sydney/en/Closure" target="_blank" rel="noopener"><span>https://docwiki.embarcadero.com/RADStudio/Sydney/en/Closure</span></a> <a href="#fnref10" class="footnote-backref">↩︎</a></p>
</li>
<li id="fn11" class="footnote-item"><p><span>Waterloo, J.J. P2472R1 </span><em><span>make function_ref more functional</span></em><span>. </span><a href="http://wg21.link/p2472r1" target="_blank" rel="noopener"><span>http://wg21.link/p2472r1</span></a> <a href="#fnref11" class="footnote-backref">↩︎</a></p>
</li>
</ol>
</section></div>
    <div class="ui-toc dropup unselectable hidden-print" style="display:none;">
        <div class="pull-right dropdown">
            <a id="tocLabel" class="ui-toc-label btn btn-default" data-toggle="dropdown" href="#" role="button" aria-haspopup="true" aria-expanded="false" title="Table of content">
                <i class="fa fa-bars"></i>
            </a>
            <ul id="ui-toc" class="ui-toc-dropdown dropdown-menu" aria-labelledby="tocLabel">
                <div class="toc"><ul class="nav">
<li class=""><a href="#Beyond-operator-NTTP-callables-in-type-erased-call-wrappers" title="Beyond operator(): NTTP callables in type-erased call wrappers">Beyond operator(): NTTP callables in type-erased call wrappers</a><ul class="nav">
<li class=""><a href="#Changes-Since-R1" title="Changes Since R1">Changes Since R1</a></li>
<li><a href="#Changes-Since-R0" title="Changes Since R0">Changes Since R0</a></li>
<li class=""><a href="#Introduction" title="Introduction">Introduction</a></li>
<li class=""><a href="#Motivation" title="Motivation">Motivation</a></li>
<li class=""><a href="#Analysis" title="Analysis">Analysis</a><ul class="nav">
<li class=""><a href="#Why-don’t-people-make-their-classes-callable" title="Why don’t people make their classes callable?">Why don’t people make their classes callable?</a></li>
<li class=""><a href="#Can-we-do-this-with-wrapping" title="Can we do this with wrapping?">Can we do this with wrapping?</a></li>
<li class=""><a href="#Why-the-ask-has-to-have-something-to-do-with-type-erasure" title="Why the ask has to have something to do with type-erasure?">Why the ask has to have something to do with type-erasure?</a></li>
</ul>
</li>
<li class=""><a href="#Proposal" title="Proposal">Proposal</a></li>
<li class=""><a href="#Discussion" title="Discussion">Discussion</a><ul class="nav">
<li class=""><a href="#How-do-other-programming-languages-solve-this-problem" title="How do other programming languages solve this problem?">How do other programming languages solve this problem?</a></li>
<li><a href="#Why-this-proposal-is-different-from-delegates-and-other-solutions" title="Why this proposal is different from delegates and other solutions?">Why this proposal is different from delegates and other solutions?</a></li>
<li><a href="#Should-we-add-those-constructors-to-all-type-erased-call-wrappers" title="Should we add those constructors to all type-erased call wrappers?">Should we add those constructors to all type-erased call wrappers?</a></li>
<li><a href="#Should-type-passing-call-wrappers-support-NTTP-callables" title="Should type-passing call wrappers support NTTP callables?">Should type-passing call wrappers support NTTP callables?</a></li>
<li><a href="#Should-nontype_t-itself-be-callable" title="Should nontype_t itself be callable?">Should nontype_t itself be callable?</a></li>
<li><a href="#Can-some-form-of-lambda-solve-the-problem" title="Can some form of lambda solve the problem?">Can some form of lambda solve the problem?</a></li>
</ul>
</li>
<li><a href="#Prior-Art" title="Prior Art">Prior Art</a></li>
<li><a href="#Wording" title="Wording">Wording</a><ul class="nav">
<li><a href="#Part-1" title="Part 1.">Part 1.</a></li>
<li><a href="#Part-2" title="Part 2.">Part 2.</a></li>
<li><a href="#Part-3" title="Part 3.">Part 3.</a></li>
<li><a href="#Feature-test-macro" title="Feature test macro">Feature test macro</a></li>
</ul>
</li>
<li><a href="#Implementation-Experience" title="Implementation Experience">Implementation Experience</a></li>
<li><a href="#Acknowledgments" title="Acknowledgments">Acknowledgments</a></li>
<li><a href="#References" title="References">References</a></li>
</ul>
</li>
</ul>
</div><div class="toc-menu"><a class="expand-toggle" href="#">Expand all</a><a class="back-to-top" href="#">Back to top</a><a class="go-to-bottom" href="#">Go to bottom</a></div>
            </ul>
        </div>
    </div>
    <div id="ui-toc-affix" class="ui-affix-toc ui-toc-dropdown unselectable hidden-print" data-spy="affix" style="top:17px;display:none;" null null>
        <div class="toc"><ul class="nav">
<li class=""><a href="#Beyond-operator-NTTP-callables-in-type-erased-call-wrappers" title="Beyond operator(): NTTP callables in type-erased call wrappers">Beyond operator(): NTTP callables in type-erased call wrappers</a><ul class="nav">
<li class=""><a href="#Changes-Since-R1" title="Changes Since R1">Changes Since R1</a></li>
<li><a href="#Changes-Since-R0" title="Changes Since R0">Changes Since R0</a></li>
<li class=""><a href="#Introduction" title="Introduction">Introduction</a></li>
<li class=""><a href="#Motivation" title="Motivation">Motivation</a></li>
<li class=""><a href="#Analysis" title="Analysis">Analysis</a><ul class="nav">
<li class=""><a href="#Why-don’t-people-make-their-classes-callable" title="Why don’t people make their classes callable?">Why don’t people make their classes callable?</a></li>
<li class=""><a href="#Can-we-do-this-with-wrapping" title="Can we do this with wrapping?">Can we do this with wrapping?</a></li>
<li class=""><a href="#Why-the-ask-has-to-have-something-to-do-with-type-erasure" title="Why the ask has to have something to do with type-erasure?">Why the ask has to have something to do with type-erasure?</a></li>
</ul>
</li>
<li class=""><a href="#Proposal" title="Proposal">Proposal</a></li>
<li class=""><a href="#Discussion" title="Discussion">Discussion</a><ul class="nav">
<li class=""><a href="#How-do-other-programming-languages-solve-this-problem" title="How do other programming languages solve this problem?">How do other programming languages solve this problem?</a></li>
<li><a href="#Why-this-proposal-is-different-from-delegates-and-other-solutions" title="Why this proposal is different from delegates and other solutions?">Why this proposal is different from delegates and other solutions?</a></li>
<li><a href="#Should-we-add-those-constructors-to-all-type-erased-call-wrappers" title="Should we add those constructors to all type-erased call wrappers?">Should we add those constructors to all type-erased call wrappers?</a></li>
<li><a href="#Should-type-passing-call-wrappers-support-NTTP-callables" title="Should type-passing call wrappers support NTTP callables?">Should type-passing call wrappers support NTTP callables?</a></li>
<li><a href="#Should-nontype_t-itself-be-callable" title="Should nontype_t itself be callable?">Should nontype_t itself be callable?</a></li>
<li><a href="#Can-some-form-of-lambda-solve-the-problem" title="Can some form of lambda solve the problem?">Can some form of lambda solve the problem?</a></li>
</ul>
</li>
<li><a href="#Prior-Art" title="Prior Art">Prior Art</a></li>
<li><a href="#Wording" title="Wording">Wording</a><ul class="nav">
<li><a href="#Part-1" title="Part 1.">Part 1.</a></li>
<li><a href="#Part-2" title="Part 2.">Part 2.</a></li>
<li><a href="#Part-3" title="Part 3.">Part 3.</a></li>
<li><a href="#Feature-test-macro" title="Feature test macro">Feature test macro</a></li>
</ul>
</li>
<li><a href="#Implementation-Experience" title="Implementation Experience">Implementation Experience</a></li>
<li><a href="#Acknowledgments" title="Acknowledgments">Acknowledgments</a></li>
<li><a href="#References" title="References">References</a></li>
</ul>
</li>
</ul>
</div><div class="toc-menu"><a class="expand-toggle" href="#">Expand all</a><a class="back-to-top" href="#">Back to top</a><a class="go-to-bottom" href="#">Go to bottom</a></div>
    </div>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js" integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8=" crossorigin="anonymous"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha256-U5ZEeKfGNOja007MMD3YBI0A3OSZOQbeG6z2f2Y0hu8=" crossorigin="anonymous" defer></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gist-embed/2.6.0/gist-embed.min.js" integrity="sha256-KyF2D6xPIJUW5sUDSs93vWyZm+1RzIpKCexxElmxl8g=" crossorigin="anonymous" defer></script>
    <script>
        var markdown = $(".markdown-body");
        //smooth all hash trigger scrolling
        function smoothHashScroll() {
            var hashElements = $("a[href^='#']").toArray();
            for (var i = 0; i < hashElements.length; i++) {
                var element = hashElements[i];
                var $element = $(element);
                var hash = element.hash;
                if (hash) {
                    $element.on('click', function (e) {
                        // store hash
                        var hash = this.hash;
                        if ($(hash).length <= 0) return;
                        // prevent default anchor click behavior
                        e.preventDefault();
                        // animate
                        $('body, html').stop(true, true).animate({
                            scrollTop: $(hash).offset().top
                        }, 100, "linear", function () {
                            // when done, add hash to url
                            // (default click behaviour)
                            window.location.hash = hash;
                        });
                    });
                }
            }
        }

        smoothHashScroll();
        var toc = $('.ui-toc');
        var tocAffix = $('.ui-affix-toc');
        var tocDropdown = $('.ui-toc-dropdown');
        //toc
        tocDropdown.click(function (e) {
            e.stopPropagation();
        });

        var enoughForAffixToc = true;

        function generateScrollspy() {
            $(document.body).scrollspy({
                target: ''
            });
            $(document.body).scrollspy('refresh');
            if (enoughForAffixToc) {
                toc.hide();
                tocAffix.show();
            } else {
                tocAffix.hide();
                toc.show();
            }
            $(document.body).scroll();
        }

        function windowResize() {
            //toc right
            var paddingRight = parseFloat(markdown.css('padding-right'));
            var right = ($(window).width() - (markdown.offset().left + markdown.outerWidth() - paddingRight));
            toc.css('right', right + 'px');
            //affix toc left
            var newbool;
            var rightMargin = (markdown.parent().outerWidth() - markdown.outerWidth()) / 2;
            //for ipad or wider device
            if (rightMargin >= 133) {
                newbool = true;
                var affixLeftMargin = (tocAffix.outerWidth() - tocAffix.width()) / 2;
                var left = markdown.offset().left + markdown.outerWidth() - affixLeftMargin;
                tocAffix.css('left', left + 'px');
            } else {
                newbool = false;
            }
            if (newbool != enoughForAffixToc) {
                enoughForAffixToc = newbool;
                generateScrollspy();
            }
        }
        $(window).resize(function () {
            windowResize();
        });
        $(document).ready(function () {
            windowResize();
            generateScrollspy();
        });

        //remove hash
        function removeHash() {
            window.location.hash = '';
        }

        var backtotop = $('.back-to-top');
        var gotobottom = $('.go-to-bottom');

        backtotop.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            if (scrollToTop)
                scrollToTop();
            removeHash();
        });
        gotobottom.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            if (scrollToBottom)
                scrollToBottom();
            removeHash();
        });

        var toggle = $('.expand-toggle');
        var tocExpand = false;

        checkExpandToggle();
        toggle.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            tocExpand = !tocExpand;
            checkExpandToggle();
        })

        function checkExpandToggle () {
            var toc = $('.ui-toc-dropdown .toc');
            var toggle = $('.expand-toggle');
            if (!tocExpand) {
                toc.removeClass('expand');
                toggle.text('Expand all');
            } else {
                toc.addClass('expand');
                toggle.text('Collapse all');
            }
        }

        function scrollToTop() {
            $('body, html').stop(true, true).animate({
                scrollTop: 0
            }, 100, "linear");
        }

        function scrollToBottom() {
            $('body, html').stop(true, true).animate({
                scrollTop: $(document.body)[0].scrollHeight
            }, 100, "linear");
        }
    </script>
</body>

</html>
