Hi,

I'm not sure if this is the right place or the right way to ask but I was wondering if there is a (similar) proposal for the following:

Adding an explicit name and an initial value to the return value of a function.

I imagine the following function signature (in pseudocode) :

auto func_name(Type1 arg1, Type2 arg2, etc.) -> RetType ret_value_name {init_value};

 

The change from existing code is the addition of a name after the return type and an initialization.

Think of the initialization as a default value.

I've noticed a lot of cases where a programmer would write functions like this:

int vector_sum(const std::vector<int>& vec) // or auto sum(const std::vector<int>& vec) -> int

{

  int result = 0;

  for(const auto value : vec) result += value;

  return result;

}

The bolded lines are repeated in many functions which return a new object constructed or built from the function arguments.

I imagine with this new syntax these lines would be implicitly generated by the compiler.

So, the function above can be written like this:

auto vector_sum(const std::vector<int>& vec) -> int result {0}

{

  for(const auto value : vec) result += value;

}

I was inspired by Ben Deane's talk at CppCon2021 about adding an explicit type to the 'this' argument.

This is a similar idea but related to an explicit name of the return value.

Some clarifications:

As far as I can tell the initialization is required because if it's optional the compiler won't be able to tell if the curly braces belong to the initialization or the function body.

So, if the compiler sees an identifier after the return type it should always expect an initializer before the function body (or before the semicolon for function declarations).

If it doesn't see an identifier after the return type it should expect the function body straight away (how it is now).

For function declarations (without a body) if you don't need (or you cannot) provide an initial value, you should not provide an explicit return value name.

So it's either both a name and an initialization or none.

Then in the actual definition you can provide the name and the initial value.

Similarly to how currently you can omit the argument names in function declarations and then provide them in the definition.

The usage of curly braces in the initialization also doesn't cause problems with pure virtual function declarations.

For example:

virtual auto func(int arg) -> int result {10} = 0;

Although, in most cases I don't think you would need an explicit return value name in pure virtual functions.

What do you think about this idea?

Has anyone proposed something like this?

Best regards,

Zamfir Yonchev