[ruby-core:122799] [Ruby Feature#21515] Add `&return` as sugar for `x=my_calculation; return x if x`

Issue #21515 has been updated by vo.x (Vit Ondruch).


Proposal like this always reminds me:

https://poignant.guide/book/chapter-3.html

How am I supposed to read the `&return my_calculation(input_a, input_b)`. Reading it "and return my calculations from input_a and input_b" does not make sense to me.

----------------------------------------
Feature #21515: Add `&return` as sugar for `x=my_calculation; return x if x`
https://bugs.ruby-lang.org/issues/21515#change-114078

* Author: nhorton (Noah Horton)
* Status: Open
----------------------------------------
Let me preface this by saying I have no marriage to the exact keyword name of `&return`.

# Problem
It is very common to have an early return in code where you get some initial value and return it if it is non-null. i.e.

```
return my_calculation(input_a, input_b) if my_calculation(input_a, input_b)
```

That form on its own is verbose and one where you need to look at it for a moment to confirm it is the same code on either side of the if.

If `my_calculation` is non-trivial at all, it normally gets turned into something with a variable:

```
my_calc = my_calculation(input_a, input_b)
return my_calc if my_calc
```

That is now two lines. The worse scenario, however, is if the user did not bother doing that and my_calculation turned out to be expensive (and they did not know it).

# Proposal
I propose a syntax of `&return my_calculation(input_a, input_b)` where it will evaluate the argument and return it as the result of the method if it is non-nil, otherwise it will continue on.

# Alternatives
## Do Nothing
There is no way to work around this with rolling your own methods. You can't make a `returnif` method or something yourself since you can't do a return in the caller's scope.

## Different Name

The best other name I saw were permutations of `returnif`. The biggest issue I see is the similarity of the following two statements:

```
return if foo
returnif foo
```

Those are obviously very, very different statements, but are somewhat similar. However, things like this are common, and the code is still quite distinct on those, so I think it is acceptable.

Ultimately, this feels so similar to the safe navigator that using `&` in this context feels appropriate.

Thank you all for your consideration.





-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/