› P0917R4 Making operator?: overloadable
Matthias Kretz
M. Kretz
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper proposes user-defined overloads of `operator?:`. In addition to normal function calls, `operator?:` can also be defaulted, in which case it simply defines a common type to use for the built-in conditional operator. To avoid a breaking change, user-defined overloads of `operator?:` are only considered when no built-in candidate is viable.
› P1219R3 Homogeneous variadic function parameters
Ian Pike
I. Pike
,
Eczbek
Eczbek
,
Jan Schultke
J. Schultke
,
James Touton
J. Touton
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
We propose homogeneous function parameter packs for C++29: a variable number of parameters of one declared type. One declaration replaces fixed-arity overload families, retaining ordinary parameter initialization, conversion ranking, and a compile-time count.
› P2034R10 Partially Mutable Lambda Captures
Ryan McDougall
R. McDougall
,
Lakshay Garg
L. Garg
2026-10-08
2026-10
Doc Date
2026-10-08
Abstract
`const` and `mutable` extend cleanly to lambda captures. The design is easy to implement, follows the language’s direction, and matches the common model of a lambda as shorthand for an object of a callable struct:
› P2970R1 Partial application of concepts in template arguments
Corentin Jabot
C. Jabot
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
Concept template parameters were introduced in C++26 by [P2841R7](https://wg21.link/P2841R7) [3]. We propose to extend this feature with partially applied concepts. This feature was introduced in [P2841R0](https://wg21.link/P2841R0) [1] and removed in R1 to reduce the scope of the initial paper, and because [EWG initially found](https://github.com/cplusplus/papers/issues/1546#issuecomment-15874016
› P2989R3 A Simple Approach to Universal Template Parameters
Corentin Jabot
C. Jabot
,
Gašper Ažman
G. Ažman
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
In [P1985R3](https://wg21.link/P1985R3) [3], we explore universal template parameters (a template parameter that can be a type, non-type, or template name). We proposed allowing the use of universal template parameters in all contexts, which would have added a large amount of complexity to both the specification and implementations for limited benefits. In this paper, we propose a much simpler sub
› P3100R9 A framework for systematically addressing undefined behaviour in the C++ Standard
Timur Doumler
T. Doumler
,
Joshua Berne
J. Berne
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
In this paper, we enumerate all cases of core language undefined behaviour explicitly specified in the C++ Standard, group them into ten categories, and classify them along a number of relevant criteria.
› P3400R5 Controlling Contract-Assertion Properties
Joshua Berne
J. Berne
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
C++26 Contracts, adopted with [P2900R14], provides a framework for specifying and checking contract assertions whose behavior is controlled through implementation-defined build configurations. This paper introduces *assertion-control* *objects* — compile-time objects, composed from `constexpr` *labels*, that let developers customize contract-assertion behavior directly in C++ source code. Labels p
› P3412R4 String Interpolation
Bengt Gustafsson
B. Gustafsson
,
Victor Zverovich
V. Zverovich
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
In contrast with P3951 this proposal includes a way that f-literals are converted to some kind of string by calling a `__format__` function under certain conditions. The motivation for this is mainly that it is what users expect and that it is convenient.
› P3549R1 Diverging expressions
Barry Revzin
B. Revzin
,
Michael Park
M. Park
,
Zach Laine
Z. Laine
,
Bruno Cardoso Lopes
B. Lopes
2026-10-18
2026-10
Doc Date
2026-10-18
Abstract
One pattern that will occur with some regularity with pattern matching [[P2688R6] (Pattern Matching with `match` and `case`)](https://wg21.link/p2688r6) (and [[P2806R5] (do expressions)](https://wg21.link/p2806r5)) is the desire to produce values for some patterns but not for all. Consider the following simplified example:
› P3704R1 What are profiles?
Bjarne Stroustrup
B. Stroustrup
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
The aim of this note is to give a brief explanation of what Profiles are and what problems they aim to address. It also tries to dispel some myths about the scope of Profiles and give an idea of the current state of implementation.
› P3816R4 Hashing meta::info
Matt Cummins
M. Cummins
,
Valentyn Yukhymenko
V. Yukhymenko
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper proposes a new standard library template, `consteval_hash<T>`, with a single specialization for `meta::info`. The purpose of this facility is to provide a standard interface for compile-time hashing, thereby allowing unordered containers such as `unordered_map` and `unordered_set` to be used with `meta::info` keys, and potentially with other types in the future.
› P3817R1 Structured Binding Assignments
Yehonatan Simian yonisimian@gmail.com
Y. yonisimian@gmail.com
,
Ran Regev regev.ran@gmail.com
R. regev.ran@gmail.com
2026-10-18
2026-10
Doc Date
2026-10-18
Abstract
This proposal introduces an extension to C++ structured bindings, allowing assignment to existing variables.
› P3963R1 Assignable lambdas with capture
Ruslan Arutyunyan
R. Arutyunyan
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper proposes making lambdas with captures copy assignable and move assignable when all captured entities are themselves copy/move assignable respectively.
› P4222R3 An initialization profile
Bjarne Stroustrup
B. Stroustrup
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This note emphasizes the rationale of the initialization profile, considers a few alternatives, and suggests simplifications. Implementations exist and are tested nightly [Impl1, Impl2].
› P4235R1 Removing Digraphs
Matthias Wippich
M. Wippich
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
Digraphs are a complicated solution to a very old problem, which cause more problems than they solve in a modern environment. Digraphs also severely limit the design space of C++, although as we have seen with [[P2996]](https://www%2eopen-std%2eorg/jtc1/sc22/wg21/docs/papers/2025/p2996r13%2ehtml) we are already fine with special-casing our way out of this pickle.
› P4277R1 Overview and Implementation Report for P3100
Joshua Berne
J. Berne
2026-10-23
2026-10
› P4307R1 An Infix Operator and a Keyword Escape for C++
Steve Downey
S. Downey
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
C++ reserves non-strict evaluation to a fixed set of built-ins: ‘&&‘, ‘||‘ and ‘?:‘. The comma operator is the near neighbor, and is not one of them: it evaluates both of its operands, and what it fixes is the **sequencing**. Overloading does not get non-strict evaluation back: an overloaded ‘operator&&‘ evaluates both operands, which is the trap everyone has been bitten by, and the reason the sta
› P4345R1 Extending C++ with Unicode Mathematical Operators
Steve Downey
S. Downey
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
I propose adding the ability to declare user defined operators, such as operator⊞, allowing users to write `a` `⊞` `b`. The list of allowed operators is drawn from the mathematical operators described in Unicode Technical Report #25, *Unicode* *Support* *for* *Mathematics* (Beeton, Freytag, and Sargent III 2017), with confusables removed. [The operators are otherwise normal functions, found by ord
› P4380R1 Token Sequence Injection
Barry Revzin
B. Revzin
,
Daveed Vandevoorde
D. Vandevoorde
,
Andrei Alexandrescu
A. Alexandrescu
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This is a follow-up to [[P3294R2] (Code Injection with Token Sequences)](https://wg21.link/p3294r2). In that paper, we argued that the right model for code generation in C++ is through token sequences by comparing to other potential models. In short, we believe that code generation in C++ must be C++-shaped, must be able to generate all of C++, and must allow for the full use of C++ in that genera
› P4414R0 Structural classes: a bugfix for reflection
Ville Voutilainen
V. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This proposal allows encapsulated types, including `string_view` and `span`, to be used with `define_static_array`, and to be conveyed from compile-time code to run-time code.
› P4415R0 Profiles: implementation status and experience
Michael Wong
M. Wong
,
Krystian Stasiowski ; Ville Voutilainen
K. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
Profiles now have two independent implementations. Krystian Stasiowski's Clang implements the P3589R2 framework, except <ins>[[profiles::exempt]]</ins>, and most of the P4222R2 initialization profile <ins>std::init</ins>. Ville Voutilainen's GCC implements the framework, <ins>std::init, and the first working invalidation profile, std::invalidation</ins>, on the design of P3446R0 with the default-d
› P4418R0 An invalidation Profile
Bjarne Stroustrup
B. Stroustrup
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
Memory safety has been a popular topic over the last few years. It is a subset of type-and-resource safety which has been my ideal for C++ since its inception and for which the general solution for C++ was outlined in [BS’15, HS’15, BS’21]. This paper describes the enforcement part of the solution that relates to prevention of dangling pointers and its rationale.
› P4422R0 Function Summaries for Scaling Code Analysis of C++
Gabriel Dos Reis
G. Reis
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
Profiles [P3589R3] are to be enforced by local static analysis [P3274R0]: one translation unit at a time, and within it one function at a time. At a call to a function defined elsewhere, such an analysis has only the callee's declaration. The declaration says little about what the callee writes, and nothing about what it retains, releases or invalidates. The analysis gives the same verdict for eve
› P4423R0 Strict contracts: conveyor functions and conveyor predicates
Ville Voutilainen
V. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper presents the design and an implementation of strict contracts: contract predicates that are guaranteed by the compiler to be free of side effects and of undefined behavior. It builds on the conveyor functions of [P2680](https://wg21.link/p2680) and [P3285](https://wg21.link/p3285), and expresses strictness through the control objects of [P4324](https://wg21.link/p4324), of which this pa
› P4424R0 [[indeterminate]] for non-static data members
Barry Revzin
B. Revzin
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
[[P2795R5] (Erroneous behaviour for uninitialized reads)](https://wg21.link/p2795r5) was adopted for C++26 and implemented in gcc 16. In practice, it ensures that automatic storage duration variables are initialized unless they are marked `[[indeterminate]]` — both [gcc](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#index-ftrivial-auto-var-init) and [clang](https://clang.llvm.org/docs/C
› P4425R0 Symbolic contracts
Ville Voutilainen
V. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper describes the design and an implementation exploration for *symbolic contracts*: contract assertions whose predicate has, by default, no run-time representation at all, and whose truth is instead established and consumed purely by the compiler's own static reasoning about the program. We explain what a symbolic function is, the escape hatch for predicates that are known to be unprovable
› P4426R0 Contracts for (member) function pointers
Ville Voutilainen
V. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper supplies a design and implementation exploration for contracts on function pointers and member function pointers.
› P4427R0 Configurable contracts for virtual functions
Ville Voutilainen
V. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
This paper supplies a design and implementation exploration for configurable contracts on virtual functions.
› P4428R0 Contract concerns and where they are addressed
Ville Voutilainen
V. Voutilainen
2026-10-23
2026-10
Doc Date
2026-10-23
Abstract
Several concerns have been raised about the C++26 contracts facility, [P2900](https://wg21.link/p2900), most compactly in [P3173R0](https://wg21.link/p3173r0), "P2900R6 May Be Minimal, but It Is Not Viable": that it doesn't prioritize safety, that the evaluation of a contract assertion can have undefined behavior, that it doesn't support virtual functions and function pointers, and that it isn't a
› P4433R0 Do not remove Contracts from C++26
Timur Doumler
T. Doumler
,
Joshua Berne
J. Berne
,
Gašper Ažman
G. Ažman
,
Peter Bindels
P. Bindels
,
Peter Dimov
P. Dimov
,
Eric Fiselier
E. Fiselier
,
Fabio Fracassi
F. Fracassi
,
Pablo Halpern
P. Halpern
,
Tom Honermann
T. Honermann
,
John Lakos
J. Lakos
,
Nevin Liber
N. Liber
,
Lisa Lippincott
L. Lippincott
,
René Ferdinand Rivera Morell
R. Morell
,
Oliver Rosten
O. Rosten
,
Jan Schultke
J. Schultke
,
Hui Xie
H. Xie
2026-10-23
2026-10
Doc Date
2026-10-23
Author(s)
Timur Doumler , Joshua Berne , Gašper Ažman , Peter Bindels , Peter Dimov , Eric Fiselier , Fabio Fracassi , Pablo Halpern , Tom Honermann , John Lakos , Nevin Liber , Lisa Lippincott , René Ferdinand Rivera Morell , Oliver Rosten , Jan Schultke , Hui Xie
Abstract
In addition, the description of C++26 contract assertions given in [[P4334R0](http://wg21.link/p4334r0)] contains a number of inaccuracies. It misrepresents the specification itself,3 the amount of wording it consists of,4 its design intent,5 how it relates to hardening6 and static analysis,7 its existing implementations,8 existing practice,9 teachability,10 and proposed extensions.11 None of the
