Why trailing return types?

[lefticus]

That's all - let's discuss why you might want to use them

[elbeno]

Potentially 2 separate issues:

• why use return types over return type deduction? (one answer e.g. SFINAE friendliness)
• why use trailing return types over expression-syntax declarations? (one answer e.g. sometimes you have to)

And corollaries of consistent TRT usage:

• implies AAA style for variable declarations?
• extends to things like type aliases.

Con: TRT style is probably not consistent across the whole language like expression-syntax declarations are.

[elbeno]

A few examples (at Jason's request, in case he has omitted any):

// regular functions
auto f0() -> void; 

// lambdas
auto f1 = [] () -> void {}; // pre-23
auto f2 = [] -> void {}; // empty param clause may be omitted from 23

// aliases - commonly function pointer types
// if you want to use using, I think you have to use TRT
using F0 = auto (*)() -> void;
typedef  auto (*F1)() -> void;

// or indeed just function types
using F2 = auto () -> void;
typedef  auto (F3)() -> void;

// or member function types, etc

// many uses in generic code, for SFINAE-friendliness or otherwise
auto f3(auto x, auto y) -> decltype(x + y); // return type dependent on arg types
auto f4(auto &&t) -> decltype(auto);
auto f5(auto &&t) -> std::integral auto;

// perhaps more obvious to put return type ref qualifiers at the end 
// rather than attached to the function name (if that's the formatting style you use)?
auto f6(auto &&t) -> auto&;
 
// even this: it is redundant but if you want to emphasize auto as the unconstrained concept...
auto f7(auto &&t) -> auto;

Of course https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-trailing-return-type.html

[elbeno]

For out-of-line member functions the lookup is different on the trailing return:

struct S {
  struct inner {};

  auto f() -> inner;
};

// non-trailing requires qualification of inner:
S::inner S::f() { return {}; }

// trailing does not:
auto S::f() -> inner { return {}; }

[lefticus]

I want to mention that deduction guides have similar syntax

template<typename Param> MyType(Param) -> MyType<Param>;

also consistent with AAA

auto i = 42;
auto data = std::vector<int>{1,2,3,4};

and consistent with Rust:

fn make_data() -> i32

And typescript

function make_data(): number;

and python

def make_data() -> int

[elbeno]

One more thing: https://godbolt.org/z/xY4bdfa36

Clang does not implement NRVO on function templates with deduced return types. So wherever possible, add the return type (either trailing or otherwise).

See llvm/llvm-project#95280