Best practice with Return in Module or Block

Question

I am a bit confused on the use of Return in either Block or Module when defining a custom function that is used a lot. For instance, The two simple functions (not using initialisation to examplify)

f1[x_] := Module[{y},y=x+1; Return[y];];
f2[x_] := Module[{y},y=x+1; y];

I am familiar with the differences between Module and Block---see e.g. here---but I don't really understand what the difference between f1 and f2 are in the present case. As someone familiar with other languages, the first seems more natural than the second, especially with respect to the absence of a final semi-colon in the module.

I have noticed that with Return I get a bunch of variables y$1, y$2, ... that get out of scope and not in the other case, but I haven't used it enough to see if it happens also in that case.

Is there a fundamental difference between those two functions, and what is considered best practice?

Answer 1

The use case for Return is not to return a value at the end of a scoping construct like Module or Block, but to return something from the middle of the construct:

func[x_] := Module[
    {answer1,answer2},
    <code>
    If[isValid[answer1],
        Return[answer1, Module]
    ];
    <more code>
    answer2
]

Here I check a whether some condition is satisfied, and if so I exit the Module early. This could be achieved with a Catch and Throw, but I tend to reserve that more for errors and exceptions. Here I view the Return as a normal operation, and not exceptional.

The caveat here is that the 2-argument form of Return, where the second argument says what to return from, is severely under-documented.