_ is probably a good choice as a placeholder but maybe it’s unnecessary inside using block. Since the only functions are methods of class.
So maybe it wouldn’t be better to add class keyword to indicate that better.

using class A {
  foo();
  bar();
};

This then looks as if it’s a use inside of the class member function.

Could be expanded to something that OP has stated:
void foo(A a, B b) using class A, B {
  foo();
  bar();
}

The error here would be to write something like that if the classes have the same method names.
Functions from global namespace are not permitted then.
It’s easily templateable and essentially implies that you’re requiring every function to exist in class stated.

Cheers, Filip

Wiadomość napisana przez Sebastian Wittmeier via Std-Proposals <std-proposals@lists.isocpp.org> w dniu 22 mar 2025, o godz. 12:57:

 AW: [std-proposals] Proposal Idea: with Block for C++ – Extending Object Scope

One could use a shortcut instead.

E.g. _, if it is not too confusing with discard.

 

using A {

    _.foo();

    _.bar();

}

 

 

Alternative:

 

[&](auto& a) {

    a.foo();

    a.bar();

}(A);
 

-----Ursprüngliche Nachricht-----
Von: Filip via Std-Proposals <std-proposals@lists.isocpp.org>
Gesendet: Sa 22.03.2025 11:50
Betreff: Re: [std-proposals] Proposal Idea: with Block for C++ – Extending Object Scope
An: std-proposals@lists.isocpp.org;
CC: Filip <fph2137@gmail.com>; Tiago Freire via Std-Proposals <std-proposals@lists.isocpp.org>;
The only way I see something like this helping would be:
 
‘’’
void foo(A a, B b) {
using A {
foo();
bar();
};
 
using B {
foo();
bar();
};
}
‘’’
 
Inside of this block only those functions from the object are valid.
But I agree that it’s better to be explicit and removing identifier is a bad idea generally.

Cheers, Filip

Wiadomość napisana przez organicoman via Std-Proposals <std-proposals@lists.isocpp.org> w dniu 22 mar 2025, o godz. 09:22:


+1
 
 
 
Sent from my Galaxy
 
 
-------- Original message --------
From: Tiago Freire via Std-Proposals <std-proposals@lists.isocpp.org>
Date: 3/22/25 8:55 AM (GMT+01:00)
To: std-proposals@lists.isocpp.org
Cc: Tiago Freire <tmiguelf@hotmail.com>
Subject: Re: [std-proposals] Proposal Idea: with Block for C++ – Extending Object Scope
 
It's not unnecessary verbosity, it expresses exactly what you mean without having to think about convoluted interpretation rules about things that appear on multiple lines that might not even be visible on screen.
 
void foo()
 
void bar (A a, A& b) with (a, b) {
foo();
}
 
Does this mean:
a.foo()?
b.foo()?
::foo()?
 
Notice that it is very clear when I write what I want explicitly.
At some point being too lazy is bad.
 

From: Std-Proposals <std-proposals-bounces@lists.isocpp.org> on behalf of Vaibhav Parate via Std-Proposals <std-proposals@lists.isocpp.org>
Sent: Saturday, March 22, 2025 7:55:43 AM
To: std-proposals@lists.isocpp.org <std-proposals@lists.isocpp.org>
Cc: Vaibhav Parate <vaibhavparate321@gmail.com>
Subject: [std-proposals] Proposal Idea: with Block for C++ – Extending Object Scope

Hello,
Before I spend time on a formal paper for this idea, I want some feedback and suggestions.

Idea:
I'd like to propose a with block for C++ that allows extending the scope of objects, making field access easier and reducing redundant qualifiers.

Motivation (while working on some personal projects):
Currently, in C++, working with objects often requires repeatedly qualifying fields with object-> or object. inside functions and lambdas. This leads to unnecessary verbosity, especially when dealing with deeply nested structures.
 
Example:
C++ Currently (It is readable but very quickly gets messy, specially when you are the author of the entire codebase):
void foo (A a, B* b, C& c) { // let's assume A, B, and C are types
a.doSomething();
b->doSomethingElse();
// some other calles
c.trySomethingElse();
}
 
C++ with "with" blocks:
void foo (A a, B* b, C& c) {
with (a, *b, c) {
doSomething();
doSomethingElse();
// some other calles
trySomethingElse();
}
}
 
Or if you want to use them for the entire function? Consider this:
void foo (A a, B* b, C& c) with (a, *b, c) {
doSomething();
doSomethingElse();
// some other calles
trySomethingElse();
}
 
What about field name collisions?
They can be easily solved using existing syntax of using object. or object->.
 
Maybe it will be harder for people to port old code that uses "with" as an identifier (variable name etc.) what about that?
It's not necessary to use this exact keyword, it can be something else like "using" which is already a keyword.
 
Why?
I always find it annoying to use qualifiers while initializing objects, yeah there are constructors (and other initializers), but there are sometimes where constructors aren't enough and the object needs to be initialized in different ways. I may be wrong here and maybe the only one facing these issues, but does it hurt to have this feature?
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
-- 
 Std-Proposals mailing list
 Std-Proposals@lists.isocpp.org
 https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals