AW: [std-proposals] A new C++ keyword: forget

Hi Ville,

I am not convinced that spelling this as

std::redact(x);

is a good direction if redact is not actually a library entity.

static_assert does not seem like a particularly good analogy here. static_assert may syntactically resemble a function call, but static_assert is a keyword and the grammar explicitly recognizes a static-assert-declaration. There is no ambiguity about whether name lookup, overload resolution, taking its address, a using-declaration, etc. apply to it.

With std::redact(x), however, the spelling strongly suggests an ordinary qualified name referring to an entity in namespace std.

If it is instead recognized specially by the parser and changes core-language rules such as name lookup, reachability, or whether a later declaration is well-formed, then I think the syntax is somewhat misleading.

For example, what should these mean?

using std::redact;  auto p = &std::redact;  std::redact<int>;  namespace foo {     void redact(int&); }  foo::redact(x);   // ordinary function std::redact(x);   // core-language construct?

Presumably most or all of the first three would simply be invalid because std::redact is not actually a name denoting a function. But that is exactly what feels strange to me: it has the lexical appearance of a qualified library name while deliberately not obeying the normal rules associated with one.

The proposed operation also seems fundamentally core-language in nature. If

int x; redact x; ++x;       // ill-formed double x;  // perhaps also ill-formed

affects lookup, declaration matching, shadowing, and scope semantics, then I would expect the syntax to make that fact visible.

A keyword, or possibly a contextual keyword, seems more natural to me:

redact x;

or perhaps

redact(x);

where redact is explicitly part of the grammar.

A contextual keyword might also address the source-compatibility concern that motivated avoiding a new keyword in the first place, without making a core-language construct look like a standard-library function.

Best,
Connor

Ville Voutilainen via Std-Proposals <std-proposals@lists.isocpp.org> 于2026年8月12日周三 08:15写道：

On Wed, 12 Aug 2026 at 03:08, Marcin Jaczewski
<marcinjaczewski86@gmail.com> wrote:
> if this is `std::redact` this means its normal function as it can't be
> a keyword, right?

It's not a normal function. It's a language construct recognized by
the compiler. And despite
being spelled like a function, it can be a declaration, like static_assert is.

> This means it will need some tag to mark this behavior like:
> void redact([[redact]] auto& val) {}

No.

> class Foo
> {
> int i;
> void dispose() [[redact]]; //as it refer to `this`
> }
> int main()
> {
> Foo a;
> a.i = 1;
> a.dispose();
> //a..i = 2; //error
> }

Well.. the idea here is to redact names. Not objects. Now you're
entering a territory
where we need some sort of flow analysis.

> Another thing we could simply use:
> int a = 3;
> [[redact]] a;

If our construct is a declaration, you can just do

int a = 3;
std::redact(a);

regardless of what the scope of a is.
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals