› P2249R7 Mixed comparisons for smart pointers G. D'Angelo
2026-07-22
Doc Date
2026-07-22
Abstract
Smart pointer classes are universally recognized as the idiomatic way to express ownership of a resource (very incomplete list: [Sutter], [Meyers], [R.20]). On the other hand, raw pointers (and references) are supposed to be used as non-owning types to access a resource.
› P3100R8 A framework for systematically addressing undefined behaviour in the C++ Standard T. Doumler , J. Berne
2026-08-14
Doc Date
2026-08-14
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.
› P3139R2 Pointer cast for unique_ptr Z. Yuan , J. Saxonberg
2026-08-14
Doc Date
2026-08-14
Abstract
We propose `unique_ptr` overloads for `std::const_pointer_cast` and `std::dynamic_pointer_cast`. For each kind of cast, we allow users to choose between either using the defaulted deleter or preserving the original deleter type for each kind of cast.
› P3216R4 views::slice H. Kang
2026-07-27
Doc Date
2026-07-27
Abstract
This paper proposes the Tier 1 adaptor `views::slice` (as described in [P2760](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2760r1.html)) to enhance the C++29 ranges library. Notably, this is the first standard range adaptor that accepts two arguments — `start` and `end` — to specify the interval [`start`, `end`) for slicing a range.
› P3351R5 views::scan Y. Li
2026-08-12
Doc Date
2026-08-12
Abstract
The motivation for this view is given in [P2760R1] and quoted below for convenience:
› P3955R1 It's Scopes All the Way Down R. Leahy
2026-08-10
Doc Date
2026-08-10
Abstract
The fundamental scope algorithm is `within`. It establishes a scope by running an enter scope sender. Thereafter it allows a child operation to run (in that scope since the exit scope sender has not yet run), and then before completing the overall operation runs the exit scope sender yielded by the enter scope sender.
› P4049R1 Relaxing and extending std::copy G. D'Angelo
2026-07-30
Doc Date
2026-07-30
Abstract
In this table we’re summarizing the status quo and the changes brought by the options and extensions illustrated above. The table refers to `std::copy`, but similar changes are expected for the other algorithms of the family.
› P4282R1 Away From co_yield For std::execution::task R. Leahy
2026-08-02
Doc Date
2026-08-02
Abstract
The coroutine promise protocol shipped in C++20 not only banned `return_void` and `return_value` on the same promise type, but did so in an unusually restrictive manner [1]. Notably the aforementioned manner barred implementing the aforementioned mutual exclusion via mutually exclusive constraints.
› P4288R1 Stop the Decay R. Leahy
2026-07-31
Doc Date
2026-07-31
Abstract
`std::execution` can be thought of as the realization of the asynchronous analogue of a synchronous function [1][2]. The sender is the function itself (with all arguments selected and applied), the receiver is the channel by which the function communicates with its caller (in the synchronous realm by returning or throwing), and the operation state is the “stack” (i.e. a collection of variables wit
› P4294R1 views::take_last and views::drop_last H. Kang
2026-07-20
Doc Date
2026-07-20
Abstract
This paper proposes two new range adaptors, `views::take_last` and `views::drop_last`, that respectively produce the last *N* elements of a range and all-but-the-last *N* elements of a range. They mirror the shape of the existing `views::take` / `views::drop` adaptors and fill an obvious gap in the standard range adaptor set.
› P4311R1 Getting a const element type version of an mdspan accessor, and of an mdspan too M. Hoemmen , R. Parolin
2026-08-14
Doc Date
2026-08-14
Abstract
Given an accessor `a` of type `A`, a “const element type version of `a`” (if it exists) is an accessor `b` of a possibly different type `B`, where
› P4313R1 Bitmask operations for enums I. Guterman , A. Williams
2026-07-21
Doc Date
2026-07-21
Abstract
As a developer coming from languages other than C++, I grew accustomed to using enums to represent flags. However, such behavior is noticeably absent from the C++ language.
› P4329R0 variant_sender R. Leahy
2026-07-29
Doc Date
2026-07-29
Abstract
Under the status quo of the C++29 working draft one can write asynchronous code which branches synchronously:
› P4337R0 emplace_from R. Leahy
2026-08-03
Doc Date
2026-08-03
Abstract
Enabled by variadic templates and forwarding references, C++11 brought emplace construction. Containers, wrappers, et cetera could provide variadic constructors or functions which forwarded arguments through to a constructor of some wrapped or contained type thereby creating an instance of that type without intervening temporaries (which would be copied or moved from).
› P4338R0 deduce R. Leahy
2026-08-03
Doc Date
2026-08-03
Abstract
`emplace_from` is a proposed standard library class template which enables emplace functionality (e.g. `std::vector::emplace_back`, `std::optional::emplace`, et cetera) to be used to construct immovable types returned by factory functions (e.g. `std::execution::connect`).
