Issue #21515 has been updated by jeremyevans0 (Jeremy Evans). lpogic (Łukasz Pomietło) wrote in #note-5:
The advantage of the proposed syntax is that it does not require an explicit declaration of an auxiliary variable, like here: ```rb return result if result = my_calculation(input_a, input_b) ``` and here: ```rb x = my_calculation(input_a, input_b) and return x ``` It also does not require creating an extra Proc like here: ```rb my_calculation(input_a, input_b)&.then{return it} ```
Not sure why the local variable declaration would matter, as long as you don't pick one already in use. However, you are incorrect about `my_calculation(input_a, input_b)&.then{return it}` creating a Proc. Using a block does not automatically create a Proc (that would be very slow). Using `&.then{return it}` does not create a Proc: ```ruby def my_calculation(a, b) a == b || nil end def t(a, b) my_calculation(a, b)&.then{return it} proc{} end before = {} after = {} cases = [[1, 1], [1, 2]] GC.start GC.disable cases.each do |a, b| ObjectSpace.count_objects(before) c = t(a, b) ObjectSpace.count_objects(after) # Procs have T_DATA internal type p [a, b, c, after[:T_DATA] - before[:T_DATA]] end ``` Output: ``` [1, 1, true, 0] [1, 2, #<Proc:0x0000011fe401f310 -:7>, 1] ``` ---------------------------------------- Feature #21515: Add `&return` as sugar for `x=my_calculation; return x if x` https://bugs.ruby-lang.org/issues/21515#change-114118 * 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/