Trailing return syntax for new functions

[scarf005]

TL;DR

• trailing return syntax is C++11 feature
• you can write stuff like

  auto foo(std::string a, std::string b) -> std::string

Rationale

• please check code style questions #1940 for more

1. Extendability: There are cases where trailing return syntax is mandatory, but no vise versa.
2. Readability:

• It helps when return types get long.

  std::list<std::pair<std::string, std::string>> get_note_color_names();         // classic c++
  auto get_note_color_names() -> std::list<std::pair<std::string, std::string>>; // trailing return syntax

• It uses same syntax as lambda, enhancing readability.

  auto foo(int a, int b) -> int { /* ... */ }      // trailing function return syntax
  auto bar = [](int a, int b) -> int { /* ... */ } // lambda syntax

3. Documentation: It could act as a visual cue that the function is new/refactored recently.

Note:
I do not intend to change all function signature, that'd make merging existing PR and porting from DDA much harder.
My intention is to only allow trailing return syntax on new or refactored functions.

[Coolthulhu]

My arguments against:

• It is different from the "default" that we can see on 99.9% of tutorials on the internet
• Most people who just use C++ for small projects probably don't know it
• It would mean two different styles for the project (old vs new/refactor), which is inherently ugly, possibly worse than loss of compatibility with DDA

I consider each of these to be more significant than all of the arguments "for", combined.

[scarf005]

on other thoughts, yeah, they also make sense.

[scarf005]

...closing since I've been (ab)using trailing return syntax for new functions many months ago.