Hello all,
This is a floating idea intended to explore possible directions by extending the core language by (optionaly) reducing syntactic repetition in C++, not a concrete proposal.
Motivation
As C++ continues to evolve, functions increasingly accumulate multiple qualifiers (const, noexcept, constexpr, virtual, etc.). While each serves a clear purpose, the repeated spelling of identical qualifier sets across many member functions can make interfaces verbose and harder to read, especially for newcomers.
For example:

class A {
public:
  const int ​f() const noexcept;
  double g() const noexcept;
  void h() const noexcept;
};

The repetition here is mechanical rather than expressive.
Idea: qualifier grouping blocks
One possible direction would be to allow grouping of common qualifiers in a declaration block, with enclosed declarations implicitly inheriting them .
Illustrative syntax (purely hypothetical):

class A {
public const noexcept: // note: const is for the object const'nes
  const int f();
  double g();
  void h();
};

This would be equivalent to today’s spelling, but visually emphasizes what varies (the function names and signatures) rather than what does not.
Class-level qualifiers
A similar idea could apply at class scope for qualifiers like constexpr, when meaningful:

struct S constexpr {
  S();
  ~S();
  int f();
  int g();
};

Which would be equivalent to:

struct S {
  constexpr S();
  constexpr ~S();
  constexpr int f();
  constexpr int g();
};

This could be seen as analogous to how access specifiers already work at block scope.
Potential benefits

  * Reduces visual noise caused by repetitive qualifiers
  * Improves readability of interfaces with many similarly-qualified members
  * Makes class declarations less intimidating to newer developers
  * Encourages consistency (qualifiers are declared once, not copied)

Open questions / concerns

  * Which qualifiers would be eligible? (const, noexcept, constexpr, virtual, others?)
  * Interaction with overrides, ref-qualifiers, attributes, and trailing requires-clauses
  *
Parsing complexity
  * Whether this meaningfully improves clarity compared to existing verbosity
  * Risk of hiding important semantics “far away” from the function declaration

Prior art / comparison
This idea is conceptually similar to:

  *
Access specifier blocks (public:, private: or Qt signals:, slots:)
  * Attribute grouping in some other languages
  * Namespace-level defaults or pragmas

However, C++ traditionally favors explicitness at the declaration site, so this would represent a shift in style.
Intent
The goal is not to reduce expressiveness or weaken type safety, but to explore whether the language could offer a more approachable and readable way to express common patterns that already exist in practice.
I’m interested in feedback on whether this direction is worth exploring further, what pitfalls I may be missing, or whether similar ideas have already been discussed or rejected.
Thanks for your time.