Trailing return type in non-template functions

I have seen people using the following syntax to implement functions:

auto get_next() -> int 
{
   /// ...
}

Instead of:

int get_next()
{
   /// ...
}

I understand both and I know that the trailing return type syntax is useful for template code using decltype. Personally I would avoid that syntax for other code since when reading code I prefer to read the concrete return type of a function first, not last.

Is there any advantage in using the trailing return type syntax for non-template code as shown above (except personal preference or style)?

In addition to sergeyrar's answer, those are the points I could imagine someone might like about trailing return types for non-template functions:

1. Specifying a return type for lambda expressions and functions is identical w.r.t. the syntax.

2. When you read a function signature left-to-right, the function parameters come first. This might make more sense, as any function will need the parameters to produce any outcome in the form of a return value.

3. You can use function parameter types when specifying the return type (the inverse doesn't work):

   auto f(int x) -> decltype(x)
   {
       return x + 42;
   }
   

   That doesn't make sense in the example above, but think about long iterator type names.