Value of "return" keyword

[billdueber]

Excellent work! I ask that you reconsider "Avoid return where not required."

The return keyword is excellent syntactic sugar for two reasons:

1. It gives a very easy way to differentiate between methods whose return values are meaningful and methods whose return values are incidental.
2. It's invaluable for reading code where the value returned doesn't come from the last line of the method (because the last line executed is within a conditional of some sort).

[asiazhang]

I agree.Better to have a explict return word in your code when need, that makes code more readable.

[argent-smith]

Objections to @billdueber:

1. A Ruby programmer should know and remember that ALL methods return a value, which is the value of a last operation.
2. This straightforward principle is very familiar and comfortable for those of us who's returned to Ruby from the realm of functional languages (or is developing in either). "return" for us is a bad "defensive" style. However a lot of guys came from imerative background... Well, we all have something to learn anew.
3. This is a guide, not the Law. If a language gives you a certain sugar, use and enjoy it ;-)

[bbatsov]

As @argent-smith commented - this is only a guide, you're free to decide for yourselves. I will never change that point for a few reasons:

1. Programmers should be encouraged to write straightforward code without lots of branching. It's only natural that the last thing evaluated in such a method is the thing of interest (the return value).
2. There is no real distinction between "meaningful" and "incidental" return values in Ruby except the one we impose in our minds; if you don't need the return value - just discard it. I don't feel that there is a need to mark the methods as void in some way.
3. Conditionals in Ruby are expressions, so if a method ends with a conditional it doesn't really matter and the flow continues to be as natural as always (at least for me)

I have spent a very long time as a professional Java developer (and C/C++ before that) so I understand your frustration. But I can assure you that the implicit return style has improved the quality of the code that I write and I encourage you to give it a shot.

[billdueber]

@agent-smith:

There's a difference between knowing that all methods return a value and (a) knowing that a particular methods returns a value intended to be useful (as opposed to whatever the value of the last side-effect was) and (b) being able to easily identify all the places in a code block where a value is returned.

In a purely functional style (esp. if you're militant about allowing tail-recursion), you know the last line of your block is the return value, and that it's useful, and "return" is redundant. But Ruby code generally exhibits plenty of side effects and imperative structure.

I can see where either of these cases (pure side-effect method; return values buried mid-method) might justifiably make a functional programmer throw up in her mouth a little :-) I'm just arguing that both are common (esp. the pure side-effect method, whose return value is always assumed to be thrown away) and that always explicitly using "return" is a win on the extra-syntax-vs-readable-code spectrum. You, apparently, believe that those readability benefits don't justify the extra keyword, and I guess we'll agree to disagree :-)

[argent-smith]

@billdueber:

You are right! My struggle is with all those nasty () :-)))

[agrimm]

I use return in my code, but only if it's required, like "I've got what you want, let's get out of here!" or "this ain't good, let's get out of here!". Using it only occasionally means I pay more attention when it is used, and making sure I use it correctly.

I recently had a bug caused because I was using return for "this ain't good, let's get out of here" within an each loop, when I should have merely done next, causing me to avoid later iterations of the each that were perfectly valid.

If I had been more judicious with return, noticing this bug would have been easier.

[DAddYE]

I use retun only as a shortcut to skip, I don't like write things when is not really necessary. So I prefer current one.

[burke]

This should definitely stay. return is useful as a shortcut method exit, but that's acceptable under the given definition.

Explicit return when omitting it would have the same result is generally regarded to be a minor code smell in ruby. There are occasionally methods complicated enough that it seems to provide some clarity, but those methods are typically in need of refactoring.

[bbatsov]

I'm closing the issue. The return rule will not be altered.