> Right. And for "but I just want to pass two ints", it doesn't actually
> seem like that much of a burden to write
> void f(struct {int a = 42; int b = 666;} oink = {});

> and just use oink.a and oink.b in the function body.

To avoid having to use oink.a and oink.b in the function body, one can formulate a simple rule: if the type of a function parameter is a class type that is defined in the parameter list of that function, then the function body can access the parameter members directly, without having to use the member access operator. So you can write just 'a' and 'b' instead of 'oink.a' and 'oink.b.'

Such a rule wouldn't be completely strange to C++. Something similar already exists in the non-static member functions, where we can access members of the 'implicit object parameter' without having to use the member access syntax, i.e. we write 'a' as a shorthand for 'this->a'.

A name ambiguity issue can arise if parameters of this sort have members with identical names to other parameters or to members of other parameters. This is not a big deal. A simple solution can be formulated (e.g. require the user to explicitly write 'oink.a' in case there is ambiguity about the name 'a').

Probably a more consistent solution would be to find some generalized syntax (possibly some keyword) that makes it possible to import the member names of any parameter of class type into the function parameter scope, regardless of where the parameter type was declared. This is preferable because we can use the generalized syntax to import the names of an 'explicit object parameter' into the function body in case we were writing a definition of a member function with an 'explicit object parameter' rather than the usual 'implicit object parameter'.

For example, if we use the keyword 'using' to import names into the function body, we can declare a function as follows.

void f(using struct {int a = 0; int b = 0;});

The presence of the keyword 'using' (or whatever keyword to be proposed) means that the names inside the parameter type are accessible in the function body.

Similarly, a non-static member function with an 'explicit object parameter' may be defined as follows.

void T::f(this using T const&);

The presence of the keyword 'using' means that the names of the type T are accessible in the function body, exactly as if we were writing an old non-static member function with an 'implicit object parameter'.

Of course, that last example won't be really a definition of a non-static member function under the C++23 draft. Unfortunately, that syntax is now reserved for a new type of member functions that is introduced in C++23 per the proposal "Deducing this" (P0847R). As far as I understand, there is currently no possibility in C++ to write a non-static member function with an 'explicit object parameter'. Hopefully someone will propose syntax to make that possible.